[deliverable/binutils-gdb.git] / sim / arm / wrapper.c

/* run front end support for arm
   Copyright (C) 1995, 1996, 1997 Free Software Foundation, Inc.

This file is part of ARM SIM.

GNU CC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.

GNU CC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */

/* This file provides the interface between the simulator and run.c and gdb
   (when the simulator is linked with gdb).
   All simulator interaction should go through this file.  */

#include <stdio.h>
#include <stdarg.h>
#include <string.h>
#include <bfd.h>
#include <signal.h>
#include "callback.h"
#include "remote-sim.h"
#include "armdefs.h"
#include "armemu.h"
#include "dbg_rdi.h"
#include "ansidecl.h"

host_callback *sim_callback;

static struct ARMul_State *state;

/* Who is using the simulator.  */
static SIM_OPEN_KIND sim_kind;

/* argv[0] */
static char *myname;

/* Memory size in bytes.  */
static int mem_size = (1 << 21);

/* Non-zero to display start up banner, and maybe other things.  */
static int verbosity;

/* Non-zero to set big endian mode.  */
static int big_endian;

int stop_simulator;

static void
init ()
{
  static int done;

  if (!done)
    {
      ARMul_EmulateInit ();
      state = ARMul_NewState ();
      state->bigendSig = (big_endian ? HIGH : LOW);
      ARMul_MemoryInit (state, mem_size);
      ARMul_OSInit (state);
      ARMul_CoProInit (state);
      state->verbose = verbosity;
      done = 1;
    }
}

/* Set verbosity level of simulator.
   This is not intended to produce detailed tracing or debugging information.
   Just summaries.  */
/* FIXME: common/run.c doesn't do this yet.  */

void
sim_set_verbose (v)
     int v;
{
  verbosity = v;
}

/* Set the memory size to SIZE bytes.
   Must be called before initializing simulator.  */
/* FIXME: Rename to sim_set_mem_size.  */

void
sim_size (size)
     int size;
{
  mem_size = size;
}

void
ARMul_ConsolePrint (ARMul_State * state, const char *format, ...)
{
  va_list ap;

  if (state->verbose)
    {
      va_start (ap, format);
      vprintf (format, ap);
      va_end (ap);
    }
}

ARMword
ARMul_Debug (ARMul_State * state ATTRIBUTE_UNUSED, ARMword pc ATTRIBUTE_UNUSED, ARMword instr ATTRIBUTE_UNUSED)
{
  return 0;
}

int
sim_write (sd, addr, buffer, size)
     SIM_DESC sd ATTRIBUTE_UNUSED;
     SIM_ADDR addr;
     unsigned char *buffer;
     int size;
{
  int i;
  init ();
  for (i = 0; i < size; i++)
    {
      ARMul_WriteByte (state, addr + i, buffer[i]);
    }
  return size;
}

int
sim_read (sd, addr, buffer, size)
     SIM_DESC sd ATTRIBUTE_UNUSED;
     SIM_ADDR addr;
     unsigned char *buffer;
     int size;
{
  int i;
  init ();
  for (i = 0; i < size; i++)
    {
      buffer[i] = ARMul_ReadByte (state, addr + i);
    }
  return size;
}

int
sim_trace (sd)
     SIM_DESC sd ATTRIBUTE_UNUSED;
{  
  (*sim_callback->printf_filtered) (sim_callback,
				    "This simulator does not support tracing\n");
  return 1;
}

int
sim_stop (sd)
     SIM_DESC sd ATTRIBUTE_UNUSED;
{
  state->Emulate = STOP;
  stop_simulator = 1;
  return 1;
}

void
sim_resume (sd, step, siggnal)
     SIM_DESC sd ATTRIBUTE_UNUSED;
     int step;
     int siggnal ATTRIBUTE_UNUSED;
{
  state->EndCondition = 0;
  stop_simulator = 0;

  if (step)
    {
      state->Reg[15] = ARMul_DoInstr (state);
      if (state->EndCondition == 0)
	state->EndCondition = RDIError_BreakpointReached;
    }
  else
    {
#if 1				/* JGS */
      state->NextInstr = RESUME;	/* treat as PC change */
#endif
      state->Reg[15] = ARMul_DoProg (state);
    }

  FLUSHPIPE;
}

