gdb/remote-sim.c

   1 /* Generic remote debugging interface for simulators.
   2    Copyright 1993 Free Software Foundation, Inc.
   3    Contributed by Cygnus Support.
   4    Steve Chamberlain (sac@cygnus.com) and Doug Evans (dje@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., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  21
  22 #include "defs.h"
  23 #include "inferior.h"
  24 #include "wait.h"
  25 #include "value.h"
  26 #include <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
  38 /* Naming convention:
  39
  40    sim_* are the interface to the simulator (see remote-sim.h).
  41
  42    gdbsim_* are stuff which is internal to gdb.  */
  43
  44 /* Forward data declarations */
  45 extern struct target_ops gdbsim_ops;
  46
  47 static int program_loaded = 0;
  48
  49 static void
  50 dump_mem (buf, len)
  51      char *buf;
  52      int len;
  53 {
  54   if (len <= 8)
  55     {
  56       if (len == 8 || len == 4)
  57         {
  58           long l[2];
  59           memcpy (l, buf, len);
  60           printf_filtered ("\t0x%x", l[0]);
  61           printf_filtered (len == 8 ? " 0x%x\n" : "\n", l[1]);
  62         }
  63       else
  64         {
  65           int i;
  66           printf_filtered ("\t");
  67           for (i = 0; i < len; i++)
  68             printf_filtered ("0x%x ", buf[i]);
  69           printf_filtered ("\n");
  70         }
  71     }
  72 }
  73
  74 static void
  75 gdbsim_fetch_register (regno)
  76 int regno;
  77 {
  78   if (regno == -1)
  79     {
  80       for (regno = 0; regno < NUM_REGS; regno++)
  81         gdbsim_fetch_register (regno);
  82     }
  83   else
  84     {
  85       char buf[MAX_REGISTER_RAW_SIZE];
  86
  87       sim_fetch_register (regno, buf);
  88       supply_register (regno, buf);
  89       if (sr_get_debug ())
  90         {
  91           printf_filtered ("gdbsim_fetch_register: %d", regno);
  92           /* FIXME: We could print something more intelligible.  */
  93           dump_mem (buf, REGISTER_RAW_SIZE (regno));
  94         }
  95     }
  96 }
  97
  98 static void
  99 gdbsim_store_register (regno)
 100 int regno;
 101 {
 102   if (regno  == -1)
 103     {
 104       for (regno = 0; regno < NUM_REGS; regno++)
 105         gdbsim_store_register (regno);
 106     }
 107   else
 108     {
 109       /* FIXME: Until read_register() returns LONGEST, we have this.  */
 110       char value[MAX_REGISTER_RAW_SIZE];
 111       read_register_gen (regno, value);
 112       sim_store_register (regno, value);
 113       if (sr_get_debug ())
 114         {
 115           printf_filtered ("gdbsim_store_register: %d", regno);
 116           /* FIXME: We could print something more intelligible.  */
 117           dump_mem (value, REGISTER_RAW_SIZE (regno));
 118         }
 119     }
 120 }
 121
 122 static void
 123 gdbsim_kill ()
 124 {
 125   if (sr_get_debug ())
 126     printf_filtered ("gdbsim_kill\n");
 127
 128   sim_kill ();  /* close fd's, remove mappings */
 129   inferior_pid = 0;
 130 }
 131
 132 /* Load an executable file into the target process.  This is expected to
 133    not only bring new code into the target process, but also to update
 134    GDB's symbol tables to match.  */
 135
 136 static void
 137 gdbsim_load (prog, fromtty)
 138      char *prog;
 139      int fromtty;
 140 {
 141   bfd   *abfd;
 142
 143   if (sr_get_debug ())
 144     printf_filtered ("gdbsim_load: prog \"%s\"\n", prog);
 145
 146   inferior_pid = 0;
 147   program_loaded = 0;
 148   abfd = bfd_openr (prog, gnutarget);
 149
 150   if (!abfd)
 151     error ("Unable to open file %s.", prog);
 152
 153   if (bfd_check_format (abfd, bfd_object) == 0)
 154     error ("File is not an object file.");
 155
 156   if (sim_load (abfd, prog) != 0)
 157     return;
 158
 159   program_loaded = 1;
 160
 161   sim_set_pc (abfd->start_address);
 162 }
 163
 164 /*
 165  * This is a utility routine that sim_load() can call to do the work.
 166  * The result is 0 for success, non-zero for failure.
 167  *
 168  * Eg: int sim_load (bfd *bfd, char *prog) { return sim_load_standard (bfd); }
 169  */
 170
 171 sim_load_standard (abfd)
 172      bfd *abfd;
 173 {
 174   asection *s;
 175
 176   s = abfd->sections;
 177   while (s != (asection *)NULL)
 178   {
 179     if (s->flags & SEC_LOAD)
 180     {
 181       int i;
 182       int delta = 4096;
 183       char *buffer = xmalloc (delta);
 184       printf_filtered ("%s\t: 0x%4x .. 0x%4x  ",
 185                       s->name, s->vma, s->vma + s->_raw_size);
 186       for (i = 0; i < s->_raw_size; i+= delta)
 187       {
 188         int sub_delta = delta;
 189         if (sub_delta > s->_raw_size - i)
 190           sub_delta = s->_raw_size - i ;
 191
 192         bfd_get_section_contents (abfd, s, buffer, i, sub_delta);
 193         sim_write (s->vma + i, buffer, sub_delta);
 194         printf_filtered ("*");
 195         fflush (stdout);
 196       }
 197       printf_filtered ("\n");
 198       free (buffer);
 199     }
 200     s = s->next;
 201   }
 202
 203   return 0;
 204 }
 205
 206 /* Start an inferior process and set inferior_pid to its pid.
 207    EXEC_FILE is the file to run.
 208    ALLARGS is a string containing the arguments to the program.
 209    ENV is the environment vector to pass.  Errors reported with error().
 210    On VxWorks and various standalone systems, we ignore exec_file.  */
 211 /* This is called not only when we first attach, but also when the
 212    user types "run" after having attached.  */
 213
 214 static void
 215 gdbsim_create_inferior (exec_file, args, env)
 216      char *exec_file;
 217      char *args;
 218      char **env;
 219 {
 220   int len,entry_pt;
 221   char *arg_buf,**argv;
 222
 223   if (! program_loaded)
 224     error ("No program loaded.");
 225
 226   if (sr_get_debug ())
 227     printf_filtered ("gdbsim_create_inferior: exec_file \"%s\", args \"%s\"\n",
 228       exec_file, args);
 229
 230   if (exec_file == 0 || exec_bfd == 0)
 231    error ("No exec file specified.");
 232
 233   entry_pt = (int) bfd_get_start_address (exec_bfd);
 234
 235   gdbsim_kill (NULL, NULL);
 236   remove_breakpoints ();
 237   init_wait_for_inferior ();
 238
 239   len = 5 + strlen (exec_file) + 1 + strlen (args) + 1 + /*slop*/ 10;
 240   arg_buf = (char *) alloca (len);
 241   arg_buf[0] = '\0';
 242   strcat (arg_buf, exec_file);
 243   strcat (arg_buf, " ");
 244   strcat (arg_buf, args);
 245   argv = buildargv (arg_buf);
 246   make_cleanup (freeargv, (char *) argv);
 247   /* FIXME: remote-sim.h says targets that don't support this return
 248      non-zero.  Perhaps distinguish between "not supported" and other errors?
 249      Or maybe that can be the only error.  */
 250   if (sim_set_args (argv, env) != 0)
 251     return;
 252
 253   inferior_pid = 42;
 254   insert_breakpoints ();        /* Needed to get correct instruction in cache */
 255   proceed (entry_pt, -1, 0);
 256 }
 257
 258 /* The open routine takes the rest of the parameters from the command,
 259    and (if successful) pushes a new target onto the stack.
 260    Targets should supply this routine, if only to provide an error message.  */
 261 /* Called when selecting the simulator. EG: (gdb) target sim name.  */
 262
 263 static void
 264 gdbsim_open (args, from_tty)
 265      char *args;
 266      int from_tty;
 267 {
 268   if (sr_get_debug ())
 269     printf_filtered ("gdbsim_open: args \"%s\"\n", args);
 270
 271   if (sim_open (args) != 0)
 272     {
 273       /* FIXME: This is totally bogus.  sim_open should have a way to
 274          tell us what the error was, so we can tell the user.  */
 275       error ("Unable to initialize simulator (insufficient memory?).");
 276       return;
 277     }
 278
 279   push_target (&gdbsim_ops);
 280   target_fetch_registers (-1);
 281
 282   printf_filtered ("Connected to the simulator.\n");
 283 }
 284
 285 /* Does whatever cleanup is required for a target that we are no longer
 286    going to be calling.  Argument says whether we are quitting gdb and
 287    should not get hung in case of errors, or whether we want a clean
 288    termination even if it takes a while.  This routine is automatically
 289    always called just before a routine is popped off the target stack.
 290    Closing file descriptors and freeing memory are typical things it should
 291    do.  */
 292 /* Close out all files and local state before this target loses control. */
 293
 294 static void
 295 gdbsim_close (quitting)
 296      int quitting;
 297 {
 298   if (sr_get_debug ())
 299     printf_filtered ("gdbsim_close: quitting %d\n", quitting);
 300
 301   program_loaded = 0;
 302
 303   /* FIXME: Need to call sim_close() to close all files and
 304      delete all mappings. */
 305 }
 306
 307 /* Takes a program previously attached to and detaches it.
 308    The program may resume execution (some targets do, some don't) and will
 309    no longer stop on signals, etc.  We better not have left any breakpoints
 310    in the program or it'll die when it hits one.  ARGS is arguments
 311    typed by the user (e.g. a signal to send the process).  FROM_TTY
 312    says whether to be verbose or not.  */
 313 /* Terminate the open connection to the remote debugger.
 314    Use this when you want to detach and do something else with your gdb.  */
 315
 316 static void
 317 gdbsim_detach (args,from_tty)
 318      char *args;
 319      int from_tty;
 320 {
 321   if (sr_get_debug ())
 322     printf_filtered ("gdbsim_detach: args \"%s\"\n", args);
 323
 324   pop_target ();                /* calls gdbsim_close to do the real work */
 325   if (from_tty)
 326     printf_filtered ("Ending simulator %s debugging\n", target_shortname);
 327 }
 328
 329 /* Resume execution of the target process.  STEP says whether to single-step
 330    or to run free; SIGGNAL is the signal value (e.g. SIGINT) to be given
 331    to the target, or zero for no signal.  */
 332
 333 static void
 334 gdbsim_resume (pid, step, siggnal)
 335      int pid, step, siggnal;
 336 {
 337   if (sr_get_debug ())
 338     printf_filtered ("gdbsim_resume: step %d, signal %d\n", step, siggnal);
 339
 340   sim_resume (step, siggnal);
 341 }
 342
 343 /* Wait for inferior process to do something.  Return pid of child,
 344    or -1 in case of error; store status through argument pointer STATUS,
 345    just as `wait' would.  */
 346
 347 static int
 348 gdbsim_wait (status)
 349      WAITTYPE *status;
 350 {
 351   if (sr_get_debug ())
 352     printf_filtered ("gdbsim_wait: ");
 353   WSETSTOP (*status, sim_stop_signal ());
 354   if (sr_get_debug ())
 355     printf_filtered ("status %d\n", *status);
 356   return inferior_pid;
 357 }
 358
 359 /* Get ready to modify the registers array.  On machines which store
 360    individual registers, this doesn't need to do anything.  On machines
 361    which store all the registers in one fell swoop, this makes sure
 362    that registers contains all the registers from the program being
 363    debugged.  */
 364
 365 static void
 366 gdbsim_prepare_to_store ()
 367 {
 368   /* Do nothing, since we can store individual regs */
 369 }
 370
 371 static int
 372 gdbsim_xfer_inferior_memory (memaddr, myaddr, len, write, target)
 373      CORE_ADDR memaddr;
 374      char *myaddr;
 375      int len;
 376      int write;
 377      struct target_ops *target;                 /* ignored */
 378 {
 379   if (! program_loaded)
 380     error ("No program loaded.");
 381
 382   if (sr_get_debug ())
 383     {
 384       printf_filtered ("gdbsim_xfer_inferior_memory: myaddr 0x%x, memaddr 0x%x, len %d, write %d\n",
 385                        myaddr, memaddr, len, write);
 386       if (sr_get_debug () && write)
 387         dump_mem(myaddr, len);
 388     }
 389
 390   if (write)
 391     {
 392       len = sim_write (memaddr, myaddr, len);
 393     }
 394   else
 395     {
 396       len = sim_read (memaddr, myaddr, len);
 397       if (sr_get_debug () && len > 0)
 398         dump_mem(myaddr, len);
 399     }
 400   return len;
 401 }
 402
 403 static void
 404 gdbsim_files_info (target)
 405      struct target_ops *target;
 406 {
 407   char *file = "nothing";
 408
 409   if (exec_bfd)
 410     file = bfd_get_filename (exec_bfd);
 411
 412   if (sr_get_debug ())
 413     printf_filtered ("gdbsim_files_info: file \"%s\"\n", file);
 414
 415   if (exec_bfd)
 416     {
 417       printf_filtered ("\tAttached to %s running program %s\n",
 418                        target_shortname, file);
 419       sim_info ();
 420     }
 421 }
 422
 423 /* Clear the sims notion of what the break points are.  */
 424
 425 static void
 426 gdbsim_mourn_inferior ()
 427 {
 428   if (sr_get_debug ())
 429     printf_filtered ("gdbsim_mourn_inferior:\n");
 430
 431   remove_breakpoints ();
 432   generic_mourn_inferior ();
 433 }
 434
 435 /* Define the target subroutine names */
 436
 437 struct target_ops gdbsim_ops =
 438 {
 439   "sim", "simulator",
 440   "Use the simulator",
 441   gdbsim_open, gdbsim_close,
 442   0, gdbsim_detach, gdbsim_resume, gdbsim_wait, /* attach */
 443   gdbsim_fetch_register, gdbsim_store_register,
 444   gdbsim_prepare_to_store,
 445   gdbsim_xfer_inferior_memory,
 446   gdbsim_files_info,
 447   0, 0,                         /* Breakpoints */
 448   0, 0, 0, 0, 0,                /* Terminal handling */
 449   gdbsim_kill,                  /* kill */
 450   gdbsim_load,
 451   0,                            /* lookup_symbol */
 452   gdbsim_create_inferior,               /* create_inferior */
 453   gdbsim_mourn_inferior,                /* mourn_inferior */
 454   0,                            /* can_run */
 455   0,                            /* notice_signals */
 456   process_stratum, 0,           /* next */
 457   1, 1, 1, 1, 1,                /* all mem, mem, stack, regs, exec */
 458   0, 0,                         /* Section pointers */
 459   OPS_MAGIC,                    /* Always the last thing */
 460 };
 461
 462 void
 463 _initialize_remote_sim ()
 464 {
 465   add_target (&gdbsim_ops);
 466 }