gdb/remote-sim.c

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