SIM_RC
sim_create_inferior (sd, abfd, argv, env)
     SIM_DESC sd ATTRIBUTE_UNUSED;
     struct _bfd *abfd;
     char **argv;
     char **env;
{
  int argvlen = 0;
  char **arg;

  if (abfd != NULL)
    ARMul_SetPC (state, bfd_get_start_address (abfd));
  else
    ARMul_SetPC (state, 0);	/* ??? */

#if 1				/* JGS */
  /* We explicitly select a processor capable of supporting the ARM
     32bit mode, and then we force the simulated CPU into the 32bit
     User mode: */
  ARMul_SelectProcessor (state, ARM600);
  ARMul_SetCPSR (state, USER32MODE);
#endif

  if (argv != NULL)
    {
      /*
         ** Set up the command line (by laboriously stringing together the
         ** environment carefully picked apart by our caller...)
       */
      /* Free any old stuff */
      if (state->CommandLine != NULL)
	{
	  free (state->CommandLine);
	  state->CommandLine = NULL;
	}

      /* See how much we need */
      for (arg = argv; *arg != NULL; arg++)
	argvlen += strlen (*arg) + 1;

      /* allocate it... */
      state->CommandLine = malloc (argvlen + 1);
      if (state->CommandLine != NULL)
	{
	  arg = argv;
	  state->CommandLine[0] = '\0';
	  for (arg = argv; *arg != NULL; arg++)
	    {
	      strcat (state->CommandLine, *arg);
	      strcat (state->CommandLine, " ");
	    }
	}
    }

  if (env != NULL)
    {
      /* Now see if there's a MEMSIZE spec in the environment */
      while (*env)
	{
	  if (strncmp (*env, "MEMSIZE=", sizeof ("MEMSIZE=") - 1) == 0)
	    {
	      char *end_of_num;

	      /* Set up memory limit */
	      state->MemSize =
		strtoul (*env + sizeof ("MEMSIZE=") - 1, &end_of_num, 0);
	    }
	  env++;
	}
    }

  return SIM_RC_OK;
}

void
sim_info (sd, verbose)
     SIM_DESC sd ATTRIBUTE_UNUSED;
     int verbose ATTRIBUTE_UNUSED;
{
}


static int
frommem (state, memory)
     struct ARMul_State *state;
     unsigned char *memory;
{
  if (state->bigendSig == HIGH)
    {
      return (memory[0] << 24)
	| (memory[1] << 16) | (memory[2] << 8) | (memory[3] << 0);
    }
  else
    {
      return (memory[3] << 24)
	| (memory[2] << 16) | (memory[1] << 8) | (memory[0] << 0);
    }
}


static void
tomem (state, memory, val)
     struct ARMul_State *state;
     unsigned char *memory;
     int val;
{
  if (state->bigendSig == HIGH)
    {
      memory[0] = val >> 24;
      memory[1] = val >> 16;
      memory[2] = val >> 8;
      memory[3] = val >> 0;
    }
  else
    {
      memory[3] = val >> 24;
      memory[2] = val >> 16;
      memory[1] = val >> 8;
      memory[0] = val >> 0;
    }
}

int
sim_store_register (sd, rn, memory, length)
     SIM_DESC sd ATTRIBUTE_UNUSED;
     int rn;
     unsigned char *memory;
     int length ATTRIBUTE_UNUSED;
{
  init ();
  ARMul_SetReg (state, state->Mode, rn, frommem (state, memory));
  return -1;
}

