#include <signal.h>
+#include "sim-main.h"
#include "v850_sim.h"
#include "simops.h"
-#include "sys/syscall.h"
+
+#ifdef HAVE_UTIME_H
+#include <utime.h>
+#endif
+
+#ifdef HAVE_TIME_H
+#include <time.h>
+#endif
+
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+
+ /* FIXME - should be including a version of syscall.h that does not
+ pollute the name space */
+#include "../../libgloss/v850/sys/syscall.h"
+
#include "bfd.h"
+#include "libiberty.h"
+
#include <errno.h>
#if !defined(__GO32__) && !defined(_WIN32)
#include <sys/stat.h>
return;
}
+\f
+/* Read a null terminated string from memory, return in a buffer */
+static char *
+fetch_str (sd, addr)
+ SIM_DESC sd;
+ address_word addr;
+{
+ char *buf;
+ int nr = 0;
+ while (sim_core_read_1 (STATE_CPU (sd, 0),
+ PC, sim_core_read_map, addr + nr) != 0)
+ nr++;
+ buf = NZALLOC (char, nr + 1);
+ sim_read (simulator, addr, buf, nr);
+ return buf;
+}
+
+/* Read a null terminated argument vector from memory, return in a
+ buffer */
+static char **
+fetch_argv (sd, addr)
+ SIM_DESC sd;
+ address_word addr;
+{
+ int max_nr = 64;
+ int nr = 0;
+ char **buf = xmalloc (max_nr * sizeof (char*));
+ while (1)
+ {
+ unsigned32 a = sim_core_read_4 (STATE_CPU (sd, 0),
+ PC, sim_core_read_map, addr + nr * 4);
+ if (a == 0) break;
+ buf[nr] = fetch_str (sd, a);
+ nr ++;
+ if (nr == max_nr - 1)
+ {
+ max_nr += 50;
+ buf = xrealloc (buf, max_nr * sizeof (char*));
+ }
+ }
+ buf[nr] = 0;
+ return buf;
+}
+
\f
/* sld.b */
int
static int
branch (int code)
{
- unsigned int psw;
- int op0;
-
trace_input ("Bcond", OP_COND_BR, 0);
trace_output (OP_COND_BR);
{
trace_input ("movhi", OP_UIMM_REG_REG, 16);
- State.regs[ OP[1] ] = State.regs[ OP[0] ] + OP[2] << 16;
+ State.regs[ OP[1] ] = State.regs[ OP[0] ] + (OP[2] << 16);
trace_output (OP_UIMM_REG_REG);
}
switch (FUNC)
{
-#if !defined(__GO32__) && !defined(_WIN32)
+
+#ifdef HAVE_FORK
+#ifdef SYS_fork
case SYS_fork:
RETVAL = fork ();
break;
+#endif
+#endif
+
+#ifdef HAVE_EXECVE
+#ifdef SYS_execv
case SYS_execve:
- RETVAL = execve (MEMPTR (PARM1), (char **) MEMPTR (PARM2),
- (char **)MEMPTR (PARM3));
- break;
+ {
+ char *path = fetch_str (simulator, PARM1);
+ char **argv = fetch_argv (simulator, PARM2);
+ char **envp = fetch_argv (simulator, PARM3);
+ RETVAL = execve (path, argv, envp);
+ zfree (path);
+ freeargv (argv);
+ freeargv (envp);
+ break;
+ }
+#endif
+#endif
+
+#if HAVE_EXECV
#ifdef SYS_execv
case SYS_execv:
- RETVAL = execve (MEMPTR (PARM1), (char **) MEMPTR (PARM2), NULL);
- break;
+ {
+ char *path = fetch_str (simulator, PARM1);
+ char **argv = fetch_argv (simulator, PARM2);
+ RETVAL = execv (path, argv);
+ zfree (path);
+ freeargv (argv);
+ break;
+ }
+#endif
#endif
+
#if 0
+#ifdef SYS_pipe
case SYS_pipe:
{
reg_t buf;
SW (buf, host_fd[1]);
}
break;
+#endif
+#endif
+#if 0
+#ifdef SYS_wait
case SYS_wait:
{
int status;
#endif
#endif
+#ifdef SYS_read
case SYS_read:
- RETVAL = v850_callback->read (v850_callback, PARM1, MEMPTR (PARM2),
- PARM3);
- break;
+ {
+ char *buf = zalloc (PARM3);
+ RETVAL = sim_io_read (simulator, PARM1, buf, PARM3);
+ sim_write (simulator, PARM2, buf, PARM3);
+ zfree (buf);
+ break;
+ }
+#endif
+
+#ifdef SYS_write
case SYS_write:
- if (PARM1 == 1)
- RETVAL = (int)v850_callback->write_stdout (v850_callback,
- MEMPTR (PARM2), PARM3);
- else
- RETVAL = (int)v850_callback->write (v850_callback, PARM1,
- MEMPTR (PARM2), PARM3);
- break;
+ {
+ char *buf = zalloc (PARM3);
+ sim_read (simulator, PARM2, buf, PARM3);
+ if (PARM1 == 1)
+ RETVAL = sim_io_write_stdout (simulator, buf, PARM3);
+ else
+ RETVAL = sim_io_write (simulator, PARM1, buf, PARM3);
+ zfree (buf);
+ break;
+ }
+#endif
+
+#ifdef SYS_lseek
case SYS_lseek:
- RETVAL = v850_callback->lseek (v850_callback, PARM1, PARM2, PARM3);
+ RETVAL = sim_io_lseek (simulator, PARM1, PARM2, PARM3);
break;
+#endif
+
+#ifdef SYS_close
case SYS_close:
- RETVAL = v850_callback->close (v850_callback, PARM1);
+ RETVAL = sim_io_close (simulator, PARM1);
break;
+#endif
+
+#ifdef SYS_open
case SYS_open:
- RETVAL = v850_callback->open (v850_callback, MEMPTR (PARM1), PARM2);
- break;
+ {
+ char *buf = fetch_str (simulator, PARM1);
+ RETVAL = sim_io_open (simulator, buf, PARM2);
+ zfree (buf);
+ break;
+ }
+#endif
+
+#ifdef SYS_exit
case SYS_exit:
if ((PARM1 & 0xffff0000) == 0xdead0000 && (PARM1 & 0xffff) != 0)
State.exception = PARM1 & 0xffff; /* get signal encoded by kill */
else
State.exception = SIG_V850_EXIT; /* PARM1 has exit status encoded */
break;
+#endif
#if !defined(__GO32__) && !defined(_WIN32)
+#ifdef SYS_stat
case SYS_stat: /* added at hmsi */
/* stat system call */
{
struct stat host_stat;
reg_t buf;
+ char *path = fetch_str (simulator, PARM1);
- RETVAL = stat (MEMPTR (PARM1), &host_stat);
+ RETVAL = stat (path, &host_stat);
+ zfree (path);
buf = PARM2;
/* Just wild-assed guesses. */
store_mem (buf + 36, 4, host_stat.st_ctime);
}
break;
+#endif
+#endif
+#ifdef HAVE_CHOWN
+#ifdef SYS_chown
case SYS_chown:
- RETVAL = chown (MEMPTR (PARM1), PARM2, PARM3);
+ {
+ char *path = fetch_str (simulator, PARM1);
+ RETVAL = chown (path, PARM2, PARM3);
+ zfree (path);
+ }
break;
+#endif
+#endif
+
+#if HAVE_CHMOD
+#ifdef SYS_chmod
case SYS_chmod:
- RETVAL = chmod (MEMPTR (PARM1), PARM2);
+ {
+ char *path = fetch_str (simulator, PARM1);
+ RETVAL = chmod (path, PARM2);
+ zfree (path);
+ }
break;
+#endif
+#endif
+
#ifdef SYS_time
+#if HAVE_TIME
case SYS_time:
{
time_t now;
}
break;
#endif
+#endif
+
+#if !defined(__GO32__) && !defined(_WIN32)
#ifdef SYS_times
case SYS_times:
{
break;
}
#endif
+#endif
+
+#ifdef SYS_gettimeofday
+#if !defined(__GO32__) && !defined(_WIN32)
case SYS_gettimeofday:
{
struct timeval t;
store_mem (PARM2 + 4, 4, tz.tz_dsttime);
break;
}
+#endif
+#endif
+
#ifdef SYS_utime
+#if HAVE_UTIME
case SYS_utime:
- /* Cast the second argument to void *, to avoid type mismatch
- if a prototype is present. */
- RETVAL = utime (MEMPTR (PARM1), (void *) MEMPTR (PARM2));
+ {
+ /* Cast the second argument to void *, to avoid type mismatch
+ if a prototype is present. */
+ sim_io_error (simulator, "Utime not supported");
+ /* RETVAL = utime (path, (void *) MEMPTR (PARM2)); */
+ }
break;
#endif
#endif
+
default:
abort ();
}
int
OP_4007E0 ()
{
- unsigned int op0;
-
trace_input ("stsr", OP_STSR, 0);
State.regs[ OP[1] ] = State.sregs[ OP[0] ];
boolean * overflow_ptr
)
{
- unsigned long ald = sfi >> N - 1;
+ unsigned long ald = sfi >> (N - 1);
unsigned long alo = als;
unsigned int Q = 1;
unsigned int C;
unsigned int S = 0;
unsigned int i;
unsigned int R1 = 1;
- unsigned int OV;
unsigned int DBZ = (als == 0) ? 1 : 0;
unsigned long alt = Q ? ~als : als;
/* 1st Loop */
alo = ald + alt + Q;
- C = (alt >> 31) & (ald >> 31) | ((alt >> 31) ^ (ald >> 31)) & (~alo >> 31);
+ C = (((alt >> 31) & (ald >> 31))
+ | (((alt >> 31) ^ (ald >> 31)) & (~alo >> 31)));
C = C ^ Q;
Q = ~(C ^ S) & 1;
R1 = (alo == 0) ? 0 : (R1 & Q);
{
alt = Q ? ~als : als;
alo = ald + alt + Q;
- C = (alt >> 31) & (ald >> 31) | ((alt >> 31) ^ (ald >> 31)) & (~alo >> 31);
+ C = (((alt >> 31) & (ald >> 31))
+ | (((alt >> 31) ^ (ald >> 31)) & (~alo >> 31)));
C = C ^ Q;
Q = ~(C ^ S) & 1;
R1 = (alo == 0) ? 0 : (R1 & Q);
/* Nth Loop */
alt = Q ? ~als : als;
alo = ald + alt + Q;
- C = (alt >> 31) & (ald >> 31) | ((alt >> 31) ^ (ald >> 31)) & (~alo >> 31);
+ C = (((alt >> 31) & (ald >> 31))
+ | (((alt >> 31) ^ (ald >> 31)) & (~alo >> 31)));
C = C ^ Q;
Q = ~(C ^ S) & 1;
R1 = (alo == 0) ? 0 : (R1 & Q);
/* 1st Loop */
alo = ald + alt + Q;
- C = (alt >> 31) & (ald >> 31) | ((alt >> 31) ^ (ald >> 31)) & (~alo >> 31);
+ C = (((alt >> 31) & (ald >> 31))
+ | (((alt >> 31) ^ (ald >> 31)) & (~alo >> 31)));
Q = C ^ SS;
R1 = (alo == 0) ? 0 : (R1 & (Q ^ (SS ^ SD)));
S = alo >> 31;
{
alt = Q ? ~als : als;
alo = ald + alt + Q;
- C = (alt >> 31) & (ald >> 31) | ((alt >> 31) ^ (ald >> 31)) & (~alo >> 31);
+ C = (((alt >> 31) & (ald >> 31))
+ | (((alt >> 31) ^ (ald >> 31)) & (~alo >> 31)));
Q = C ^ SS;
R1 = (alo == 0) ? 0 : (R1 & (Q ^ (SS ^ SD)));
S = alo >> 31;
/* Nth Loop */
alt = Q ? ~als : als;
alo = ald + alt + Q;
- C = (alt >> 31) & (ald >> 31) | ((alt >> 31) ^ (ald >> 31)) & (~alo >> 31);
+ C = (((alt >> 31) & (ald >> 31))
+ | (((alt >> 31) ^ (ald >> 31)) & (~alo >> 31)));
Q = C ^ SS;
R1 = (alo == 0) ? 0 : (R1 & (Q ^ (SS ^ SD)));
sfi = (sfi << (32-N+1));
* remainder_ptr = alo;
/* Adj */
- if ((alo != 0) && ((SS ^ SD) ^ R1) || (alo == 0) && (SS ^ R1))
+ if (((alo != 0) && ((SS ^ SD) ^ R1))
+ || ((alo == 0) && (SS ^ R1)))
alo = ald + 1;
else
alo = ald;
trace_input ("ld.bu", OP_LOAD32, 1);
- adr = State.regs[ OP[0] ] + SEXT16 (OP[2] & ~1) | ((OP[3] >> 5) & 1);
+ adr = (State.regs[ OP[0] ]
+ + (SEXT16 (OP[2] & ~1) | ((OP[3] >> 5) & 1)));
State.regs[ OP[1] ] = load_mem (adr, 1);
}
trace_output (OP_PUSHPOP2);
+
+ return 4;
}
/* pushmh list18 */