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       sim_set_callbacks (gdbsim_desc, &gdb_callback);
 165
 166       callbacks_initialized = 1;
 167     }
 168 }
 169
 170 /* Release callbacks (free resources used by them).  */
 171
 172 static void
 173 end_callbacks ()
 174 {
 175   if (callbacks_initialized)
 176     {
 177       gdb_callback.shutdown (&gdb_callback);
 178       callbacks_initialized = 0;
 179     }
 180 }
 181
 182 /* GDB version of os_write_stdout callback.  */
 183
 184 static int
 185 gdb_os_write_stdout (p, buf, len)
 186      host_callback *p;
 187      const char *buf;
 188      int len;
 189 {
 190   int i;
 191   char b[2];
 192
 193   for (i = 0; i < len; i++)
 194     {
 195       b[0] = buf[i];
 196       b[1] = 0;
 197       if (target_output_hook)
 198         target_output_hook (b);
 199       else
 200         fputs_filtered (b, gdb_stdout);
 201     }
 202   return len;
 203 }
 204
 205 /* GDB version of os_flush_stdout callback.  */
 206
 207 static void
 208 gdb_os_flush_stdout (p)
 209      host_callback *p;
 210 {
 211   gdb_flush (gdb_stdout);
 212 }
 213
 214 /* GDB version of os_write_stderr callback.  */
 215
 216 static int
 217 gdb_os_write_stderr (p, buf, len)
 218      host_callback *p;
 219      const char *buf;
 220      int len;
 221 {
 222   int i;
 223   char b[2];
 224
 225   for (i = 0; i < len; i++)
 226     {
 227       b[0] = buf[i];
 228       b[1] = 0;
 229       if (target_output_hook)
 230         target_output_hook (b);
 231       else
 232         fputs_filtered (b, gdb_stderr);
 233     }
 234   return len;
 235 }
 236
 237 /* GDB version of os_flush_stderr callback.  */
 238
 239 static void
 240 gdb_os_flush_stderr (p)
 241      host_callback *p;
 242 {
 243   gdb_flush (gdb_stderr);
 244 }
 245
 246 /* GDB version of printf_filtered callback.  */
 247
 248 /* VARARGS */
 249 static void
 250 #ifdef ANSI_PROTOTYPES
 251 gdb_os_printf_filtered (host_callback *p, const char *format, ...)
 252 #else
 253 gdb_os_printf_filtered (p, va_alist)
 254      host_callback *p;
 255      va_dcl
 256 #endif
 257 {
 258   va_list args;
 259 #ifdef ANSI_PROTOTYPES
 260   va_start (args, format);
 261 #else
 262   char *format;
 263
 264   va_start (args);
 265   format = va_arg (args, char *);
 266 #endif
 267
 268   vfprintf_filtered (gdb_stdout, format, args);
 269
 270   va_end (args);
 271 }
 272
 273 /* GDB version of error vprintf_filtered.  */
 274
 275 /* VARARGS */
 276 static void
 277 #ifdef ANSI_PROTOTYPES
 278 gdb_os_vprintf_filtered (host_callback *p, const char *format, va_list ap)
 279 #else
 280 gdb_os_vprintf_filtered (p, format, ap)
 281      host_callback *p;
 282      char *format;
 283      va_list ap;
 284 #endif
 285 {
 286   vfprintf_filtered (gdb_stdout, format, ap);
 287 }
 288
 289 /* GDB version of error evprintf_filtered.  */
 290
 291 /* VARARGS */
 292 static void
 293 #ifdef ANSI_PROTOTYPES
 294 gdb_os_evprintf_filtered (host_callback *p, const char *format, va_list ap)
 295 #else
 296 gdb_os_evprintf_filtered (p, format, ap)
 297      host_callback *p;
 298      char *format;
 299      va_list ap;
 300 #endif
 301 {
 302   vfprintf_filtered (gdb_stderr, format, ap);
 303 }
 304
 305 /* GDB version of error callback.  */
 306
 307 /* VARARGS */
 308 static void
 309 #ifdef ANSI_PROTOTYPES
 310 gdb_os_error (host_callback *p, const char *format, ...)
 311 #else
 312 gdb_os_error (p, va_alist)
 313      host_callback *p;
 314      va_dcl
 315 #endif
 316 {
 317   if (error_hook)
 318     (*error_hook) ();
 319   else
 320     {
 321       va_list args;
 322 #ifdef ANSI_PROTOTYPES
 323       va_start (args, format);
 324 #else
 325       char *format;
 326
 327       va_start (args);
 328       format = va_arg (args, char *);
 329 #endif
 330
 331       error_begin ();
 332       vfprintf_filtered (gdb_stderr, format, args);
 333       fprintf_filtered (gdb_stderr, "\n");
 334       va_end (args);
 335       return_to_top_level (RETURN_ERROR);
 336     }
 337 }
 338
 339 static void
 340 gdbsim_fetch_register (regno)
 341 int regno;
 342 {
 343   if (regno == -1)
 344     {
 345       for (regno = 0; regno < NUM_REGS; regno++)
 346         gdbsim_fetch_register (regno);
 347     }
 348   else
 349     {
 350       char buf[MAX_REGISTER_RAW_SIZE];
 351
 352       sim_fetch_register (gdbsim_desc, regno, buf);
 353       supply_register (regno, buf);
 354       if (sr_get_debug ())
 355         {
 356           printf_filtered ("gdbsim_fetch_register: %d", regno);
 357           /* FIXME: We could print something more intelligible.  */
 358           dump_mem (buf, REGISTER_RAW_SIZE (regno));
 359         }
 360     }
 361 }
 362
 363
 364 static void
 365 gdbsim_store_register (regno)
 366 int regno;
 367 {
 368   if (regno  == -1)
 369     {
 370       for (regno = 0; regno < NUM_REGS; regno++)
 371         gdbsim_store_register (regno);
 372     }
 373   else
 374     {
 375       /* FIXME: Until read_register() returns LONGEST, we have this.  */
 376       char tmp[MAX_REGISTER_RAW_SIZE];
 377       read_register_gen (regno, tmp);
 378       sim_store_register (gdbsim_desc, regno, tmp);
 379       if (sr_get_debug ())
 380         {
 381           printf_filtered ("gdbsim_store_register: %d", regno);
 382           /* FIXME: We could print something more intelligible.  */
 383           dump_mem (tmp, REGISTER_RAW_SIZE (regno));
 384         }
 385     }
 386 }
 387
 388 /* Kill the running program.  This may involve closing any open files
 389    and releasing other resources acquired by the simulated program.  */
 390
 391 static void
 392 gdbsim_kill ()
 393 {
 394   if (sr_get_debug ())
 395     printf_filtered ("gdbsim_kill\n");
 396
 397   sim_kill (gdbsim_desc);       /* close fd's, remove mappings, etc. */
 398   inferior_pid = 0;
 399 }
 400
 401 /* Load an executable file into the target process.  This is expected to
 402    not only bring new code into the target process, but also to update
 403    GDB's symbol tables to match.  */
 404
 405 static void
 406 gdbsim_load (prog, fromtty)
 407      char *prog;
 408      int fromtty;
 409 {
 410   if (sr_get_debug ())
 411     printf_filtered ("gdbsim_load: prog \"%s\"\n", prog);
 412
 413   inferior_pid = 0;
 414
 415   /* FIXME: We will print two messages on error.
 416      Need error to either not print anything if passed NULL or need
 417      another routine that doesn't take any arguments.  */
 418   if (sim_load (gdbsim_desc, prog, NULL, fromtty) == SIM_RC_FAIL)
 419     error ("unable to load program");
 420
 421   program_loaded = 1;
 422 }
 423
 424
 425 /* Start an inferior process and set inferior_pid to its pid.
 426    EXEC_FILE is the file to run.
 427    ARGS is a string containing the arguments to the program.
 428    ENV is the environment vector to pass.  Errors reported with error().
 429    On VxWorks and various standalone systems, we ignore exec_file.  */
 430 /* This is called not only when we first attach, but also when the
 431    user types "run" after having attached.  */
 432
 433 static void
 434 gdbsim_create_inferior (exec_file, args, env)
 435      char *exec_file;
 436      char *args;
 437      char **env;
 438 {
 439   int len;
 440   char *arg_buf,**argv;
 441   CORE_ADDR entry_pt;
 442
 443   if (! program_loaded)
 444     error ("No program loaded.");
 445
 446   if (sr_get_debug ())
 447     printf_filtered ("gdbsim_create_inferior: exec_file \"%s\", args \"%s\"\n",
 448       exec_file, args);
 449
 450   if (exec_file == 0 || exec_bfd == 0)
 451    error ("No exec file specified.");
 452
 453   entry_pt = (CORE_ADDR) bfd_get_start_address (exec_bfd);
 454
 455   gdbsim_kill ();
 456   remove_breakpoints ();
 457   init_wait_for_inferior ();
 458
 459   len = strlen (exec_file) + 1 + strlen (args) + 1 + /*slop*/ 10;
 460   arg_buf = (char *) alloca (len);
 461   arg_buf[0] = '\0';
 462   strcat (arg_buf, exec_file);
 463   strcat (arg_buf, " ");
 464   strcat (arg_buf, args);
 465   argv = buildargv (arg_buf);
 466   make_cleanup (freeargv, (char *) argv);
 467   sim_create_inferior (gdbsim_desc, argv, env);
 468
 469   inferior_pid = 42;
 470   insert_breakpoints ();        /* Needed to get correct instruction in cache */
 471   proceed (entry_pt, TARGET_SIGNAL_DEFAULT, 0);
 472 }
 473
 474 /* The open routine takes the rest of the parameters from the command,
 475    and (if successful) pushes a new target onto the stack.
 476    Targets should supply this routine, if only to provide an error message.  */
 477 /* Called when selecting the simulator. EG: (gdb) target sim name.  */
 478
 479 static void
 480 gdbsim_open (args, from_tty)
 481      char *args;
 482      int from_tty;
 483 {
 484   int len;
 485   char *arg_buf;
 486   char **argv;
 487
 488   if (sr_get_debug ())
 489     printf_filtered ("gdbsim_open: args \"%s\"\n", args ? args : "(null)");
 490
 491   /* Remove current simulator if one exists.  Only do this if the simulator
 492      has been opened because sim_close requires it.
 493      This is important because the call to push_target below will cause
 494      sim_close to be called if the simulator is already open, but push_target
 495      is called after sim_open!  We can't move the call to push_target before
 496      the call to sim_open because sim_open may invoke `error'.  */
 497   if (gdbsim_desc != NULL)
 498     unpush_target (&gdbsim_ops);
 499
 500   init_callbacks ();
 501
 502   len = 7 + 1 + (args ? strlen (args) : 0) + 50;
 503   arg_buf = (char *) alloca (len);
 504   sprintf (arg_buf, "gdbsim%s%s",
 505            args ? " " : "", args ? args : "");
 506 #ifdef TARGET_BYTE_ORDER_SELECTABLE
 507   if (TARGET_BYTE_ORDER == BIG_ENDIAN)
 508     strcat (arg_buf, " -E big");
 509   else
 510     strcat (arg_buf, " -E little");
 511 #endif
 512   argv = buildargv (arg_buf);
 513   if (argv == NULL)
 514     error ("Insufficient memory available to allocate simulator arg list.");
 515   make_cleanup (freeargv, (char *) argv);
 516
 517   gdbsim_desc = sim_open (SIM_OPEN_DEBUG, argv);
 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   /* The user may give a command before the simulator is opened, so
 783      ensure that the callbacks have been set up.  */
 784   init_callbacks ();
 785
 786   /* Note that if the simulator hasn't been opened, gdbsim_desc == NULL
 787      which is correct (??? assuming of course one wishes to continue to
 788      allow commands to be sent to unopened simulators, which isn't entirely
 789      unreasonable).  Simulators should be prepared to deal with any
 790      combination of NULL or empty args. */
 791   sim_do_command (gdbsim_desc, args);
 792 }
 793
 794 /* Define the target subroutine names */
 795
 796 struct target_ops gdbsim_ops = {
 797   "sim",                        /* to_shortname */
 798   "simulator",                  /* to_longname */
 799   "Use the compiled-in simulator.",  /* to_doc */
 800   gdbsim_open,                  /* to_open */
 801   gdbsim_close,                 /* to_close */
 802   NULL,                         /* to_attach */
 803   gdbsim_detach,                /* to_detach */
 804   gdbsim_resume,                /* to_resume */
 805   gdbsim_wait,                  /* to_wait */
 806   gdbsim_fetch_register,        /* to_fetch_registers */
 807   gdbsim_store_register,        /* to_store_registers */
 808   gdbsim_prepare_to_store,      /* to_prepare_to_store */
 809   gdbsim_xfer_inferior_memory,  /* to_xfer_memory */
 810   gdbsim_files_info,            /* to_files_info */
 811   memory_insert_breakpoint,     /* to_insert_breakpoint */
 812   memory_remove_breakpoint,     /* to_remove_breakpoint */
 813   NULL,                         /* to_terminal_init */
 814   NULL,                         /* to_terminal_inferior */
 815   NULL,                         /* to_terminal_ours_for_output */
 816   NULL,                         /* to_terminal_ours */
 817   NULL,                         /* to_terminal_info */
 818   gdbsim_kill,                  /* to_kill */
 819   gdbsim_load,                  /* to_load */
 820   NULL,                         /* to_lookup_symbol */
 821   gdbsim_create_inferior,       /* to_create_inferior */
 822   gdbsim_mourn_inferior,        /* to_mourn_inferior */
 823   0,                            /* to_can_run */
 824   0,                            /* to_notice_signals */
 825   0,                            /* to_thread_alive */
 826   gdbsim_stop,                  /* to_stop */
 827   process_stratum,              /* to_stratum */
 828   NULL,                         /* to_next */
 829   1,                            /* to_has_all_memory */
 830   1,                            /* to_has_memory */
 831   1,                            /* to_has_stack */
 832   1,                            /* to_has_registers */
 833   1,                            /* to_has_execution */
 834   NULL,                         /* sections */
 835   NULL,                         /* sections_end */
 836   OPS_MAGIC,                    /* to_magic */
 837 };
 838
 839 void
 840 _initialize_remote_sim ()
 841 {
 842   add_target (&gdbsim_ops);
 843
 844   add_com ("sim <command>", class_obscure, simulator_command,
 845            "Send a command to the simulator.");
 846 }