gdb/remote-sim.c

   1 /* Generic remote debugging interface for simulators.
   2    Copyright 1993, 1994, 1996, 1997 Free Software Foundation, Inc.
   3    Contributed by Cygnus Support.
   4    Steve Chamberlain (sac@cygnus.com).
   5
   6 This file is part of GDB.
   7
   8 This program is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 2 of the License, or
  11 (at your option) any later version.
  12
  13 This program is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with this program; if not, write to the Free Software
  20 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  21
  22 #include "defs.h"
  23 #include "inferior.h"
  24 #include "wait.h"
  25 #include "value.h"
  26 #include "gdb_string.h"
  27 #include <ctype.h>
  28 #include <fcntl.h>
  29 #include <signal.h>
  30 #include <setjmp.h>
  31 #include <errno.h>
  32 #include "terminal.h"
  33 #include "target.h"
  34 #include "gdbcore.h"
  35 #include "callback.h"
  36 #include "remote-sim.h"
  37 #include "remote-utils.h"
  38
  39 /* Prototypes */
  40
  41 static void dump_mem PARAMS ((char *buf, int len));
  42
  43 static void init_callbacks PARAMS ((void));
  44
  45 static void end_callbacks PARAMS ((void));
  46
  47 static int gdb_os_write_stdout PARAMS ((host_callback *, const char *, int));
  48
  49 static void gdb_os_flush_stdout PARAMS ((host_callback *));
  50
  51 static int gdb_os_write_stderr PARAMS ((host_callback *, const char *, int));
  52
  53 static void gdb_os_flush_stderr PARAMS ((host_callback *));
  54
  55 static int gdb_os_poll_quit PARAMS ((host_callback *));
  56
  57 /* printf_filtered is depreciated */
  58 static void gdb_os_printf_filtered PARAMS ((host_callback *, const char *, ...));
  59
  60 static void gdb_os_vprintf_filtered PARAMS ((host_callback *, const char *, va_list));
  61
  62 static void gdb_os_evprintf_filtered PARAMS ((host_callback *, const char *, va_list));
  63
  64 static void gdb_os_error PARAMS ((host_callback *, const char *, ...));
  65
  66 static void gdbsim_fetch_register PARAMS ((int regno));
  67
  68 static void gdbsim_store_register PARAMS ((int regno));
  69
  70 static void gdbsim_kill PARAMS ((void));
  71
  72 static void gdbsim_load PARAMS ((char *prog, int fromtty));
  73
  74 static void gdbsim_create_inferior PARAMS ((char *exec_file, char *args, char **env));
  75
  76 static void gdbsim_open PARAMS ((char *args, int from_tty));
  77
  78 static void gdbsim_close PARAMS ((int quitting));
  79
  80 static void gdbsim_detach PARAMS ((char *args, int from_tty));
  81
  82 static void gdbsim_resume PARAMS ((int pid, int step, enum target_signal siggnal));
  83
  84 static int gdbsim_wait PARAMS ((int pid, struct target_waitstatus *status));
  85
  86 static void gdbsim_prepare_to_store PARAMS ((void));
  87
  88 static int gdbsim_xfer_inferior_memory PARAMS ((CORE_ADDR memaddr,
  89                                                 char *myaddr, int len,
  90                                                 int write,
  91                                                 struct target_ops *target));
  92
  93 static void gdbsim_files_info PARAMS ((struct target_ops *target));
  94
  95 static void gdbsim_mourn_inferior PARAMS ((void));
  96
  97 static void gdbsim_stop PARAMS ((void));
  98
  99 static void simulator_command PARAMS ((char *args, int from_tty));
 100
 101 /* Naming convention:
 102
 103    sim_* are the interface to the simulator (see remote-sim.h).
 104    gdbsim_* are stuff which is internal to gdb.  */
 105
 106 /* Forward data declarations */
 107 extern struct target_ops gdbsim_ops;
 108
 109 static int program_loaded = 0;
 110
 111 /* We must keep track of whether the simulator has been opened or not because
 112    GDB can call a target's close routine twice, but sim_close doesn't allow
 113    this.  We also need to record the result of sim_open so we can pass it
 114    back to the other sim_foo routines.  */
 115 static SIM_DESC gdbsim_desc = 0;
 116
 117 static void
 118 dump_mem (buf, len)
 119      char *buf;
 120      int len;
 121 {
 122   if (len <= 8)
 123     {
 124       if (len == 8 || len == 4)
 125         {
 126           long l[2];
 127           memcpy (l, buf, len);
 128           printf_filtered ("\t0x%x", l[0]);
 129           printf_filtered (len == 8 ? " 0x%x\n" : "\n", l[1]);
 130         }
 131       else
 132         {
 133           int i;
 134           printf_filtered ("\t");
 135           for (i = 0; i < len; i++)
 136             printf_filtered ("0x%x ", buf[i]);
 137           printf_filtered ("\n");
 138         }
 139     }
 140 }
 141
 142 static host_callback gdb_callback;
 143 static int callbacks_initialized = 0;
 144
 145 /* Initialize gdb_callback.  */
 146
 147 static void
 148 init_callbacks ()
 149 {
 150   if (! callbacks_initialized)
 151     {
 152       gdb_callback = default_callback;
 153       gdb_callback.init (&gdb_callback);
 154       gdb_callback.write_stdout = gdb_os_write_stdout;
 155       gdb_callback.flush_stdout = gdb_os_flush_stdout;
 156       gdb_callback.write_stderr = gdb_os_write_stderr;
 157       gdb_callback.flush_stderr = gdb_os_flush_stderr;
 158       gdb_callback.printf_filtered = gdb_os_printf_filtered;
 159       gdb_callback.vprintf_filtered = gdb_os_vprintf_filtered;
 160       gdb_callback.evprintf_filtered = gdb_os_evprintf_filtered;
 161       gdb_callback.error = gdb_os_error;
 162       gdb_callback.poll_quit = gdb_os_poll_quit;
 163       gdb_callback.magic = HOST_CALLBACK_MAGIC;
 164       callbacks_initialized = 1;
 165     }
 166 }
 167
 168 /* Release callbacks (free resources used by them).  */
 169
 170 static void
 171 end_callbacks ()
 172 {
 173   if (callbacks_initialized)
 174     {
 175       gdb_callback.shutdown (&gdb_callback);
 176       callbacks_initialized = 0;
 177     }
 178 }
 179
 180 /* GDB version of os_write_stdout callback.  */
 181
 182 static int
 183 gdb_os_write_stdout (p, buf, len)
 184      host_callback *p;
 185      const char *buf;
 186      int len;
 187 {
 188   int i;
 189   char b[2];
 190
 191   for (i = 0; i < len; i++)
 192     {
 193       b[0] = buf[i];
 194       b[1] = 0;
 195       if (target_output_hook)
 196         target_output_hook (b);
 197       else
 198         fputs_filtered (b, gdb_stdout);
 199     }
 200   return len;
 201 }
 202
 203 /* GDB version of os_flush_stdout callback.  */
 204
 205 static void
 206 gdb_os_flush_stdout (p)
 207      host_callback *p;
 208 {
 209   gdb_flush (gdb_stdout);
 210 }
 211
 212 /* GDB version of os_write_stderr callback.  */
 213
 214 static int
 215 gdb_os_write_stderr (p, buf, len)
 216      host_callback *p;
 217      const char *buf;
 218      int len;
 219 {
 220   int i;
 221   char b[2];
 222
 223   for (i = 0; i < len; i++)
 224     {
 225       b[0] = buf[i];
 226       b[1] = 0;
 227       if (target_output_hook)
 228         target_output_hook (b);
 229       else
 230         fputs_filtered (b, gdb_stderr);
 231     }
 232   return len;
 233 }
 234
 235 /* GDB version of os_flush_stderr callback.  */
 236
 237 static void
 238 gdb_os_flush_stderr (p)
 239      host_callback *p;
 240 {
 241   gdb_flush (gdb_stderr);
 242 }
 243
 244 /* GDB version of printf_filtered callback.  */
 245
 246 /* VARARGS */
 247 static void
 248 #ifdef ANSI_PROTOTYPES
 249 gdb_os_printf_filtered (host_callback *p, const char *format, ...)
 250 #else
 251 gdb_os_printf_filtered (p, va_alist)
 252      host_callback *p;
 253      va_dcl
 254 #endif
 255 {
 256   va_list args;
 257 #ifdef ANSI_PROTOTYPES
 258   va_start (args, format);
 259 #else
 260   char *format;
 261
 262   va_start (args);
 263   format = va_arg (args, char *);
 264 #endif
 265
 266   vfprintf_filtered (gdb_stdout, format, args);
 267
 268   va_end (args);
 269 }
 270
 271 /* GDB version of error vprintf_filtered.  */
 272
 273 /* VARARGS */
 274 static void
 275 #ifdef ANSI_PROTOTYPES
 276 gdb_os_vprintf_filtered (host_callback *p, const char *format, va_list ap)
 277 #else
 278 gdb_os_vprintf_filtered (p, format, ap)
 279      host_callback *p;
 280      char *format;
 281      va_list ap;
 282 #endif
 283 {
 284   vfprintf_filtered (gdb_stdout, format, ap);
 285 }
 286
 287 /* GDB version of error evprintf_filtered.  */
 288
 289 /* VARARGS */
 290 static void
 291 #ifdef ANSI_PROTOTYPES
 292 gdb_os_evprintf_filtered (host_callback *p, const char *format, va_list ap)
 293 #else
 294 gdb_os_evprintf_filtered (p, format, ap)
 295      host_callback *p;
 296      char *format;
 297      va_list ap;
 298 #endif
 299 {
 300   vfprintf_filtered (gdb_stderr, format, ap);
 301 }
 302
 303 /* GDB version of error callback.  */
 304
 305 /* VARARGS */
 306 static void
 307 #ifdef ANSI_PROTOTYPES
 308 gdb_os_error (host_callback *p, const char *format, ...)
 309 #else
 310 gdb_os_error (p, va_alist)
 311      host_callback *p;
 312      va_dcl
 313 #endif
 314 {
 315   if (error_hook)
 316     (*error_hook) ();
 317   else
 318     {
 319       va_list args;
 320 #ifdef ANSI_PROTOTYPES
 321       va_start (args, format);
 322 #else
 323       char *format;
 324
 325       va_start (args);
 326       format = va_arg (args, char *);
 327 #endif
 328
 329       error_begin ();
 330       vfprintf_filtered (gdb_stderr, format, args);
 331       fprintf_filtered (gdb_stderr, "\n");
 332       va_end (args);
 333       return_to_top_level (RETURN_ERROR);
 334     }
 335 }
 336
 337 static void
 338 gdbsim_fetch_register (regno)
 339 int regno;
 340 {
 341   if (regno == -1)
 342     {
 343       for (regno = 0; regno < NUM_REGS; regno++)
 344         gdbsim_fetch_register (regno);
 345     }
 346   else
 347     {
 348       char buf[MAX_REGISTER_RAW_SIZE];
 349
 350       sim_fetch_register (gdbsim_desc, regno, buf);
 351       supply_register (regno, buf);
 352       if (sr_get_debug ())
 353         {
 354           printf_filtered ("gdbsim_fetch_register: %d", regno);
 355           /* FIXME: We could print something more intelligible.  */
 356           dump_mem (buf, REGISTER_RAW_SIZE (regno));
 357         }
 358     }
 359 }
 360
 361
 362 static void
 363 gdbsim_store_register (regno)
 364 int regno;
 365 {
 366   if (regno  == -1)
 367     {
 368       for (regno = 0; regno < NUM_REGS; regno++)
 369         gdbsim_store_register (regno);
 370     }
 371   else
 372     {
 373       /* FIXME: Until read_register() returns LONGEST, we have this.  */
 374       char tmp[MAX_REGISTER_RAW_SIZE];
 375       read_register_gen (regno, tmp);
 376       sim_store_register (gdbsim_desc, regno, tmp);
 377       if (sr_get_debug ())
 378         {
 379           printf_filtered ("gdbsim_store_register: %d", regno);
 380           /* FIXME: We could print something more intelligible.  */
 381           dump_mem (tmp, REGISTER_RAW_SIZE (regno));
 382         }
 383     }
 384 }
 385
 386 /* Kill the running program.  This may involve closing any open files
 387    and releasing other resources acquired by the simulated program.  */
 388
 389 static void
 390 gdbsim_kill ()
 391 {
 392   if (sr_get_debug ())
 393     printf_filtered ("gdbsim_kill\n");
 394
 395   sim_kill (gdbsim_desc);       /* close fd's, remove mappings, etc. */
 396   inferior_pid = 0;
 397 }
 398
 399 /* Load an executable file into the target process.  This is expected to
 400    not only bring new code into the target process, but also to update
 401    GDB's symbol tables to match.  */
 402
 403 static void
 404 gdbsim_load (prog, fromtty)
 405      char *prog;
 406      int fromtty;
 407 {
 408   if (sr_get_debug ())
 409     printf_filtered ("gdbsim_load: prog \"%s\"\n", prog);
 410
 411   inferior_pid = 0;
 412
 413   /* FIXME: We will print two messages on error.
 414      Need error to either not print anything if passed NULL or need
 415      another routine that doesn't take any arguments.  */
 416   if (sim_load (gdbsim_desc, prog, NULL, fromtty) == SIM_RC_FAIL)
 417     error ("unable to load program");
 418
 419   program_loaded = 1;
 420 }
 421
 422
 423 /* Start an inferior process and set inferior_pid to its pid.
 424    EXEC_FILE is the file to run.
 425    ARGS is a string containing the arguments to the program.
 426    ENV is the environment vector to pass.  Errors reported with error().
 427    On VxWorks and various standalone systems, we ignore exec_file.  */
 428 /* This is called not only when we first attach, but also when the
 429    user types "run" after having attached.  */
 430
 431 static void
 432 gdbsim_create_inferior (exec_file, args, env)
 433      char *exec_file;
 434      char *args;
 435      char **env;
 436 {
 437   int len;
 438   char *arg_buf,**argv;
 439   CORE_ADDR entry_pt;
 440
 441   if (! program_loaded)
 442     error ("No program loaded.");
 443
 444   if (sr_get_debug ())
 445     printf_filtered ("gdbsim_create_inferior: exec_file \"%s\", args \"%s\"\n",
 446       exec_file, args);
 447
 448   if (exec_file == 0 || exec_bfd == 0)
 449    error ("No exec file specified.");
 450
 451   entry_pt = (CORE_ADDR) bfd_get_start_address (exec_bfd);
 452
 453   gdbsim_kill ();
 454   remove_breakpoints ();
 455   init_wait_for_inferior ();
 456
 457   len = strlen (exec_file) + 1 + strlen (args) + 1 + /*slop*/ 10;
 458   arg_buf = (char *) alloca (len);
 459   arg_buf[0] = '\0';
 460   strcat (arg_buf, exec_file);
 461   strcat (arg_buf, " ");
 462   strcat (arg_buf, args);
 463   argv = buildargv (arg_buf);
 464   make_cleanup (freeargv, (char *) argv);
 465   sim_create_inferior (gdbsim_desc, argv, env);
 466
 467   inferior_pid = 42;
 468   insert_breakpoints ();        /* Needed to get correct instruction in cache */
 469   proceed (entry_pt, TARGET_SIGNAL_DEFAULT, 0);
 470 }
 471
 472 /* The open routine takes the rest of the parameters from the command,
 473    and (if successful) pushes a new target onto the stack.
 474    Targets should supply this routine, if only to provide an error message.  */
 475 /* Called when selecting the simulator. EG: (gdb) target sim name.  */
 476
 477 static void
 478 gdbsim_open (args, from_tty)
 479      char *args;
 480      int from_tty;
 481 {
 482   int len;
 483   char *arg_buf;
 484   char **argv;
 485
 486   if (sr_get_debug ())
 487     printf_filtered ("gdbsim_open: args \"%s\"\n", args ? args : "(null)");
 488
 489   /* Remove current simulator if one exists.  Only do this if the simulator
 490      has been opened because sim_close requires it.
 491      This is important because the call to push_target below will cause
 492      sim_close to be called if the simulator is already open, but push_target
 493      is called after sim_open!  We can't move the call to push_target before
 494      the call to sim_open because sim_open may invoke `error'.  */
 495   if (gdbsim_desc != NULL)
 496     unpush_target (&gdbsim_ops);
 497
 498   len = 7 + 1 + (args ? strlen (args) : 0) + 50;
 499   arg_buf = (char *) alloca (len);
 500   sprintf (arg_buf, "gdbsim%s%s",
 501            args ? " " : "", args ? args : "");
 502 #ifdef TARGET_BYTE_ORDER_SELECTABLE
 503   if (TARGET_BYTE_ORDER == BIG_ENDIAN)
 504     strcat (arg_buf, " -E big");
 505   else
 506     strcat (arg_buf, " -E little");
 507 #endif
 508   argv = buildargv (arg_buf);
 509   if (argv == NULL)
 510     error ("Insufficient memory available to allocate simulator arg list.");
 511   make_cleanup (freeargv, (char *) argv);
 512
 513   init_callbacks ();
 514   gdbsim_desc = sim_open (SIM_OPEN_DEBUG, &gdb_callback, argv);
 515
 516   if (gdbsim_desc == 0)
 517     error ("unable to create simulator instance");
 518
 519   push_target (&gdbsim_ops);
 520   target_fetch_registers (-1);
 521   printf_filtered ("Connected to the simulator.\n");
 522 }
 523
 524 /* Does whatever cleanup is required for a target that we are no longer
 525    going to be calling.  Argument says whether we are quitting gdb and
 526    should not get hung in case of errors, or whether we want a clean
 527    termination even if it takes a while.  This routine is automatically
 528    always called just before a routine is popped off the target stack.
 529    Closing file descriptors and freeing memory are typical things it should
 530    do.  */
 531 /* Close out all files and local state before this target loses control. */
 532
 533 static void
 534 gdbsim_close (quitting)
 535      int quitting;
 536 {
 537   if (sr_get_debug ())
 538     printf_filtered ("gdbsim_close: quitting %d\n", quitting);
 539
 540   program_loaded = 0;
 541
 542   if (gdbsim_desc != NULL)
 543     {
 544       sim_close (gdbsim_desc, quitting);
 545       gdbsim_desc = NULL;
 546     }
 547
 548   end_callbacks ();
 549 }
 550
 551 /* Takes a program previously attached to and detaches it.
 552    The program may resume execution (some targets do, some don't) and will
 553    no longer stop on signals, etc.  We better not have left any breakpoints
 554    in the program or it'll die when it hits one.  ARGS is arguments
 555    typed by the user (e.g. a signal to send the process).  FROM_TTY
 556    says whether to be verbose or not.  */
 557 /* Terminate the open connection to the remote debugger.
 558    Use this when you want to detach and do something else with your gdb.  */
 559
 560 static void
 561 gdbsim_detach (args,from_tty)
 562      char *args;
 563      int from_tty;
 564 {
 565   if (sr_get_debug ())
 566     printf_filtered ("gdbsim_detach: args \"%s\"\n", args);
 567
 568   pop_target ();                /* calls gdbsim_close to do the real work */
 569   if (from_tty)
 570     printf_filtered ("Ending simulator %s debugging\n", target_shortname);
 571 }
 572
 573 /* Resume execution of the target process.  STEP says whether to single-step
 574    or to run free; SIGGNAL is the signal value (e.g. SIGINT) to be given
 575    to the target, or zero for no signal.  */
 576
 577 static enum target_signal resume_siggnal;
 578 static int resume_step;
 579
 580 static void
 581 gdbsim_resume (pid, step, siggnal)
 582      int pid, step;
 583      enum target_signal siggnal;
 584 {
 585   if (inferior_pid != 42)
 586     error ("The program is not being run.");
 587
 588   if (sr_get_debug ())
 589     printf_filtered ("gdbsim_resume: step %d, signal %d\n", step, siggnal);
 590
 591   resume_siggnal = siggnal;
 592   resume_step = step;
 593 }
 594
 595 /* Notify the simulator of an asynchronous request to stop.
 596
 597    The simulator shall ensure that the stop request is eventually
 598    delivered to the simulator.  If the call is made while the
 599    simulator is not running then the stop request is processed when
 600    the simulator is next resumed.
 601
 602    For simulators that do not support this operation, just abort */
 603
 604 static void
 605 gdbsim_stop ()
 606 {
 607   if (! sim_stop (gdbsim_desc))
 608     {
 609       quit ();
 610     }
 611 }
 612
 613 /* GDB version of os_poll_quit callback.
 614    Taken from gdb/util.c - should be in a library */
 615
 616 static int
 617 gdb_os_poll_quit (p)
 618      host_callback *p;
 619 {
 620   notice_quit ();
 621   if (quit_flag) /* gdb's idea of quit */
 622     {
 623       quit_flag = 0; /* we've stolen it */
 624       return 1;
 625     }
 626   else if (immediate_quit)
 627     {
 628       return 1;
 629     }
 630   return 0;
 631 }
 632
 633 /* Wait for inferior process to do something.  Return pid of child,
 634    or -1 in case of error; store status through argument pointer STATUS,
 635    just as `wait' would. */
 636
 637 static void
 638 gdbsim_cntrl_c (int signo)
 639 {
 640   gdbsim_stop ();
 641 }
 642
 643 static int
 644 gdbsim_wait (pid, status)
 645      int pid;
 646      struct target_waitstatus *status;
 647 {
 648   static RETSIGTYPE (*prev_sigint) ();
 649   int sigrc = 0;
 650   enum sim_stop reason = sim_running;
 651
 652   if (sr_get_debug ())
 653     printf_filtered ("gdbsim_wait\n");
 654
 655   prev_sigint = signal (SIGINT, gdbsim_cntrl_c);
 656   sim_resume (gdbsim_desc, resume_step,
 657               target_signal_to_host (resume_siggnal));
 658   signal (SIGINT, prev_sigint);
 659   resume_step = 0;
 660
 661   sim_stop_reason (gdbsim_desc, &reason, &sigrc);
 662
 663   switch (reason)
 664     {
 665     case sim_exited:
 666       status->kind = TARGET_WAITKIND_EXITED;
 667       status->value.integer = sigrc;
 668       break;
 669     case sim_stopped:
 670       switch (sigrc)
 671         {
 672         case SIGABRT:
 673           quit ();
 674           break;
 675         case SIGINT:
 676         case SIGTRAP:
 677         default:
 678           status->kind = TARGET_WAITKIND_STOPPED;
 679           /* The signal in sigrc is a host signal.  That probably
 680              should be fixed.  */
 681           status->value.sig = target_signal_from_host (sigrc);
 682           break;
 683         }
 684       break;
 685     case sim_signalled:
 686       status->kind = TARGET_WAITKIND_SIGNALLED;
 687       /* The signal in sigrc is a host signal.  That probably
 688          should be fixed.  */
 689       status->value.sig = target_signal_from_host (sigrc);
 690       break;
 691     }
 692
 693   return inferior_pid;
 694 }
 695
 696 /* Get ready to modify the registers array.  On machines which store
 697    individual registers, this doesn't need to do anything.  On machines
 698    which store all the registers in one fell swoop, this makes sure
 699    that registers contains all the registers from the program being
 700    debugged.  */
 701
 702 static void
 703 gdbsim_prepare_to_store ()
 704 {
 705   /* Do nothing, since we can store individual regs */
 706 }
 707
 708 static int
 709 gdbsim_xfer_inferior_memory (memaddr, myaddr, len, write, target)
 710      CORE_ADDR memaddr;
 711      char *myaddr;
 712      int len;
 713      int write;
 714      struct target_ops *target;                 /* ignored */
 715 {
 716   if (! program_loaded)
 717     error ("No program loaded.");
 718
 719   if (sr_get_debug ())
 720     {
 721       printf_filtered ("gdbsim_xfer_inferior_memory: myaddr 0x%x, memaddr 0x%x, len %d, write %d\n",
 722                        myaddr, memaddr, len, write);
 723       if (sr_get_debug () && write)
 724         dump_mem(myaddr, len);
 725     }
 726
 727   if (write)
 728     {
 729       len = sim_write (gdbsim_desc, memaddr, myaddr, len);
 730     }
 731   else
 732     {
 733       len = sim_read (gdbsim_desc, memaddr, myaddr, len);
 734       if (sr_get_debug () && len > 0)
 735         dump_mem(myaddr, len);
 736     }
 737   return len;
 738 }
 739
 740 static void
 741 gdbsim_files_info (target)
 742      struct target_ops *target;
 743 {
 744   char *file = "nothing";
 745
 746   if (exec_bfd)
 747     file = bfd_get_filename (exec_bfd);
 748
 749   if (sr_get_debug ())
 750     printf_filtered ("gdbsim_files_info: file \"%s\"\n", file);
 751
 752   if (exec_bfd)
 753     {
 754       printf_filtered ("\tAttached to %s running program %s\n",
 755                        target_shortname, file);
 756       sim_info (gdbsim_desc, 0);
 757     }
 758 }
 759
 760 /* Clear the simulator's notion of what the break points are.  */
 761
 762 static void
 763 gdbsim_mourn_inferior ()
 764 {
 765   if (sr_get_debug ())
 766     printf_filtered ("gdbsim_mourn_inferior:\n");
 767
 768   remove_breakpoints ();
 769   generic_mourn_inferior ();
 770 }
 771
 772 /* Pass the command argument through to the simulator verbatim.  The
 773    simulator must do any command interpretation work.  */
 774
 775 static void
 776 simulator_command (args, from_tty)
 777      char *args;
 778      int from_tty;
 779 {
 780   /* The user may give a command before the simulator is opened, so
 781      ensure that the callbacks have been set up.  */
 782   init_callbacks ();
 783
 784   /* Note that if the simulator hasn't been opened, gdbsim_desc == NULL
 785      which is correct (??? assuming of course one wishes to continue to
 786      allow commands to be sent to unopened simulators, which isn't entirely
 787      unreasonable).  Simulators should be prepared to deal with any
 788      combination of NULL or empty args. */
 789   sim_do_command (gdbsim_desc, args);
 790 }
 791
 792 /* Define the target subroutine names */
 793
 794 struct target_ops gdbsim_ops = {
 795   "sim",                        /* to_shortname */
 796   "simulator",                  /* to_longname */
 797   "Use the compiled-in simulator.",  /* to_doc */
 798   gdbsim_open,                  /* to_open */
 799   gdbsim_close,                 /* to_close */
 800   NULL,                         /* to_attach */
 801   gdbsim_detach,                /* to_detach */
 802   gdbsim_resume,                /* to_resume */
 803   gdbsim_wait,                  /* to_wait */
 804   gdbsim_fetch_register,        /* to_fetch_registers */
 805   gdbsim_store_register,        /* to_store_registers */
 806   gdbsim_prepare_to_store,      /* to_prepare_to_store */
 807   gdbsim_xfer_inferior_memory,  /* to_xfer_memory */
 808   gdbsim_files_info,            /* to_files_info */
 809   memory_insert_breakpoint,     /* to_insert_breakpoint */
 810   memory_remove_breakpoint,     /* to_remove_breakpoint */
 811   NULL,                         /* to_terminal_init */
 812   NULL,                         /* to_terminal_inferior */
 813   NULL,                         /* to_terminal_ours_for_output */
 814   NULL,                         /* to_terminal_ours */
 815   NULL,                         /* to_terminal_info */
 816   gdbsim_kill,                  /* to_kill */
 817   gdbsim_load,                  /* to_load */
 818   NULL,                         /* to_lookup_symbol */
 819   gdbsim_create_inferior,       /* to_create_inferior */
 820   gdbsim_mourn_inferior,        /* to_mourn_inferior */
 821   0,                            /* to_can_run */
 822   0,                            /* to_notice_signals */
 823   0,                            /* to_thread_alive */
 824   gdbsim_stop,                  /* to_stop */
 825   process_stratum,              /* to_stratum */
 826   NULL,                         /* to_next */
 827   1,                            /* to_has_all_memory */
 828   1,                            /* to_has_memory */
 829   1,                            /* to_has_stack */
 830   1,                            /* to_has_registers */
 831   1,                            /* to_has_execution */
 832   NULL,                         /* sections */
 833   NULL,                         /* sections_end */
 834   OPS_MAGIC,                    /* to_magic */
 835 };
 836
 837 void
 838 _initialize_remote_sim ()
 839 {
 840   add_target (&gdbsim_ops);
 841
 842   add_com ("sim <command>", class_obscure, simulator_command,
 843            "Send a command to the simulator.");
 844 }