*
* 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)
+ * Software Foundation; either version 3 of the License, or (at your option)
* any later version.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* 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.
+ * this program; if not, see <http://www.gnu.org/licenses/>.
*
*/
+#include "config.h"
#include <signal.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
-#include <time.h>
#include <sys/fcntl.h>
#include "sis.h"
+#include "libiberty.h"
#include "bfd.h"
#include <dis-asm.h>
#include "sim-config.h"
-#include "remote-sim.h"
-
-#ifndef fprintf
-extern fprintf();
-#endif
+#include "gdb/remote-sim.h"
+#include "gdb/signals.h"
#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 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
run_sim(sregs, icount, dis)
struct pstate *sregs;
- unsigned int icount;
+ uint64 icount;
int dis;
{
- int mexc;
+ int mexc, irq;
if (sis_verbose)
(*sim_callback->printf_filtered) (sim_callback, "resuming at %x\n",
sregs->pc);
init_stdio();
- sregs->starttime = time(NULL);
+ sregs->starttime = get_time();
+ irq = 0;
+ if ((sregs->pc != 0) && (ebase.simtime == 0))
+ boot_init();
while (!sregs->err_mode & (icount > 0)) {
sregs->fhold = 0;
sregs->hold = 0;
sregs->icnt = 1;
- check_interrupts(sregs);
- if (sregs->trap) {
- sregs->err_mode = execute_trap(sregs);
- } else {
- if (sregs->psr & 0x080)
- sregs->asi = 8;
- else
- sregs->asi = 9;
+ if (sregs->psr & 0x080)
+ sregs->asi = 8;
+ else
+ sregs->asi = 9;
#if 0 /* DELETE ME! for debugging purposes only */
- printf("pc = %08x, npc = %08x\n", sregs->pc, sregs->npc);
- if (sregs->pc == 0 || sregs->npc == 0)
- printf ("bogus pc or npc\n");
+ 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 (sregs->annul) {
- sregs->annul = 0;
- sregs->icnt = 1;
- sregs->pc = sregs->npc;
- sregs->npc = sregs->npc + 4;
- } else {
+ mexc = memory_iread (sregs->pc, &sregs->inst, &sregs->hold);
+#if 0 /* DELETE ME! for debugging purposes only */
+ 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 {
sim_halt();
restore_stdio();
clearerr(stdin);
- return (BPT_HIT);
+ return BPT_HIT;
} else
dispatch_instruction(sregs);
}
icount--;
}
if (sregs->trap) {
+ irq = 0;
sregs->err_mode = execute_trap(sregs);
}
}
}
}
sim_halt();
- sregs->tottime += time(NULL) - sregs->starttime;
+ sregs->tottime += get_time() - sregs->starttime;
restore_stdio();
clearerr(stdin);
if (sregs->err_mode)
error_mode(sregs->pc);
if (sregs->err_mode)
- return (ERROR);
+ 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);
+ return BPT_HIT;
}
if (ctrl_c) {
ctrl_c = 0;
- return (CTRL_C);
+ return CTRL_C;
}
- return (TIME_OUT);
-}
-
-void
-sim_set_callbacks (ptr)
- host_callback *ptr;
-{
- sim_callback = ptr;
-}
-
-void
-sim_size (memsize)
- int memsize;
-{
+ return TIME_OUT;
}
SIM_DESC
sim_open (kind, callback, abfd, argv)
SIM_OPEN_KIND kind;
struct host_callback_struct *callback;
- struct _bfd *abfd;
+ struct bfd *abfd;
char **argv;
{
while (stat < argc) {
if (argv[stat][0] == '-') {
if (strcmp(argv[stat], "-v") == 0) {
- sis_verbose = 1;
+ sis_verbose++;
} else
if (strcmp(argv[stat], "-nfp") == 0) {
nfp = 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], "-freq") == 0) {
if ((stat + 1) < argc) {
- freq = VAL(argv[++stat]);
+ freq = strtol(argv[++stat], (char **)NULL, 0);
}
+ } else
+ if (strncmp(argv[stat], "--sysroot=", sizeof("--sysroot=") - 1) == 0) {
+ /* Ignore until we start to support this. */
} else {
(*sim_callback->printf_filtered) (sim_callback,
"unknown option %s\n",
(*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_RC
sim_load(sd, prog, abfd, from_tty)
SIM_DESC sd;
- char *prog;
+ const char *prog;
bfd *abfd;
int from_tty;
{
SIM_RC
sim_create_inferior(sd, abfd, argv, env)
SIM_DESC sd;
- struct _bfd *abfd;
+ struct bfd *abfd;
char **argv;
char **env;
{
int
sim_store_register(sd, regno, value, length)
- SIM_DESC sd;
+ SIM_DESC sd;
int regno;
unsigned char *value;
- int length;
+ int length;
{
/* FIXME: Review the computation of regval. */
- int regval = (value[0] << 24) | (value[1] << 16) | (value[2] << 8) | value[3];
+ 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;
+ return length;
}
sim_write(sd, mem, buf, length)
SIM_DESC sd;
SIM_ADDR mem;
- unsigned char *buf;
+ const unsigned char *buf;
int length;
{
- return (sis_memory_write(mem, buf, length));
+ return sis_memory_write (mem, buf, length);
}
int
unsigned char *buf;
int length;
{
- return (sis_memory_read(mem, buf, length));
+ return sis_memory_read (mem, buf, length);
}
void
switch (simstat) {
case CTRL_C:
*reason = sim_stopped;
- *sigrc = SIGINT;
+ *sigrc = GDB_SIGNAL_INT;
break;
case OK:
case TIME_OUT:
case BPT_HIT:
*reason = sim_stopped;
-#ifdef _WIN32
-#define SIGTRAP 5
-#endif
- *sigrc = SIGTRAP;
+ *sigrc = GDB_SIGNAL_TRAP;
break;
case ERROR:
*sigrc = 0;
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,
void
sim_resume(SIM_DESC sd, int step, int siggnal)
{
- simstat = run_sim(&sregs, -1, 0);
+ simstat = run_sim(&sregs, UINT64_MAX, 0);
if (sis_gdb_break) flush_windows ();
}
-int
-sim_trace (sd)
- SIM_DESC sd;
-{
- /* FIXME: unfinished */
- sim_resume (sd, 0, 0);
- return 1;
-}
-
void
sim_do_command(sd, cmd)
SIM_DESC sd;
- char *cmd;
+ const char *cmd;
{
exec_cmd(&sregs, cmd);
}
+char **
+sim_complete_command (SIM_DESC sd, const char *text, const char *word)
+{
+ return NULL;
+}
+
#if 0 /* FIXME: These shouldn't exist. */
int