#include <signal.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <sys/fcntl.h>
#include "sis.h"
#include "bfd.h"
#include <dis-asm.h>
#include "sim-config.h"
#include "gdb/remote-sim.h"
#ifndef fprintf
extern fprintf();
#endif
#define PSR_CWP 0x7
#define VAL(x) strtol(x,(char **)NULL,0)
extern char **buildargv(char *input);
extern struct disassemble_info dinfo;
extern struct pstate sregs;
extern struct estate ebase;
extern int current_target_byte_order;
extern int ctrl_c;
extern int nfp;
extern int ift;
extern int rom8;
extern int wrp;
extern int uben;
extern int sis_verbose;
extern char *sis_version;
extern struct estate ebase;
extern struct evcell evbuf[];
extern struct irqcell irqarr[];
extern int irqpend, ext_irl;
extern int sparclite;
extern int dumbio;
extern int sparclite_board;
extern int termsave;
extern char uart_dev1[], uart_dev2[];
int sis_gdb_break = 1;
host_callback *sim_callback;
int
run_sim(sregs, icount, dis)
struct pstate *sregs;
unsigned int icount;
int dis;
{
int mexc, irq;
if (sis_verbose)
(*sim_callback->printf_filtered) (sim_callback, "resuming at %x\n",
sregs->pc);
init_stdio();
sregs->starttime = time(NULL);
irq = 0;
while (!sregs->err_mode & (icount > 0)) {
sregs->fhold = 0;
sregs->hold = 0;
sregs->icnt = 1;
if (sregs->psr & 0x080)
sregs->asi = 8;
else
sregs->asi = 9;
#if 0
if (sis_verbose > 1)
if (sregs->pc == 0 || sregs->npc == 0)
printf ("bogus pc or npc\n");
#endif
mexc = memory_read(sregs->asi, sregs->pc, &sregs->inst,
2, &sregs->hold);
#if 1
if (sis_verbose > 2)
printf("pc %x, np %x, sp %x, fp %x, wm %x, cw %x, i %08x\n",
sregs->pc, sregs->npc,
sregs->r[(((sregs->psr & 7) << 4) + 14) & 0x7f],
sregs->r[(((sregs->psr & 7) << 4) + 30) & 0x7f],
sregs->wim,
sregs->psr & 7,
sregs->inst);
#endif
if (sregs->annul) {
sregs->annul = 0;
sregs->icnt = 1;
sregs->pc = sregs->npc;
sregs->npc = sregs->npc + 4;
} else {
if (ext_irl) irq = check_interrupts(sregs);
if (!irq) {
if (mexc) {
sregs->trap = I_ACC_EXC;
} else {
if ((sis_gdb_break) && (sregs->inst == 0x91d02001)) {
if (sis_verbose)
(*sim_callback->printf_filtered) (sim_callback,
"SW BP hit at %x\n", sregs->pc);
sim_halt();
restore_stdio();
clearerr(stdin);
return (BPT_HIT);
} else
dispatch_instruction(sregs);
}
icount--;
}
if (sregs->trap) {
irq = 0;
sregs->err_mode = execute_trap(sregs);
}
}
advance_time(sregs);
if (ctrl_c) {
icount = 0;
}
}
sim_halt();
sregs->tottime += time(NULL) - sregs->starttime;
restore_stdio();
clearerr(stdin);
if (sregs->err_mode)
error_mode(sregs->pc);
if (sregs->err_mode)
return (ERROR);
if (sregs->bphit) {
if (sis_verbose)
(*sim_callback->printf_filtered) (sim_callback,
"HW BP hit at %x\n", sregs->pc);
return (BPT_HIT);
}
if (ctrl_c) {
ctrl_c = 0;
return (CTRL_C);
}
return (TIME_OUT);
}
void
sim_set_callbacks (ptr)
host_callback *ptr;
{
sim_callback = ptr;
}
void
sim_size (memsize)
int memsize;
{
}
SIM_DESC
sim_open (kind, callback, abfd, argv)
SIM_OPEN_KIND kind;
struct host_callback_struct *callback;
struct _bfd *abfd;
char **argv;
{
int argc = 0;
int stat = 1;
int freq = 0;
sim_callback = callback;
while (argv[argc])
argc++;
while (stat < argc) {
if (argv[stat][0] == '-') {
if (strcmp(argv[stat], "-v") == 0) {
sis_verbose++;
} else
if (strcmp(argv[stat], "-nfp") == 0) {
nfp = 1;
} else
if (strcmp(argv[stat], "-ift") == 0) {
ift = 1;
} else
if (strcmp(argv[stat], "-sparclite") == 0) {
sparclite = 1;
} else
if (strcmp(argv[stat], "-sparclite-board") == 0) {
sparclite_board = 1;
} else
if (strcmp(argv[stat], "-dumbio") == 0) {
dumbio = 1;
} else
if (strcmp(argv[stat], "-wrp") == 0) {
wrp = 1;
} else
if (strcmp(argv[stat], "-rom8") == 0) {
rom8 = 1;
} else
if (strcmp(argv[stat], "-uben") == 0) {
uben = 1;
} else
if (strcmp(argv[stat], "-uart1") == 0) {
if ((stat + 1) < argc)
strcpy(uart_dev1, argv[++stat]);
} else
if (strcmp(argv[stat], "-uart2") == 0) {
if ((stat + 1) < argc)
strcpy(uart_dev2, argv[++stat]);
} else
if (strcmp(argv[stat], "-nogdb") == 0) {
sis_gdb_break = 0;
} else
if (strcmp(argv[stat], "-freq") == 0) {
if ((stat + 1) < argc) {
freq = VAL(argv[++stat]);
}
} else {
(*sim_callback->printf_filtered) (sim_callback,
"unknown option %s\n",
argv[stat]);
}
} else
bfd_load(argv[stat]);
stat++;
}
if (sis_verbose) {
(*sim_callback->printf_filtered) (sim_callback, "\n SIS - SPARC instruction simulator %s\n", sis_version);
(*sim_callback->printf_filtered) (sim_callback, " Bug-reports to Jiri Gaisler ESA/ESTEC (jgais@wd.estec.esa.nl)\n");
if (nfp)
(*sim_callback->printf_filtered) (sim_callback, "no FPU\n");
if (sparclite)
(*sim_callback->printf_filtered) (sim_callback, "simulating Sparclite\n");
if (dumbio)
(*sim_callback->printf_filtered) (sim_callback, "dumb IO (no input, dumb output)\n");
if (sis_gdb_break == 0)
(*sim_callback->printf_filtered) (sim_callback, "disabling GDB trap handling for breakpoints\n");
if (freq)
(*sim_callback->printf_filtered) (sim_callback, " ERC32 freq %d Mhz\n", freq);
}
sregs.freq = freq ? freq : 15;
termsave = fcntl(0, F_GETFL, 0);
INIT_DISASSEMBLE_INFO(dinfo, stdout,(fprintf_ftype)fprintf);
dinfo.endian = BFD_ENDIAN_BIG;
reset_all();
ebase.simtime = 0;
init_sim();
init_bpt(&sregs);
reset_stat(&sregs);
return (SIM_DESC) 1;
}
void
sim_close(sd, quitting)
SIM_DESC sd;
int quitting;
{
exit_sim();
fcntl(0, F_SETFL, termsave);
};
SIM_RC
sim_load(sd, prog, abfd, from_tty)
SIM_DESC sd;
char *prog;
bfd *abfd;
int from_tty;
{
bfd_load (prog);
return SIM_RC_OK;
}
SIM_RC
sim_create_inferior(sd, abfd, argv, env)
SIM_DESC sd;
struct _bfd *abfd;
char **argv;
char **env;
{
bfd_vma start_address = 0;
if (abfd != NULL)
start_address = bfd_get_start_address (abfd);
ebase.simtime = 0;
reset_all();
reset_stat(&sregs);
sregs.pc = start_address & ~3;
sregs.npc = sregs.pc + 4;
return SIM_RC_OK;
}
int
sim_store_register(sd, regno, value, length)
SIM_DESC sd;
int regno;
unsigned char *value;
int length;
{
int regval;
if (current_target_byte_order == BIG_ENDIAN)
regval = (value[0] << 24) | (value[1] << 16)
| (value[2] << 8) | value[3];
else
regval = (value[3] << 24) | (value[2] << 16)
| (value[1] << 8) | value[0];
set_regi(&sregs, regno, regval);
return -1;
}
int
sim_fetch_register(sd, regno, buf, length)
SIM_DESC sd;
int regno;
unsigned char *buf;
int length;
{
get_regi(&sregs, regno, buf);
return -1;
}
int
sim_write(sd, mem, buf, length)
SIM_DESC sd;
SIM_ADDR mem;
unsigned char *buf;
int length;
{
return (sis_memory_write(mem, buf, length));
}
int
sim_read(sd, mem, buf, length)
SIM_DESC sd;
SIM_ADDR mem;
unsigned char *buf;
int length;
{
return (sis_memory_read(mem, buf, length));
}
void
sim_info(sd, verbose)
SIM_DESC sd;
int verbose;
{
show_stat(&sregs);
}
int simstat = OK;
void
sim_stop_reason(sd, reason, sigrc)
SIM_DESC sd;
enum sim_stop * reason;
int *sigrc;
{
switch (simstat) {
case CTRL_C:
*reason = sim_stopped;
*sigrc = SIGINT;
break;
case OK:
case TIME_OUT:
case BPT_HIT:
*reason = sim_stopped;
#ifdef _WIN32
#define SIGTRAP 5
#endif
*sigrc = SIGTRAP;
break;
case ERROR:
*sigrc = 0;
*reason = sim_exited;
}
ctrl_c = 0;
simstat = OK;
}
static void
flush_windows ()
{
int invwin;
int cwp;
int win;
int ws;
cwp = sregs.psr & PSR_CWP;
for (invwin = 0; invwin <= PSR_CWP; invwin++)
if ((sregs.wim >> invwin) & 1)
break;
invwin = (invwin - 1) & PSR_CWP;
for (win = invwin; ; win = (win - 1) & PSR_CWP)
{
uint32 sp;
int i;
sp = sregs.r[(win * 16 + 14) & 0x7f];
#if 1
if (sis_verbose > 2) {
uint32 fp = sregs.r[(win * 16 + 30) & 0x7f];
printf("flush_window: win %d, sp %x, fp %x\n", win, sp, fp);
}
#endif
for (i = 0; i < 16; i++)
memory_write (11, sp + 4 * i, &sregs.r[(win * 16 + 16 + i) & 0x7f], 2,
&ws);
if (win == cwp)
break;
}
}
void
sim_resume(SIM_DESC sd, int step, int siggnal)
{
simstat = run_sim(&sregs, -1, 0);
if (sis_gdb_break) flush_windows ();
}
int
sim_trace (sd)
SIM_DESC sd;
{
sim_resume (sd, 0, 0);
return 1;
}
void
sim_do_command(sd, cmd)
SIM_DESC sd;
char *cmd;
{
exec_cmd(&sregs, cmd);
}
#if 0
int
sim_insert_breakpoint(int addr)
{
if (sregs.bptnum < BPT_MAX) {
sregs.bpts[sregs.bptnum] = addr & ~0x3;
sregs.bptnum++;
if (sis_verbose)
(*sim_callback->printf_filtered) (sim_callback, "inserted HW BP at %x\n", addr);
return 0;
} else
return 1;
}
int
sim_remove_breakpoint(int addr)
{
int i = 0;
while ((i < sregs.bptnum) && (sregs.bpts[i] != addr))
i++;
if (addr == sregs.bpts[i]) {
for (; i < sregs.bptnum - 1; i++)
sregs.bpts[i] = sregs.bpts[i + 1];
sregs.bptnum -= 1;
if (sis_verbose)
(*sim_callback->printf_filtered) (sim_callback, "removed HW BP at %x\n", addr);
return 0;
}
return 1;
}
#endif