int
sim_fetch_register (sd, rn, memory, length)
     SIM_DESC sd ATTRIBUTE_UNUSED;
     int rn;
     unsigned char *memory;
     int length ATTRIBUTE_UNUSED;
{
  ARMword regval;

  init ();
  if (rn < 16)
    regval = ARMul_GetReg (state, state->Mode, rn);
  else if (rn == 25)		/* FIXME: use PS_REGNUM from gdb/config/arm/tm-arm.h */
    regval = ARMul_GetCPSR (state);
  else
    regval = 0;			/* FIXME: should report an error */
  tomem (state, memory, regval);
  return -1;
}

SIM_DESC
sim_open (kind, ptr, abfd, argv)
     SIM_OPEN_KIND kind;
     host_callback *ptr;
     struct _bfd *abfd;
     char **argv;
{
  sim_kind = kind;
  myname = argv[0];
  sim_callback = ptr;

  /* Decide upon the endian-ness of the processor.
     If we can, get the information from the bfd itself.
     Otherwise look to see if we have been given a command
     line switch that tells us.  Otherwise default to little endian.  */
  if (abfd != NULL)
    big_endian = bfd_big_endian (abfd);
  else if (argv[1] != NULL)
    {
      int i;

      /* Scan for endian-ness switch.  */
      for (i = 0; (argv[i] != NULL) && (argv[i][0] != 0); i++)
	if (argv[i][0] == '-' && argv[i][1] == 'E')
	  {
	    char c;

	    if ((c = argv[i][2]) == 0)
	      {
		++i;
		c = argv[i][0];
	      }

	    switch (c)
	      {
	      case 0:
		sim_callback->printf_filtered
		  (sim_callback, "No argument to -E option provided\n");
		break;

	      case 'b':
	      case 'B':
		big_endian = 1;
		break;

	      case 'l':
	      case 'L':
		big_endian = 0;
		break;

	      default:
		sim_callback->printf_filtered
		  (sim_callback, "Unrecognised argument to -E option\n");
		break;
	      }
	  }
    }

  return (SIM_DESC) 1;
}

void
sim_close (sd, quitting)
     SIM_DESC sd ATTRIBUTE_UNUSED;
     int quitting ATTRIBUTE_UNUSED;
{
  /* nothing to do */
}

SIM_RC
sim_load (sd, prog, abfd, from_tty)
     SIM_DESC sd;
     char *prog;
     bfd *abfd;
     int from_tty ATTRIBUTE_UNUSED;
{
  extern bfd *sim_load_file ();	/* ??? Don't know where this should live.  */
  bfd *prog_bfd;

  prog_bfd = sim_load_file (sd, myname, sim_callback, prog, abfd,
			    sim_kind == SIM_OPEN_DEBUG, 0, sim_write);
  if (prog_bfd == NULL)
    return SIM_RC_FAIL;
  ARMul_SetPC (state, bfd_get_start_address (prog_bfd));
  if (abfd == NULL)
    bfd_close (prog_bfd);
  return SIM_RC_OK;
}

void
sim_stop_reason (sd, reason, sigrc)
     SIM_DESC sd ATTRIBUTE_UNUSED;
     enum sim_stop *reason;
     int *sigrc;
{
  if (stop_simulator)
    {
      *reason = sim_stopped;
      *sigrc = SIGINT;
    }
  else if (state->EndCondition == 0)
    {
      *reason = sim_exited;
      *sigrc = state->Reg[0] & 255;
    }
  else
    {
      *reason = sim_stopped;
      if (state->EndCondition == RDIError_BreakpointReached)
	*sigrc = SIGTRAP;
      else
	*sigrc = 0;
    }
}

void
sim_do_command (sd, cmd)
     SIM_DESC sd ATTRIBUTE_UNUSED;
     char *cmd ATTRIBUTE_UNUSED;
{  
  (*sim_callback->printf_filtered) (sim_callback,
				    "This simulator does not accept any commands.\n");
}


void
sim_set_callbacks (ptr)
     host_callback *ptr;
{
  sim_callback = ptr;
}
Commit	Line	Data
c906108c SS	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>
6d358e86	26	#include <string.h>
c906108c SS	27	#include <bfd.h>
	28	#include <signal.h>
	29	#include "callback.h"
	30	#include "remote-sim.h"
	31	#include "armdefs.h"
	32	#include "armemu.h"
	33	#include "dbg_rdi.h"
