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