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   /* Since GDB always closes the target and updates byte-order when
 504      opening a new file, TARGET_BYTE_ORDER is normally correct. */
 505   if (TARGET_BYTE_ORDER == BIG_ENDIAN)
 506     strcat (arg_buf, " -E big");
 507   else
 508     strcat (arg_buf, " -E little");
 509 #endif
 510   argv = buildargv (arg_buf);
 511   if (argv == NULL)
 512     error ("Insufficient memory available to allocate simulator arg list.");
 513   make_cleanup (freeargv, (char *) argv);
 514
 515   init_callbacks ();
 516   gdbsim_desc = sim_open (SIM_OPEN_DEBUG, &gdb_callback, argv);
 517
 518   if (gdbsim_desc == 0)
 519     error ("unable to create simulator instance");
 520
 521   push_target (&gdbsim_ops);
 522   target_fetch_registers (-1);
 523   printf_filtered ("Connected to the simulator.\n");
 524 }
 525
 526 /* Does whatever cleanup is required for a target that we are no longer
 527    going to be calling.  Argument says whether we are quitting gdb and
 528    should not get hung in case of errors, or whether we want a clean
 529    termination even if it takes a while.  This routine is automatically
 530    always called just before a routine is popped off the target stack.
 531    Closing file descriptors and freeing memory are typical things it should
 532    do.  */
 533 /* Close out all files and local state before this target loses control. */
 534
 535 static void
 536 gdbsim_close (quitting)
 537      int quitting;
 538 {
 539   if (sr_get_debug ())
 540     printf_filtered ("gdbsim_close: quitting %d\n", quitting);
 541
 542   program_loaded = 0;
 543
 544   if (gdbsim_desc != NULL)
 545     {
 546       sim_close (gdbsim_desc, quitting);
 547       gdbsim_desc = NULL;
 548     }
 549
 550   end_callbacks ();
 551 }
 552
 553 /* Takes a program previously attached to and detaches it.
 554    The program may resume execution (some targets do, some don't) and will
 555    no longer stop on signals, etc.  We better not have left any breakpoints
 556    in the program or it'll die when it hits one.  ARGS is arguments
 557    typed by the user (e.g. a signal to send the process).  FROM_TTY
 558    says whether to be verbose or not.  */
 559 /* Terminate the open connection to the remote debugger.
 560    Use this when you want to detach and do something else with your gdb.  */
 561
 562 static void
 563 gdbsim_detach (args,from_tty)
 564      char *args;
 565      int from_tty;
 566 {
 567   if (sr_get_debug ())
 568     printf_filtered ("gdbsim_detach: args \"%s\"\n", args);
 569
 570   pop_target ();                /* calls gdbsim_close to do the real work */
 571   if (from_tty)
 572     printf_filtered ("Ending simulator %s debugging\n", target_shortname);
 573 }
 574
 575 /* Resume execution of the target process.  STEP says whether to single-step
 576    or to run free; SIGGNAL is the signal value (e.g. SIGINT) to be given
 577    to the target, or zero for no signal.  */
 578
 579 static enum target_signal resume_siggnal;
 580 static int resume_step;
 581
 582 static void
 583 gdbsim_resume (pid, step, siggnal)
 584      int pid, step;
 585      enum target_signal siggnal;
 586 {
 587   if (inferior_pid != 42)
 588     error ("The program is not being run.");
 589
 590   if (sr_get_debug ())
 591     printf_filtered ("gdbsim_resume: step %d, signal %d\n", step, siggnal);
 592
 593   resume_siggnal = siggnal;
 594   resume_step = step;
 595 }
 596
 597 /* Notify the simulator of an asynchronous request to stop.
 598
 599    The simulator shall ensure that the stop request is eventually
 600    delivered to the simulator.  If the call is made while the
 601    simulator is not running then the stop request is processed when
 602    the simulator is next resumed.
 603
 604    For simulators that do not support this operation, just abort */
 605
 606 static void
 607 gdbsim_stop ()
 608 {
 609   if (! sim_stop (gdbsim_desc))
 610     {
 611       quit ();
 612     }
 613 }
 614
 615 /* GDB version of os_poll_quit callback.
 616    Taken from gdb/util.c - should be in a library */
 617
 618 static int
 619 gdb_os_poll_quit (p)
 620      host_callback *p;
 621 {
 622   notice_quit ();
 623   if (quit_flag) /* gdb's idea of quit */
 624     {
 625       quit_flag = 0; /* we've stolen it */
 626       return 1;
 627     }
 628   else if (immediate_quit)
 629     {
 630       return 1;
 631     }
 632   return 0;
 633 }
 634
 635 /* Wait for inferior process to do something.  Return pid of child,
 636    or -1 in case of error; store status through argument pointer STATUS,
 637    just as `wait' would. */
 638
 639 static void
 640 gdbsim_cntrl_c (int signo)
 641 {
 642   gdbsim_stop ();
 643 }
 644
 645 static int
 646 gdbsim_wait (pid, status)
 647      int pid;
 648      struct target_waitstatus *status;
 649 {
 650   static RETSIGTYPE (*prev_sigint) ();
 651   int sigrc = 0;
 652   enum sim_stop reason = sim_running;
 653
 654   if (sr_get_debug ())
 655     printf_filtered ("gdbsim_wait\n");
 656
 657   prev_sigint = signal (SIGINT, gdbsim_cntrl_c);
 658   sim_resume (gdbsim_desc, resume_step,
 659               target_signal_to_host (resume_siggnal));
 660   signal (SIGINT, prev_sigint);
 661   resume_step = 0;
 662
 663   sim_stop_reason (gdbsim_desc, &reason, &sigrc);
 664
 665   switch (reason)
 666     {
 667     case sim_exited:
 668       status->kind = TARGET_WAITKIND_EXITED;
 669       status->value.integer = sigrc;
 670       break;
 671     case sim_stopped:
 672       switch (sigrc)
 673         {
 674         case SIGABRT:
 675           quit ();
 676           break;
 677         case SIGINT:
 678         case SIGTRAP:
 679         default:
 680           status->kind = TARGET_WAITKIND_STOPPED;
 681           /* The signal in sigrc is a host signal.  That probably
 682              should be fixed.  */
 683           status->value.sig = target_signal_from_host (sigrc);
 684           break;
 685         }
 686       break;
 687     case sim_signalled:
 688       status->kind = TARGET_WAITKIND_SIGNALLED;
 689       /* The signal in sigrc is a host signal.  That probably
 690          should be fixed.  */
 691       status->value.sig = target_signal_from_host (sigrc);
 692       break;
 693     }
 694
 695   return inferior_pid;
 696 }
 697
 698 /* Get ready to modify the registers array.  On machines which store
 699    individual registers, this doesn't need to do anything.  On machines
 700    which store all the registers in one fell swoop, this makes sure
 701    that registers contains all the registers from the program being
 702    debugged.  */
 703
 704 static void
 705 gdbsim_prepare_to_store ()
 706 {
 707   /* Do nothing, since we can store individual regs */
 708 }
 709
 710 static int
 711 gdbsim_xfer_inferior_memory (memaddr, myaddr, len, write, target)
 712      CORE_ADDR memaddr;
 713      char *myaddr;
 714      int len;
 715      int write;
 716      struct target_ops *target;                 /* ignored */
 717 {
 718   if (! program_loaded)
 719     error ("No program loaded.");
 720
 721   if (sr_get_debug ())
 722     {
 723       printf_filtered ("gdbsim_xfer_inferior_memory: myaddr 0x%x, memaddr 0x%x, len %d, write %d\n",
 724                        myaddr, memaddr, len, write);
 725       if (sr_get_debug () && write)
 726         dump_mem(myaddr, len);
 727     }
 728
 729   if (write)
 730     {
 731       len = sim_write (gdbsim_desc, memaddr, myaddr, len);
 732     }
 733   else
 734     {
 735       len = sim_read (gdbsim_desc, memaddr, myaddr, len);
 736       if (sr_get_debug () && len > 0)
 737         dump_mem(myaddr, len);
 738     }
 739   return len;
 740 }
 741
 742 static void
 743 gdbsim_files_info (target)
 744      struct target_ops *target;
 745 {
 746   char *file = "nothing";
 747
 748   if (exec_bfd)
 749     file = bfd_get_filename (exec_bfd);
 750
 751   if (sr_get_debug ())
 752     printf_filtered ("gdbsim_files_info: file \"%s\"\n", file);
 753
 754   if (exec_bfd)
 755     {
 756       printf_filtered ("\tAttached to %s running program %s\n",
 757                        target_shortname, file);
 758       sim_info (gdbsim_desc, 0);
 759     }
 760 }
 761
 762 /* Clear the simulator's notion of what the break points are.  */
 763
 764 static void
 765 gdbsim_mourn_inferior ()
 766 {
 767   if (sr_get_debug ())
 768     printf_filtered ("gdbsim_mourn_inferior:\n");
 769
 770   remove_breakpoints ();
 771   generic_mourn_inferior ();
 772 }
 773
 774 /* Pass the command argument through to the simulator verbatim.  The
 775    simulator must do any command interpretation work.  */
 776
 777 static void
 778 simulator_command (args, from_tty)
 779      char *args;
 780      int from_tty;
 781 {
 782   if (gdbsim_desc == NULL)
 783     {
 784
 785       /* PREVIOUSLY: The user may give a command before the simulator
 786          is opened. [...] (??? assuming of course one wishes to
 787          continue to allow commands to be sent to unopened simulators,
 788          which isn't entirely unreasonable). */
 789
 790       /* The simulator is a builtin abstraction of a remote target.
 791          Consistent with that model, access to the simulator, via sim
 792          commands, is restricted to the period when the channel to the
 793          simulator is open. */
 794
 795       error ("Not connected to the simulator target");
 796     }
 797
 798   sim_do_command (gdbsim_desc, args);
 799 }
 800
 801 /* Define the target subroutine names */
 802
 803 struct target_ops gdbsim_ops = {
 804   "sim",                        /* to_shortname */
 805   "simulator",                  /* to_longname */
 806   "Use the compiled-in simulator.",  /* to_doc */
 807   gdbsim_open,                  /* to_open */
 808   gdbsim_close,                 /* to_close */
 809   NULL,                         /* to_attach */
 810   gdbsim_detach,                /* to_detach */
 811   gdbsim_resume,                /* to_resume */
 812   gdbsim_wait,                  /* to_wait */
 813   gdbsim_fetch_register,        /* to_fetch_registers */
 814   gdbsim_store_register,        /* to_store_registers */
 815   gdbsim_prepare_to_store,      /* to_prepare_to_store */
 816   gdbsim_xfer_inferior_memory,  /* to_xfer_memory */
 817   gdbsim_files_info,            /* to_files_info */
 818   memory_insert_breakpoint,     /* to_insert_breakpoint */
 819   memory_remove_breakpoint,     /* to_remove_breakpoint */
 820   NULL,                         /* to_terminal_init */
 821   NULL,                         /* to_terminal_inferior */
 822   NULL,                         /* to_terminal_ours_for_output */
 823   NULL,                         /* to_terminal_ours */
 824   NULL,                         /* to_terminal_info */
 825   gdbsim_kill,                  /* to_kill */
 826   gdbsim_load,                  /* to_load */
 827   NULL,                         /* to_lookup_symbol */
 828   gdbsim_create_inferior,       /* to_create_inferior */
 829   gdbsim_mourn_inferior,        /* to_mourn_inferior */
 830   0,                            /* to_can_run */
 831   0,                            /* to_notice_signals */
 832   0,                            /* to_thread_alive */
 833   gdbsim_stop,                  /* to_stop */
 834   process_stratum,              /* to_stratum */
 835   NULL,                         /* to_next */
 836   1,                            /* to_has_all_memory */
 837   1,                            /* to_has_memory */
 838   1,                            /* to_has_stack */
 839   1,                            /* to_has_registers */
 840   1,                            /* to_has_execution */
 841   NULL,                         /* sections */
 842   NULL,                         /* sections_end */
 843   OPS_MAGIC,                    /* to_magic */
 844 };
 845
 846 void
 847 _initialize_remote_sim ()
 848 {
 849   add_target (&gdbsim_ops);
 850
 851   add_com ("sim <command>", class_obscure, simulator_command,
 852            "Send a command to the simulator.");
 853 }