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