#include "target.h"
#include "gdbcore.h"
#include "command.h"
-#include "ieee-float.h"
+#include "floatformat.h"
#include "wait.h"
#include <sys/file.h>
extern struct target_ops nindy_ops;
extern GDB_FILE *instream;
-extern struct ext_format ext_format_i960; /* i960-tdep.c */
extern char ninStopWhy ();
extern int ninMemGet ();
savename = savestring (name, strlen (name));
push_target (&nindy_ops);
+
target_fetch_registers(-1);
+
+ init_thread_list ();
+ init_wait_for_inferior ();
+ clear_proceed_status ();
+ normal_stop ();
}
/* User-initiated quit of nindy operations. */
char *buf; /* Character buffer; NOT '\0'-terminated */
int n; /* Number of characters in buffer */
{
- int i;
+ int i;
- for ( i = 0; i < n; i++ ){
- if ( buf[i] == DLE ){
- break;
- }
- }
- return i;
+ for ( i = 0; i < n; i++ ){
+ if ( buf[i] == DLE ){
+ break;
+ }
+ }
+ return i;
}
\f
/* Tell the remote machine to resume. */
if (siggnal != TARGET_SIGNAL_0 && siggnal != stop_signal)
warning ("Can't send signals to remote NINDY targets.");
- dcache_flush(nindy_dcache);
- if ( regs_changed ){
- nindy_store_registers (-1);
- regs_changed = 0;
- }
- have_regs = 0;
- ninGo( step );
+ dcache_flush(nindy_dcache);
+ if ( regs_changed )
+ {
+ nindy_store_registers (-1);
+ regs_changed = 0;
+ }
+ have_regs = 0;
+ ninGo( step );
}
\f
/* FIXME, we can probably use the normal terminal_inferior stuff here.
serial_ttystate state;
serial_t serial;
};
+static struct clean_up_tty_args tty_args;
static void
clean_up_tty (ptrarg)
struct clean_up_tty_args *args = (struct clean_up_tty_args *) ptrarg;
SERIAL_SET_TTY_STATE (args->serial, args->state);
free (args->state);
- warning ("\n\n\
-You may need to reset the 80960 and/or reload your program.\n");
+ warning ("\n\nYou may need to reset the 80960 and/or reload your program.\n");
+}
+
+/* Recover from ^Z or ^C while remote process is running */
+static void (*old_ctrlc)();
+#ifdef SIGTSTP
+static void (*old_ctrlz)();
+#endif
+
+static void
+clean_up_int()
+{
+ SERIAL_SET_TTY_STATE (tty_args.serial, tty_args.state);
+ free (tty_args.state);
+
+ signal(SIGINT, old_ctrlc);
+#ifdef SIGTSTP
+ signal(SIGTSTP, old_ctrlz);
+#endif
+ error("\n\nYou may need to reset the 80960 and/or reload your program.\n");
}
/* Wait until the remote machine stops. While waiting, operate in passthrough
struct target_waitstatus *status;
{
fd_set fds;
- char buf[500]; /* FIXME, what is "500" here? */
+ int c;
+ char buf[2];
int i, n;
unsigned char stop_exit;
unsigned char stop_code;
- struct clean_up_tty_args tty_args;
struct cleanup *old_cleanups;
long ip_value, fp_value, sp_value; /* Reg values from stop */
/* Save current tty attributes, and restore them when done. */
tty_args.serial = SERIAL_FDOPEN (0);
tty_args.state = SERIAL_GET_TTY_STATE (tty_args.serial);
+ old_ctrlc = signal( SIGINT, clean_up_int );
+#ifdef SIGTSTP
+ old_ctrlz = signal( SIGTSTP, clean_up_int );
+#endif
+
old_cleanups = make_cleanup (clean_up_tty, &tty_args);
/* Pass input from keyboard to NINDY as it arrives. NINDY will interpret
while (1)
{
- /* Wait for input on either the remote port or stdin. */
- FD_ZERO (&fds);
- FD_SET (0, &fds);
- FD_SET (nindy_serial->fd, &fds);
- if (select (nindy_serial->fd + 1, &fds, 0, 0, 0) <= 0)
- continue;
-
- /* Pass input through to correct place */
- if (FD_ISSET (0, &fds))
+ /* Input on remote */
+ c = SERIAL_READCHAR (nindy_serial, -1);
+ if (c == SERIAL_ERROR)
{
- /* Input on stdin */
- n = read (0, buf, sizeof (buf));
- if (n)
- {
- SERIAL_WRITE (nindy_serial, buf, n );
- }
+ error ("Cannot read from serial line");
}
-
- if (FD_ISSET (nindy_serial->fd, &fds))
+ else if (c == 0x1b) /* ESC */
{
- /* Input on remote */
- n = read (nindy_serial->fd, buf, sizeof (buf));
- if (n)
+ c = SERIAL_READCHAR (nindy_serial, -1);
+ c &= ~0x40;
+ }
+ else if (c != 0x10) /* DLE */
+ /* Write out any characters preceding DLE */
+ {
+ buf[0] = (char)c;
+ write (1, buf, 1);
+ }
+ else
+ {
+ stop_exit = ninStopWhy(&stop_code,
+ &ip_value, &fp_value, &sp_value);
+ if (!stop_exit && (stop_code == STOP_SRQ))
+ {
+ immediate_quit++;
+ ninSrq();
+ immediate_quit--;
+ }
+ else
{
- /* Write out any characters in buffer preceding DLE */
- i = non_dle( buf, n );
- if ( i > 0 )
- {
- write (1, buf, i);
- }
-
- if (i != n)
- {
- /* There *was* a DLE in the buffer */
- stop_exit = ninStopWhy(&stop_code,
- &ip_value, &fp_value, &sp_value);
- if (!stop_exit && (stop_code == STOP_SRQ))
- {
- immediate_quit++;
- ninSrq();
- immediate_quit--;
- }
- else
- {
- /* Get out of loop */
- supply_register (IP_REGNUM,
- (char *)&ip_value);
- supply_register (FP_REGNUM,
- (char *)&fp_value);
- supply_register (SP_REGNUM,
- (char *)&sp_value);
- break;
- }
- }
+ /* Get out of loop */
+ supply_register (IP_REGNUM,
+ (char *)&ip_value);
+ supply_register (FP_REGNUM,
+ (char *)&fp_value);
+ supply_register (SP_REGNUM,
+ (char *)&sp_value);
+ break;
}
}
}
- do_cleanups (old_cleanups);
+ SERIAL_SET_TTY_STATE (tty_args.serial, tty_args.state);
+ free (tty_args.state);
+ discard_cleanups (old_cleanups);
if (stop_exit)
{
}
else
{
+ /* nindy has some special stop code need to be handled */
+ if (stop_code == STOP_GDB_BPT)
+ stop_code = TRACE_STEP;
status->kind = TARGET_WAITKIND_STOPPED;
status->value.sig = i960_fault_to_signal (stop_code);
}
int regno;
{
struct nindy_regs nindy_regs;
- int regnum, inv;
- double dub;
+ int regnum;
immediate_quit++;
ninRegsGet( (char *) &nindy_regs );
memcpy (®isters[REGISTER_BYTE (PCW_REGNUM)], nindy_regs.pcw_acw, 2*4);
memcpy (®isters[REGISTER_BYTE (IP_REGNUM)], nindy_regs.ip, 1*4);
memcpy (®isters[REGISTER_BYTE (TCW_REGNUM)], nindy_regs.tcw, 1*4);
- for (regnum = FP0_REGNUM; regnum < FP0_REGNUM + 4; regnum++) {
- dub = unpack_double (builtin_type_double,
- &nindy_regs.fp_as_double[8 * (regnum - FP0_REGNUM)],
- &inv);
- /* dub now in host byte order */
- double_to_ieee_extended (&ext_format_i960, &dub,
- ®isters[REGISTER_BYTE (regnum)]);
- }
+ memcpy (®isters[REGISTER_BYTE (FP0_REGNUM)], nindy_regs.fp_as_double, 4 * 8);
registers_fetched ();
}
{
struct nindy_regs nindy_regs;
int regnum;
- double dub;
memcpy (nindy_regs.local_regs, ®isters[REGISTER_BYTE (R0_REGNUM)], 16*4);
memcpy (nindy_regs.global_regs, ®isters[REGISTER_BYTE (G0_REGNUM)], 16*4);
memcpy (nindy_regs.pcw_acw, ®isters[REGISTER_BYTE (PCW_REGNUM)], 2*4);
memcpy (nindy_regs.ip, ®isters[REGISTER_BYTE (IP_REGNUM)], 1*4);
memcpy (nindy_regs.tcw, ®isters[REGISTER_BYTE (TCW_REGNUM)], 1*4);
- for (regnum = FP0_REGNUM; regnum < FP0_REGNUM + 4; regnum++)
- {
- ieee_extended_to_double (&ext_format_i960,
- ®isters[REGISTER_BYTE (regnum)], &dub);
- store_floating (&nindy_regs.fp_as_double[8 * (regnum - FP0_REGNUM)],
- REGISTER_VIRTUAL_SIZE (regnum),
- dub);
- }
+ memcpy (nindy_regs.fp_as_double, ®isters[REGISTER_BYTE (FP0_REGNUM)], 8*4);
immediate_quit++;
ninRegsPut( (char *) &nindy_regs );
FIXME, rewrite this to not use the word-oriented routines. */
int
-nindy_xfer_inferior_memory(memaddr, myaddr, len, write, target)
+nindy_xfer_inferior_memory(memaddr, myaddr, len, should_write, target)
CORE_ADDR memaddr;
char *myaddr;
int len;
- int write;
+ int should_write;
struct target_ops *target; /* ignored */
{
register int i;
/* Allocate buffer of that many longwords. */
register int *buffer = (int *) alloca (count * sizeof (int));
- if (write)
+ if (should_write)
{
/* Fill start and end extra bytes of buffer with existing memory data. */
return 1;
}
+static void
+nindy_load( filename, from_tty )
+ char *filename;
+ int from_tty;
+{
+ asection *s;
+ /* Can't do unix style forking on a VMS system, so we'll use bfd to do
+ all the work for us
+ */
+
+ bfd *file = bfd_openr(filename,0);
+ if (!file)
+ {
+ perror_with_name(filename);
+ return;
+ }
+
+ if (!bfd_check_format(file, bfd_object))
+ {
+ error("can't prove it's an object file\n");
+ return;
+ }
+
+ for ( s = file->sections; s; s=s->next)
+ {
+ if (s->flags & SEC_LOAD)
+ {
+ char *buffer = xmalloc(s->_raw_size);
+ bfd_get_section_contents(file, s, buffer, 0, s->_raw_size);
+ printf("Loading section %s, size %x vma %x\n",
+ s->name,
+ s->_raw_size,
+ s->vma);
+ ninMemPut(s->vma, buffer, s->_raw_size);
+ free(buffer);
+ }
+ }
+ bfd_close(file);
+}
+
static int
load_stub (arg)
char *arg;
char ttyname[100];
char *p, *p2;
- while (current_target != &nindy_ops) { /* remote tty not specified yet */
+ while (target_stack->target_ops != &nindy_ops) /* What is this crap??? */
+ { /* remote tty not specified yet */
if ( instream == stdin ){
printf_unfiltered("\nAttach /dev/ttyNN -- specify NN, or \"quit\" to quit: ");
gdb_flush( gdb_stdout );
RETURN_MASK_ALL);
}
}
- }
+ }
}
\f
/* Define the target subroutine names */
nindy_fetch_registers, nindy_store_registers,
nindy_prepare_to_store,
nindy_xfer_inferior_memory, nindy_files_info,
- 0, 0, /* insert_breakpoint, remove_breakpoint, */
+ memory_insert_breakpoint,
+ memory_remove_breakpoint,
0, 0, 0, 0, 0, /* Terminal crud */
nindy_kill,
- generic_load,
+ nindy_load,
0, /* lookup_symbol */
nindy_create_inferior,
nindy_mourn_inferior,
0, /* can_run */
0, /* notice_signals */
+ 0, /* to_thread_alive */
+ 0, /* to_stop */
process_stratum, 0, /* next */
1, 1, 1, 1, 1, /* all mem, mem, stack, regs, exec */
0, 0, /* Section pointers */
projects / binutils.git / blobdiff