sim/arm/wrapper.c

   1 /* run front end support for arm
   2    Copyright (C) 1995, 1996, 1997 Free Software Foundation, Inc.
   3
   4 This file is part of ARM SIM.
   5
   6 GNU CC 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, or (at your option)
   9 any later version.
  10
  11 GNU CC 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 /* This file provides the interface between the simulator and run.c and gdb
  21    (when the simulator is linked with gdb).
  22    All simulator interaction should go through this file.  */
  23
  24 #include <stdio.h>
  25 #include <stdarg.h>
  26 #include <bfd.h>
  27 #include <signal.h>
  28 #include "callback.h"
  29 #include "remote-sim.h"
  30 #include "armdefs.h"
  31 #include "armemu.h"
  32 #include "dbg_rdi.h"
  33
  34 host_callback *sim_callback;
  35
  36 static struct ARMul_State *state;
  37
  38 /* Who is using the simulator.  */
  39 static SIM_OPEN_KIND sim_kind;
  40
  41 /* argv[0] */
  42 static char *myname;
  43
  44 /* Memory size in bytes.  */
  45 static int mem_size = (1 << 21);
  46
  47 /* Non-zero to display start up banner, and maybe other things.  */
  48 static int verbosity;
  49
  50 static void
  51 init ()
  52 {
  53   static int done;
  54
  55   if (!done)
  56     {
  57       ARMul_EmulateInit();
  58       state = ARMul_NewState ();
  59       ARMul_MemoryInit(state, mem_size);
  60       ARMul_OSInit(state);
  61       ARMul_CoProInit(state);
  62       state->verbose = verbosity;
  63       done = 1;
  64     }
  65 }
  66
  67 /* Set verbosity level of simulator.
  68    This is not intended to produce detailed tracing or debugging information.
  69    Just summaries.  */
  70 /* FIXME: common/run.c doesn't do this yet.  */
  71
  72 void
  73 sim_set_verbose (v)
  74      int v;
  75 {
  76   verbosity = v;
  77 }
  78
  79 /* Set the memory size to SIZE bytes.
  80    Must be called before initializing simulator.  */
  81 /* FIXME: Rename to sim_set_mem_size.  */
  82
  83 void
  84 sim_size (size)
  85      int size;
  86 {
  87   mem_size = size;
  88 }
  89
  90 void
  91 ARMul_ConsolePrint (ARMul_State * state, const char *format,...)
  92 {
  93   va_list ap;
  94
  95   if (state->verbose)
  96     {
  97       va_start (ap, format);
  98       vprintf (format, ap);
  99       va_end (ap);
 100     }
 101 }
 102
 103 ARMword
 104 ARMul_Debug (ARMul_State * state, ARMword pc, ARMword instr)
 105 {
 106
 107 }
 108
 109 int
 110 sim_write (sd, addr, buffer, size)
 111      SIM_DESC sd;
 112      SIM_ADDR addr;
 113      unsigned char *buffer;
 114      int size;
 115 {
 116   int i;
 117   init ();
 118   for (i = 0; i < size; i++)
 119     {
 120       ARMul_WriteByte (state, addr+i, buffer[i]);
 121     }
 122   return size;
 123 }
 124
 125 int
 126 sim_read (sd, addr, buffer, size)
 127      SIM_DESC sd;
 128      SIM_ADDR addr;
 129      unsigned char *buffer;
 130      int size;
 131 {
 132   int i;
 133   init ();
 134   for (i = 0; i < size; i++)
 135     {
 136       buffer[i] = ARMul_ReadByte (state, addr + i);
 137     }
 138   return size;
 139 }
 140
 141 int
 142 sim_trace (sd)
 143      SIM_DESC sd;
 144 {
 145   (*sim_callback->printf_filtered) (sim_callback, "This simulator does not support tracing\n");
 146   return 1;
 147 }
 148
 149 int
 150 sim_stop (sd)
 151      SIM_DESC sd;
 152 {
 153   return 0;
 154 }
 155
 156 void
 157 sim_resume (sd, step, siggnal)
 158      SIM_DESC sd;
 159      int step, siggnal;
 160 {
 161   state->EndCondition = 0;
 162
 163   if (step)
 164     {
 165       state->Reg[15] = ARMul_DoInstr (state);
 166       if (state->EndCondition == 0)
 167         state->EndCondition = RDIError_BreakpointReached;
 168     }
 169   else
 170     {
 171       state->Reg[15] = ARMul_DoProg (state);
 172     }
 173
 174   FLUSHPIPE;
 175 }
 176
 177 SIM_RC
 178 sim_create_inferior (sd, abfd, argv, env)
 179      SIM_DESC sd;
 180      struct _bfd *abfd;
 181      char **argv;
 182      char **env;
 183 {
 184   if (abfd != NULL)
 185     ARMul_SetPC (state, bfd_get_start_address (abfd));
 186   else
 187     ARMul_SetPC (state, 0); /* ??? */
 188   return SIM_RC_OK;
 189 }
 190
 191 void
 192 sim_info (sd, verbose)
 193      SIM_DESC sd;
 194      int verbose;
 195 {
 196 }
 197
 198
 199 static int
 200 frommem (state, memory)
 201      struct ARMul_State *state;
 202      unsigned char *memory;
 203 {
 204   if (state->bigendSig == HIGH)
 205     {
 206       return (memory[0] << 24)
 207         | (memory[1] << 16)
 208         | (memory[2] << 8)
 209         | (memory[3] << 0);
 210     }
 211   else
 212     {
 213       return (memory[3] << 24)
 214         | (memory[2] << 16)
 215         | (memory[1] << 8)
 216         | (memory[0] << 0);
 217     }
 218 }
 219
 220
 221 static void
 222 tomem (state, memory,  val)
 223      struct ARMul_State *state;
 224      unsigned char *memory;
 225      int val;
 226 {
 227   if (state->bigendSig == HIGH)
 228     {
 229       memory[0] = val >> 24;
 230       memory[1] = val >> 16;
 231       memory[2] = val >> 8;
 232       memory[3] = val >> 0;
 233     }
 234   else
 235     {
 236       memory[3] = val >> 24;
 237       memory[2] = val >> 16;
 238       memory[1] = val >> 8;
 239       memory[0] = val >> 0;
 240     }
 241 }
 242
 243 void
 244 sim_store_register (sd, rn, memory)
 245      SIM_DESC sd;
 246      int rn;
 247      unsigned char *memory;
 248 {
 249   init ();
 250   ARMul_SetReg(state, state->Mode, rn, frommem (state, memory));
 251 }
 252
 253 void
 254 sim_fetch_register (sd, rn, memory)
 255      SIM_DESC sd;
 256      int rn;
 257      unsigned char *memory;
 258 {
 259   init ();
 260   tomem (state, memory, ARMul_GetReg(state, state->Mode, rn));
 261 }
 262
 263
 264
 265
 266 SIM_DESC
 267 sim_open (kind, ptr, abfd, argv)
 268      SIM_OPEN_KIND kind;
 269      host_callback *ptr;
 270      struct _bfd *abfd;
 271      char **argv;
 272 {
 273   sim_kind = kind;
 274   myname = argv[0];
 275   sim_callback = ptr;
 276   return (SIM_DESC) 1;
 277 }
 278
 279 void
 280 sim_close (sd, quitting)
 281      SIM_DESC sd;
 282      int quitting;
 283 {
 284   /* nothing to do */
 285 }
 286
 287 SIM_RC
 288 sim_load (sd, prog, abfd, from_tty)
 289      SIM_DESC sd;
 290      char *prog;
 291      bfd *abfd;
 292      int from_tty;
 293 {
 294   extern bfd *sim_load_file (); /* ??? Don't know where this should live.  */
 295   bfd *prog_bfd;
 296
 297   prog_bfd = sim_load_file (sd, myname, sim_callback, prog, abfd,
 298                             sim_kind == SIM_OPEN_DEBUG,
 299                             0, sim_write);
 300   if (prog_bfd == NULL)
 301     return SIM_RC_FAIL;
 302   if (abfd == NULL)
 303     bfd_close (prog_bfd);
 304   return SIM_RC_OK;
 305 }
 306
 307 void
 308 sim_stop_reason (sd, reason, sigrc)
 309      SIM_DESC sd;
 310      enum sim_stop *reason;
 311      int *sigrc;
 312 {
 313   if (state->EndCondition == 0)
 314     {
 315       *reason = sim_exited;
 316       *sigrc = state->Reg[0] & 255;
 317     }
 318   else
 319     {
 320       *reason = sim_stopped;
 321       if (state->EndCondition == RDIError_BreakpointReached)
 322         *sigrc = SIGTRAP;
 323       else
 324         *sigrc = 0;
 325     }
 326 }
 327
 328 void
 329 sim_do_command (sd, cmd)
 330      SIM_DESC sd;
 331      char *cmd;
 332 {
 333   (*sim_callback->printf_filtered) (sim_callback, "This simulator does not accept any commands.\n");
 334 }
 335
 336
 337 void
 338 sim_set_callbacks (ptr)
 339      host_callback *ptr;
 340 {
 341   sim_callback = ptr;
 342 }