[thirdparty/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);	/* ??? */

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

  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 ();
  if (rn == 25)
    {
      state->Cpsr = frommem (state, memory);
      ARMul_CPSRAltered (state);	     
    }
  else
    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;
  if (myname) free (myname);
  myname = (char *) xstrdup (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;
{
  if (myname) free (myname);
  myname = NULL;
}

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
c906108c	208	/* We explicitly select a processor capable of supporting the ARM
c1a72ffd	209	32bit mode. JGS */
dfcd3bfb	210	ARMul_SelectProcessor (state, ARM600);
c1a72ffd	211	/* And then we force the simulated CPU into the 32bit User mode. */
dfcd3bfb	212	ARMul_SetCPSR (state, USER32MODE);
c906108c SS	213
	214	if (argv != NULL)
	215	{
	216	/*
dfcd3bfb JM	217	** Set up the command line (by laboriously stringing together the
	218	** environment carefully picked apart by our caller...)
	219	*/
c906108c SS	220	/* Free any old stuff */
	221	if (state->CommandLine != NULL)
	222	{
dfcd3bfb	223	free (state->CommandLine);
c906108c SS	224	state->CommandLine = NULL;
c906108c SS	225	}
dfcd3bfb	226
c906108c SS	227	/* See how much we need */
c906108c SS	228	for (arg = argv; *arg != NULL; arg++)
dfcd3bfb JM	229	argvlen += strlen (*arg) + 1;
dfcd3bfb JM	230
c906108c	231	/* allocate it... */
dfcd3bfb	232	state->CommandLine = malloc (argvlen + 1);
c906108c SS	233	if (state->CommandLine != NULL)
	234	{
	235	arg = argv;
dfcd3bfb	236	state->CommandLine[0] = '\0';
c906108c SS	237	for (arg = argv; *arg != NULL; arg++)
c906108c SS	238	{
dfcd3bfb JM	239	strcat (state->CommandLine, *arg);
dfcd3bfb JM	240	strcat (state->CommandLine, " ");
c906108c SS	241	}
	242	}
	243	}
	244
	245	if (env != NULL)
	246	{
	247	/* Now see if there's a MEMSIZE spec in the environment */
	248	while (*env)
	249	{
dfcd3bfb	250	if (strncmp (*env, "MEMSIZE=", sizeof ("MEMSIZE=") - 1) == 0)
c906108c	251	{
c906108c	252	char *end_of_num;
dfcd3bfb	253
c906108c	254	/* Set up memory limit */
dfcd3bfb JM	255	state->MemSize =
dfcd3bfb JM	256	strtoul (*env + sizeof ("MEMSIZE=") - 1, &end_of_num, 0);
c906108c SS	257	}
	258	env++;
	259	}
	260	}
	261
	262	return SIM_RC_OK;
	263	}
	264
	265	void
	266	sim_info (sd, verbose)
6d358e86 NC	267	SIM_DESC sd ATTRIBUTE_UNUSED;
6d358e86 NC	268	int verbose ATTRIBUTE_UNUSED;
c906108c SS	269	{
	270	}
	271
	272
dfcd3bfb	273	static int
c906108c SS	274	frommem (state, memory)
	275	struct ARMul_State *state;
	276	unsigned char *memory;
	277	{
	278	if (state->bigendSig == HIGH)
	279	{
	280	return (memory[0] << 24)
dfcd3bfb	281	\| (memory[1] << 16) \| (memory[2] << 8) \| (memory[3] << 0);
c906108c SS	282	}
	283	else
	284	{
	285	return (memory[3] << 24)
dfcd3bfb	286	\| (memory[2] << 16) \| (memory[1] << 8) \| (memory[0] << 0);
c906108c SS	287	}
	288	}
	289
	290
	291	static void
dfcd3bfb	292	tomem (state, memory, val)
c906108c SS	293	struct ARMul_State *state;
	294	unsigned char *memory;
	295	int val;
	296	{
	297	if (state->bigendSig == HIGH)
	298	{
	299	memory[0] = val >> 24;
	300	memory[1] = val >> 16;
	301	memory[2] = val >> 8;
	302	memory[3] = val >> 0;
	303	}
	304	else
	305	{
	306	memory[3] = val >> 24;
	307	memory[2] = val >> 16;
	308	memory[1] = val >> 8;
	309	memory[0] = val >> 0;
	310	}
	311	}
	312
	313	int
	314	sim_store_register (sd, rn, memory, length)
6d358e86	315	SIM_DESC sd ATTRIBUTE_UNUSED;
c906108c SS	316	int rn;
c906108c SS	317	unsigned char *memory;
6d358e86	318	int length ATTRIBUTE_UNUSED;
c906108c SS	319	{
c906108c SS	320	init ();
3463c3fb NC	321	if (rn == 25)
	322	{
	323	state->Cpsr = frommem (state, memory);
	324	ARMul_CPSRAltered (state);
	325	}
	326	else
	327	ARMul_SetReg (state, state->Mode, rn, frommem (state, memory));
c906108c SS	328	return -1;
	329	}
	330
	331	int
	332	sim_fetch_register (sd, rn, memory, length)
