sim/ppc/sim_calls.c

   1 /*  This file is part of the program psim.
   2
   3     Copyright 1994, 1995, 1996, 1998, 2003 Andrew Cagney
   4
   5     This program is free software; you can redistribute it and/or modify
   6     it under the terms of the GNU General Public License as published by
   7     the Free Software Foundation; either version 2 of the License, or
   8     (at your option) any later version.
   9
  10     This program is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13     GNU General Public License for more details.
  14
  15     You should have received a copy of the GNU General Public License
  16     along with this program; if not, write to the Free Software
  17     Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18
  19     */
  20
  21
  22 #include <signal.h> /* FIXME - should be machine dependant version */
  23 #include <stdarg.h>
  24 #include <ctype.h>
  25
  26 #include "psim.h"
  27 #include "options.h"
  28 #include "registers.h"
  29
  30 #undef printf_filtered /* blow away the mapping */
  31
  32 #ifdef HAVE_STDLIB_H
  33 #include <stdlib.h>
  34 #endif
  35
  36 #ifdef HAVE_STRING_H
  37 #include <string.h>
  38 #else
  39 #ifdef HAVE_STRINGS_H
  40 #include <strings.h>
  41 #endif
  42 #endif
  43
  44 #include "bfd.h"
  45 #include "gdb/callback.h"
  46 #include "gdb/remote-sim.h"
  47 #include "gdb/sim-ppc.h"
  48
  49 /* Define the rate at which the simulator should poll the host
  50    for a quit. */
  51 #ifndef POLL_QUIT_INTERVAL
  52 #define POLL_QUIT_INTERVAL 0x20
  53 #endif
  54
  55 static int poll_quit_count = POLL_QUIT_INTERVAL;
  56
  57 /* Structures used by the simulator, for gdb just have static structures */
  58
  59 static psim *simulator;
  60 static device *root_device;
  61 static host_callback *callbacks;
  62
  63 SIM_DESC
  64 sim_open (SIM_OPEN_KIND kind,
  65           host_callback *callback,
  66           struct bfd *abfd,
  67           char **argv)
  68 {
  69   callbacks = callback;
  70
  71   /* Note: The simulation is not created by sim_open() because
  72      complete information is not yet available */
  73   /* trace the call */
  74   TRACE(trace_gdb, ("sim_open called\n"));
  75
  76   if (root_device != NULL)
  77     sim_io_printf_filtered("Warning - re-open of simulator leaks memory\n");
  78   root_device = psim_tree();
  79   simulator = NULL;
  80
  81   psim_options(root_device, argv + 1);
  82
  83   if (ppc_trace[trace_opts])
  84     print_options ();
  85
  86   /* fudge our descriptor for now */
  87   return (SIM_DESC) 1;
  88 }
  89
  90
  91 void
  92 sim_close (SIM_DESC sd, int quitting)
  93 {
  94   TRACE(trace_gdb, ("sim_close(quitting=%d) called\n", quitting));
  95   if (ppc_trace[trace_print_info] && simulator != NULL)
  96     psim_print_info (simulator, ppc_trace[trace_print_info]);
  97 }
  98
  99
 100 SIM_RC
 101 sim_load (SIM_DESC sd, char *prog, bfd *abfd, int from_tty)
 102 {
 103   TRACE(trace_gdb, ("sim_load(prog=%s, from_tty=%d) called\n",
 104                     prog, from_tty));
 105   ASSERT(prog != NULL);
 106
 107   /* create the simulator */
 108   TRACE(trace_gdb, ("sim_load() - first time, create the simulator\n"));
 109   simulator = psim_create(prog, root_device);
 110
 111   /* bring in all the data section */
 112   psim_init(simulator);
 113
 114   /* get the start address */
 115   if (abfd == NULL)
 116     {
 117       abfd = bfd_openr (prog, 0);
 118       if (abfd == NULL)
 119         error ("psim: can't open \"%s\": %s\n",
 120                prog, bfd_errmsg (bfd_get_error ()));
 121       if (!bfd_check_format (abfd, bfd_object))
 122         {
 123           const char *errmsg = bfd_errmsg (bfd_get_error ());
 124           bfd_close (abfd);
 125           error ("psim: \"%s\" is not an object file: %s\n",
 126                  prog, errmsg);
 127         }
 128       bfd_close (abfd);
 129     }
 130
 131   return SIM_RC_OK;
 132 }
 133
 134
 135 int
 136 sim_read (SIM_DESC sd, SIM_ADDR mem, unsigned char *buf, int length)
 137 {
 138   int result = psim_read_memory(simulator, MAX_NR_PROCESSORS,
 139                                 buf, mem, length);
 140   TRACE(trace_gdb, ("sim_read(mem=0x%lx, buf=0x%lx, length=%d) = %d\n",
 141                     (long)mem, (long)buf, length, result));
 142   return result;
 143 }
 144
 145
 146 int
 147 sim_write (SIM_DESC sd, SIM_ADDR mem, unsigned char *buf, int length)
 148 {
 149   int result = psim_write_memory(simulator, MAX_NR_PROCESSORS,
 150                                  buf, mem, length,
 151                                  1/*violate_ro*/);
 152   TRACE(trace_gdb, ("sim_write(mem=0x%lx, buf=0x%lx, length=%d) = %d\n",
 153                     (long)mem, (long)buf, length, result));
 154   return result;
 155 }
 156
 157
 158 /* A table mapping register numbers (as received from GDB) to register
 159    names.  This table does not handle special-purpose registers: the
 160    SPR whose number is N is assigned the register number
 161    sim_ppc_spr0_regnum + N.  */
 162 static const char *gdb_register_name_table[] = {
 163
 164   /* General-purpose registers: 0 .. 31.  */
 165   "r0",   "r1",  "r2",  "r3",  "r4",  "r5",  "r6",  "r7",
 166   "r8",   "r9", "r10", "r11", "r12", "r13", "r14", "r15",
 167   "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
 168   "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
 169
 170   /* Floating-point registers: 32 .. 63.  */
 171   "f0",   "f1",  "f2",  "f3",  "f4",  "f5",  "f6",  "f7",
 172   "f8",   "f9", "f10", "f11", "f12", "f13", "f14", "f15",
 173   "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
 174   "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
 175
 176   /* Altivec registers: 64 .. 95.  */
 177   "vr0",   "vr1",  "vr2",  "vr3",  "vr4",  "vr5",  "vr6",  "vr7",
 178   "vr8",   "vr9", "vr10", "vr11", "vr12", "vr13", "vr14", "vr15",
 179   "vr16", "vr17", "vr18", "vr19", "vr20", "vr21", "vr22", "vr23",
 180   "vr24", "vr25", "vr26", "vr27", "vr28", "vr29", "vr30", "vr31",
 181
 182   /* SPE APU GPR upper halves: 96 .. 127.  */
 183   "rh0",   "rh1",  "rh2",  "rh3",  "rh4",  "rh5",  "rh6",  "rh7",
 184   "rh8",   "rh9", "rh10", "rh11", "rh12", "rh13", "rh14", "rh15",
 185   "rh16", "rh17", "rh18", "rh19", "rh20", "rh21", "rh22", "rh23",
 186   "rh24", "rh25", "rh26", "rh27", "rh28", "rh29", "rh30", "rh31",
 187
 188   /* SPE APU full 64-bit vector registers: 128 .. 159.  */
 189   "ev0",   "ev1",  "ev2",  "ev3",  "ev4",  "ev5",  "ev6",  "ev7",
 190   "ev8",   "ev9", "ev10", "ev11", "ev12", "ev13", "ev14", "ev15",
 191   "ev16", "ev17", "ev18", "ev19", "ev20", "ev21", "ev22", "ev23",
 192   "ev24", "ev25", "ev26", "ev27", "ev28", "ev29", "ev30", "ev31",
 193
 194   /* Segment registers: 160 .. 175.  */
 195   "sr0", "sr1",  "sr2",  "sr3",  "sr4",  "sr5",  "sr6",  "sr7",
 196   "sr8", "sr9", "sr10", "sr11", "sr12", "sr13", "sr14", "sr15",
 197
 198   /* Miscellaneous (not special-purpose!) registers: 176 .. 181.  */
 199   "pc", "ps", "cr", "fpscr", "acc", "vscr"
 200 };
 201
 202 enum {
 203   gdb_register_name_table_size = (sizeof (gdb_register_name_table)
 204                                   / sizeof (gdb_register_name_table[0])),
 205 };
 206
 207
 208 /* Return the name of the register whose number is REGNUM, or zero if
 209    REGNUM is an invalid register number.  */
 210 static const char *
 211 gdb_register_name (int regnum)
 212 {
 213   /* Is it a special-purpose register?  */
 214   if (sim_ppc_spr0_regnum <= regnum
 215       && regnum < sim_ppc_spr0_regnum + sim_ppc_num_sprs)
 216     {
 217       int spr = regnum - sim_ppc_spr0_regnum;
 218       if (spr_is_valid (spr))
 219         return spr_name (spr);
 220       else
 221         return 0;
 222     }
 223
 224   /* Is it a valid non-SPR register number?  */
 225   else if (0 <= regnum && regnum < gdb_register_name_table_size)
 226     return gdb_register_name_table[regnum];
 227
 228   /* Not a valid register number at all.  */
 229   else
 230     return 0;
 231 }
 232
 233
 234 int
 235 sim_fetch_register (SIM_DESC sd, int regno, unsigned char *buf, int length)
 236 {
 237   const char *regname;
 238
 239   if (simulator == NULL) {
 240     return 0;
 241   }
 242
 243   regname = gdb_register_name (regno);
 244
 245   /* Occasionally, GDB will pass invalid register numbers to us; it
 246      wants us to ignore them.  */
 247   if (! regname)
 248     return -1;
 249
 250   TRACE(trace_gdb, ("sim_fetch_register(regno=%d(%s), buf=0x%lx)\n",
 251                     regno, regname, (long)buf));
 252   return psim_read_register(simulator, MAX_NR_PROCESSORS,
 253                             buf, regname, raw_transfer);
 254 }
 255
 256
 257 int
 258 sim_store_register (SIM_DESC sd, int regno, unsigned char *buf, int length)
 259 {
 260   const char *regname;
 261
 262   if (simulator == NULL)
 263     return 0;
 264
 265   regname = gdb_register_name (regno);
 266
 267   /* Occasionally, GDB will pass invalid register numbers to us; it
 268      wants us to ignore them.  */
 269   if (! regname)
 270     return -1;
 271
 272   TRACE(trace_gdb, ("sim_store_register(regno=%d(%s), buf=0x%lx)\n",
 273                     regno, regname, (long)buf));
 274   return psim_write_register(simulator, MAX_NR_PROCESSORS,
 275                              buf, regname, raw_transfer);
 276 }
 277
 278
 279 void
 280 sim_info (SIM_DESC sd, int verbose)
 281 {
 282   TRACE(trace_gdb, ("sim_info(verbose=%d) called\n", verbose));
 283   psim_print_info (simulator, verbose);
 284 }
 285
 286
 287 SIM_RC
 288 sim_create_inferior (SIM_DESC sd,
 289                      struct bfd *abfd,
 290                      char **argv,
 291                      char **envp)
 292 {
 293   unsigned_word entry_point;
 294   TRACE(trace_gdb, ("sim_create_inferior(start_address=0x%x, ...)\n",
 295                     entry_point));
 296
 297   if (simulator == NULL)
 298     error ("No program loaded");
 299
 300   if (abfd != NULL)
 301     entry_point = bfd_get_start_address (abfd);
 302   else
 303     entry_point = 0xfff00000; /* ??? */
 304
 305   psim_init(simulator);
 306   psim_stack(simulator, argv, envp);
 307
 308   ASSERT (psim_write_register(simulator, -1 /* all start at same PC */,
 309                               &entry_point, "pc", cooked_transfer) > 0);
 310   return SIM_RC_OK;
 311 }
 312
 313
 314 void
 315 sim_stop_reason (SIM_DESC sd, enum sim_stop *reason, int *sigrc)
 316 {
 317   psim_status status = psim_get_status(simulator);
 318
 319   switch (status.reason) {
 320   case was_continuing:
 321     *reason = sim_stopped;
 322     if (status.signal == 0)
 323       *sigrc = SIGTRAP;
 324     else
 325       *sigrc = status.signal;
 326     break;
 327   case was_trap:
 328     *reason = sim_stopped;
 329     *sigrc = SIGTRAP;
 330     break;
 331   case was_exited:
 332     *reason = sim_exited;
 333     *sigrc = status.signal;
 334     break;
 335   case was_signalled:
 336     *reason = sim_signalled;
 337     *sigrc = status.signal;
 338     break;
 339   }
 340
 341   TRACE(trace_gdb, ("sim_stop_reason(reason=0x%lx(%ld), sigrc=0x%lx(%ld))\n",
 342                     (long)reason, (long)*reason, (long)sigrc, (long)*sigrc));
 343 }
 344
 345
 346
 347 /* Run (or resume) the program.  */
 348
 349 int
 350 sim_stop (SIM_DESC sd)
 351 {
 352   psim_stop (simulator);
 353   return 1;
 354 }
 355
 356 void
 357 sim_resume (SIM_DESC sd, int step, int siggnal)
 358 {
 359   TRACE(trace_gdb, ("sim_resume(step=%d, siggnal=%d)\n",
 360                     step, siggnal));
 361
 362   if (step)
 363     {
 364       psim_step (simulator);
 365     }
 366   else
 367     {
 368       psim_run (simulator);
 369     }
 370 }
 371
 372 void
 373 sim_do_command (SIM_DESC sd, char *cmd)
 374 {
 375   TRACE(trace_gdb, ("sim_do_commands(cmd=%s) called\n",
 376                     cmd ? cmd : "(null)"));
 377   if (cmd != NULL) {
 378     char **argv = buildargv(cmd);
 379     psim_command(root_device, argv);
 380     freeargv(argv);
 381   }
 382 }
 383
 384
 385 /* Polling, if required */
 386
 387 void
 388 sim_io_poll_quit (void)
 389 {
 390   if (callbacks->poll_quit != NULL && poll_quit_count-- < 0)
 391     {
 392       poll_quit_count = POLL_QUIT_INTERVAL;
 393       if (callbacks->poll_quit (callbacks))
 394         psim_stop (simulator);
 395     }
 396 }
 397
 398
 399
 400 /* Map simulator IO operations onto the corresponding GDB I/O
 401    functions.
 402
 403    NB: Only a limited subset of operations are mapped across.  More
 404    advanced operations (such as dup or write) must either be mapped to
 405    one of the below calls or handled internally */
 406
 407 int
 408 sim_io_read_stdin(char *buf,
 409                   int sizeof_buf)
 410 {
 411   switch (CURRENT_STDIO) {
 412   case DO_USE_STDIO:
 413     return callbacks->read_stdin(callbacks, buf, sizeof_buf);
 414     break;
 415   case DONT_USE_STDIO:
 416     return callbacks->read(callbacks, 0, buf, sizeof_buf);
 417     break;
 418   default:
 419     error("sim_io_read_stdin: unaccounted switch\n");
 420     break;
 421   }
 422   return 0;
 423 }
 424
 425 int
 426 sim_io_write_stdout(const char *buf,
 427                     int sizeof_buf)
 428 {
 429   switch (CURRENT_STDIO) {
 430   case DO_USE_STDIO:
 431     return callbacks->write_stdout(callbacks, buf, sizeof_buf);
 432     break;
 433   case DONT_USE_STDIO:
 434     return callbacks->write(callbacks, 1, buf, sizeof_buf);
 435     break;
 436   default:
 437     error("sim_io_write_stdout: unaccounted switch\n");
 438     break;
 439   }
 440   return 0;
 441 }
 442
 443 int
 444 sim_io_write_stderr(const char *buf,
 445                     int sizeof_buf)
 446 {
 447   switch (CURRENT_STDIO) {
 448   case DO_USE_STDIO:
 449     /* NB: I think there should be an explicit write_stderr callback */
 450     return callbacks->write(callbacks, 3, buf, sizeof_buf);
 451     break;
 452   case DONT_USE_STDIO:
 453     return callbacks->write(callbacks, 3, buf, sizeof_buf);
 454     break;
 455   default:
 456     error("sim_io_write_stderr: unaccounted switch\n");
 457     break;
 458   }
 459   return 0;
 460 }
 461
 462
 463 void
 464 sim_io_printf_filtered(const char *fmt,
 465                        ...)
 466 {
 467   char message[1024];
 468   va_list ap;
 469   /* format the message */
 470   va_start(ap, fmt);
 471   vsprintf(message, fmt, ap);
 472   va_end(ap);
 473   /* sanity check */
 474   if (strlen(message) >= sizeof(message))
 475     error("sim_io_printf_filtered: buffer overflow\n");
 476   callbacks->printf_filtered(callbacks, "%s", message);
 477 }
 478
 479 void
 480 sim_io_flush_stdoutput(void)
 481 {
 482   switch (CURRENT_STDIO) {
 483   case DO_USE_STDIO:
 484     callbacks->flush_stdout (callbacks);
 485     break;
 486   case DONT_USE_STDIO:
 487     break;
 488   default:
 489     error("sim_io_read_stdin: unaccounted switch\n");
 490     break;
 491   }
 492 }
 493
 494 void
 495 sim_io_error (SIM_DESC sd, const char *fmt, ...)
 496 {
 497   va_list ap;
 498   va_start(ap, fmt);
 499   callbacks->evprintf_filtered (callbacks, fmt, ap);
 500   va_end(ap);
 501   callbacks->error (callbacks, "");
 502 }
 503
 504 /****/
 505
 506 void *
 507 zalloc(long size)
 508 {
 509   void *memory = (void*)xmalloc(size);
 510   if (memory == NULL)
 511     error("xmalloc failed\n");
 512   memset(memory, 0, size);
 513   return memory;
 514 }
 515
 516 void zfree(void *data)
 517 {
 518   free(data);
 519 }