gdb/gdbserver/low-sim.c

   1 /* Low level interface to simulators, for the remote server for GDB.
   2    Copyright (C) 1995, 1996 Free Software Foundation, Inc.
   3
   4 This file is part of GDB.
   5
   6 This program is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2 of the License, or
   9 (at your option) any later version.
  10
  11 This program is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with this program; if not, write to the Free Software
  18 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  19
  20 #include "defs.h"
  21 #include "bfd.h"
  22 #include "server.h"
  23 #include "callback.h"   /* GDB simulator callback interface */
  24 #include "remote-sim.h" /* GDB simulator interface */
  25
  26 extern int remote_debug;
  27
  28 extern host_callback default_callback;  /* in sim/common/callback.c */
  29
  30 char registers[REGISTER_BYTES] __attribute__ ((aligned));
  31
  32 int target_byte_order;  /* used by simulator */
  33
  34 /* We record the result of sim_open so we can pass it
  35    back to the other sim_foo routines.  */
  36 static SIM_DESC gdbsim_desc = 0;
  37
  38 /* This version of "load" should be usable for any simulator that
  39    does not support loading itself.  */
  40
  41 static void
  42 generic_load (loadfile_bfd)
  43     bfd *loadfile_bfd;
  44 {
  45   asection *s;
  46
  47   for (s = loadfile_bfd->sections; s; s = s->next)
  48     {
  49       if (s->flags & SEC_LOAD)
  50         {
  51           bfd_size_type size;
  52
  53           size = bfd_get_section_size_before_reloc (s);
  54           if (size > 0)
  55             {
  56               char *buffer;
  57               bfd_vma lma;      /* use load address, not virtual address */
  58
  59               buffer = xmalloc (size);
  60               lma = s->lma;
  61
  62               /* Is this really necessary?  I guess it gives the user something
  63                  to look at during a long download.  */
  64               printf ("Loading section %s, size 0x%lx lma 0x%lx\n",
  65                       bfd_get_section_name (loadfile_bfd, s),
  66                       (unsigned long) size,
  67                       (unsigned long) lma); /* chops high 32 bits.  FIXME!! */
  68
  69               bfd_get_section_contents (loadfile_bfd, s, buffer, 0, size);
  70
  71               write_inferior_memory (lma, buffer, size);
  72               free (buffer);
  73             }
  74         }
  75     }
  76
  77   printf ("Start address 0x%lx\n",
  78           (unsigned long)loadfile_bfd->start_address);
  79
  80   /* We were doing this in remote-mips.c, I suspect it is right
  81      for other targets too.  */
  82   /* write_pc (loadfile_bfd->start_address); */ /* FIXME!! */
  83 }
  84
  85 int
  86 create_inferior (program, argv)
  87      char *program;
  88      char **argv;
  89 {
  90   bfd *abfd;
  91   int pid = 0;
  92 #ifdef TARGET_BYTE_ORDER_SELECTABLE
  93   char **new_argv;
  94   int nargs;
  95 #endif
  96
  97   abfd = bfd_openr (program, 0);
  98   if (!abfd)
  99     {
 100       fprintf (stderr, "gdbserver: can't open %s: %s\n",
 101                program, bfd_errmsg (bfd_get_error ()));
 102       exit (1);
 103     }
 104
 105   if (!bfd_check_format (abfd, bfd_object))
 106     {
 107       fprintf (stderr, "gdbserver: unknown load format for %s: %s\n",
 108                program, bfd_errmsg (bfd_get_error ()));
 109       exit (1);
 110     }
 111
 112 #ifdef TARGET_BYTE_ORDER_SELECTABLE
 113   /* Add "-E big" or "-E little" to the argument list depending on the
 114      endianness of the program to be loaded.  */
 115   for (nargs = 0; argv[nargs] != NULL; nargs++)         /* count the args */
 116     ;
 117   new_argv = alloca (sizeof (char *) * (nargs + 3));    /* allocate new args */
 118   for (nargs = 0; argv[nargs] != NULL; nargs++)         /* copy old to new */
 119     new_argv[nargs] = argv[nargs];
 120   new_argv[nargs] = "-E";
 121   new_argv[nargs + 1] = bfd_big_endian (abfd) ? "big" : "little";
 122   new_argv[nargs + 2] = NULL;
 123   argv = new_argv;
 124 #endif
 125
 126   /* Create an instance of the simulator.  */
 127   default_callback.init (&default_callback);
 128   gdbsim_desc = sim_open (SIM_OPEN_STANDALONE, &default_callback, abfd, argv);
 129   if (gdbsim_desc == 0)
 130     exit (1);
 131
 132   /* Load the program into the simulator.  */
 133   if (abfd)
 134     if (sim_load (gdbsim_desc, program, NULL, 0) == SIM_RC_FAIL)
 135       generic_load (abfd);
 136
 137   /* Create an inferior process in the simulator.  This initializes SP.  */
 138   sim_create_inferior (gdbsim_desc, abfd, argv, /* env */ NULL);
 139   sim_resume (gdbsim_desc, 1, 0);       /* execute one instr */
 140   return pid;
 141 }
 142
 143 /* Kill the inferior process.  Make us have no inferior.  */
 144
 145 void
 146 kill_inferior ()
 147 {
 148   sim_close (gdbsim_desc, 0);
 149   default_callback.shutdown (&default_callback);
 150 }
 151
 152 /* Fetch one register.  */
 153
 154 static void
 155 fetch_register (regno)
 156      int regno;
 157 {
 158   sim_fetch_register (gdbsim_desc, regno, &registers[REGISTER_BYTE (regno)],
 159                       REGISTER_RAW_SIZE (regno));
 160 }
 161
 162 /* Fetch all registers, or just one, from the child process.  */
 163
 164 void
 165 fetch_inferior_registers (regno)
 166      int regno;
 167 {
 168   if (regno == -1 || regno == 0)
 169     for (regno = 0; regno < NUM_REGS/*-NUM_FREGS*/; regno++)
 170       fetch_register (regno);
 171   else
 172     fetch_register (regno);
 173 }
 174
 175 /* Store our register values back into the inferior.
 176    If REGNO is -1, do this for all registers.
 177    Otherwise, REGNO specifies which register (so we can save time).  */
 178
 179 void
 180 store_inferior_registers (regno)
 181      int regno;
 182 {
 183   if (regno  == -1)
 184     {
 185       for (regno = 0; regno < NUM_REGS; regno++)
 186         store_inferior_registers (regno);
 187     }
 188   else
 189     sim_store_register (gdbsim_desc, regno, &registers[REGISTER_BYTE (regno)],
 190                         REGISTER_RAW_SIZE (regno));
 191 }
 192
 193 /* Return nonzero if the given thread is still alive.  */
 194 int
 195 mythread_alive (pid)
 196      int pid;
 197 {
 198   return 1;
 199 }
 200
 201 /* Wait for process, returns status */
 202
 203 unsigned char
 204 mywait (status)
 205      char *status;
 206 {
 207   int sigrc;
 208   enum sim_stop reason;
 209
 210   sim_stop_reason (gdbsim_desc, &reason, &sigrc);
 211   switch (reason)
 212     {
 213     case sim_exited:
 214       if (remote_debug)
 215         printf ("\nChild exited with retcode = %x \n", sigrc);
 216       *status = 'W';
 217       return sigrc;
 218
 219 #if 0
 220     case sim_stopped:
 221       if (remote_debug)
 222         printf ("\nChild terminated with signal = %x \n", sigrc);
 223       *status = 'X';
 224       return sigrc;
 225 #endif
 226
 227     default:   /* should this be sim_signalled or sim_stopped?  FIXME!! */
 228       if (remote_debug)
 229         printf ("\nChild received signal = %x \n", sigrc);
 230       fetch_inferior_registers (0);
 231       *status = 'T';
 232       return (unsigned char) sigrc;
 233     }
 234 }
 235
 236 /* Resume execution of the inferior process.
 237    If STEP is nonzero, single-step it.
 238    If SIGNAL is nonzero, give it that signal.  */
 239
 240 void
 241 myresume (step, signo)
 242      int step;
 243      int signo;
 244 {
 245   /* Should be using target_signal_to_host() or signal numbers in target.h
 246      to convert GDB signal number to target signal number.  */
 247   sim_resume (gdbsim_desc, step, signo);
 248 }
 249
 250 /* Copy LEN bytes from inferior's memory starting at MEMADDR
 251    to debugger memory starting at MYADDR.  */
 252
 253 void
 254 read_inferior_memory (memaddr, myaddr, len)
 255      CORE_ADDR memaddr;
 256      char *myaddr;
 257      int len;
 258 {
 259   sim_read (gdbsim_desc, memaddr, myaddr, len);
 260 }
 261
 262 /* Copy LEN bytes of data from debugger memory at MYADDR
 263    to inferior's memory at MEMADDR.
 264    On failure (cannot write the inferior)
 265    returns the value of errno.  */
 266
 267 int
 268 write_inferior_memory (memaddr, myaddr, len)
 269      CORE_ADDR memaddr;
 270      char *myaddr;
 271      int len;
 272 {
 273   sim_write (gdbsim_desc, memaddr, myaddr, len);  /* should check for error.  FIXME!! */
 274   return 0;
 275 }
 276
 277 #if 0
 278 void
 279 initialize ()
 280 {
 281   inferior_pid = 0;
 282 }
 283
 284 int
 285 have_inferior_p ()
 286 {
 287   return inferior_pid != 0;
 288 }
 289 #endif