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, argv, env)
 179      SIM_DESC sd;
 180      char **argv;
 181      char **env;
 182 {
 183   return SIM_RC_OK;
 184 }
 185
 186 void
 187 sim_info (sd, verbose)
 188      SIM_DESC sd;
 189      int verbose;
 190 {
 191 }
 192
 193
 194 static int
 195 frommem (state, memory)
 196      struct ARMul_State *state;
 197      unsigned char *memory;
 198 {
 199   if (state->bigendSig == HIGH)
 200     {
 201       return (memory[0] << 24)
 202         | (memory[1] << 16)
 203         | (memory[2] << 8)
 204         | (memory[3] << 0);
 205     }
 206   else
 207     {
 208       return (memory[3] << 24)
 209         | (memory[2] << 16)
 210         | (memory[1] << 8)
 211         | (memory[0] << 0);
 212     }
 213 }
 214
 215
 216 static void
 217 tomem (state, memory,  val)
 218      struct ARMul_State *state;
 219      unsigned char *memory;
 220      int val;
 221 {
 222   if (state->bigendSig == HIGH)
 223     {
 224       memory[0] = val >> 24;
 225       memory[1] = val >> 16;
 226       memory[2] = val >> 8;
 227       memory[3] = val >> 0;
 228     }
 229   else
 230     {
 231       memory[3] = val >> 24;
 232       memory[2] = val >> 16;
 233       memory[1] = val >> 8;
 234       memory[0] = val >> 0;
 235     }
 236 }
 237
 238 void
 239 sim_store_register (sd, rn, memory)
 240      SIM_DESC sd;
 241      int rn;
 242      unsigned char *memory;
 243 {
 244   init ();
 245   ARMul_SetReg(state, state->Mode, rn, frommem (state, memory));
 246 }
 247
 248 void
 249 sim_fetch_register (sd, rn, memory)
 250      SIM_DESC sd;
 251      int rn;
 252      unsigned char *memory;
 253 {
 254   init ();
 255   tomem (state, memory, ARMul_GetReg(state, state->Mode, rn));
 256 }
 257
 258
 259
 260
 261 SIM_DESC
 262 sim_open (kind, ptr, abfd, argv)
 263      SIM_OPEN_KIND kind;
 264      host_callback *ptr;
 265      struct _bfd *abfd;
 266      char **argv;
 267 {
 268   sim_kind = kind;
 269   myname = argv[0];
 270   sim_callback = ptr;
 271   return (SIM_DESC) 1;
 272 }
 273
 274 void
 275 sim_close (sd, quitting)
 276      SIM_DESC sd;
 277      int quitting;
 278 {
 279   /* nothing to do */
 280 }
 281
 282 SIM_RC
 283 sim_load (sd, prog, abfd, from_tty)
 284      SIM_DESC sd;
 285      char *prog;
 286      bfd *abfd;
 287      int from_tty;
 288 {
 289   extern bfd *sim_load_file (); /* ??? Don't know where this should live.  */
 290   bfd *prog_bfd;
 291
 292   prog_bfd = sim_load_file (sd, myname, sim_callback, prog, abfd,
 293                             sim_kind == SIM_OPEN_DEBUG);
 294   if (prog_bfd == NULL)
 295     return SIM_RC_FAIL;
 296   ARMul_SetPC (state, bfd_get_start_address (prog_bfd));
 297   if (abfd == NULL)
 298     bfd_close (prog_bfd);
 299   return SIM_RC_OK;
 300 }
 301
 302 void
 303 sim_stop_reason (sd, reason, sigrc)
 304      SIM_DESC sd;
 305      enum sim_stop *reason;
 306      int *sigrc;
 307 {
 308   if (state->EndCondition == 0)
 309     {
 310       *reason = sim_exited;
 311       *sigrc = state->Reg[0] & 255;
 312     }
 313   else
 314     {
 315       *reason = sim_stopped;
 316       if (state->EndCondition == RDIError_BreakpointReached)
 317         *sigrc = SIGTRAP;
 318       else
 319         *sigrc = 0;
 320     }
 321 }
 322
 323 void
 324 sim_kill (sd)
 325      SIM_DESC sd;
 326 {
 327   /* nothing to do */
 328 }
 329
 330 void
 331 sim_do_command (sd, cmd)
 332      SIM_DESC sd;
 333      char *cmd;
 334 {
 335   (*sim_callback->printf_filtered) (sim_callback, "This simulator does not accept any commands.\n");
 336 }
 337
 338
 339 void
 340 sim_set_callbacks (ptr)
 341      host_callback *ptr;
 342 {
 343   sim_callback = ptr;
 344 }