gdb/remote-sim.c

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