6d358e86	333	SIM_DESC sd ATTRIBUTE_UNUSED;
c906108c SS	334	int rn;
c906108c SS	335	unsigned char *memory;
6d358e86	336	int length ATTRIBUTE_UNUSED;
c906108c SS	337	{
	338	ARMword regval;
	339
	340	init ();
	341	if (rn < 16)
dfcd3bfb JM	342	regval = ARMul_GetReg (state, state->Mode, rn);
	343	else if (rn == 25) /* FIXME: use PS_REGNUM from gdb/config/arm/tm-arm.h */
	344	regval = ARMul_GetCPSR (state);
c906108c	345	else
dfcd3bfb	346	regval = 0; /* FIXME: should report an error */
c906108c SS	347	tomem (state, memory, regval);
	348	return -1;
	349	}
	350
	351	SIM_DESC
	352	sim_open (kind, ptr, abfd, argv)
	353	SIM_OPEN_KIND kind;
	354	host_callback *ptr;
	355	struct _bfd *abfd;
	356	char **argv;
	357	{
	358	sim_kind = kind;
6c9e0292	359	if (myname) free (myname);
c1a72ffd	360	myname = (char *) xstrdup (argv[0]);
c906108c	361	sim_callback = ptr;
dfcd3bfb	362
c906108c SS	363	/* Decide upon the endian-ness of the processor.
	364	If we can, get the information from the bfd itself.
	365	Otherwise look to see if we have been given a command
	366	line switch that tells us. Otherwise default to little endian. */
	367	if (abfd != NULL)
	368	big_endian = bfd_big_endian (abfd);
	369	else if (argv[1] != NULL)
	370	{
	371	int i;
dfcd3bfb	372
c906108c SS	373	/* Scan for endian-ness switch. */
c906108c SS	374	for (i = 0; (argv[i] != NULL) && (argv[i][0] != 0); i++)
dfcd3bfb JM	375	if (argv[i][0] == '-' && argv[i][1] == 'E')
	376	{
	377	char c;
	378
	379	if ((c = argv[i][2]) == 0)
	380	{
	381	++i;
	382	c = argv[i][0];
	383	}
	384
	385	switch (c)
	386	{
	387	case 0:
	388	sim_callback->printf_filtered
	389	(sim_callback, "No argument to -E option provided\n");
	390	break;
	391
	392	case 'b':
	393	case 'B':
	394	big_endian = 1;
	395	break;
	396
	397	case 'l':
	398	case 'L':
	399	big_endian = 0;
	400	break;
	401
	402	default:
	403	sim_callback->printf_filtered
	404	(sim_callback, "Unrecognised argument to -E option\n");
	405	break;
	406	}
	407	}
c906108c SS	408	}
	409
	410	return (SIM_DESC) 1;
	411	}
	412
	413	void
	414	sim_close (sd, quitting)
6d358e86 NC	415	SIM_DESC sd ATTRIBUTE_UNUSED;
6d358e86 NC	416	int quitting ATTRIBUTE_UNUSED;
c906108c	417	{
6c9e0292 FCE	418	if (myname) free (myname);
6c9e0292 FCE	419	myname = NULL;
c906108c SS	420	}
	421
	422	SIM_RC
	423	sim_load (sd, prog, abfd, from_tty)
	424	SIM_DESC sd;
	425	char *prog;
	426	bfd *abfd;
6d358e86	427	int from_tty ATTRIBUTE_UNUSED;
c906108c	428	{
dfcd3bfb	429	extern bfd sim_load_file (); / ??? Don't know where this should live. */
c906108c SS	430	bfd *prog_bfd;
	431
	432	prog_bfd = sim_load_file (sd, myname, sim_callback, prog, abfd,
dfcd3bfb	433	sim_kind == SIM_OPEN_DEBUG, 0, sim_write);
c906108c SS	434	if (prog_bfd == NULL)
	435	return SIM_RC_FAIL;
	436	ARMul_SetPC (state, bfd_get_start_address (prog_bfd));
	437	if (abfd == NULL)
	438	bfd_close (prog_bfd);
	439	return SIM_RC_OK;
	440	}
	441
	442	void
	443	sim_stop_reason (sd, reason, sigrc)
6d358e86	444	SIM_DESC sd ATTRIBUTE_UNUSED;
c906108c SS	445	enum sim_stop *reason;
	446	int *sigrc;
	447	{
7a292a7a SS	448	if (stop_simulator)
	449	{
	450	*reason = sim_stopped;
	451	*sigrc = SIGINT;
	452	}
	453	else if (state->EndCondition == 0)
c906108c SS	454	{
	455	*reason = sim_exited;
	456	*sigrc = state->Reg[0] & 255;
	457	}
	458	else
	459	{
	460	*reason = sim_stopped;
	461	if (state->EndCondition == RDIError_BreakpointReached)
	462	*sigrc = SIGTRAP;
	463	else
	464	*sigrc = 0;
	465	}
	466	}
	467
	468	void
	469	sim_do_command (sd, cmd)
6d358e86 NC	470	SIM_DESC sd ATTRIBUTE_UNUSED;
6d358e86 NC	471	char *cmd ATTRIBUTE_UNUSED;
dfcd3bfb JM	472	{
	473	(*sim_callback->printf_filtered) (sim_callback,
	474	"This simulator does not accept any commands.\n");
c906108c SS	475	}
	476
	477
	478	void
	479	sim_set_callbacks (ptr)
	480	host_callback *ptr;
	481	{
	482	sim_callback = ptr;
	483	}