6d358e86	34	#include "ansidecl.h"
c906108c SS	35
	36	host_callback *sim_callback;
	37
	38	static struct ARMul_State *state;
	39
	40	/* Who is using the simulator. */
	41	static SIM_OPEN_KIND sim_kind;
	42
	43	/* argv[0] */
	44	static char *myname;
	45
	46	/* Memory size in bytes. */
	47	static int mem_size = (1 << 21);
	48
	49	/* Non-zero to display start up banner, and maybe other things. */
	50	static int verbosity;
	51
	52	/* Non-zero to set big endian mode. */
	53	static int big_endian;
	54
7a292a7a SS	55	int stop_simulator;
7a292a7a SS	56
dfcd3bfb	57	static void
c906108c SS	58	init ()
	59	{
	60	static int done;
	61
	62	if (!done)
	63	{
dfcd3bfb	64	ARMul_EmulateInit ();
c906108c SS	65	state = ARMul_NewState ();
c906108c SS	66	state->bigendSig = (big_endian ? HIGH : LOW);
dfcd3bfb JM	67	ARMul_MemoryInit (state, mem_size);
	68	ARMul_OSInit (state);
	69	ARMul_CoProInit (state);
c906108c SS	70	state->verbose = verbosity;
	71	done = 1;
	72	}
	73	}
	74
	75	/* Set verbosity level of simulator.
	76	This is not intended to produce detailed tracing or debugging information.
	77	Just summaries. */
	78	/* FIXME: common/run.c doesn't do this yet. */
	79
	80	void
	81	sim_set_verbose (v)
	82	int v;
	83	{
	84	verbosity = v;
	85	}
	86
	87	/* Set the memory size to SIZE bytes.
dfcd3bfb	88	Must be called before initializing simulator. */
c906108c SS	89	/* FIXME: Rename to sim_set_mem_size. */
c906108c SS	90
dfcd3bfb	91	void
c906108c SS	92	sim_size (size)
	93	int size;
	94	{
	95	mem_size = size;
	96	}
	97
dfcd3bfb JM	98	void
dfcd3bfb JM	99	ARMul_ConsolePrint (ARMul_State * state, const char *format, ...)
c906108c SS	100	{
	101	va_list ap;
	102
	103	if (state->verbose)
	104	{
	105	va_start (ap, format);
	106	vprintf (format, ap);
	107	va_end (ap);
	108	}
	109	}
	110
6d358e86 NC	111	ARMword
6d358e86 NC	112	ARMul_Debug (ARMul_State * state ATTRIBUTE_UNUSED, ARMword pc ATTRIBUTE_UNUSED, ARMword instr ATTRIBUTE_UNUSED)
c906108c	113	{
6d358e86	114	return 0;
c906108c SS	115	}
	116
	117	int
	118	sim_write (sd, addr, buffer, size)
6d358e86	119	SIM_DESC sd ATTRIBUTE_UNUSED;
c906108c SS	120	SIM_ADDR addr;
	121	unsigned char *buffer;
	122	int size;
	123	{
	124	int i;
	125	init ();
	126	for (i = 0; i < size; i++)
	127	{
dfcd3bfb	128	ARMul_WriteByte (state, addr + i, buffer[i]);
c906108c SS	129	}
	130	return size;
	131	}
	132
	133	int
	134	sim_read (sd, addr, buffer, size)
6d358e86	135	SIM_DESC sd ATTRIBUTE_UNUSED;
c906108c SS	136	SIM_ADDR addr;
	137	unsigned char *buffer;
	138	int size;
	139	{
	140	int i;
	141	init ();
	142	for (i = 0; i < size; i++)
	143	{
	144	buffer[i] = ARMul_ReadByte (state, addr + i);
	145	}
	146	return size;
	147	}
	148
	149	int
	150	sim_trace (sd)
