gdb/remote-sim.c

   1 /* Generic remote debugging interface for simulators.
   2    Copyright 1993, 1994 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 "remote-sim.h"
  36 #include "remote-utils.h"
  37 #include "callback.h"
  38
  39 /* Naming convention:
  40
  41    sim_* are the interface to the simulator (see remote-sim.h).
  42    sim_callback_* are the stuff which the simulator can see inside GDB.
  43    gdbsim_* are stuff which is internal to gdb.  */
  44
  45 /* Forward data declarations */
  46 extern struct target_ops gdbsim_ops;
  47
  48 static int program_loaded = 0;
  49
  50 static void
  51 dump_mem (buf, len)
  52      char *buf;
  53      int len;
  54 {
  55   if (len <= 8)
  56     {
  57       if (len == 8 || len == 4)
  58         {
  59           long l[2];
  60           memcpy (l, buf, len);
  61           printf_filtered ("\t0x%x", l[0]);
  62           printf_filtered (len == 8 ? " 0x%x\n" : "\n", l[1]);
  63         }
  64       else
  65         {
  66           int i;
  67           printf_filtered ("\t");
  68           for (i = 0; i < len; i++)
  69             printf_filtered ("0x%x ", buf[i]);
  70           printf_filtered ("\n");
  71         }
  72     }
  73 }
  74
  75 static void
  76 gdbsim_fetch_register (regno)
  77 int regno;
  78 {
  79   if (regno == -1)
  80     {
  81       for (regno = 0; regno < NUM_REGS; regno++)
  82         gdbsim_fetch_register (regno);
  83     }
  84   else
  85     {
  86       char buf[MAX_REGISTER_RAW_SIZE];
  87
  88       sim_fetch_register (regno, buf);
  89       supply_register (regno, buf);
  90       if (sr_get_debug ())
  91         {
  92           printf_filtered ("gdbsim_fetch_register: %d", regno);
  93           /* FIXME: We could print something more intelligible.  */
  94           dump_mem (buf, REGISTER_RAW_SIZE (regno));
  95         }
  96     }
  97 }
  98
  99
 100 static void
 101 gdbsim_store_register (regno)
 102 int regno;
 103 {
 104   if (regno  == -1)
 105     {
 106       for (regno = 0; regno < NUM_REGS; regno++)
 107         gdbsim_store_register (regno);
 108     }
 109   else
 110     {
 111       /* FIXME: Until read_register() returns LONGEST, we have this.  */
 112       char tmp[MAX_REGISTER_RAW_SIZE];
 113       read_register_gen (regno, tmp);
 114       sim_store_register (regno, tmp);
 115       if (sr_get_debug ())
 116         {
 117           printf_filtered ("gdbsim_store_register: %d", regno);
 118           /* FIXME: We could print something more intelligible.  */
 119           dump_mem (tmp, REGISTER_RAW_SIZE (regno));
 120         }
 121     }
 122 }
 123
 124 /* Kill the running program.  This may involve closing any open files
 125    and releasing other resources acquired by the simulated program.  */
 126
 127 static void
 128 gdbsim_kill ()
 129 {
 130   if (sr_get_debug ())
 131     printf_filtered ("gdbsim_kill\n");
 132
 133   sim_kill ();  /* close fd's, remove mappings */
 134   inferior_pid = 0;
 135 }
 136
 137 /* Load an executable file into the target process.  This is expected to
 138    not only bring new code into the target process, but also to update
 139    GDB's symbol tables to match.  */
 140
 141 static void
 142 gdbsim_load (prog, fromtty)
 143      char *prog;
 144      int fromtty;
 145 {
 146   if (sr_get_debug ())
 147     printf_filtered ("gdbsim_load: prog \"%s\"\n", prog);
 148
 149   inferior_pid = 0;
 150
 151   /* This must be done before calling gr_load_image.  */
 152   program_loaded = 1;
 153
 154   if (sim_load (prog, fromtty) != 0)
 155     generic_load (prog, fromtty);
 156 }
 157
 158
 159 /* Start an inferior process and set inferior_pid to its pid.
 160    EXEC_FILE is the file to run.
 161    ALLARGS is a string containing the arguments to the program.
 162    ENV is the environment vector to pass.  Errors reported with error().
 163    On VxWorks and various standalone systems, we ignore exec_file.  */
 164 /* This is called not only when we first attach, but also when the
 165    user types "run" after having attached.  */
 166
 167 static void
 168 gdbsim_create_inferior (exec_file, args, env)
 169      char *exec_file;
 170      char *args;
 171      char **env;
 172 {
 173   int len;
 174   char *arg_buf,**argv;
 175   CORE_ADDR entry_pt;
 176
 177   if (! program_loaded)
 178     error ("No program loaded.");
 179
 180   if (sr_get_debug ())
 181     printf_filtered ("gdbsim_create_inferior: exec_file \"%s\", args \"%s\"\n",
 182       exec_file, args);
 183
 184   if (exec_file == 0 || exec_bfd == 0)
 185    error ("No exec file specified.");
 186
 187   entry_pt = (CORE_ADDR) bfd_get_start_address (exec_bfd);
 188
 189   gdbsim_kill (NULL, NULL);
 190   remove_breakpoints ();
 191   init_wait_for_inferior ();
 192
 193   len = 5 + strlen (exec_file) + 1 + strlen (args) + 1 + /*slop*/ 10;
 194   arg_buf = (char *) alloca (len);
 195   arg_buf[0] = '\0';
 196   strcat (arg_buf, exec_file);
 197   strcat (arg_buf, " ");
 198   strcat (arg_buf, args);
 199   argv = buildargv (arg_buf);
 200   make_cleanup (freeargv, (char *) argv);
 201   sim_create_inferior (entry_pt, argv, env);
 202
 203   inferior_pid = 42;
 204   insert_breakpoints ();        /* Needed to get correct instruction in cache */
 205   proceed (entry_pt, TARGET_SIGNAL_DEFAULT, 0);
 206 }
 207
 208 /* The open routine takes the rest of the parameters from the command,
 209    and (if successful) pushes a new target onto the stack.
 210    Targets should supply this routine, if only to provide an error message.  */
 211 /* Called when selecting the simulator. EG: (gdb) target sim name.  */
 212
 213 static void
 214 gdbsim_open (args, from_tty)
 215      char *args;
 216      int from_tty;
 217 {
 218   if (sr_get_debug ())
 219     printf_filtered ("gdbsim_open: args \"%s\"\n", args ? args : "(null)");
 220
 221   sim_set_callbacks (&default_callback);
 222   default_callback.init (&default_callback);
 223
 224   sim_open (args);
 225
 226   push_target (&gdbsim_ops);
 227   target_fetch_registers (-1);
 228   printf_filtered ("Connected to the simulator.\n");
 229 }
 230
 231 /* Does whatever cleanup is required for a target that we are no longer
 232    going to be calling.  Argument says whether we are quitting gdb and
 233    should not get hung in case of errors, or whether we want a clean
 234    termination even if it takes a while.  This routine is automatically
 235    always called just before a routine is popped off the target stack.
 236    Closing file descriptors and freeing memory are typical things it should
 237    do.  */
 238 /* Close out all files and local state before this target loses control. */
 239
 240 static void
 241 gdbsim_close (quitting)
 242      int quitting;
 243 {
 244   if (sr_get_debug ())
 245     printf_filtered ("gdbsim_close: quitting %d\n", quitting);
 246
 247   program_loaded = 0;
 248
 249   sim_close (quitting);
 250 }
 251
 252 /* Takes a program previously attached to and detaches it.
 253    The program may resume execution (some targets do, some don't) and will
 254    no longer stop on signals, etc.  We better not have left any breakpoints
 255    in the program or it'll die when it hits one.  ARGS is arguments
 256    typed by the user (e.g. a signal to send the process).  FROM_TTY
 257    says whether to be verbose or not.  */
 258 /* Terminate the open connection to the remote debugger.
 259    Use this when you want to detach and do something else with your gdb.  */
 260
 261 static void
 262 gdbsim_detach (args,from_tty)
 263      char *args;
 264      int from_tty;
 265 {
 266   if (sr_get_debug ())
 267     printf_filtered ("gdbsim_detach: args \"%s\"\n", args);
 268
 269   pop_target ();                /* calls gdbsim_close to do the real work */
 270   if (from_tty)
 271     printf_filtered ("Ending simulator %s debugging\n", target_shortname);
 272 }
 273
 274 /* Resume execution of the target process.  STEP says whether to single-step
 275    or to run free; SIGGNAL is the signal value (e.g. SIGINT) to be given
 276    to the target, or zero for no signal.  */
 277
 278 static void
 279 gdbsim_resume (pid, step, siggnal)
 280      int pid, step;
 281      enum target_signal siggnal;
 282 {
 283   if (inferior_pid != 42)
 284     error ("The program is not being run.");
 285
 286   if (sr_get_debug ())
 287     printf_filtered ("gdbsim_resume: step %d, signal %d\n", step, siggnal);
 288
 289   sim_resume (step, target_signal_to_host (siggnal));
 290 }
 291
 292 /* Wait for inferior process to do something.  Return pid of child,
 293    or -1 in case of error; store status through argument pointer STATUS,
 294    just as `wait' would.  */
 295
 296 static int
 297 gdbsim_wait (pid, status)
 298      int pid;
 299      struct target_waitstatus *status;
 300 {
 301   int sigrc;
 302   enum sim_stop reason;
 303
 304   if (sr_get_debug ())
 305     printf_filtered ("gdbsim_wait\n");
 306
 307   sim_stop_reason (&reason, &sigrc);
 308   switch (reason)
 309     {
 310     case sim_exited:
 311       status->kind = TARGET_WAITKIND_EXITED;
 312       status->value.integer = sigrc;
 313       break;
 314     case sim_stopped:
 315       status->kind = TARGET_WAITKIND_STOPPED;
 316       /* The signal in sigrc is a host signal.  That probably
 317          should be fixed.  */
 318       status->value.sig = target_signal_from_host (sigrc);
 319       break;
 320     case sim_signalled:
 321       status->kind = TARGET_WAITKIND_SIGNALLED;
 322       /* The signal in sigrc is a host signal.  That probably
 323          should be fixed.  */
 324       status->value.sig = target_signal_from_host (sigrc);
 325       break;
 326     }
 327
 328   return inferior_pid;
 329 }
 330
 331 /* Get ready to modify the registers array.  On machines which store
 332    individual registers, this doesn't need to do anything.  On machines
 333    which store all the registers in one fell swoop, this makes sure
 334    that registers contains all the registers from the program being
 335    debugged.  */
 336
 337 static void
 338 gdbsim_prepare_to_store ()
 339 {
 340   /* Do nothing, since we can store individual regs */
 341 }
 342
 343 static int
 344 gdbsim_xfer_inferior_memory (memaddr, myaddr, len, write, target)
 345      CORE_ADDR memaddr;
 346      char *myaddr;
 347      int len;
 348      int write;
 349      struct target_ops *target;                 /* ignored */
 350 {
 351   if (! program_loaded)
 352     error ("No program loaded.");
 353
 354   if (sr_get_debug ())
 355     {
 356       printf_filtered ("gdbsim_xfer_inferior_memory: myaddr 0x%x, memaddr 0x%x, len %d, write %d\n",
 357                        myaddr, memaddr, len, write);
 358       if (sr_get_debug () && write)
 359         dump_mem(myaddr, len);
 360     }
 361
 362   if (write)
 363     {
 364       len = sim_write (memaddr, myaddr, len);
 365     }
 366   else
 367     {
 368       len = sim_read (memaddr, myaddr, len);
 369       if (sr_get_debug () && len > 0)
 370         dump_mem(myaddr, len);
 371     }
 372   return len;
 373 }
 374
 375 static void
 376 gdbsim_files_info (target)
 377      struct target_ops *target;
 378 {
 379   char *file = "nothing";
 380
 381   if (exec_bfd)
 382     file = bfd_get_filename (exec_bfd);
 383
 384   if (sr_get_debug ())
 385     printf_filtered ("gdbsim_files_info: file \"%s\"\n", file);
 386
 387   if (exec_bfd)
 388     {
 389       printf_filtered ("\tAttached to %s running program %s\n",
 390                        target_shortname, file);
 391       sim_info (0);
 392     }
 393 }
 394
 395 /* Clear the simulator's notion of what the break points are.  */
 396
 397 static void
 398 gdbsim_mourn_inferior ()
 399 {
 400   if (sr_get_debug ())
 401     printf_filtered ("gdbsim_mourn_inferior:\n");
 402
 403   remove_breakpoints ();
 404   generic_mourn_inferior ();
 405 }
 406
 407 /* Put a command string, in args, out to MONITOR.  Output from MONITOR
 408    is placed on the users terminal until the prompt is seen. FIXME: We
 409    read the characters ourseleves here cause of a nasty echo.  */
 410
 411 static void
 412 simulator_command (args, from_tty)
 413      char *args;
 414      int from_tty;
 415 {
 416   sim_do_command (args);
 417 }
 418
 419 /* Define the target subroutine names */
 420
 421 struct target_ops gdbsim_ops = {
 422   "sim",                        /* to_shortname */
 423   "simulator",                  /* to_longname */
 424   "Use the compiled-in simulator.",  /* to_doc */
 425   gdbsim_open,                  /* to_open */
 426   gdbsim_close,                 /* to_close */
 427   NULL,                         /* to_attach */
 428   gdbsim_detach,                /* to_detach */
 429   gdbsim_resume,                /* to_resume */
 430   gdbsim_wait,                  /* to_wait */
 431   gdbsim_fetch_register,        /* to_fetch_registers */
 432   gdbsim_store_register,        /* to_store_registers */
 433   gdbsim_prepare_to_store,      /* to_prepare_to_store */
 434   gdbsim_xfer_inferior_memory,  /* to_xfer_memory */
 435   gdbsim_files_info,            /* to_files_info */
 436   memory_insert_breakpoint,     /* to_insert_breakpoint */
 437   memory_remove_breakpoint,     /* to_remove_breakpoint */
 438   NULL,                         /* to_terminal_init */
 439   NULL,                         /* to_terminal_inferior */
 440   NULL,                         /* to_terminal_ours_for_output */
 441   NULL,                         /* to_terminal_ours */
 442   NULL,                         /* to_terminal_info */
 443   gdbsim_kill,                  /* to_kill */
 444   gdbsim_load,                  /* to_load */
 445   NULL,                         /* to_lookup_symbol */
 446   gdbsim_create_inferior,       /* to_create_inferior */
 447   gdbsim_mourn_inferior,        /* to_mourn_inferior */
 448   0,                            /* to_can_run */
 449   0,                            /* to_notice_signals */
 450   0,                            /* to_thread_alive */
 451   0,                            /* to_stop */
 452   process_stratum,              /* to_stratum */
 453   NULL,                         /* to_next */
 454   1,                            /* to_has_all_memory */
 455   1,                            /* to_has_memory */
 456   1,                            /* to_has_stack */
 457   1,                            /* to_has_registers */
 458   1,                            /* to_has_execution */
 459   NULL,                         /* sections */
 460   NULL,                         /* sections_end */
 461   OPS_MAGIC,                    /* to_magic */
 462 };
 463
 464 void
 465 _initialize_remote_sim ()
 466 {
 467   add_target (&gdbsim_ops);
 468
 469   add_com ("sim <command>", class_obscure, simulator_command,
 470            "Send a command to the simulator.");
 471 }