gdb/remote-sim.c

   1 /* Generic remote debugging interface for simulators.
   2    Copyright 1993, 1994, 1996 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_printf_filtered PARAMS ((host_callback *, const char *, ...));
  50
  51 static void gdb_os_error PARAMS ((host_callback *, const char *, ...));
  52
  53 static void gdbsim_fetch_register PARAMS ((int regno));
  54
  55 static void gdbsim_store_register PARAMS ((int regno));
  56
  57 static void gdbsim_kill PARAMS ((void));
  58
  59 static void gdbsim_load PARAMS ((char *prog, int fromtty));
  60
  61 static void gdbsim_create_inferior PARAMS ((char *exec_file, char *args, char **env));
  62
  63 static void gdbsim_open PARAMS ((char *args, int from_tty));
  64
  65 static void gdbsim_close PARAMS ((int quitting));
  66
  67 static void gdbsim_detach PARAMS ((char *args, int from_tty));
  68
  69 static void gdbsim_resume PARAMS ((int pid, int step, enum target_signal siggnal));
  70
  71 static int gdbsim_wait PARAMS ((int pid, struct target_waitstatus *status));
  72
  73 static void gdbsim_prepare_to_store PARAMS ((void));
  74
  75 static int gdbsim_xfer_inferior_memory PARAMS ((CORE_ADDR memaddr,
  76                                                 char *myaddr, int len,
  77                                                 int write,
  78                                                 struct target_ops *target));
  79
  80 static void gdbsim_files_info PARAMS ((struct target_ops *target));
  81
  82 static void gdbsim_mourn_inferior PARAMS ((void));
  83
  84 static void simulator_command PARAMS ((char *args, int from_tty));
  85
  86 /* Naming convention:
  87
  88    sim_* are the interface to the simulator (see remote-sim.h).
  89    gdbsim_* are stuff which is internal to gdb.  */
  90
  91 /* Forward data declarations */
  92 extern struct target_ops gdbsim_ops;
  93
  94 static int program_loaded = 0;
  95
  96 /* We must keep track of whether the simulator has been opened or not because
  97    GDB can call a target's close routine twice, but sim_close doesn't allow
  98    this.  */
  99 static int gdbsim_open_p = 0;
 100
 101 static void
 102 dump_mem (buf, len)
 103      char *buf;
 104      int len;
 105 {
 106   if (len <= 8)
 107     {
 108       if (len == 8 || len == 4)
 109         {
 110           long l[2];
 111           memcpy (l, buf, len);
 112           printf_filtered ("\t0x%x", l[0]);
 113           printf_filtered (len == 8 ? " 0x%x\n" : "\n", l[1]);
 114         }
 115       else
 116         {
 117           int i;
 118           printf_filtered ("\t");
 119           for (i = 0; i < len; i++)
 120             printf_filtered ("0x%x ", buf[i]);
 121           printf_filtered ("\n");
 122         }
 123     }
 124 }
 125
 126 static host_callback gdb_callback;
 127 static int callbacks_initialized = 0;
 128
 129 /* Initialize gdb_callback.  */
 130
 131 static void
 132 init_callbacks ()
 133 {
 134   if (! callbacks_initialized)
 135     {
 136       gdb_callback = default_callback;
 137       gdb_callback.init (&gdb_callback);
 138       gdb_callback.write_stdout = gdb_os_write_stdout;
 139       gdb_callback.printf_filtered = gdb_os_printf_filtered;
 140       /* ??? where'd error come from? */
 141       /*gdb_callback.error = gdb_os_error;*/
 142       gdb_callback.last_errno= gdb_os_error;
 143       sim_set_callbacks (&gdb_callback);
 144       callbacks_initialized = 1;
 145     }
 146 }
 147
 148 /* Release callbacks (free resources used by them).  */
 149
 150 static void
 151 end_callbacks ()
 152 {
 153   if (callbacks_initialized)
 154     {
 155       gdb_callback.shutdown (&gdb_callback);
 156       callbacks_initialized = 0;
 157     }
 158 }
 159
 160 /* GDB version of os_write_stdout callback.  */
 161
 162 static int
 163 gdb_os_write_stdout (p, buf, len)
 164      host_callback *p;
 165      const char *buf;
 166      int len;
 167 {
 168   int i;
 169   char b[2];
 170
 171   for (i = 0; i < len; i++)
 172     {
 173       b[0] = buf[i];
 174       b[1] = 0;
 175       if (target_output_hook)
 176         target_output_hook (b);
 177       else
 178         fputs_filtered (b, gdb_stdout);
 179     }
 180   return len;
 181 }
 182
 183 /* GDB version of printf_filtered callback.  */
 184
 185 /* VARARGS */
 186 static void
 187 #ifdef ANSI_PROTOTYPES
 188 gdb_os_printf_filtered (host_callback *p, const char *format, ...)
 189 #else
 190 gdb_os_printf_filtered (p, va_alist)
 191      host_callback *p;
 192      va_dcl
 193 #endif
 194 {
 195   va_list args;
 196 #ifdef ANSI_PROTOTYPES
 197   va_start (args, format);
 198 #else
 199   char *format;
 200
 201   va_start (args);
 202   format = va_arg (args, char *);
 203 #endif
 204
 205   vfprintf_filtered (gdb_stdout, format, args);
 206
 207   va_end (args);
 208 }
 209
 210 /* GDB version of error callback.  */
 211
 212 /* VARARGS */
 213 static void
 214 #ifdef ANSI_PROTOTYPES
 215 gdb_os_error (host_callback *p, const char *format, ...)
 216 #else
 217 gdb_os_error (p, va_alist)
 218      host_callback *p;
 219      va_dcl
 220 #endif
 221 {
 222   if (error_hook)
 223     (*error_hook) ();
 224   else
 225     {
 226       va_list args;
 227 #ifdef ANSI_PROTOTYPES
 228       va_start (args, format);
 229 #else
 230       char *format;
 231
 232       va_start (args);
 233       format = va_arg (args, char *);
 234 #endif
 235
 236       error_begin ();
 237       vfprintf_filtered (gdb_stderr, format, args);
 238       fprintf_filtered (gdb_stderr, "\n");
 239       va_end (args);
 240       return_to_top_level (RETURN_ERROR);
 241     }
 242 }
 243
 244 static void
 245 gdbsim_fetch_register (regno)
 246 int regno;
 247 {
 248   if (regno == -1)
 249     {
 250       for (regno = 0; regno < NUM_REGS; regno++)
 251         gdbsim_fetch_register (regno);
 252     }
 253   else
 254     {
 255       char buf[MAX_REGISTER_RAW_SIZE];
 256
 257       sim_fetch_register (regno, buf);
 258       supply_register (regno, buf);
 259       if (sr_get_debug ())
 260         {
 261           printf_filtered ("gdbsim_fetch_register: %d", regno);
 262           /* FIXME: We could print something more intelligible.  */
 263           dump_mem (buf, REGISTER_RAW_SIZE (regno));
 264         }
 265     }
 266 }
 267
 268
 269 static void
 270 gdbsim_store_register (regno)
 271 int regno;
 272 {
 273   if (regno  == -1)
 274     {
 275       for (regno = 0; regno < NUM_REGS; regno++)
 276         gdbsim_store_register (regno);
 277     }
 278   else
 279     {
 280       /* FIXME: Until read_register() returns LONGEST, we have this.  */
 281       char tmp[MAX_REGISTER_RAW_SIZE];
 282       read_register_gen (regno, tmp);
 283       sim_store_register (regno, tmp);
 284       if (sr_get_debug ())
 285         {
 286           printf_filtered ("gdbsim_store_register: %d", regno);
 287           /* FIXME: We could print something more intelligible.  */
 288           dump_mem (tmp, REGISTER_RAW_SIZE (regno));
 289         }
 290     }
 291 }
 292
 293 /* Kill the running program.  This may involve closing any open files
 294    and releasing other resources acquired by the simulated program.  */
 295
 296 static void
 297 gdbsim_kill ()
 298 {
 299   if (sr_get_debug ())
 300     printf_filtered ("gdbsim_kill\n");
 301
 302   sim_kill ();  /* close fd's, remove mappings */
 303   inferior_pid = 0;
 304 }
 305
 306 /* Load an executable file into the target process.  This is expected to
 307    not only bring new code into the target process, but also to update
 308    GDB's symbol tables to match.  */
 309
 310 static void
 311 gdbsim_load (prog, fromtty)
 312      char *prog;
 313      int fromtty;
 314 {
 315   if (sr_get_debug ())
 316     printf_filtered ("gdbsim_load: prog \"%s\"\n", prog);
 317
 318   inferior_pid = 0;
 319
 320   /* This must be done before calling gr_load_image.  */
 321   program_loaded = 1;
 322
 323   if (sim_load (prog, fromtty) != 0)
 324     generic_load (prog, fromtty);
 325 }
 326
 327
 328 /* Start an inferior process and set inferior_pid to its pid.
 329    EXEC_FILE is the file to run.
 330    ARGS is a string containing the arguments to the program.
 331    ENV is the environment vector to pass.  Errors reported with error().
 332    On VxWorks and various standalone systems, we ignore exec_file.  */
 333 /* This is called not only when we first attach, but also when the
 334    user types "run" after having attached.  */
 335
 336 static void
 337 gdbsim_create_inferior (exec_file, args, env)
 338      char *exec_file;
 339      char *args;
 340      char **env;
 341 {
 342   int len;
 343   char *arg_buf,**argv;
 344   CORE_ADDR entry_pt;
 345
 346   if (! program_loaded)
 347     error ("No program loaded.");
 348
 349   if (sr_get_debug ())
 350     printf_filtered ("gdbsim_create_inferior: exec_file \"%s\", args \"%s\"\n",
 351       exec_file, args);
 352
 353   if (exec_file == 0 || exec_bfd == 0)
 354    error ("No exec file specified.");
 355
 356   entry_pt = (CORE_ADDR) bfd_get_start_address (exec_bfd);
 357
 358   gdbsim_kill ();
 359   remove_breakpoints ();
 360   init_wait_for_inferior ();
 361
 362   len = strlen (exec_file) + 1 + strlen (args) + 1 + /*slop*/ 10;
 363   arg_buf = (char *) alloca (len);
 364   arg_buf[0] = '\0';
 365   strcat (arg_buf, exec_file);
 366   strcat (arg_buf, " ");
 367   strcat (arg_buf, args);
 368   argv = buildargv (arg_buf);
 369   make_cleanup (freeargv, (char *) argv);
 370   sim_create_inferior (entry_pt, argv, env);
 371
 372   inferior_pid = 42;
 373   insert_breakpoints ();        /* Needed to get correct instruction in cache */
 374   proceed (entry_pt, TARGET_SIGNAL_DEFAULT, 0);
 375 }
 376
 377 /* The open routine takes the rest of the parameters from the command,
 378    and (if successful) pushes a new target onto the stack.
 379    Targets should supply this routine, if only to provide an error message.  */
 380 /* Called when selecting the simulator. EG: (gdb) target sim name.  */
 381
 382 static void
 383 gdbsim_open (args, from_tty)
 384      char *args;
 385      int from_tty;
 386 {
 387   if (sr_get_debug ())
 388     printf_filtered ("gdbsim_open: args \"%s\"\n", args ? args : "(null)");
 389
 390   /* Remove current simulator if one exists.  Only do this if the simulator
 391      has been opened because sim_close requires it.
 392      This is important because the call to push_target below will cause
 393      sim_close to be called if the simulator is already open, but push_target
 394      is called after sim_open!  We can't move the call to push_target before
 395      the call to sim_open because sim_open may invoke `error'.  */
 396   if (gdbsim_open_p)
 397     unpush_target (&gdbsim_ops);
 398
 399   init_callbacks ();
 400
 401   sim_open (args);
 402   gdbsim_open_p = 1;
 403
 404   push_target (&gdbsim_ops);
 405   target_fetch_registers (-1);
 406   printf_filtered ("Connected to the simulator.\n");
 407 }
 408
 409 /* Does whatever cleanup is required for a target that we are no longer
 410    going to be calling.  Argument says whether we are quitting gdb and
 411    should not get hung in case of errors, or whether we want a clean
 412    termination even if it takes a while.  This routine is automatically
 413    always called just before a routine is popped off the target stack.
 414    Closing file descriptors and freeing memory are typical things it should
 415    do.  */
 416 /* Close out all files and local state before this target loses control. */
 417
 418 static void
 419 gdbsim_close (quitting)
 420      int quitting;
 421 {
 422   if (sr_get_debug ())
 423     printf_filtered ("gdbsim_close: quitting %d\n", quitting);
 424
 425   program_loaded = 0;
 426
 427   if (gdbsim_open_p)
 428     {
 429       sim_close (quitting);
 430       gdbsim_open_p = 0;
 431     }
 432
 433   end_callbacks ();
 434 }
 435
 436 /* Takes a program previously attached to and detaches it.
 437    The program may resume execution (some targets do, some don't) and will
 438    no longer stop on signals, etc.  We better not have left any breakpoints
 439    in the program or it'll die when it hits one.  ARGS is arguments
 440    typed by the user (e.g. a signal to send the process).  FROM_TTY
 441    says whether to be verbose or not.  */
 442 /* Terminate the open connection to the remote debugger.
 443    Use this when you want to detach and do something else with your gdb.  */
 444
 445 static void
 446 gdbsim_detach (args,from_tty)
 447      char *args;
 448      int from_tty;
 449 {
 450   if (sr_get_debug ())
 451     printf_filtered ("gdbsim_detach: args \"%s\"\n", args);
 452
 453   pop_target ();                /* calls gdbsim_close to do the real work */
 454   if (from_tty)
 455     printf_filtered ("Ending simulator %s debugging\n", target_shortname);
 456 }
 457
 458 /* Resume execution of the target process.  STEP says whether to single-step
 459    or to run free; SIGGNAL is the signal value (e.g. SIGINT) to be given
 460    to the target, or zero for no signal.  */
 461
 462 static void
 463 gdbsim_resume (pid, step, siggnal)
 464      int pid, step;
 465      enum target_signal siggnal;
 466 {
 467   if (inferior_pid != 42)
 468     error ("The program is not being run.");
 469
 470   if (sr_get_debug ())
 471     printf_filtered ("gdbsim_resume: step %d, signal %d\n", step, siggnal);
 472
 473   sim_resume (step, target_signal_to_host (siggnal));
 474 }
 475
 476 /* Wait for inferior process to do something.  Return pid of child,
 477    or -1 in case of error; store status through argument pointer STATUS,
 478    just as `wait' would.  */
 479
 480 static int
 481 gdbsim_wait (pid, status)
 482      int pid;
 483      struct target_waitstatus *status;
 484 {
 485   int sigrc;
 486   enum sim_stop reason;
 487
 488   if (sr_get_debug ())
 489     printf_filtered ("gdbsim_wait\n");
 490
 491   sim_stop_reason (&reason, &sigrc);
 492   switch (reason)
 493     {
 494     case sim_exited:
 495       status->kind = TARGET_WAITKIND_EXITED;
 496       status->value.integer = sigrc;
 497       break;
 498     case sim_stopped:
 499       status->kind = TARGET_WAITKIND_STOPPED;
 500       /* The signal in sigrc is a host signal.  That probably
 501          should be fixed.  */
 502       status->value.sig = target_signal_from_host (sigrc);
 503       break;
 504     case sim_signalled:
 505       status->kind = TARGET_WAITKIND_SIGNALLED;
 506       /* The signal in sigrc is a host signal.  That probably
 507          should be fixed.  */
 508       status->value.sig = target_signal_from_host (sigrc);
 509       break;
 510     }
 511
 512   return inferior_pid;
 513 }
 514
 515 /* Get ready to modify the registers array.  On machines which store
 516    individual registers, this doesn't need to do anything.  On machines
 517    which store all the registers in one fell swoop, this makes sure
 518    that registers contains all the registers from the program being
 519    debugged.  */
 520
 521 static void
 522 gdbsim_prepare_to_store ()
 523 {
 524   /* Do nothing, since we can store individual regs */
 525 }
 526
 527 static int
 528 gdbsim_xfer_inferior_memory (memaddr, myaddr, len, write, target)
 529      CORE_ADDR memaddr;
 530      char *myaddr;
 531      int len;
 532      int write;
 533      struct target_ops *target;                 /* ignored */
 534 {
 535   if (! program_loaded)
 536     error ("No program loaded.");
 537
 538   if (sr_get_debug ())
 539     {
 540       printf_filtered ("gdbsim_xfer_inferior_memory: myaddr 0x%x, memaddr 0x%x, len %d, write %d\n",
 541                        myaddr, memaddr, len, write);
 542       if (sr_get_debug () && write)
 543         dump_mem(myaddr, len);
 544     }
 545
 546   if (write)
 547     {
 548       len = sim_write (memaddr, myaddr, len);
 549     }
 550   else
 551     {
 552       len = sim_read (memaddr, myaddr, len);
 553       if (sr_get_debug () && len > 0)
 554         dump_mem(myaddr, len);
 555     }
 556   return len;
 557 }
 558
 559 static void
 560 gdbsim_files_info (target)
 561      struct target_ops *target;
 562 {
 563   char *file = "nothing";
 564
 565   if (exec_bfd)
 566     file = bfd_get_filename (exec_bfd);
 567
 568   if (sr_get_debug ())
 569     printf_filtered ("gdbsim_files_info: file \"%s\"\n", file);
 570
 571   if (exec_bfd)
 572     {
 573       printf_filtered ("\tAttached to %s running program %s\n",
 574                        target_shortname, file);
 575       sim_info (0);
 576     }
 577 }
 578
 579 /* Clear the simulator's notion of what the break points are.  */
 580
 581 static void
 582 gdbsim_mourn_inferior ()
 583 {
 584   if (sr_get_debug ())
 585     printf_filtered ("gdbsim_mourn_inferior:\n");
 586
 587   remove_breakpoints ();
 588   generic_mourn_inferior ();
 589 }
 590
 591 /* Pass the command argument through to the simulator verbatim.  The
 592    simulator must do any command interpretation work.  */
 593
 594 static void
 595 simulator_command (args, from_tty)
 596      char *args;
 597      int from_tty;
 598 {
 599   /* The user may give a command before the simulator is opened, so
 600      ensure that the callbacks have been set up.  */
 601   init_callbacks ();
 602
 603   sim_do_command (args);
 604 }
 605
 606 /* Define the target subroutine names */
 607
 608 struct target_ops gdbsim_ops = {
 609   "sim",                        /* to_shortname */
 610   "simulator",                  /* to_longname */
 611   "Use the compiled-in simulator.",  /* to_doc */
 612   gdbsim_open,                  /* to_open */
 613   gdbsim_close,                 /* to_close */
 614   NULL,                         /* to_attach */
 615   gdbsim_detach,                /* to_detach */
 616   gdbsim_resume,                /* to_resume */
 617   gdbsim_wait,                  /* to_wait */
 618   gdbsim_fetch_register,        /* to_fetch_registers */
 619   gdbsim_store_register,        /* to_store_registers */
 620   gdbsim_prepare_to_store,      /* to_prepare_to_store */
 621   gdbsim_xfer_inferior_memory,  /* to_xfer_memory */
 622   gdbsim_files_info,            /* to_files_info */
 623   memory_insert_breakpoint,     /* to_insert_breakpoint */
 624   memory_remove_breakpoint,     /* to_remove_breakpoint */
 625   NULL,                         /* to_terminal_init */
 626   NULL,                         /* to_terminal_inferior */
 627   NULL,                         /* to_terminal_ours_for_output */
 628   NULL,                         /* to_terminal_ours */
 629   NULL,                         /* to_terminal_info */
 630   gdbsim_kill,                  /* to_kill */
 631   gdbsim_load,                  /* to_load */
 632   NULL,                         /* to_lookup_symbol */
 633   gdbsim_create_inferior,       /* to_create_inferior */
 634   gdbsim_mourn_inferior,        /* to_mourn_inferior */
 635   0,                            /* to_can_run */
 636   0,                            /* to_notice_signals */
 637   0,                            /* to_thread_alive */
 638   0,                            /* to_stop */
 639   process_stratum,              /* to_stratum */
 640   NULL,                         /* to_next */
 641   1,                            /* to_has_all_memory */
 642   1,                            /* to_has_memory */
 643   1,                            /* to_has_stack */
 644   1,                            /* to_has_registers */
 645   1,                            /* to_has_execution */
 646   NULL,                         /* sections */
 647   NULL,                         /* sections_end */
 648   OPS_MAGIC,                    /* to_magic */
 649 };
 650
 651 void
 652 _initialize_remote_sim ()
 653 {
 654   add_target (&gdbsim_ops);
 655
 656   add_com ("sim <command>", class_obscure, simulator_command,
 657            "Send a command to the simulator.");
 658 }