From fe031f82c4c3cd6e0eb36ec1ecf2ff2cec223d06 Mon Sep 17 00:00:00 2001 From: David Edelsohn Date: Wed, 18 May 1994 21:37:08 +0000 Subject: * interp.c (sim_*): Make result void where there isn't one. (sim_set_pc): Delete. (sim_info): Delete printf_fn arg, all callers changed. Call printf_filtered instead. (sim_close): New function. (sim_load): New function. (sim_create_inferior): Renamed from sim_set_args, all callers changed. * run.c: #include , "remote-sim.h". (printf_filtered): New function. --- sim/sh/interp.c | 261 +++++++++++++++++++++++++++++++++++++++++++++----------- 1 file changed, 211 insertions(+), 50 deletions(-) (limited to 'sim/sh/interp.c') diff --git a/sim/sh/interp.c b/sim/sh/interp.c index e28fe86..0f3e5d5 100644 --- a/sim/sh/interp.c +++ b/sim/sh/interp.c @@ -17,11 +17,14 @@ MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. */ + #include #include "sysdep.h" #include #include #include "bfd.h" +#include "remote-sim.h" +#include "../../newlib/libc/sys/sh/sys/syscall.h" #define O_RECOMPILE 85 #define DEFINE_TABLE @@ -48,7 +51,36 @@ #define PC pc #define C cycles +char *fail() +{ + + +} + + + +/* Define this to enable register lifetime checking. + The compiler generates "add #0,rn" insns to mark registers as invalid, + the simulator uses this info to call fail if it finds a ref to an invalid + register before a def + + #define PARANOID +*/ + +#ifdef PARANOID +int valid[16]; +#define CREF(x) if(!valid[x]) fail(); +#define CDEF(x) valid[x] = 1; +#define UNDEF(x) valid[x] = 0; +#else +#define CREF(x) +#define CDEF(x) +#define UNDEF(x) +#endif + + #ifdef TARGET_BIG_ENDIAN +#if 0 #define LMEM(x) *((long *)(memory+((x)&maskl))) #define BMEM(x) *((char *)(memory+((x)&maskb))) #define UWMEM(x) *((unsigned short *)(memory+((x)&maskw))) @@ -61,6 +93,19 @@ #define WBAT(x,value) (BMEM(x) = value) #define RBAT(x) (BMEM(x)) #else +#define LMEM(x) ((x)&maskl ? fail() : *((long *)(memory+((x)&maskl)))) +#define BMEM(x) ((x) &maskb ? fail() : *((char *)(memory+((x)&maskb)))) +#define UWMEM(x) ((x)&maskw ? fail() : *((unsigned short *)(memory+((x)&maskw)))) +#define SWMEM(x) ((x)&maskw ? fail() : *((short *)(memory+((x)&maskw)))) +#define WLAT(x,value) (LMEM(x) = value) +#define RLAT(x) (LMEM(x)) +#define WWAT(x,value) (UWMEM(x) = value) +#define RSWAT(x) (SWMEM(x)) +#define RUWAT(x) (UWMEM(x)) +#define WBAT(x,value) (BMEM(x) = value) +#define RBAT(x) (BMEM(x)) +#endif +#else /* For little endian or unknown host machines */ #define WLAT(x,value)\ { int v = value; unsigned char *p = memory + ((x) & maskl);\ @@ -95,10 +140,18 @@ #define SL(TEMPPC) iword= RUWAT(TEMPPC); goto top; +int empty[16]; + #define L(x) thislock = x; #define TL(x) if ((x) == prevlock) stalls++; #define TB(x,y) if ((x) == prevlock || (y)==prevlock) stalls++; + +#ifdef __GO32__ int sim_memory_size = 19; +#else +int sim_memory_size = 24; +#endif + static int sim_profile_size = 17; static int nsamples; static int sim_timeout; @@ -163,7 +216,7 @@ saved_state_type saved_state; static int get_now () { - return time((char*)0); + return time((long*)0); } static int @@ -226,7 +279,27 @@ ptr (x) return (char *) (x + saved_state.asregs.memory); } -/* Simulate a monitor trap. */ +static char *wwat(ptr, val) +char *ptr; +int val; +{ + ptr[0] = val >> 8; + ptr[1] = val; + return ptr+2; +} + +static char *wlat(ptr,val) +char *ptr; +int val; +{ + ptr[0] = val>> 24; + ptr[1] = val >> 16; + ptr[2] = val >>8; + ptr[3] = val; + return ptr+4; +} + +/* Simulate a monitor trap, put the result into r0 and errno into r1 */ static void trap (i, regs) @@ -249,31 +322,102 @@ trap (i, regs) switch (regs[4]) { - case 3: - regs[4] = read (regs[5], ptr (regs[6]), regs[7]); +#ifndef __GO32__ + case SYS_fork: + regs[0] = fork(); + break; + + case SYS_execve: + regs[0] = execve(ptr(regs[5]), ptr(regs[6]), ptr(regs[7])); + break; + case SYS_execv: + regs[0] = execv(ptr(regs[5]), ptr(regs[6])); + break; + case SYS_pipe: + { + char* buf; + int host_fd[2]; + + buf = ptr(regs[5]); + + regs[0] = pipe(host_fd); + + buf = wlat(buf, host_fd[0]); + buf = wlat(buf, host_fd[1]); + } + break; + + case SYS_wait: + regs[0] = wait(ptr(regs[5])); + break; +#endif + case SYS_read: + regs[0] = read (regs[5], ptr (regs[6]), regs[7]); break; - case 4: - regs[4] = write (regs[5], ptr (regs[6]), regs[7]); + case SYS_write: + regs[0] = write (regs[5], ptr (regs[6]), regs[7]); break; - case 19: - regs[4] = lseek (regs[5], regs[6], regs[7]); + case SYS_lseek: + regs[0] = lseek (regs[5], regs[6], regs[7]); break; - case 6: - regs[4] = close (regs[5]); + case SYS_close: + regs[0] = close (regs[5]); break; - case 5: - regs[4] = open (ptr (regs[5]), regs[6]); + case SYS_open: + regs[0] = open (ptr (regs[5]), regs[6]); break; - case 1: + case SYS_exit: /* EXIT */ saved_state.asregs.exception = SIGQUIT; errno = regs[5]; break; + case SYS_stat: /* added at hmsi */ + /* stat system call */ + { + struct stat host_stat; + char *buf; + + regs[0] = stat( ptr(regs[5]), &host_stat); + + buf = ptr(regs[6]); + + buf = wwat(buf, host_stat.st_dev); + buf = wwat(buf, host_stat.st_ino); + + buf = wlat(buf, host_stat.st_mode); + + buf = wwat(buf, host_stat.st_nlink); + buf = wwat(buf, host_stat.st_uid); + buf = wwat(buf, host_stat.st_gid); + buf = wwat(buf, host_stat.st_rdev); + + buf = wlat(buf, host_stat.st_size); + buf = wlat(buf, host_stat.st_atime); + buf = wlat(buf, 0); + buf = wlat(buf, host_stat.st_mtime); + buf = wlat(buf, 0); + buf = wlat(buf, host_stat.st_ctime); + buf = wlat(buf, 0); + buf = wlat(buf, host_stat.st_blksize); + buf = wlat(buf, host_stat.st_blocks); + } + break; + + case SYS_chown: + regs[0] = chown( ptr(regs[5]), regs[6], regs[7] ); + break; + case SYS_chmod: + regs[0] = chmod( ptr(regs[5]), regs[6]); + break; + case SYS_utime: + regs[0] = utime (ptr(regs[5]), ptr(regs[6])); + break; + default: abort (); } - regs[0] = errno; + regs[1] = errno; errno = perrno; } @@ -281,6 +425,7 @@ trap (i, regs) case 255: saved_state.asregs.exception = SIGTRAP; + saved_state.asregs.exception = 5; break; } @@ -528,9 +673,10 @@ gotcall (from, to) } #define MMASKB ((saved_state.asregs.msize -1) & ~0) + void -sim_resume (step) - int step; +sim_resume (step, siggnal) + int step, siggnal; { register unsigned int pc; register int cycles = 0; @@ -651,7 +797,7 @@ sim_resume (step) int sim_write (addr, buffer, size) - long int addr; + SIM_ADDR addr; unsigned char *buffer; int size; { @@ -662,13 +808,13 @@ sim_write (addr, buffer, size) { saved_state.asregs.memory[MMASKB & (addr + i)] = buffer[i]; } -return size; + return size; } int sim_read (addr, buffer, size) - long int addr; - char *buffer; + SIM_ADDR addr; + unsigned char *buffer; int size; { int i; @@ -679,14 +825,14 @@ sim_read (addr, buffer, size) { buffer[i] = saved_state.asregs.memory[MMASKB & (addr + i)]; } -return size; + return size; } void sim_store_register (rn, value) int rn; - unsigned char value[4]; + unsigned char *value; { saved_state.asregs.regs[rn] = (value[0] << 24) | (value[1] << 16) | (value[2] << 8) | (value[3]); } @@ -694,7 +840,7 @@ sim_store_register (rn, value) void sim_fetch_register (rn, buf) int rn; - char *buf; + unsigned char *buf; { int value = ((int *) (&saved_state))[rn]; @@ -708,41 +854,36 @@ sim_trace () return 0; } -enum sim_stop -sim_stop_signal (sigrc) +void +sim_stop_reason (reason, sigrc) + enum sim_stop *reason; int *sigrc; { + *reason = sim_stopped; *sigrc = saved_state.asregs.exception; - return sim_stopped; -} - -void -sim_set_pc (x) - int x; -{ - saved_state.asregs.pc = x; } void -sim_info () +sim_info (verbose) + int verbose; { double timetaken = (double) saved_state.asregs.ticks / (double) now_persec (); double virttime = saved_state.asregs.cycles / 36.0e6; - printf ("\n\n# instructions executed %10d\n", saved_state.asregs.insts); - printf ("# cycles %10d\n", saved_state.asregs.cycles); - printf ("# pipeline stalls %10d\n", saved_state.asregs.stalls); - printf ("# real time taken %10.4f\n", timetaken); - printf ("# virtual time taken %10.4f\n", virttime); - printf ("# profiling size %10d\n", sim_profile_size); - printf ("# profiling frequency %10d\n", saved_state.asregs.profile); - printf ("# profile maxpc %10x\n", (1 << sim_profile_size) << PROFILE_SHIFT); + printf_filtered ("\n\n# instructions executed %10d\n", saved_state.asregs.insts); + printf_filtered ("# cycles %10d\n", saved_state.asregs.cycles); + printf_filtered ("# pipeline stalls %10d\n", saved_state.asregs.stalls); + printf_filtered ("# real time taken %10.4f\n", timetaken); + printf_filtered ("# virtual time taken %10.4f\n", virttime); + printf_filtered ("# profiling size %10d\n", sim_profile_size); + printf_filtered ("# profiling frequency %10d\n", saved_state.asregs.profile); + printf_filtered ("# profile maxpc %10x\n", (1 << sim_profile_size) << PROFILE_SHIFT); if (timetaken != 0) { - printf ("# cycles/second %10d\n", (int) (saved_state.asregs.cycles / timetaken)); - printf ("# simulation ratio %10.4f\n", virttime / timetaken); + printf_filtered ("# cycles/second %10d\n", (int) (saved_state.asregs.cycles / timetaken)); + printf_filtered ("# simulation ratio %10.4f\n", virttime / timetaken); } } @@ -763,19 +904,39 @@ sim_set_profile_size (n) void -sim_kill() +sim_open (name) + char *name; { + /* nothing to do */ +} +void +sim_close (quitting) + int quitting; +{ + /* nothing to do */ } int -sim_open() +sim_load (prog, from_tty) + char *prog; + int from_tty; { - return 0; + /* Return nonzero so GDB will handle it. */ + return 1; } -int sim_set_args() + +void +sim_create_inferior (start_address, argv, env) + SIM_ADDR start_address; + char **argv; + char **env; { - return 0; + saved_state.asregs.pc = start_address; } - +void +sim_kill () +{ + /* nothing to do */ +} -- cgit v1.1