6d358e86	151	SIM_DESC sd ATTRIBUTE_UNUSED;
dfcd3bfb JM	152	{
	153	(*sim_callback->printf_filtered) (sim_callback,
	154	"This simulator does not support tracing\n");
c906108c SS	155	return 1;
	156	}
	157
	158	int
	159	sim_stop (sd)
6d358e86	160	SIM_DESC sd ATTRIBUTE_UNUSED;
c906108c	161	{
7a292a7a SS	162	state->Emulate = STOP;
	163	stop_simulator = 1;
	164	return 1;
c906108c SS	165	}
	166
	167	void
	168	sim_resume (sd, step, siggnal)
6d358e86 NC	169	SIM_DESC sd ATTRIBUTE_UNUSED;
	170	int step;
	171	int siggnal ATTRIBUTE_UNUSED;
c906108c SS	172	{
c906108c SS	173	state->EndCondition = 0;
7a292a7a	174	stop_simulator = 0;
c906108c SS	175
	176	if (step)
	177	{
	178	state->Reg[15] = ARMul_DoInstr (state);
	179	if (state->EndCondition == 0)
	180	state->EndCondition = RDIError_BreakpointReached;
	181	}
	182	else
	183	{
dfcd3bfb JM	184	#if 1 /* JGS */
dfcd3bfb JM	185	state->NextInstr = RESUME; /* treat as PC change */
c906108c SS	186	#endif
	187	state->Reg[15] = ARMul_DoProg (state);
	188	}
	189
	190	FLUSHPIPE;
	191	}
	192
	193	SIM_RC
	194	sim_create_inferior (sd, abfd, argv, env)
6d358e86	195	SIM_DESC sd ATTRIBUTE_UNUSED;
c906108c SS	196	struct _bfd *abfd;
	197	char **argv;
	198	char **env;
	199	{
dfcd3bfb	200	int argvlen = 0;
c906108c SS	201	char **arg;
	202
	203	if (abfd != NULL)
	204	ARMul_SetPC (state, bfd_get_start_address (abfd));
	205	else
dfcd3bfb	206	ARMul_SetPC (state, 0); /* ??? */
c906108c	207
dfcd3bfb	208	#if 1 /* JGS */
c906108c SS	209	/* We explicitly select a processor capable of supporting the ARM
	210	32bit mode, and then we force the simulated CPU into the 32bit
	211	User mode: */
dfcd3bfb JM	212	ARMul_SelectProcessor (state, ARM600);
dfcd3bfb JM	213	ARMul_SetCPSR (state, USER32MODE);
c906108c SS	214	#endif
	215
	216	if (argv != NULL)
	217	{
	218	/*
dfcd3bfb JM	219	** Set up the command line (by laboriously stringing together the
	220	** environment carefully picked apart by our caller...)
	221	*/
c906108c SS	222	/* Free any old stuff */
	223	if (state->CommandLine != NULL)
	224	{
dfcd3bfb	225	free (state->CommandLine);
c906108c SS	226	state->CommandLine = NULL;
c906108c SS	227	}
dfcd3bfb	228
c906108c SS	229	/* See how much we need */
c906108c SS	230	for (arg = argv; *arg != NULL; arg++)
dfcd3bfb JM	231	argvlen += strlen (*arg) + 1;
dfcd3bfb JM	232
c906108c	233	/* allocate it... */
dfcd3bfb	234	state->CommandLine = malloc (argvlen + 1);
c906108c SS	235	if (state->CommandLine != NULL)
	236	{
	237	arg = argv;
dfcd3bfb	238	state->CommandLine[0] = '\0';
c906108c SS	239	for (arg = argv; *arg != NULL; arg++)
c906108c SS	240	{
dfcd3bfb JM	241	strcat (state->CommandLine, *arg);
dfcd3bfb JM	242	strcat (state->CommandLine, " ");
c906108c SS	243	}
	244	}
	245	}
	246
	247	if (env != NULL)
	248	{
	249	/* Now see if there's a MEMSIZE spec in the environment */
	250	while (*env)
	251	{
dfcd3bfb	252	if (strncmp (*env, "MEMSIZE=", sizeof ("MEMSIZE=") - 1) == 0)
c906108c	253	{
c906108c	254	char *end_of_num;
dfcd3bfb	255
c906108c	256	/* Set up memory limit */
dfcd3bfb JM	257	state->MemSize =
dfcd3bfb JM	258	strtoul (*env + sizeof ("MEMSIZE=") - 1, &end_of_num, 0);
c906108c SS	259	}
	260	env++;
	261	}
	262	}
	263
	264	return SIM_RC_OK;
	265	}
	266
	267	void
	268	sim_info (sd, verbose)
