1163 lines
29 KiB
C
1163 lines
29 KiB
C
/*
|
|
* func.c, misc simulator functions. This file is part of SIS.
|
|
*
|
|
* SIS, SPARC instruction simulator V1.8 Copyright (C) 1995 Jiri Gaisler,
|
|
* European Space Agency
|
|
*
|
|
* This program 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 of the License, or (at your option)
|
|
* any later version.
|
|
*
|
|
* This program 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., 675
|
|
* Mass Ave, Cambridge, MA 02139, USA.
|
|
*
|
|
*/
|
|
|
|
#include <signal.h>
|
|
#include <string.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <ctype.h>
|
|
#include "sis.h"
|
|
#include "end.h"
|
|
#include <dis-asm.h>
|
|
#include "sim-config.h"
|
|
|
|
|
|
#define VAL(x) strtoul(x,(char **)NULL,0)
|
|
|
|
extern int current_target_byte_order;
|
|
struct disassemble_info dinfo;
|
|
struct pstate sregs;
|
|
extern struct estate ebase;
|
|
int ctrl_c = 0;
|
|
int sis_verbose = 0;
|
|
char *sis_version = "2.7.5";
|
|
int nfp = 0;
|
|
int ift = 0;
|
|
int wrp = 0;
|
|
int rom8 = 0;
|
|
int uben = 0;
|
|
int termsave;
|
|
int sparclite = 0; /* emulating SPARClite instructions? */
|
|
int sparclite_board = 0; /* emulating SPARClite board RAM? */
|
|
char uart_dev1[128] = "";
|
|
char uart_dev2[128] = "";
|
|
extern int ext_irl;
|
|
uint32 last_load_addr = 0;
|
|
|
|
#ifdef ERRINJ
|
|
uint32 errcnt = 0;
|
|
uint32 errper = 0;
|
|
uint32 errtt = 0;
|
|
uint32 errftt = 0;
|
|
uint32 errmec = 0;
|
|
#endif
|
|
|
|
/* Forward declarations */
|
|
|
|
static int batch PARAMS ((struct pstate *sregs, char *fname));
|
|
static void set_rega PARAMS ((struct pstate *sregs, char *reg, uint32 rval));
|
|
static void disp_reg PARAMS ((struct pstate *sregs, char *reg));
|
|
static uint32 limcalc PARAMS ((float32 freq));
|
|
static void int_handler PARAMS ((int32 sig));
|
|
static void init_event PARAMS ((void));
|
|
static int disp_fpu PARAMS ((struct pstate *sregs));
|
|
static void disp_regs PARAMS ((struct pstate *sregs, int cwp));
|
|
static void disp_ctrl PARAMS ((struct pstate *sregs));
|
|
static void disp_mem PARAMS ((uint32 addr, uint32 len));
|
|
|
|
static int
|
|
batch(sregs, fname)
|
|
struct pstate *sregs;
|
|
char *fname;
|
|
{
|
|
FILE *fp;
|
|
char lbuf[1024];
|
|
|
|
if ((fp = fopen(fname, "r")) == NULL) {
|
|
fprintf(stderr, "couldn't open batch file %s\n", fname);
|
|
return (0);
|
|
}
|
|
while (!feof(fp)) {
|
|
lbuf[0] = 0;
|
|
fgets(lbuf, 1023, fp);
|
|
if ((strlen(lbuf) > 0) && (lbuf[strlen(lbuf) - 1] == '\n'))
|
|
lbuf[strlen(lbuf) - 1] = 0;
|
|
printf("sis> %s\n", lbuf);
|
|
exec_cmd(sregs, lbuf);
|
|
}
|
|
fclose(fp);
|
|
return (1);
|
|
}
|
|
|
|
void
|
|
set_regi(sregs, reg, rval)
|
|
struct pstate *sregs;
|
|
int32 reg;
|
|
uint32 rval;
|
|
{
|
|
uint32 cwp;
|
|
|
|
cwp = ((sregs->psr & 0x7) << 4);
|
|
if ((reg > 0) && (reg < 8)) {
|
|
sregs->g[reg] = rval;
|
|
} else if ((reg >= 8) && (reg < 32)) {
|
|
sregs->r[(cwp + reg) & 0x7f] = rval;
|
|
} else if ((reg >= 32) && (reg < 64)) {
|
|
sregs->fsi[reg - 32] = rval;
|
|
} else {
|
|
switch (reg) {
|
|
case 64:
|
|
sregs->y = rval;
|
|
break;
|
|
case 65:
|
|
sregs->psr = rval;
|
|
break;
|
|
case 66:
|
|
sregs->wim = rval;
|
|
break;
|
|
case 67:
|
|
sregs->tbr = rval;
|
|
break;
|
|
case 68:
|
|
sregs->pc = rval;
|
|
break;
|
|
case 69:
|
|
sregs->npc = rval;
|
|
break;
|
|
case 70:
|
|
sregs->fsr = rval;
|
|
set_fsr(rval);
|
|
break;
|
|
default:break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
get_regi(struct pstate * sregs, int32 reg, char *buf)
|
|
{
|
|
uint32 cwp;
|
|
uint32 rval = 0;
|
|
|
|
cwp = ((sregs->psr & 0x7) << 4);
|
|
if ((reg >= 0) && (reg < 8)) {
|
|
rval = sregs->g[reg];
|
|
} else if ((reg >= 8) && (reg < 32)) {
|
|
rval = sregs->r[(cwp + reg) & 0x7f];
|
|
} else if ((reg >= 32) && (reg < 64)) {
|
|
rval = sregs->fsi[reg - 32];
|
|
} else {
|
|
switch (reg) {
|
|
case 64:
|
|
rval = sregs->y;
|
|
break;
|
|
case 65:
|
|
rval = sregs->psr;
|
|
break;
|
|
case 66:
|
|
rval = sregs->wim;
|
|
break;
|
|
case 67:
|
|
rval = sregs->tbr;
|
|
break;
|
|
case 68:
|
|
rval = sregs->pc;
|
|
break;
|
|
case 69:
|
|
rval = sregs->npc;
|
|
break;
|
|
case 70:
|
|
rval = sregs->fsr;
|
|
break;
|
|
default:break;
|
|
}
|
|
}
|
|
if (current_target_byte_order == BIG_ENDIAN) {
|
|
buf[0] = (rval >> 24) & 0x0ff;
|
|
buf[1] = (rval >> 16) & 0x0ff;
|
|
buf[2] = (rval >> 8) & 0x0ff;
|
|
buf[3] = rval & 0x0ff;
|
|
}
|
|
else {
|
|
buf[3] = (rval >> 24) & 0x0ff;
|
|
buf[2] = (rval >> 16) & 0x0ff;
|
|
buf[1] = (rval >> 8) & 0x0ff;
|
|
buf[0] = rval & 0x0ff;
|
|
}
|
|
}
|
|
|
|
|
|
static void
|
|
set_rega(sregs, reg, rval)
|
|
struct pstate *sregs;
|
|
char *reg;
|
|
uint32 rval;
|
|
{
|
|
uint32 cwp;
|
|
int32 err = 0;
|
|
|
|
cwp = ((sregs->psr & 0x7) << 4);
|
|
if (strcmp(reg, "psr") == 0)
|
|
sregs->psr = (rval = (rval & 0x00f03fff));
|
|
else if (strcmp(reg, "tbr") == 0)
|
|
sregs->tbr = (rval = (rval & 0xfffffff0));
|
|
else if (strcmp(reg, "wim") == 0)
|
|
sregs->wim = (rval = (rval & 0x0ff));
|
|
else if (strcmp(reg, "y") == 0)
|
|
sregs->y = rval;
|
|
else if (strcmp(reg, "pc") == 0)
|
|
sregs->pc = rval;
|
|
else if (strcmp(reg, "npc") == 0)
|
|
sregs->npc = rval;
|
|
else if (strcmp(reg, "fsr") == 0) {
|
|
sregs->fsr = rval;
|
|
set_fsr(rval);
|
|
} else if (strcmp(reg, "g0") == 0)
|
|
err = 2;
|
|
else if (strcmp(reg, "g1") == 0)
|
|
sregs->g[1] = rval;
|
|
else if (strcmp(reg, "g2") == 0)
|
|
sregs->g[2] = rval;
|
|
else if (strcmp(reg, "g3") == 0)
|
|
sregs->g[3] = rval;
|
|
else if (strcmp(reg, "g4") == 0)
|
|
sregs->g[4] = rval;
|
|
else if (strcmp(reg, "g5") == 0)
|
|
sregs->g[5] = rval;
|
|
else if (strcmp(reg, "g6") == 0)
|
|
sregs->g[6] = rval;
|
|
else if (strcmp(reg, "g7") == 0)
|
|
sregs->g[7] = rval;
|
|
else if (strcmp(reg, "o0") == 0)
|
|
sregs->r[(cwp + 8) & 0x7f] = rval;
|
|
else if (strcmp(reg, "o1") == 0)
|
|
sregs->r[(cwp + 9) & 0x7f] = rval;
|
|
else if (strcmp(reg, "o2") == 0)
|
|
sregs->r[(cwp + 10) & 0x7f] = rval;
|
|
else if (strcmp(reg, "o3") == 0)
|
|
sregs->r[(cwp + 11) & 0x7f] = rval;
|
|
else if (strcmp(reg, "o4") == 0)
|
|
sregs->r[(cwp + 12) & 0x7f] = rval;
|
|
else if (strcmp(reg, "o5") == 0)
|
|
sregs->r[(cwp + 13) & 0x7f] = rval;
|
|
else if (strcmp(reg, "o6") == 0)
|
|
sregs->r[(cwp + 14) & 0x7f] = rval;
|
|
else if (strcmp(reg, "o7") == 0)
|
|
sregs->r[(cwp + 15) & 0x7f] = rval;
|
|
else if (strcmp(reg, "l0") == 0)
|
|
sregs->r[(cwp + 16) & 0x7f] = rval;
|
|
else if (strcmp(reg, "l1") == 0)
|
|
sregs->r[(cwp + 17) & 0x7f] = rval;
|
|
else if (strcmp(reg, "l2") == 0)
|
|
sregs->r[(cwp + 18) & 0x7f] = rval;
|
|
else if (strcmp(reg, "l3") == 0)
|
|
sregs->r[(cwp + 19) & 0x7f] = rval;
|
|
else if (strcmp(reg, "l4") == 0)
|
|
sregs->r[(cwp + 20) & 0x7f] = rval;
|
|
else if (strcmp(reg, "l5") == 0)
|
|
sregs->r[(cwp + 21) & 0x7f] = rval;
|
|
else if (strcmp(reg, "l6") == 0)
|
|
sregs->r[(cwp + 22) & 0x7f] = rval;
|
|
else if (strcmp(reg, "l7") == 0)
|
|
sregs->r[(cwp + 23) & 0x7f] = rval;
|
|
else if (strcmp(reg, "i0") == 0)
|
|
sregs->r[(cwp + 24) & 0x7f] = rval;
|
|
else if (strcmp(reg, "i1") == 0)
|
|
sregs->r[(cwp + 25) & 0x7f] = rval;
|
|
else if (strcmp(reg, "i2") == 0)
|
|
sregs->r[(cwp + 26) & 0x7f] = rval;
|
|
else if (strcmp(reg, "i3") == 0)
|
|
sregs->r[(cwp + 27) & 0x7f] = rval;
|
|
else if (strcmp(reg, "i4") == 0)
|
|
sregs->r[(cwp + 28) & 0x7f] = rval;
|
|
else if (strcmp(reg, "i5") == 0)
|
|
sregs->r[(cwp + 29) & 0x7f] = rval;
|
|
else if (strcmp(reg, "i6") == 0)
|
|
sregs->r[(cwp + 30) & 0x7f] = rval;
|
|
else if (strcmp(reg, "i7") == 0)
|
|
sregs->r[(cwp + 31) & 0x7f] = rval;
|
|
else
|
|
err = 1;
|
|
switch (err) {
|
|
case 0:
|
|
printf("%s = %d (0x%08x)\n", reg, rval, rval);
|
|
break;
|
|
case 1:
|
|
printf("no such regiser: %s\n", reg);
|
|
break;
|
|
case 2:
|
|
printf("cannot set g0\n");
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
static void
|
|
disp_reg(sregs, reg)
|
|
struct pstate *sregs;
|
|
char *reg;
|
|
{
|
|
if (strncmp(reg, "w",1) == 0)
|
|
disp_regs(sregs, VAL(®[1]));
|
|
}
|
|
|
|
#ifdef ERRINJ
|
|
|
|
void
|
|
errinj()
|
|
{
|
|
int err;
|
|
|
|
switch (err = (random() % 12)) {
|
|
case 0: errtt = 0x61; break;
|
|
case 1: errtt = 0x62; break;
|
|
case 2: errtt = 0x63; break;
|
|
case 3: errtt = 0x64; break;
|
|
case 4: errtt = 0x65; break;
|
|
case 5:
|
|
case 6:
|
|
case 7: errftt = err;
|
|
break;
|
|
case 8: errmec = 1; break;
|
|
case 9: errmec = 2; break;
|
|
case 10: errmec = 5; break;
|
|
case 11: errmec = 6; break;
|
|
}
|
|
errcnt++;
|
|
if (errper) event(errinj, 0, (random()%errper));
|
|
}
|
|
|
|
void
|
|
errinjstart()
|
|
{
|
|
if (errper) event(errinj, 0, (random()%errper));
|
|
}
|
|
|
|
#endif
|
|
|
|
static uint32
|
|
limcalc (freq)
|
|
float32 freq;
|
|
{
|
|
uint32 unit, lim;
|
|
double flim;
|
|
char *cmd1, *cmd2;
|
|
|
|
unit = 1;
|
|
lim = -1;
|
|
if ((cmd1 = strtok(NULL, " \t\n\r")) != NULL) {
|
|
lim = VAL(cmd1);
|
|
if ((cmd2 = strtok(NULL, " \t\n\r")) != NULL) {
|
|
if (strcmp(cmd2,"us")==0) unit = 1;
|
|
if (strcmp(cmd2,"ms")==0) unit = 1000;
|
|
if (strcmp(cmd2,"s")==0) unit = 1000000;
|
|
}
|
|
flim = (double) lim * (double) unit * (double) freq +
|
|
(double) ebase.simtime;
|
|
if ((flim > ebase.simtime) && (flim < 4294967296.0)) {
|
|
lim = (uint32) flim;
|
|
} else {
|
|
printf("error in expression\n");
|
|
lim = -1;
|
|
}
|
|
}
|
|
return (lim);
|
|
}
|
|
|
|
int
|
|
exec_cmd(sregs, cmd)
|
|
char *cmd;
|
|
struct pstate *sregs;
|
|
{
|
|
char *cmd1, *cmd2;
|
|
int32 stat;
|
|
uint32 len, i, clen, j;
|
|
static uint32 daddr = 0;
|
|
char *cmdsave;
|
|
|
|
stat = OK;
|
|
cmdsave = strdup(cmd);
|
|
if ((cmd1 = strtok(cmd, " \t")) != NULL) {
|
|
clen = strlen(cmd1);
|
|
if (strncmp(cmd1, "bp", clen) == 0) {
|
|
for (i = 0; i < sregs->bptnum; i++) {
|
|
printf(" %d : 0x%08x\n", i + 1, sregs->bpts[i]);
|
|
}
|
|
} else if (strncmp(cmd1, "+bp", clen) == 0) {
|
|
if ((cmd1 = strtok(NULL, " \t\n\r")) != NULL) {
|
|
sregs->bpts[sregs->bptnum] = VAL(cmd1) & ~0x3;
|
|
printf("added breakpoint %d at 0x%08x\n",
|
|
sregs->bptnum + 1, sregs->bpts[sregs->bptnum]);
|
|
sregs->bptnum += 1;
|
|
}
|
|
} else if (strncmp(cmd1, "-bp", clen) == 0) {
|
|
if ((cmd1 = strtok(NULL, " \t\n\r")) != NULL) {
|
|
i = VAL(cmd1) - 1;
|
|
if ((i >= 0) && (i < sregs->bptnum)) {
|
|
printf("deleted breakpoint %d at 0x%08x\n", i + 1,
|
|
sregs->bpts[i]);
|
|
for (; i < sregs->bptnum - 1; i++) {
|
|
sregs->bpts[i] = sregs->bpts[i + 1];
|
|
}
|
|
sregs->bptnum -= 1;
|
|
}
|
|
}
|
|
} else if (strncmp(cmd1, "batch", clen) == 0) {
|
|
if ((cmd1 = strtok(NULL, " \t\n\r")) == NULL) {
|
|
printf("no file specified\n");
|
|
} else {
|
|
batch(sregs, cmd1);
|
|
}
|
|
} else if (strncmp(cmd1, "cont", clen) == 0) {
|
|
if ((cmd1 = strtok(NULL, " \t\n\r")) == NULL) {
|
|
stat = run_sim(sregs, -1, 0);
|
|
} else {
|
|
stat = run_sim(sregs, VAL(cmd1), 0);
|
|
}
|
|
daddr = sregs->pc;
|
|
sim_halt();
|
|
} else if (strncmp(cmd1, "debug", clen) == 0) {
|
|
if ((cmd1 = strtok(NULL, " \t\n\r")) != NULL) {
|
|
sis_verbose = VAL(cmd1);
|
|
}
|
|
printf("Debug level = %d\n",sis_verbose);
|
|
} else if (strncmp(cmd1, "dis", clen) == 0) {
|
|
if ((cmd1 = strtok(NULL, " \t\n\r")) != NULL) {
|
|
daddr = VAL(cmd1);
|
|
}
|
|
if ((cmd2 = strtok(NULL, " \t\n\r")) != NULL) {
|
|
len = VAL(cmd2);
|
|
} else
|
|
len = 16;
|
|
printf("\n");
|
|
dis_mem(daddr, len, &dinfo);
|
|
printf("\n");
|
|
daddr += len * 4;
|
|
} else if (strncmp(cmd1, "echo", clen) == 0) {
|
|
if ((cmd1 = strtok(NULL, " \t\n\r")) != NULL) {
|
|
printf("%s\n", (&cmdsave[clen+1]));
|
|
}
|
|
#ifdef ERRINJ
|
|
} else if (strncmp(cmd1, "error", clen) == 0) {
|
|
if ((cmd1 = strtok(NULL, " \t\n\r")) != NULL) {
|
|
errper = VAL(cmd1);
|
|
if (errper) {
|
|
event(errinj, 0, (len = (random()%errper)));
|
|
printf("Error injection started with period %d\n",len);
|
|
}
|
|
} else printf("Injected errors: %d\n",errcnt);
|
|
#endif
|
|
} else if (strncmp(cmd1, "float", clen) == 0) {
|
|
stat = disp_fpu(sregs);
|
|
} else if (strncmp(cmd1, "go", clen) == 0) {
|
|
if ((cmd1 = strtok(NULL, " \t\n\r")) == NULL) {
|
|
len = last_load_addr;
|
|
} else {
|
|
len = VAL(cmd1);
|
|
}
|
|
sregs->pc = len & ~3;
|
|
sregs->npc = sregs->pc + 4;
|
|
printf("resuming at 0x%08x\n",sregs->pc);
|
|
if ((cmd2 = strtok(NULL, " \t\n\r")) != NULL) {
|
|
stat = run_sim(sregs, VAL(cmd2), 0);
|
|
} else {
|
|
stat = run_sim(sregs, -1, 0);
|
|
}
|
|
daddr = sregs->pc;
|
|
sim_halt();
|
|
} else if (strncmp(cmd1, "help", clen) == 0) {
|
|
gen_help();
|
|
} else if (strncmp(cmd1, "history", clen) == 0) {
|
|
if ((cmd1 = strtok(NULL, " \t\n\r")) != NULL) {
|
|
sregs->histlen = VAL(cmd1);
|
|
if (sregs->histbuf != NULL)
|
|
free(sregs->histbuf);
|
|
sregs->histbuf = (struct histype *) calloc(sregs->histlen, sizeof(struct histype));
|
|
printf("trace history length = %d\n\r", sregs->histlen);
|
|
sregs->histind = 0;
|
|
|
|
} else {
|
|
j = sregs->histind;
|
|
for (i = 0; i < sregs->histlen; i++) {
|
|
if (j >= sregs->histlen)
|
|
j = 0;
|
|
printf(" %8d ", sregs->histbuf[j].time);
|
|
dis_mem(sregs->histbuf[j].addr, 1, &dinfo);
|
|
j++;
|
|
}
|
|
}
|
|
|
|
} else if (strncmp(cmd1, "load", clen) == 0) {
|
|
if ((cmd1 = strtok(NULL, " \t\n\r")) != NULL) {
|
|
last_load_addr = bfd_load(cmd1);
|
|
while ((cmd1 = strtok(NULL, " \t\n\r")) != NULL)
|
|
last_load_addr = bfd_load(cmd1);
|
|
} else {
|
|
printf("load: no file specified\n");
|
|
}
|
|
} else if (strncmp(cmd1, "mem", clen) == 0) {
|
|
if ((cmd1 = strtok(NULL, " \t\n\r")) != NULL)
|
|
daddr = VAL(cmd1);
|
|
if ((cmd2 = strtok(NULL, " \t\n\r")) != NULL)
|
|
len = VAL(cmd2);
|
|
else
|
|
len = 64;
|
|
disp_mem(daddr, len);
|
|
daddr += len;
|
|
} else if (strncmp(cmd1, "perf", clen) == 0) {
|
|
cmd1 = strtok(NULL, " \t\n\r");
|
|
if ((cmd1 != NULL) &&
|
|
(strncmp(cmd1, "reset", strlen(cmd1)) == 0)) {
|
|
reset_stat(sregs);
|
|
} else
|
|
show_stat(sregs);
|
|
} else if (strncmp(cmd1, "quit", clen) == 0) {
|
|
exit(0);
|
|
} else if (strncmp(cmd1, "reg", clen) == 0) {
|
|
cmd1 = strtok(NULL, " \t\n\r");
|
|
cmd2 = strtok(NULL, " \t\n\r");
|
|
if (cmd2 != NULL)
|
|
set_rega(sregs, cmd1, VAL(cmd2));
|
|
else if (cmd1 != NULL)
|
|
disp_reg(sregs, cmd1);
|
|
else {
|
|
disp_regs(sregs,sregs->psr);
|
|
disp_ctrl(sregs);
|
|
}
|
|
} else if (strncmp(cmd1, "reset", clen) == 0) {
|
|
ebase.simtime = 0;
|
|
reset_all();
|
|
reset_stat(sregs);
|
|
} else if (strncmp(cmd1, "run", clen) == 0) {
|
|
ebase.simtime = 0;
|
|
reset_all();
|
|
reset_stat(sregs);
|
|
if ((cmd1 = strtok(NULL, " \t\n\r")) == NULL) {
|
|
stat = run_sim(sregs, -1, 0);
|
|
} else {
|
|
stat = run_sim(sregs, VAL(cmd1), 0);
|
|
}
|
|
daddr = sregs->pc;
|
|
sim_halt();
|
|
} else if (strncmp(cmd1, "shell", clen) == 0) {
|
|
if ((cmd1 = strtok(NULL, " \t\n\r")) != NULL) {
|
|
system(&cmdsave[clen]);
|
|
}
|
|
} else if (strncmp(cmd1, "step", clen) == 0) {
|
|
stat = run_sim(sregs, 1, 1);
|
|
daddr = sregs->pc;
|
|
sim_halt();
|
|
} else if (strncmp(cmd1, "tcont", clen) == 0) {
|
|
sregs->tlimit = limcalc(sregs->freq);
|
|
stat = run_sim(sregs, -1, 0);
|
|
daddr = sregs->pc;
|
|
sim_halt();
|
|
} else if (strncmp(cmd1, "tgo", clen) == 0) {
|
|
if ((cmd1 = strtok(NULL, " \t\n\r")) == NULL) {
|
|
len = last_load_addr;
|
|
} else {
|
|
len = VAL(cmd1);
|
|
sregs->tlimit = limcalc(sregs->freq);
|
|
}
|
|
sregs->pc = len & ~3;
|
|
sregs->npc = sregs->pc + 4;
|
|
printf("resuming at 0x%08x\n",sregs->pc);
|
|
stat = run_sim(sregs, -1, 0);
|
|
daddr = sregs->pc;
|
|
sim_halt();
|
|
} else if (strncmp(cmd1, "tlimit", clen) == 0) {
|
|
sregs->tlimit = limcalc(sregs->freq);
|
|
if (sregs->tlimit != (uint32) -1)
|
|
printf("simulation limit = %u (%.3f ms)\n",(uint32) sregs->tlimit,
|
|
sregs->tlimit / sregs->freq / 1000);
|
|
} else if (strncmp(cmd1, "tra", clen) == 0) {
|
|
if ((cmd1 = strtok(NULL, " \t\n\r")) == NULL) {
|
|
stat = run_sim(sregs, -1, 1);
|
|
} else {
|
|
stat = run_sim(sregs, VAL(cmd1), 1);
|
|
}
|
|
printf("\n");
|
|
daddr = sregs->pc;
|
|
sim_halt();
|
|
} else if (strncmp(cmd1, "trun", clen) == 0) {
|
|
ebase.simtime = 0;
|
|
reset_all();
|
|
reset_stat(sregs);
|
|
sregs->tlimit = limcalc(sregs->freq);
|
|
stat = run_sim(sregs, -1, 0);
|
|
daddr = sregs->pc;
|
|
sim_halt();
|
|
} else
|
|
printf("syntax error\n");
|
|
}
|
|
if (cmdsave != NULL)
|
|
free(cmdsave);
|
|
return (stat);
|
|
}
|
|
|
|
|
|
void
|
|
reset_stat(sregs)
|
|
struct pstate *sregs;
|
|
{
|
|
sregs->tottime = 0;
|
|
sregs->pwdtime = 0;
|
|
sregs->ninst = 0;
|
|
sregs->fholdt = 0;
|
|
sregs->holdt = 0;
|
|
sregs->icntt = 0;
|
|
sregs->finst = 0;
|
|
sregs->nstore = 0;
|
|
sregs->nload = 0;
|
|
sregs->nbranch = 0;
|
|
sregs->simstart = ebase.simtime;
|
|
|
|
}
|
|
|
|
void
|
|
show_stat(sregs)
|
|
struct pstate *sregs;
|
|
{
|
|
uint32 iinst;
|
|
uint32 stime, tottime;
|
|
|
|
if (sregs->tottime == 0) tottime = 1; else tottime = sregs->tottime;
|
|
stime = ebase.simtime - sregs->simstart; /* Total simulated time */
|
|
#ifdef STAT
|
|
|
|
iinst = sregs->ninst - sregs->finst - sregs->nload - sregs->nstore -
|
|
sregs->nbranch;
|
|
#endif
|
|
|
|
printf("\n Cycles : %9d\n\r", ebase.simtime - sregs->simstart);
|
|
printf(" Instructions : %9d\n", sregs->ninst);
|
|
|
|
#ifdef STAT
|
|
printf(" integer : %9.2f %%\n", 100.0 * (float) iinst / (float) sregs->ninst);
|
|
printf(" load : %9.2f %%\n",
|
|
100.0 * (float) sregs->nload / (float) sregs->ninst);
|
|
printf(" store : %9.2f %%\n",
|
|
100.0 * (float) sregs->nstore / (float) sregs->ninst);
|
|
printf(" branch : %9.2f %%\n",
|
|
100.0 * (float) sregs->nbranch / (float) sregs->ninst);
|
|
printf(" float : %9.2f %%\n",
|
|
100.0 * (float) sregs->finst / (float) sregs->ninst);
|
|
printf(" Integer CPI : %9.2f\n",
|
|
((float) (stime - sregs->pwdtime - sregs->fholdt - sregs->finst))
|
|
/
|
|
(float) (sregs->ninst - sregs->finst));
|
|
printf(" Float CPI : %9.2f\n",
|
|
((float) sregs->fholdt / (float) sregs->finst) + 1.0);
|
|
#endif
|
|
printf(" Overall CPI : %9.2f\n",
|
|
(float) (stime - sregs->pwdtime) / (float) sregs->ninst);
|
|
printf("\n ERC32 performance (%4.1f MHz): %5.2f MOPS (%5.2f MIPS, %5.2f MFLOPS)\n",
|
|
sregs->freq, sregs->freq * (float) sregs->ninst / (float) (stime - sregs->pwdtime),
|
|
sregs->freq * (float) (sregs->ninst - sregs->finst) /
|
|
(float) (stime - sregs->pwdtime),
|
|
sregs->freq * (float) sregs->finst / (float) (stime - sregs->pwdtime));
|
|
printf(" Simulated ERC32 time : %5.2f ms\n", (float) (ebase.simtime - sregs->simstart) / 1000.0 / sregs->freq);
|
|
printf(" Processor utilisation : %5.2f %%\n", 100.0 * (1.0 - ((float) sregs->pwdtime / (float) stime)));
|
|
printf(" Real-time / simulator-time : 1/%.2f \n",
|
|
((float) sregs->tottime) / ((float) (stime) / (sregs->freq * 1.0E6)));
|
|
printf(" Simulator performance : %d KIPS\n",sregs->ninst/tottime/1000);
|
|
printf(" Used time (sys + user) : %3d s\n\n", sregs->tottime);
|
|
}
|
|
|
|
|
|
|
|
void
|
|
init_bpt(sregs)
|
|
struct pstate *sregs;
|
|
{
|
|
sregs->bptnum = 0;
|
|
sregs->histlen = 0;
|
|
sregs->histind = 0;
|
|
sregs->histbuf = NULL;
|
|
sregs->tlimit = -1;
|
|
}
|
|
|
|
static void
|
|
int_handler(sig)
|
|
int32 sig;
|
|
{
|
|
if (sig != 2)
|
|
printf("\n\n Signal handler error (%d)\n\n", sig);
|
|
ctrl_c = 1;
|
|
}
|
|
|
|
void
|
|
init_signals()
|
|
{
|
|
typedef void (*PFI) ();
|
|
static PFI int_tab[2];
|
|
|
|
int_tab[0] = signal(SIGTERM, int_handler);
|
|
int_tab[1] = signal(SIGINT, int_handler);
|
|
}
|
|
|
|
|
|
extern struct disassemble_info dinfo;
|
|
|
|
struct estate ebase;
|
|
struct evcell evbuf[EVENT_MAX];
|
|
struct irqcell irqarr[16];
|
|
|
|
static int
|
|
disp_fpu(sregs)
|
|
struct pstate *sregs;
|
|
{
|
|
|
|
int i;
|
|
float t;
|
|
|
|
printf("\n fsr: %08X\n\n", sregs->fsr);
|
|
|
|
#ifdef HOST_LITTLE_ENDIAN_FLOAT
|
|
for (i = 0; i < 32; i++)
|
|
sregs->fdp[i ^ 1] = sregs->fs[i];
|
|
#endif
|
|
|
|
for (i = 0; i < 32; i++) {
|
|
t = sregs->fs[i];
|
|
printf(" f%02d %08x %14e ", i, sregs->fsi[i], sregs->fs[i]);
|
|
if (!(i & 1))
|
|
printf("%14e\n", sregs->fd[i >> 1]);
|
|
else
|
|
printf("\n");
|
|
}
|
|
printf("\n");
|
|
return (OK);
|
|
}
|
|
|
|
static void
|
|
disp_regs(sregs,cwp)
|
|
struct pstate *sregs;
|
|
int cwp;
|
|
{
|
|
|
|
int i;
|
|
|
|
cwp = ((cwp & 0x7) << 4);
|
|
printf("\n\t INS LOCALS OUTS GLOBALS\n");
|
|
for (i = 0; i < 8; i++) {
|
|
printf(" %d: %08X %08X %08X %08X\n", i,
|
|
sregs->r[(cwp + i + 24) & 0x7f],
|
|
sregs->r[(cwp + i + 16) & 0x7f], sregs->r[(cwp + i + 8) & 0x7f],
|
|
sregs->g[i]);
|
|
}
|
|
}
|
|
|
|
static void
|
|
disp_ctrl(sregs)
|
|
struct pstate *sregs;
|
|
{
|
|
|
|
unsigned char i[4];
|
|
|
|
printf("\n psr: %08X wim: %08X tbr: %08X y: %08X\n",
|
|
sregs->psr, sregs->wim, sregs->tbr, sregs->y);
|
|
sis_memory_read(sregs->pc, i, 4);
|
|
printf("\n pc: %08X = %02X%02X%02X%02X ", sregs->pc,i[0],i[1],i[2],i[3]);
|
|
print_insn_sparc(sregs->pc, &dinfo);
|
|
sis_memory_read(sregs->npc, i, 4);
|
|
printf("\n npc: %08X = %02X%02X%02X%02X ",sregs->npc,i[0],i[1],i[2],i[3]);
|
|
print_insn_sparc(sregs->npc, &dinfo);
|
|
if (sregs->err_mode)
|
|
printf("\n IU in error mode");
|
|
printf("\n\n");
|
|
}
|
|
|
|
static void
|
|
disp_mem(addr, len)
|
|
uint32 addr;
|
|
uint32 len;
|
|
{
|
|
|
|
uint32 i;
|
|
unsigned char data[4];
|
|
uint32 mem[4], j;
|
|
char *p;
|
|
|
|
for (i = addr & ~3; i < ((addr + len) & ~3); i += 16) {
|
|
printf("\n %8X ", i);
|
|
for (j = 0; j < 4; j++) {
|
|
sis_memory_read((i + (j * 4)), data, 4);
|
|
printf("%02x%02x%02x%02x ", data[0],data[1],data[2],data[3]);
|
|
mem[j] = *((int *) &data);
|
|
}
|
|
printf(" ");
|
|
p = (char *) mem;
|
|
for (j = 0; j < 16; j++) {
|
|
if (isprint(p[j]))
|
|
putchar(p[j]);
|
|
else
|
|
putchar('.');
|
|
}
|
|
}
|
|
printf("\n\n");
|
|
}
|
|
|
|
void
|
|
dis_mem(addr, len, info)
|
|
uint32 addr;
|
|
uint32 len;
|
|
struct disassemble_info *info;
|
|
{
|
|
uint32 i;
|
|
unsigned char data[4];
|
|
|
|
for (i = addr & -3; i < ((addr & -3) + (len << 2)); i += 4) {
|
|
sis_memory_read(i, data, 4);
|
|
printf(" %08x %02x%02x%02x%02x ", i, data[0],data[1],data[2],data[3]);
|
|
print_insn_sparc(i, info);
|
|
if (i >= 0xfffffffc) break;
|
|
printf("\n");
|
|
}
|
|
}
|
|
|
|
int
|
|
buffer_read_memory(addr, buffer, size, info)
|
|
bfd_vma addr;
|
|
bfd_byte *buffer;
|
|
int32 size;
|
|
struct disassemble_info *info;
|
|
{
|
|
if (size == sis_memory_read(addr, buffer, size))
|
|
return (0);
|
|
else
|
|
return (1);
|
|
}
|
|
|
|
void
|
|
perror_memory(status, addr, info)
|
|
int32 status;
|
|
bfd_vma addr;
|
|
struct disassemble_info *info;
|
|
{
|
|
|
|
printf("Could not read address 0x%08x\n", (unsigned int) addr);
|
|
}
|
|
|
|
void
|
|
generic_print_address(addr, info)
|
|
bfd_vma addr;
|
|
struct disassemble_info *info;
|
|
{
|
|
|
|
printf("0x%x", (unsigned int) addr);
|
|
}
|
|
|
|
/* Just return the given address. */
|
|
|
|
int
|
|
generic_symbol_at_address (addr, info)
|
|
bfd_vma addr;
|
|
struct disassemble_info * info;
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
|
|
/* Add event to event queue */
|
|
|
|
void
|
|
event(cfunc, arg, delta)
|
|
void (*cfunc) ();
|
|
int32 arg;
|
|
uint32 delta;
|
|
{
|
|
struct evcell *ev1, *evins;
|
|
|
|
if (ebase.freeq == NULL) {
|
|
printf("Error, too many events in event queue\n");
|
|
return;
|
|
}
|
|
ev1 = &ebase.eq;
|
|
delta += ebase.simtime;
|
|
while ((ev1->nxt != NULL) && (ev1->nxt->time <= delta)) {
|
|
ev1 = ev1->nxt;
|
|
}
|
|
if (ev1->nxt == NULL) {
|
|
ev1->nxt = ebase.freeq;
|
|
ebase.freeq = ebase.freeq->nxt;
|
|
ev1->nxt->nxt = NULL;
|
|
} else {
|
|
evins = ebase.freeq;
|
|
ebase.freeq = ebase.freeq->nxt;
|
|
evins->nxt = ev1->nxt;
|
|
ev1->nxt = evins;
|
|
}
|
|
ev1->nxt->time = delta;
|
|
ev1->nxt->cfunc = cfunc;
|
|
ev1->nxt->arg = arg;
|
|
}
|
|
|
|
#if 0 /* apparently not used */
|
|
void
|
|
stop_event()
|
|
{
|
|
}
|
|
#endif
|
|
|
|
void
|
|
init_event()
|
|
{
|
|
int32 i;
|
|
|
|
ebase.eq.nxt = NULL;
|
|
ebase.freeq = evbuf;
|
|
for (i = 0; i < EVENT_MAX; i++) {
|
|
evbuf[i].nxt = &evbuf[i + 1];
|
|
}
|
|
evbuf[EVENT_MAX - 1].nxt = NULL;
|
|
}
|
|
|
|
void
|
|
set_int(level, callback, arg)
|
|
int32 level;
|
|
void (*callback) ();
|
|
int32 arg;
|
|
{
|
|
irqarr[level & 0x0f].callback = callback;
|
|
irqarr[level & 0x0f].arg = arg;
|
|
}
|
|
|
|
/* Advance simulator time */
|
|
|
|
void
|
|
advance_time(sregs)
|
|
struct pstate *sregs;
|
|
{
|
|
|
|
struct evcell *evrem;
|
|
void (*cfunc) ();
|
|
uint32 arg, endtime;
|
|
|
|
#ifdef STAT
|
|
sregs->fholdt += sregs->fhold;
|
|
sregs->holdt += sregs->hold;
|
|
sregs->icntt += sregs->icnt;
|
|
#endif
|
|
|
|
endtime = ebase.simtime + sregs->icnt + sregs->hold + sregs->fhold;
|
|
|
|
while ((ebase.eq.nxt->time <= (endtime)) && (ebase.eq.nxt != NULL)) {
|
|
ebase.simtime = ebase.eq.nxt->time;
|
|
cfunc = ebase.eq.nxt->cfunc;
|
|
arg = ebase.eq.nxt->arg;
|
|
evrem = ebase.eq.nxt;
|
|
ebase.eq.nxt = ebase.eq.nxt->nxt;
|
|
evrem->nxt = ebase.freeq;
|
|
ebase.freeq = evrem;
|
|
cfunc(arg);
|
|
}
|
|
ebase.simtime = endtime;
|
|
|
|
}
|
|
|
|
uint32
|
|
now()
|
|
{
|
|
return(ebase.simtime);
|
|
}
|
|
|
|
|
|
/* Advance time until an external interrupt is seen */
|
|
|
|
int
|
|
wait_for_irq()
|
|
{
|
|
struct evcell *evrem;
|
|
void (*cfunc) ();
|
|
int32 arg, endtime;
|
|
|
|
if (ebase.eq.nxt == NULL)
|
|
printf("Warning: event queue empty - power-down mode not entered\n");
|
|
endtime = ebase.simtime;
|
|
while (!ext_irl && (ebase.eq.nxt != NULL)) {
|
|
ebase.simtime = ebase.eq.nxt->time;
|
|
cfunc = ebase.eq.nxt->cfunc;
|
|
arg = ebase.eq.nxt->arg;
|
|
evrem = ebase.eq.nxt;
|
|
ebase.eq.nxt = ebase.eq.nxt->nxt;
|
|
evrem->nxt = ebase.freeq;
|
|
ebase.freeq = evrem;
|
|
cfunc(arg);
|
|
if (ctrl_c) {
|
|
printf("\bwarning: power-down mode interrupted\n");
|
|
break;
|
|
}
|
|
}
|
|
sregs.pwdtime += ebase.simtime - endtime;
|
|
return (ebase.simtime - endtime);
|
|
}
|
|
|
|
int
|
|
check_bpt(sregs)
|
|
struct pstate *sregs;
|
|
{
|
|
int32 i;
|
|
|
|
if ((sregs->bphit) || (sregs->annul))
|
|
return (0);
|
|
for (i = 0; i < (int32) sregs->bptnum; i++) {
|
|
if (sregs->pc == sregs->bpts[i])
|
|
return (BPT_HIT);
|
|
}
|
|
return (0);
|
|
}
|
|
|
|
void
|
|
reset_all()
|
|
{
|
|
init_event(); /* Clear event queue */
|
|
init_regs(&sregs);
|
|
reset();
|
|
#ifdef ERRINJ
|
|
errinjstart();
|
|
#endif
|
|
}
|
|
|
|
void
|
|
sys_reset()
|
|
{
|
|
reset_all();
|
|
sregs.trap = 256; /* Force fake reset trap */
|
|
}
|
|
|
|
void
|
|
sys_halt()
|
|
{
|
|
sregs.trap = 257; /* Force fake halt trap */
|
|
}
|
|
|
|
#include "ansidecl.h"
|
|
|
|
#ifdef ANSI_PROTOTYPES
|
|
#include <stdarg.h>
|
|
#else
|
|
#include <varargs.h>
|
|
#endif
|
|
|
|
#include "libiberty.h"
|
|
#include "bfd.h"
|
|
|
|
#define min(A, B) (((A) < (B)) ? (A) : (B))
|
|
#define LOAD_ADDRESS 0
|
|
|
|
int
|
|
bfd_load(fname)
|
|
char *fname;
|
|
{
|
|
asection *section;
|
|
bfd *pbfd;
|
|
const bfd_arch_info_type *arch;
|
|
|
|
pbfd = bfd_openr(fname, 0);
|
|
|
|
if (pbfd == NULL) {
|
|
printf("open of %s failed\n", fname);
|
|
return (-1);
|
|
}
|
|
if (!bfd_check_format(pbfd, bfd_object)) {
|
|
printf("file %s doesn't seem to be an object file\n", fname);
|
|
return (-1);
|
|
}
|
|
|
|
arch = bfd_get_arch_info (pbfd);
|
|
if (bfd_little_endian (pbfd) || arch->mach == bfd_mach_sparc_sparclite_le)
|
|
current_target_byte_order = LITTLE_ENDIAN;
|
|
else
|
|
current_target_byte_order = BIG_ENDIAN;
|
|
if (sis_verbose)
|
|
printf("file %s is %s-endian.\n", fname,
|
|
current_target_byte_order == BIG_ENDIAN ? "big" : "little");
|
|
|
|
if (sis_verbose)
|
|
printf("loading %s:", fname);
|
|
for (section = pbfd->sections; section; section = section->next) {
|
|
if (bfd_get_section_flags(pbfd, section) & SEC_ALLOC) {
|
|
bfd_vma section_address;
|
|
unsigned long section_size;
|
|
const char *section_name;
|
|
|
|
section_name = bfd_get_section_name(pbfd, section);
|
|
|
|
section_address = bfd_get_section_vma(pbfd, section);
|
|
/*
|
|
* Adjust sections from a.out files, since they don't carry their
|
|
* addresses with.
|
|
*/
|
|
if (bfd_get_flavour(pbfd) == bfd_target_aout_flavour) {
|
|
if (strcmp (section_name, ".text") == 0)
|
|
section_address = bfd_get_start_address (pbfd);
|
|
else if (strcmp (section_name, ".data") == 0) {
|
|
/* Read the first 8 bytes of the data section.
|
|
There should be the string 'DaTa' followed by
|
|
a word containing the actual section address. */
|
|
struct data_marker
|
|
{
|
|
char signature[4]; /* 'DaTa' */
|
|
unsigned char sdata[4]; /* &sdata */
|
|
} marker;
|
|
bfd_get_section_contents (pbfd, section, &marker, 0,
|
|
sizeof (marker));
|
|
if (strncmp (marker.signature, "DaTa", 4) == 0)
|
|
{
|
|
if (current_target_byte_order == BIG_ENDIAN)
|
|
section_address = bfd_getb32 (marker.sdata);
|
|
else
|
|
section_address = bfd_getl32 (marker.sdata);
|
|
}
|
|
}
|
|
}
|
|
|
|
section_size = bfd_section_size(pbfd, section);
|
|
|
|
if (sis_verbose)
|
|
printf("\nsection %s at 0x%08lx (0x%lx bytes)",
|
|
section_name, section_address, section_size);
|
|
|
|
/* Text, data or lit */
|
|
if (bfd_get_section_flags(pbfd, section) & SEC_LOAD) {
|
|
file_ptr fptr;
|
|
|
|
fptr = 0;
|
|
|
|
while (section_size > 0) {
|
|
char buffer[1024];
|
|
int count;
|
|
|
|
count = min(section_size, 1024);
|
|
|
|
bfd_get_section_contents(pbfd, section, buffer, fptr, count);
|
|
|
|
sis_memory_write(section_address, buffer, count);
|
|
|
|
section_address += count;
|
|
fptr += count;
|
|
section_size -= count;
|
|
}
|
|
} else /* BSS */
|
|
if (sis_verbose)
|
|
printf("(not loaded)");
|
|
}
|
|
}
|
|
if (sis_verbose)
|
|
printf("\n");
|
|
|
|
return(bfd_get_start_address (pbfd));
|
|
}
|