/* Memory-access and commands for remote NINDY process, for GDB.
- Copyright (C) 1990-1991 Free Software Foundation, Inc.
+ Copyright 1990, 1991, 1992, 1993 Free Software Foundation, Inc.
Contributed by Intel Corporation. Modified from remote.c by Chris Benenati.
GDB is distributed in the hope that it will be useful, but WITHOUT ANY
*
******************************************************************************/
-#include <stdio.h>
+#include "defs.h"
#include <signal.h>
#include <sys/types.h>
#include <setjmp.h>
-#include "defs.h"
-#include "param.h"
#include "frame.h"
#include "inferior.h"
#include "target.h"
extern char *mktemp();
extern char *coffstrip();
-extern void add_syms_addr_command ();
-extern value call_function_by_hand ();
extern void generic_mourn_inferior ();
extern struct target_ops nindy_ops;
extern jmp_buf to_top_level;
extern FILE *instream;
-extern struct ext_format ext_format_i960[]; /* i960-tdep.c */
+extern struct ext_format ext_format_i960; /* i960-tdep.c */
extern char ninStopWhy ();
static int regs_changed = 0; /* 1 iff regs were modified since last read */
extern char *exists();
-static void dcache_flush (), dcache_poke (), dcache_init();
-static int dcache_fetch ();
+
+static void
+dcache_flush (), dcache_poke (), dcache_init();
+
+static int
+dcache_fetch ();
+
+static void
+nindy_fetch_registers PARAMS ((int));
+
+static void
+nindy_store_registers PARAMS ((int));
\f
/* FIXME, we can probably use the normal terminal_inferior stuff here.
We have to do terminal_inferior and then set up the passthrough
if (!name)
error_no_arg ("serial port device name");
+ target_preopen (from_tty);
+
nindy_close (0);
have_regs = regs_changed = 0;
char *filename;
int from_tty;
{
- char *tmpfile;
- struct cleanup *old_chain;
- char *scratch_pathname;
- int scratch_chan;
-
- if (!filename)
- filename = get_exec_file (1);
-
- filename = tilde_expand (filename);
- make_cleanup (free, filename);
-
- scratch_chan = openp (getenv ("PATH"), 1, filename, O_RDONLY, 0,
- &scratch_pathname);
- if (scratch_chan < 0)
- perror_with_name (filename);
- close (scratch_chan); /* Slightly wasteful FIXME */
-
- have_regs = regs_changed = 0;
- mark_breakpoints_out();
- inferior_pid = 0;
- dcache_flush();
-
- tmpfile = coffstrip(scratch_pathname);
- if ( tmpfile ){
- old_chain = make_cleanup(unlink,tmpfile);
- immediate_quit++;
- ninDownload( tmpfile, !from_tty );
-/* FIXME, don't we want this merged in here? */
- immediate_quit--;
- do_cleanups (old_chain);
+ 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);
}
-
-
/* Return the number of characters in the buffer before the first DLE character.
*/
dcache_flush();
if ( regs_changed ){
- nindy_store_registers ();
+ nindy_store_registers (-1);
regs_changed = 0;
}
have_regs = 0;
* Return to caller, storing status in 'status' just as `wait' would.
*/
-void
+static int
nindy_wait( status )
WAITTYPE *status;
{
immediate_quit--;
} else {
/* Get out of loop */
- supply_register (IP_REGNUM, &ip_value);
- supply_register (FP_REGNUM, &fp_value);
- supply_register (SP_REGNUM, &sp_value);
+ supply_register (IP_REGNUM,
+ (char *)&ip_value);
+ supply_register (FP_REGNUM,
+ (char *)&fp_value);
+ supply_register (SP_REGNUM,
+ (char *)&sp_value);
break;
}
}
}
WSETSTOP( (*status), stop_code );
}
+ return inferior_pid;
}
/* Read the remote registers into the block REGS. */
char fp_as_double[4 * 8];
};
-static int
+static void
nindy_fetch_registers(regno)
int regno;
{
&nindy_regs.fp_as_double[8 * (regnum - FP0_REGNUM)],
&inv);
/* dub now in host byte order */
- double_to_ieee_extended (ext_format_i960, &dub,
+ double_to_ieee_extended (&ext_format_i960, &dub,
®isters[REGISTER_BYTE (regnum)]);
}
registers_fetched ();
- return 0;
}
static void
nindy_prepare_to_store()
{
- nindy_fetch_registers(-1);
+ /* Fetch all regs if they aren't already here. */
+ read_register_bytes (0, NULL, REGISTER_BYTES);
}
-static int
+static void
nindy_store_registers(regno)
int regno;
{
bcopy (®isters[REGISTER_BYTE (PCW_REGNUM)], nindy_regs.pcw_acw, 2*4);
bcopy (®isters[REGISTER_BYTE (IP_REGNUM)], nindy_regs.ip, 1*4);
bcopy (®isters[REGISTER_BYTE (TCW_REGNUM)], nindy_regs.tcw, 1*4);
- /* Float regs. Only works on IEEE_FLOAT hosts. */
+ /* Float regs. Only works on IEEE_FLOAT hosts. FIXME! */
for (regnum = FP0_REGNUM; regnum < FP0_REGNUM + 4; regnum++) {
- ieee_extended_to_double (ext_format_i960,
+ ieee_extended_to_double (&ext_format_i960,
®isters[REGISTER_BYTE (regnum)], &dub);
/* dub now in host byte order */
/* FIXME-someday, the arguments to unpack_double are backward.
It expects a target double and returns a host; we pass the opposite.
This mostly works but not quite. */
- dub = unpack_double (builtin_type_double, &dub, &inv);
+ dub = unpack_double (builtin_type_double, (char *)&dub, &inv);
/* dub now in target byte order */
bcopy ((char *)&dub, &nindy_regs.fp_as_double[8 * (regnum - FP0_REGNUM)],
8);
immediate_quit++;
ninRegsPut( (char *) &nindy_regs );
immediate_quit--;
- return 0;
}
/* Read a word from remote address ADDR and return it.
FIXME, rewrite this to not use the word-oriented routines. */
int
-nindy_xfer_inferior_memory(memaddr, myaddr, len, write)
+nindy_xfer_inferior_memory(memaddr, myaddr, len, write, target)
CORE_ADDR memaddr;
char *myaddr;
int len;
int write;
+ struct target_ops *target; /* ignored */
{
register int i;
/* Round starting address down to longword boundary. */
clear_proceed_status ();
-#if defined (START_INFERIOR_HOOK)
- START_INFERIOR_HOOK ();
-#endif
-
/* Tell wait_for_inferior that we've started a new process. */
init_wait_for_inferior ();
/* Install inferior's terminal modes. */
target_terminal_inferior ();
- /* remote_start(args); */
- /* trap_expected = 0; */
/* insert_step_breakpoint (); FIXME, do we need this? */
proceed ((CORE_ADDR)entry_pt, -1, 0); /* Let 'er rip... */
}
of this with a RETURN. This is useful when e.g. simply examining
an i960 object file on the host system. */
+void
nindy_before_main_loop ()
{
char ttyname[100];
;
}
*p2= '\0';
- if ( !strcmp("quit",p) ){
+ if ( STREQ("quit",p) ){
exit(1);
}
struct target_ops nindy_ops = {
"nindy", "Remote serial target in i960 NINDY-specific protocol",
+ "Use a remote i960 system running NINDY connected by a serial line.\n\
+Specify the name of the device the serial line is connected to.\n\
+The speed (baud rate), whether to use the old NINDY protocol,\n\
+and whether to send a break on startup, are controlled by options\n\
+specified when you started GDB.",
nindy_open, nindy_close,
- 0, nindy_detach, nindy_resume, nindy_wait,
+ 0,
+ nindy_detach,
+ nindy_resume,
+ nindy_wait,
nindy_fetch_registers, nindy_store_registers,
- nindy_prepare_to_store, 0, 0, /* conv_from, conv_to */
+ nindy_prepare_to_store,
nindy_xfer_inferior_memory, nindy_files_info,
0, 0, /* insert_breakpoint, remove_breakpoint, */
0, 0, 0, 0, 0, /* Terminal crud */
nindy_kill,
- nindy_load, add_syms_addr_command,
- call_function_by_hand,
+ nindy_load,
0, /* lookup_symbol */
nindy_create_inferior,
nindy_mourn_inferior,
+ 0, /* can_run */
+ 0, /* notice_signals */
process_stratum, 0, /* next */
1, 1, 1, 1, 1, /* all mem, mem, stack, regs, exec */
+ 0, 0, /* Section pointers */
OPS_MAGIC, /* Always the last thing */
};
projects / deliverable / binutils-gdb.git / blobdiff