6d358e86 NC	269	SIM_DESC sd ATTRIBUTE_UNUSED;
6d358e86 NC	270	int verbose ATTRIBUTE_UNUSED;
c906108c SS	271	{
	272	}
	273
	274
dfcd3bfb	275	static int
c906108c SS	276	frommem (state, memory)
	277	struct ARMul_State *state;
	278	unsigned char *memory;
	279	{
	280	if (state->bigendSig == HIGH)
	281	{
	282	return (memory[0] << 24)
dfcd3bfb	283	\| (memory[1] << 16) \| (memory[2] << 8) \| (memory[3] << 0);
c906108c SS	284	}
	285	else
	286	{
	287	return (memory[3] << 24)
dfcd3bfb	288	\| (memory[2] << 16) \| (memory[1] << 8) \| (memory[0] << 0);
c906108c SS	289	}
	290	}
	291
	292
	293	static void
dfcd3bfb	294	tomem (state, memory, val)
c906108c SS	295	struct ARMul_State *state;
	296	unsigned char *memory;
	297	int val;
	298	{
	299	if (state->bigendSig == HIGH)
	300	{
	301	memory[0] = val >> 24;
	302	memory[1] = val >> 16;
	303	memory[2] = val >> 8;
	304	memory[3] = val >> 0;
	305	}
	306	else
	307	{
	308	memory[3] = val >> 24;
	309	memory[2] = val >> 16;
	310	memory[1] = val >> 8;
	311	memory[0] = val >> 0;
	312	}
	313	}
	314
	315	int
	316	sim_store_register (sd, rn, memory, length)
6d358e86	317	SIM_DESC sd ATTRIBUTE_UNUSED;
c906108c SS	318	int rn;
c906108c SS	319	unsigned char *memory;
6d358e86	320	int length ATTRIBUTE_UNUSED;
c906108c SS	321	{
c906108c SS	322	init ();
dfcd3bfb	323	ARMul_SetReg (state, state->Mode, rn, frommem (state, memory));
c906108c SS	324	return -1;
	325	}
	326
	327	int
	328	sim_fetch_register (sd, rn, memory, length)
