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. */
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
/* Remote communication protocol.
"0* " means the same as "0000". */
#include "defs.h"
-#include <string.h>
+#include "gdb_string.h"
#include <fcntl.h>
#include "frame.h"
#include "inferior.h"
#include "gdbcmd.h"
#include "objfiles.h"
#include "gdb-stabs.h"
-
+#include "remote-utils.h"
#include "dcache.h"
#ifdef USG
/* Prototypes for local functions */
static int
-remote_write_bytes PARAMS ((CORE_ADDR memaddr, unsigned char *myaddr, int len));
+remote_remove_breakpoint PARAMS ((CORE_ADDR, char *));
static int
-remote_read_bytes PARAMS ((CORE_ADDR memaddr, unsigned char *myaddr, int len));
+remote_insert_breakpoint PARAMS ((CORE_ADDR, char *));
+
+static void
+remote_mourn PARAMS ((void));
+
+static void
+remote_kill PARAMS ((void));
+
+static int
+read_frame PARAMS ((char *));
+
+static void
+boot_board PARAMS ((void));
+
+static int
+remote_write_bytes PARAMS ((CORE_ADDR memaddr, char *myaddr, int len));
+
+static int
+remote_read_bytes PARAMS ((CORE_ADDR memaddr, char *myaddr, int len));
static void
remote_files_info PARAMS ((struct target_ops *ignore));
static int
readchar PARAMS ((int timeout));
-static int remote_wait PARAMS ((int pid, struct target_waitstatus *status));
+static int
+remote_wait PARAMS ((int pid, struct target_waitstatus *status));
static int
tohex PARAMS ((int nib));
static void
interrupt_query PARAMS ((void));
+static void
+hppro_load PARAMS ((char *name, int from_tty));
+
extern struct target_ops remote_ops; /* Forward decl */
/* This was 5 seconds, which is a long time to sit and wait.
be plenty. */
static int remote_timeout = 2;
-#if 0
-int icache;
-#endif
-
/* Descriptor for I/O to remote machine. Initialize it to NULL so that
remote_open knows that we don't have a file open when the program
starts. */
-serial_t remote_hppro_desc = NULL;
+extern serial_t remote_desc;
/* Having this larger than 400 causes us to be incompatible with m68k-stub.c
and i386-stub.c. Normally, no one would notice because it only matters
doesn't support 'P', the only consequence is some unnecessary traffic. */
static int stub_supports_P = 1;
+/* sets the download protocol, choices are srec, generic, boot */
+char *loadtype;
+static char *loadtype_str;
+static void set_loadtype_command
+PARAMS ((char *, int, struct cmd_list_element *));
+
+static void
+hppro_load (file, from_tty)
+ char *file;
+ int from_tty;
+{
+ puts ("Loading... HA!");
+}
+
\f
/* Clean up connection to a remote debugger. */
remote_close (quitting)
int quitting;
{
- if (remote_hppro_desc)
- SERIAL_CLOSE (remote_hppro_desc);
- remote_hppro_desc = NULL;
+ if (remote_desc)
+ SERIAL_CLOSE (remote_desc);
+ remote_desc = NULL;
}
/* Query the remote side for the text, data and bss offsets. */
+#if 0
+
static void
get_offsets ()
{
objfile_relocate (symfile_objfile, offs);
}
-/* Stub for catch_errors. */
+#endif /* unused */
+
+#define INBUFSIZE 10
+void
+boot_board()
+{
+ char c;
+ char buf[INBUFSIZE];
+ char *ptr;
+
+ /* See if we can connect to the boot ROM command line */
+ ptr = buf;
+ while (1) {
+ SERIAL_WRITE (remote_desc, "\r\n", 2);
+ c = readchar (2);
+ if ((sr_get_debug() > 2) && (isascii(c)))
+ putchar (c);
+ if (c == SERIAL_TIMEOUT) {
+ if (sr_get_debug())
+ puts_filtered ("Timed out.\n");
+ break;
+ }
+ if (c == '&') {
+ if (sr_get_debug() > 2)
+ puts ("Got ACK from stub");
+ break;
+ }
+ if (c == '>') {
+ if (sr_get_debug() > 2)
+ puts ("Got prompt from ROM monitor");
+ break;
+ }
+ }
+
+}
+
+/* Stub for catch_errors. */
static int
remote_start_remote (dummy)
char *dummy;
/* Ack any packet which the remote side has already sent. */
- SERIAL_WRITE (remote_hppro_desc, "+", 1);
+ if (sr_get_debug())
+ puts ("Trying a '+' to ACK the target.");
+
+ SERIAL_WRITE (remote_desc, "+", 1);
+
+#if 0
+ boot_board();
get_offsets (); /* Get text, data & bss offsets */
+#endif
putpkt ("?"); /* initiate a query from remote machine */
immediate_quit = 0;
remote_dcache = dcache_init (remote_read_bytes, remote_write_bytes);
- remote_hppro_desc = SERIAL_OPEN (name);
- if (!remote_hppro_desc)
+ remote_desc = SERIAL_OPEN (name);
+ if (!remote_desc)
perror_with_name (name);
if (baud_rate != -1)
{
- if (SERIAL_SETBAUDRATE (remote_hppro_desc, baud_rate))
+ if (SERIAL_SETBAUDRATE (remote_desc, baud_rate))
{
- SERIAL_CLOSE (remote_hppro_desc);
+ SERIAL_CLOSE (remote_desc);
perror_with_name (name);
}
}
- SERIAL_RAW (remote_hppro_desc);
+ SERIAL_RAW (remote_desc);
/* If there is something sitting in the buffer we might take it as a
response to a command, which would be bad. */
- SERIAL_FLUSH_INPUT (remote_hppro_desc);
+ SERIAL_FLUSH_INPUT (remote_desc);
if (from_tty)
{
target_terminal_ours_for_output ();
printf_filtered
("Can't send signals to a remote system. %s not sent.\n",
- target_signal_to_name (siggnal));
- target_terminal_inferior ();
+ target_signal_to_name (siggnal)); target_terminal_inferior ();
}
dcache_flush (remote_dcache);
if (remote_debug)
printf_unfiltered ("remote_interrupt called\n");
- SERIAL_WRITE (remote_hppro_desc, "\003", 1); /* Send a ^C */
+ SERIAL_WRITE (remote_desc, "\003", 1); /* Send a ^C */
}
static void (*ofunc)();
{
unsigned char *p1;
- regno = strtol (p, &p1, 16); /* Read the register number */
+ regno = strtol (p, (char **) &p1, 16); /* Read the register number */
if (p1 == p)
warning ("Remote sent badly formed register number: %s\nPacket: '%s'\n",
/* Use of the data cache is disabled because it loses for looking at
and changing hardware I/O ports and the like. Accepting `volatile'
- would perhaps be one way to fix it, but a better way which would
- win for more cases would be to use the executable file for the text
- segment, like the `icache' code below but done cleanly (in some
- target-independent place, perhaps in target_xfer_memory, perhaps
- based on assigning each target a speed or perhaps by some simpler
- mechanism). */
+ would perhaps be one way to fix it. Another idea would be to use the
+ executable file for the text segment (for all SEC_CODE sections?
+ For all SEC_READONLY sections?). This has problems if you want to
+ actually see what the memory contains (e.g. self-modifying code,
+ clobbered memory, user downloaded the wrong thing). */
/* Read a word from remote address ADDR and return it.
This goes through the data cache. */
remote_fetch_word (addr)
CORE_ADDR addr;
{
-#if 0
- if (icache)
- {
- extern CORE_ADDR text_start, text_end;
-
- if (addr >= text_start && addr < text_end)
- {
- int buffer;
- xfer_core_file (addr, &buffer, sizeof (int));
- return buffer;
- }
- }
-#endif
return dcache_fetch (remote_dcache, addr);
}
static int
remote_write_bytes (memaddr, myaddr, len)
CORE_ADDR memaddr;
- unsigned char *myaddr;
+ char *myaddr;
int len;
{
char buf[PBUFSIZ];
static int
remote_read_bytes (memaddr, myaddr, len)
CORE_ADDR memaddr;
- unsigned char *myaddr;
+ char *myaddr;
int len;
{
char buf[PBUFSIZ];
xfersize = len;
if (should_write)
- bytes_xferred = remote_write_bytes (memaddr,
- (unsigned char *)myaddr, xfersize);
+ bytes_xferred = remote_write_bytes (memaddr, myaddr, xfersize);
else
- bytes_xferred = remote_read_bytes (memaddr,
- (unsigned char *)myaddr, xfersize);
+ bytes_xferred = remote_read_bytes (memaddr, myaddr, xfersize);
/* If we get an error, we are done xferring. */
if (bytes_xferred == 0)
{
int ch;
- ch = SERIAL_READCHAR (remote_hppro_desc, timeout);
+ ch = SERIAL_READCHAR (remote_desc, timeout);
switch (ch)
{
/* Send a packet to the remote machine, with error checking.
The data of the packet is in BUF. */
-
static void
putpkt (buf)
char *buf;
printf_unfiltered ("Sending packet: %s...", buf2);
gdb_flush(gdb_stdout);
}
- if (SERIAL_WRITE (remote_hppro_desc, buf2, p - buf2))
+ if (SERIAL_WRITE (remote_desc, buf2, p - buf2))
perror_with_name ("putpkt: write failed");
/* read until either a timeout occurs (-2) or '+' is read */
case '$':
if (started_error_output)
{
- putc_unfiltered ('\n');
+ putchar_unfiltered ('\n');
started_error_output = 0;
}
}
{
case '+':
if (remote_debug)
- printf_unfiltered("Ack\n");
+ printf_unfiltered("Got Ack\n");
return;
case SERIAL_TIMEOUT:
break; /* Retransmit buffer */
started_error_output = 1;
printf_unfiltered ("putpkt: Junk: ");
}
- putc_unfiltered (ch & 0177);
+ putchar_unfiltered (ch & 0177);
}
continue;
}
char *buf;
int forever;
{
- char *bp;
int c;
int tries;
int timeout;
{
if (remote_debug)
fprintf_unfiltered (gdb_stderr, "Packet received: %s\n", buf);
- SERIAL_WRITE (remote_hppro_desc, "+", 1);
+ SERIAL_WRITE (remote_desc, "+", 1);
return;
}
/* Try the whole thing again. */
retry:
- SERIAL_WRITE (remote_hppro_desc, "-", 1);
+ SERIAL_WRITE (remote_desc, "-", 1);
}
/* We have tried hard enough, and just can't receive the packet. Give up. */
printf_unfiltered ("Ignoring packet error, continuing...\n");
- SERIAL_WRITE (remote_hppro_desc, "+", 1);
+ SERIAL_WRITE (remote_desc, "+", 1);
}
\f
static void
than other targets. */
static unsigned char break_insn[] = REMOTE_BREAKPOINT;
-/* Check that it fits in BREAKPOINT_MAX bytes. */
-static unsigned char check_break_insn_size[BREAKPOINT_MAX] = REMOTE_BREAKPOINT;
-
#else /* No REMOTE_BREAKPOINT. */
/* Same old breakpoint instruction. This code does nothing different
struct target_ops remote_hppro_ops = {
"hppro", /* to_shortname */
- "Remote serial target in gdb-specific protocol", /* to_longname */
+ "Remote serial target for HP-PRO targets", /* to_longname */
"Use a remote computer via a serial line, using a gdb-specific protocol.\n\
-Specify the serial device it is connected to (e.g. /dev/ttya). or telnet port", /* to_doc */
+This is for targets that supports the HP-PRO standard.\n\
+Specify the serial device it is connected to (e.g. /dev/ttya) or telnet port.", /* to_doc */
remote_open, /* to_open */
remote_close, /* to_close */
NULL, /* to_attach */
NULL, /* to_terminal_ours */
NULL, /* to_terminal_info */
remote_kill, /* to_kill */
- generic_load, /* to_load */
+ hppro_load, /* to_load */
NULL, /* to_lookup_symbol */
NULL, /* to_create_inferior */
remote_mourn, /* to_mourn_inferior */
0, /* to_can_run */
0, /* to_notice_signals */
+ 0, /* to_thread_alive */
+ 0, /* to_stop */
process_stratum, /* to_stratum */
NULL, /* to_next */
1, /* to_has_all_memory */
OPS_MAGIC /* to_magic */
};
-/* sets the download protocol, choices are srec, generic, boot */
-char *loadtype;
-static char *loadtype_str;
-static void set_loadtype_command
- PARAMS ((char *, int, struct cmd_list_element *));
-
void
_initialize_remote_hppro ()
{
"Set the type of the remote load protocol.\n", &setlist);
c->function.sfunc = set_loadtype_command;
add_show_from_set (c, &showlist);
- c->var = "generic";
- if (getenv ("LOADTYPE"))
- c->var = savestring (getenv ("LOADTYPE"), strlen ("LOADTYPE"));
+ loadtype_str = savestring ("generic", 8);
+
+ /* this adds a command to boot the board */
+ add_com ("boot", class_support, boot_board,
+ "Boot the damn target board.\n");
}
static void
-set_loadtype_command (newtype, from_tty, c)
- char *newtype;
+set_loadtype_command (ignore, from_tty, c)
+ char *ignore;
int from_tty;
struct cmd_list_element *c;
{
- loadtype_str = savestring (newtype, strlen (newtype));
+ loadtype_str = savestring (*(char **) c->var, strlen (*(char **) c->var));
}
-
-
-
projects / deliverable / binutils-gdb.git / blobdiff