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