6d358e86	329	SIM_DESC sd ATTRIBUTE_UNUSED;
c906108c SS	330	int rn;
c906108c SS	331	unsigned char *memory;
6d358e86	332	int length ATTRIBUTE_UNUSED;
c906108c SS	333	{
	334	ARMword regval;
	335
	336	init ();
	337	if (rn < 16)
dfcd3bfb JM	338	regval = ARMul_GetReg (state, state->Mode, rn);
	339	else if (rn == 25) /* FIXME: use PS_REGNUM from gdb/config/arm/tm-arm.h */
	340	regval = ARMul_GetCPSR (state);
c906108c	341	else
dfcd3bfb	342	regval = 0; /* FIXME: should report an error */
c906108c SS	343	tomem (state, memory, regval);
	344	return -1;
	345	}
	346
	347	SIM_DESC
	348	sim_open (kind, ptr, abfd, argv)
	349	SIM_OPEN_KIND kind;
	350	host_callback *ptr;
	351	struct _bfd *abfd;
	352	char **argv;
	353	{
	354	sim_kind = kind;
	355	myname = argv[0];
	356	sim_callback = ptr;
dfcd3bfb	357
c906108c SS	358	/* Decide upon the endian-ness of the processor.
	359	If we can, get the information from the bfd itself.
	360	Otherwise look to see if we have been given a command
	361	line switch that tells us. Otherwise default to little endian. */
	362	if (abfd != NULL)
	363	big_endian = bfd_big_endian (abfd);
	364	else if (argv[1] != NULL)
	365	{
	366	int i;
dfcd3bfb	367
c906108c SS	368	/* Scan for endian-ness switch. */
c906108c SS	369	for (i = 0; (argv[i] != NULL) && (argv[i][0] != 0); i++)
dfcd3bfb JM	370	if (argv[i][0] == '-' && argv[i][1] == 'E')
	371	{
	372	char c;
	373
	374	if ((c = argv[i][2]) == 0)
	375	{
	376	++i;
	377	c = argv[i][0];
	378	}
	379
	380	switch (c)
	381	{
	382	case 0:
	383	sim_callback->printf_filtered
	384	(sim_callback, "No argument to -E option provided\n");
	385	break;
	386
	387	case 'b':
	388	case 'B':
	389	big_endian = 1;
	390	break;
	391
	392	case 'l':
	393	case 'L':
	394	big_endian = 0;
	395	break;
	396
	397	default:
	398	sim_callback->printf_filtered
	399	(sim_callback, "Unrecognised argument to -E option\n");
	400	break;
	401	}
	402	}
c906108c SS	403	}
	404
	405	return (SIM_DESC) 1;
	406	}
	407
	408	void
	409	sim_close (sd, quitting)
6d358e86 NC	410	SIM_DESC sd ATTRIBUTE_UNUSED;
6d358e86 NC	411	int quitting ATTRIBUTE_UNUSED;
c906108c SS	412	{
	413	/* nothing to do */
	414	}
	415
	416	SIM_RC
	417	sim_load (sd, prog, abfd, from_tty)
	418	SIM_DESC sd;
	419	char *prog;
	420	bfd *abfd;
6d358e86	421	int from_tty ATTRIBUTE_UNUSED;
c906108c	422	{
dfcd3bfb	423	extern bfd sim_load_file (); / ??? Don't know where this should live. */
c906108c SS	424	bfd *prog_bfd;
	425
	426	prog_bfd = sim_load_file (sd, myname, sim_callback, prog, abfd,
dfcd3bfb	427	sim_kind == SIM_OPEN_DEBUG, 0, sim_write);
c906108c SS	428	if (prog_bfd == NULL)
	429	return SIM_RC_FAIL;
	430	ARMul_SetPC (state, bfd_get_start_address (prog_bfd));
	431	if (abfd == NULL)
	432	bfd_close (prog_bfd);
	433	return SIM_RC_OK;
	434	}
	435
	436	void
	437	sim_stop_reason (sd, reason, sigrc)
6d358e86	438	SIM_DESC sd ATTRIBUTE_UNUSED;
c906108c SS	439	enum sim_stop *reason;
	440	int *sigrc;
	441	{
7a292a7a SS	442	if (stop_simulator)
	443	{
	444	*reason = sim_stopped;
	445	*sigrc = SIGINT;
	446	}
	447	else if (state->EndCondition == 0)
c906108c SS	448	{
	449	*reason = sim_exited;
	450	*sigrc = state->Reg[0] & 255;
	451	}
	452	else
	453	{
	454	*reason = sim_stopped;
	455	if (state->EndCondition == RDIError_BreakpointReached)
	456	*sigrc = SIGTRAP;
	457	else
	458	*sigrc = 0;
	459	}
	460	}
	461
	462	void
	463	sim_do_command (sd, cmd)
6d358e86 NC	464	SIM_DESC sd ATTRIBUTE_UNUSED;
6d358e86 NC	465	char *cmd ATTRIBUTE_UNUSED;
dfcd3bfb JM	466	{
	467	(*sim_callback->printf_filtered) (sim_callback,
	468	"This simulator does not accept any commands.\n");
c906108c SS	469	}
	470
	471
	472	void
	473	sim_set_callbacks (ptr)
	474	host_callback *ptr;
	475	{
	476	sim_callback = ptr;
	477	}