/* Remote debugging interface for MIPS remote debugging protocol.
- Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001
- Free Software Foundation, Inc.
+
+ Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
+ 2002 Free Software Foundation, Inc.
+
Contributed by Cygnus Support. Written by Ian Lance Taylor
<ian@cygnus.com>.
static int mips_need_reply = 0;
/* Handle used to access serial I/O stream. */
-static serial_t mips_desc;
+static struct serial *mips_desc;
/* UDP handle used to download files to target. */
-static serial_t udp_desc;
+static struct serial *udp_desc;
static int udp_in_use;
/* TFTP filename used to download files to DDB board, in the form
close_ports (void)
{
mips_is_open = 0;
- SERIAL_CLOSE (mips_desc);
+ serial_close (mips_desc);
if (udp_in_use)
{
- SERIAL_CLOSE (udp_desc);
+ serial_close (udp_desc);
udp_in_use = 0;
}
tftp_in_use = 0;
printf_unfiltered ("Ending remote MIPS debugging.\n");
target_mourn_inferior ();
- return_to_top_level (RETURN_ERROR);
+ throw_exception (RETURN_ERROR);
}
/* putc_readable - print a character, displaying non-printable chars in
{
int c;
-/* Must use SERIAL_READCHAR here cuz mips_readchar would get confused if we
- were waiting for the mips_monitor_prompt... */
+ /* Must use serial_readchar() here cuz mips_readchar would get
+ confused if we were waiting for the mips_monitor_prompt... */
- c = SERIAL_READCHAR (mips_desc, timeout);
+ c = serial_readchar (mips_desc, timeout);
if (c == SERIAL_TIMEOUT)
{
immediate_quit++;
while (n > 0)
{
- c = SERIAL_READCHAR (mips_desc, remote_timeout);
+ c = serial_readchar (mips_desc, remote_timeout);
if (c == SERIAL_TIMEOUT)
{
}
/* Read a character from the remote, aborting on error. Returns
- SERIAL_TIMEOUT on timeout (since that's what SERIAL_READCHAR
- returns). FIXME: If we see the string mips_monitor_prompt from
- the board, then we are debugging on the main console port, and we
- have somehow dropped out of remote debugging mode. In this case,
- we automatically go back in to remote debugging mode. This is a
- hack, put in because I can't find any way for a program running on
- the remote board to terminate without also ending remote debugging
+ SERIAL_TIMEOUT on timeout (since that's what serial_readchar()
+ returns). FIXME: If we see the string mips_monitor_prompt from the
+ board, then we are debugging on the main console port, and we have
+ somehow dropped out of remote debugging mode. In this case, we
+ automatically go back in to remote debugging mode. This is a hack,
+ put in because I can't find any way for a program running on the
+ remote board to terminate without also ending remote debugging
mode. I assume users won't have any trouble with this; for one
thing, the IDT documentation generally assumes that the remote
debugging port is not the console port. This is, however, very
if (state == mips_monitor_prompt_len)
timeout = 1;
- ch = SERIAL_READCHAR (mips_desc, timeout);
+ ch = serial_readchar (mips_desc, timeout);
if (ch == SERIAL_TIMEOUT && timeout == -1) /* Watchdog went off */
{
fprintf_unfiltered (gdb_stdlog, "Writing \"%s\"\n", packet + 1);
}
- if (SERIAL_WRITE (mips_desc, packet,
+ if (serial_write (mips_desc, packet,
HDR_LENGTH + len + TRLR_LENGTH) != 0)
mips_error ("write to target failed: %s", safe_strerror (errno));
ack + 1);
}
- if (SERIAL_WRITE (mips_desc, ack, HDR_LENGTH + TRLR_LENGTH) != 0)
+ if (serial_write (mips_desc, ack, HDR_LENGTH + TRLR_LENGTH) != 0)
{
if (throw_error)
mips_error ("write to target failed: %s", safe_strerror (errno));
ack + 1);
}
- if (SERIAL_WRITE (mips_desc, ack, HDR_LENGTH + TRLR_LENGTH) != 0)
+ if (serial_write (mips_desc, ack, HDR_LENGTH + TRLR_LENGTH) != 0)
{
if (throw_error)
mips_error ("write to target failed: %s", safe_strerror (errno));
}
static void
-mips_initialize_cleanups (PTR arg)
+mips_initialize_cleanups (void *arg)
{
mips_initializing = 0;
}
static void
-mips_exit_cleanups (PTR arg)
+mips_exit_cleanups (void *arg)
{
mips_exiting = 0;
}
static void
mips_send_command (const char *cmd, int prompt)
{
- SERIAL_WRITE (mips_desc, cmd, strlen (cmd));
+ serial_write (mips_desc, cmd, strlen (cmd));
mips_expect (cmd);
mips_expect ("\n");
if (prompt)
mips_send_command ("db tty0\r", 0);
sleep (1);
- SERIAL_WRITE (mips_desc, "\r", sizeof "\r" - 1);
+ serial_write (mips_desc, "\r", sizeof "\r" - 1);
/* We don't need to absorb any spurious characters here, since the
mips_receive_header will eat up a reasonable number of characters
switch (j)
{
case 0: /* First, try sending a CR */
- SERIAL_FLUSH_INPUT (mips_desc);
- SERIAL_WRITE (mips_desc, "\r", 1);
+ serial_flush_input (mips_desc);
+ serial_write (mips_desc, "\r", 1);
break;
case 1: /* First, try sending a break */
- SERIAL_SEND_BREAK (mips_desc);
+ serial_send_break (mips_desc);
break;
case 2: /* Then, try a ^C */
- SERIAL_WRITE (mips_desc, "\003", 1);
+ serial_write (mips_desc, "\003", 1);
break;
case 3: /* Then, try escaping from download */
{
packets. In-case we were downloading a large packet
we flush the output buffer before inserting a
termination sequence. */
- SERIAL_FLUSH_OUTPUT (mips_desc);
+ serial_flush_output (mips_desc);
sprintf (tbuff, "\r/E/E\r");
- SERIAL_WRITE (mips_desc, tbuff, 6);
+ serial_write (mips_desc, tbuff, 6);
}
else
{
for (i = 1; i <= 33; i++)
{
- SERIAL_WRITE (mips_desc, srec, 8);
+ serial_write (mips_desc, srec, 8);
- if (SERIAL_READCHAR (mips_desc, 0) >= 0)
+ if (serial_readchar (mips_desc, 0) >= 0)
break; /* Break immediatly if we get something from
the board. */
}
the request itself succeeds or fails. */
mips_request ('r', 0, 0, &err, mips_receive_wait, NULL);
- set_current_frame (create_new_frame (read_fp (), read_pc ()));
- select_frame (get_current_frame (), 0);
+ /* FIXME: cagney/2002-11-29: Force the update of selected frame.
+ This shouldn't be necessary, only many many places still refer to
+ selected_frame directly (instead of using get_selected_frame(). */
+ get_selected_frame (); /* Hack!!! */
}
/* Open a connection to the remote board. */
unpush_target (current_ops);
/* Open and initialize the serial port. */
- mips_desc = SERIAL_OPEN (serial_port_name);
- if (mips_desc == (serial_t) NULL)
+ mips_desc = serial_open (serial_port_name);
+ if (mips_desc == NULL)
perror_with_name (serial_port_name);
if (baud_rate != -1)
{
- if (SERIAL_SETBAUDRATE (mips_desc, baud_rate))
+ if (serial_setbaudrate (mips_desc, baud_rate))
{
- SERIAL_CLOSE (mips_desc);
+ serial_close (mips_desc);
perror_with_name (serial_port_name);
}
}
- SERIAL_RAW (mips_desc);
+ serial_raw (mips_desc);
/* Open and initialize the optional download port. If it is in the form
hostname#portnumber, it's a UDP socket. If it is in the form
{
if (strchr (remote_name, '#'))
{
- udp_desc = SERIAL_OPEN (remote_name);
+ udp_desc = serial_open (remote_name);
if (!udp_desc)
perror_with_name ("Unable to open UDP port");
udp_in_use = 1;
if (ptype)
mips_set_processor_type_command (xstrdup (ptype), 0);
-/* This is really the job of start_remote however, that makes an assumption
- that the target is about to print out a status message of some sort. That
- doesn't happen here (in fact, it may not be possible to get the monitor to
- send the appropriate packet). */
+ /* This is really the job of start_remote however, that makes an
+ assumption that the target is about to print out a status message
+ of some sort. That doesn't happen here (in fact, it may not be
+ possible to get the monitor to send the appropriate packet). */
flush_cached_frames ();
registers_changed ();
stop_pc = read_pc ();
- set_current_frame (create_new_frame (read_fp (), stop_pc));
- select_frame (get_current_frame (), 0);
- print_stack_frame (selected_frame, -1, 1);
+ print_stack_frame (get_selected_frame (), -1, 1);
xfree (serial_port_name);
}
&rpc, &rfp, &rsp, flags);
if (nfields >= 3)
{
- char buf[MAX_REGISTER_RAW_SIZE];
+ char buf[MAX_REGISTER_SIZE];
store_unsigned_integer (buf, REGISTER_RAW_SIZE (PC_REGNUM), rpc);
supply_register (PC_REGNUM, buf);
store_unsigned_integer (buf, REGISTER_RAW_SIZE (SP_REGNUM), rsp);
supply_register (SP_REGNUM, buf);
- store_unsigned_integer (buf, REGISTER_RAW_SIZE (FP_REGNUM), 0);
- supply_register (FP_REGNUM, buf);
+ store_unsigned_integer (buf, REGISTER_RAW_SIZE (DEPRECATED_FP_REGNUM), 0);
+ supply_register (DEPRECATED_FP_REGNUM, buf);
if (nfields == 9)
{
return;
}
- if (regno == FP_REGNUM || regno == ZERO_REGNUM)
- /* FP_REGNUM on the mips is a hack which is just supposed to read
- zero (see also mips-nat.c). */
+ if (regno == DEPRECATED_FP_REGNUM || regno == ZERO_REGNUM)
+ /* DEPRECATED_FP_REGNUM on the mips is a hack which is just
+ supposed to read zero (see also mips-nat.c). */
val = 0;
else
{
}
{
- char buf[MAX_REGISTER_RAW_SIZE];
+ char buf[MAX_REGISTER_SIZE];
/* We got the number the register holds, but gdb expects to see a
value in the target byte ordering. */
static int
mips_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
- struct mem_attrib *attrib ATTRIBUTE_UNUSED,
- struct target_ops *target ATTRIBUTE_UNUSED)
+ struct mem_attrib *attrib, struct target_ops *target)
{
int i;
CORE_ADDR addr;
printf_unfiltered ("Ending remote MIPS debugging.\n");
target_mourn_inferior ();
- return_to_top_level (RETURN_QUIT);
+ throw_exception (RETURN_QUIT);
}
target_terminal_inferior ();
if (remote_debug > 0)
printf_unfiltered ("Sending break\n");
- SERIAL_SEND_BREAK (mips_desc);
+ serial_send_break (mips_desc);
#if 0
if (mips_is_open)
/* Send a ^C. */
cc = '\003';
- SERIAL_WRITE (mips_desc, &cc, 1);
+ serial_write (mips_desc, &cc, 1);
sleep (1);
target_mourn_inferior ();
}
/* We can write a breakpoint and read the shadow contents in one
operation. */
-/* Insert a breakpoint. On targets that don't have built-in breakpoint
- support, we read the contents of the target location and stash it,
- then overwrite it with a breakpoint instruction. ADDR is the target
- location in the target machine. CONTENTS_CACHE is a pointer to
- memory allocated for saving the target contents. It is guaranteed
- by the caller to be long enough to save sizeof BREAKPOINT bytes (this
- is accomplished via BREAKPOINT_MAX). */
+/* Insert a breakpoint. On targets that don't have built-in
+ breakpoint support, we read the contents of the target location and
+ stash it, then overwrite it with a breakpoint instruction. ADDR is
+ the target location in the target machine. CONTENTS_CACHE is a
+ pointer to memory allocated for saving the target contents. It is
+ guaranteed by the caller to be long enough to save the breakpoint
+ length returned by BREAKPOINT_FROM_PC. */
static int
mips_insert_breakpoint (CORE_ADDR addr, char *contents_cache)
{
int ch;
- SERIAL_WRITE (mips_desc, srec, len);
+ serial_write (mips_desc, srec, len);
ch = mips_readchar (remote_timeout);
reclen = mips_make_srec (srec, '3', s->vma + i, buffer, numbytes);
send_srec (srec, reclen, s->vma + i);
+ if (ui_load_progress_hook)
+ ui_load_progress_hook (s->name, i);
+
if (hashmark)
{
putchar_unfiltered ('#');
send_srec (srec, reclen, abfd->start_address);
- SERIAL_FLUSH_INPUT (mips_desc);
+ serial_flush_input (mips_desc);
}
/*
if (!tftp_in_use)
{
- c = SERIAL_READCHAR (udp_in_use ? udp_desc : mips_desc,
+ c = serial_readchar (udp_in_use ? udp_desc : mips_desc,
remote_timeout);
if ((c == SERIAL_TIMEOUT) || (c != 0x06))
{
if (tftp_in_use)
fwrite (buffer, 1, length, tftp_file);
else
- SERIAL_WRITE (udp_in_use ? udp_desc : mips_desc, buffer, length);
+ serial_write (udp_in_use ? udp_desc : mips_desc, buffer, length);
}
static void
break;
}
+ if (ui_load_progress_hook)
+ ui_load_progress_hook (s->name, i);
+
if (hashmark)
{
putchar_unfiltered ('#');
if (finished)
{ /* Ignore the termination message: */
- SERIAL_FLUSH_INPUT (udp_in_use ? udp_desc : mips_desc);
+ serial_flush_input (udp_in_use ? udp_desc : mips_desc);
}
else
{ /* Deal with termination message: */
/* Work around problem where PMON monitor updates the PC after a load
to a different value than GDB thinks it has. The following ensures
that the write_pc() WILL update the PC value: */
- register_valid[PC_REGNUM] = 0;
+ deprecated_register_valid[PC_REGNUM] = 0;
}
if (exec_bfd)
write_pc (bfd_get_start_address (exec_bfd));