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   sim_open (args);
 221
 222   sim_set_callbacks (&default_callback);
 223   default_callback.init (&default_callback);
 224
 225   push_target (&gdbsim_ops);
 226   target_fetch_registers (-1);
 227   printf_filtered ("Connected to the simulator.\n");
 228 }
 229
 230 /* Does whatever cleanup is required for a target that we are no longer
 231    going to be calling.  Argument says whether we are quitting gdb and
 232    should not get hung in case of errors, or whether we want a clean
 233    termination even if it takes a while.  This routine is automatically
 234    always called just before a routine is popped off the target stack.
 235    Closing file descriptors and freeing memory are typical things it should
 236    do.  */
 237 /* Close out all files and local state before this target loses control. */
 238
 239 static void
 240 gdbsim_close (quitting)
 241      int quitting;
 242 {
 243   if (sr_get_debug ())
 244     printf_filtered ("gdbsim_close: quitting %d\n", quitting);
 245
 246   program_loaded = 0;
 247
 248   sim_close (quitting);
 249 }
 250
 251 /* Takes a program previously attached to and detaches it.
 252    The program may resume execution (some targets do, some don't) and will
 253    no longer stop on signals, etc.  We better not have left any breakpoints
 254    in the program or it'll die when it hits one.  ARGS is arguments
 255    typed by the user (e.g. a signal to send the process).  FROM_TTY
 256    says whether to be verbose or not.  */
 257 /* Terminate the open connection to the remote debugger.
 258    Use this when you want to detach and do something else with your gdb.  */
 259
 260 static void
 261 gdbsim_detach (args,from_tty)
 262      char *args;
 263      int from_tty;
 264 {
 265   if (sr_get_debug ())
 266     printf_filtered ("gdbsim_detach: args \"%s\"\n", args);
 267
 268   pop_target ();                /* calls gdbsim_close to do the real work */
 269   if (from_tty)
 270     printf_filtered ("Ending simulator %s debugging\n", target_shortname);
 271 }
 272
 273 /* Resume execution of the target process.  STEP says whether to single-step
 274    or to run free; SIGGNAL is the signal value (e.g. SIGINT) to be given
 275    to the target, or zero for no signal.  */
 276
 277 static void
 278 gdbsim_resume (pid, step, siggnal)
 279      int pid, step;
 280      enum target_signal siggnal;
 281 {
 282   if (sr_get_debug ())
 283     printf_filtered ("gdbsim_resume: step %d, signal %d\n", step, siggnal);
 284
 285   sim_resume (step, target_signal_to_host (siggnal));
 286 }
 287
 288 /* Wait for inferior process to do something.  Return pid of child,
 289    or -1 in case of error; store status through argument pointer STATUS,
 290    just as `wait' would.  */
 291
 292 static int
 293 gdbsim_wait (pid, status)
 294      int pid;
 295      struct target_waitstatus *status;
 296 {
 297   int sigrc;
 298   enum sim_stop reason;
 299
 300   if (sr_get_debug ())
 301     printf_filtered ("gdbsim_wait\n");
 302
 303   sim_stop_reason (&reason, &sigrc);
 304   switch (reason)
 305     {
 306     case sim_exited:
 307       status->kind = TARGET_WAITKIND_EXITED;
 308       status->value.integer = sigrc;
 309       break;
 310     case sim_stopped:
 311       status->kind = TARGET_WAITKIND_STOPPED;
 312       /* The signal in sigrc is a host signal.  That probably
 313          should be fixed.  */
 314       status->value.sig = target_signal_from_host (sigrc);
 315       break;
 316     case sim_signalled:
 317       status->kind = TARGET_WAITKIND_SIGNALLED;
 318       /* The signal in sigrc is a host signal.  That probably
 319          should be fixed.  */
 320       status->value.sig = target_signal_from_host (sigrc);
 321       break;
 322     }
 323
 324   return inferior_pid;
 325 }
 326
 327 /* Get ready to modify the registers array.  On machines which store
 328    individual registers, this doesn't need to do anything.  On machines
 329    which store all the registers in one fell swoop, this makes sure
 330    that registers contains all the registers from the program being
 331    debugged.  */
 332
 333 static void
 334 gdbsim_prepare_to_store ()
 335 {
 336   /* Do nothing, since we can store individual regs */
 337 }
 338
 339 static int
 340 gdbsim_xfer_inferior_memory (memaddr, myaddr, len, write, target)
 341      CORE_ADDR memaddr;
 342      char *myaddr;
 343      int len;
 344      int write;
 345      struct target_ops *target;                 /* ignored */
 346 {
 347   if (! program_loaded)
 348     error ("No program loaded.");
 349
 350   if (sr_get_debug ())
 351     {
 352       printf_filtered ("gdbsim_xfer_inferior_memory: myaddr 0x%x, memaddr 0x%x, len %d, write %d\n",
 353                        myaddr, memaddr, len, write);
 354       if (sr_get_debug () && write)
 355         dump_mem(myaddr, len);
 356     }
 357
 358   if (write)
 359     {
 360       len = sim_write (memaddr, myaddr, len);
 361     }
 362   else
 363     {
 364       len = sim_read (memaddr, myaddr, len);
 365       if (sr_get_debug () && len > 0)
 366         dump_mem(myaddr, len);
 367     }
 368   return len;
 369 }
 370
 371 static void
 372 gdbsim_files_info (target)
 373      struct target_ops *target;
 374 {
 375   char *file = "nothing";
 376
 377   if (exec_bfd)
 378     file = bfd_get_filename (exec_bfd);
 379
 380   if (sr_get_debug ())
 381     printf_filtered ("gdbsim_files_info: file \"%s\"\n", file);
 382
 383   if (exec_bfd)
 384     {
 385       printf_filtered ("\tAttached to %s running program %s\n",
 386                        target_shortname, file);
 387       sim_info (0);
 388     }
 389 }
 390
 391 /* Clear the simulator's notion of what the break points are.  */
 392
 393 static void
 394 gdbsim_mourn_inferior ()
 395 {
 396   if (sr_get_debug ())
 397     printf_filtered ("gdbsim_mourn_inferior:\n");
 398
 399   remove_breakpoints ();
 400   generic_mourn_inferior ();
 401 }
 402
 403 /* Put a command string, in args, out to MONITOR.  Output from MONITOR
 404    is placed on the users terminal until the prompt is seen. FIXME: We
 405    read the characters ourseleves here cause of a nasty echo.  */
 406
 407 static void
 408 simulator_command (args, from_tty)
 409      char *args;
 410      int from_tty;
 411 {
 412   sim_do_command (args);
 413 }
 414
 415 /* Define the target subroutine names */
 416
 417 struct target_ops gdbsim_ops = {
 418   "sim",                        /* to_shortname */
 419   "simulator",                  /* to_longname */
 420   "Use the compiled-in simulator.",  /* to_doc */
 421   gdbsim_open,                  /* to_open */
 422   gdbsim_close,                 /* to_close */
 423   NULL,                         /* to_attach */
 424   gdbsim_detach,                /* to_detach */
 425   gdbsim_resume,                /* to_resume */
 426   gdbsim_wait,                  /* to_wait */
 427   gdbsim_fetch_register,        /* to_fetch_registers */
 428   gdbsim_store_register,        /* to_store_registers */
 429   gdbsim_prepare_to_store,      /* to_prepare_to_store */
 430   gdbsim_xfer_inferior_memory,  /* to_xfer_memory */
 431   gdbsim_files_info,            /* to_files_info */
 432   memory_insert_breakpoint,     /* to_insert_breakpoint */
 433   memory_remove_breakpoint,     /* to_remove_breakpoint */
 434   NULL,                         /* to_terminal_init */
 435   NULL,                         /* to_terminal_inferior */
 436   NULL,                         /* to_terminal_ours_for_output */
 437   NULL,                         /* to_terminal_ours */
 438   NULL,                         /* to_terminal_info */
 439   gdbsim_kill,                  /* to_kill */
 440   gdbsim_load,                  /* to_load */
 441   NULL,                         /* to_lookup_symbol */
 442   gdbsim_create_inferior,       /* to_create_inferior */
 443   gdbsim_mourn_inferior,        /* to_mourn_inferior */
 444   0,                            /* to_can_run */
 445   0,                            /* to_notice_signals */
 446   0,                            /* to_thread_alive */
 447   0,                            /* to_stop */
 448   process_stratum,              /* to_stratum */
 449   NULL,                         /* to_next */
 450   1,                            /* to_has_all_memory */
 451   1,                            /* to_has_memory */
 452   1,                            /* to_has_stack */
 453   1,                            /* to_has_registers */
 454   1,                            /* to_has_execution */
 455   NULL,                         /* sections */
 456   NULL,                         /* sections_end */
 457   OPS_MAGIC,                    /* to_magic */
 458 };
 459
 460 void
 461 _initialize_remote_sim ()
 462 {
 463   add_target (&gdbsim_ops);
 464
 465   add_com ("sim <command>", class_obscure, simulator_command,
 466            "Send a command to the simulator.");
 467 }