/* Remote debugging for the ARM RDP interface.
- Copyright 1994, 1995, 1998, 1999, 2000, 2001
- Free Software Foundation, Inc.
+
+ Copyright 1994, 1995, 1998, 1999, 2000, 2001, 2002, 2003 Free
+ Software Foundation, Inc.
This file is part of GDB.
#include "defs.h"
#include "inferior.h"
#include "value.h"
-#include "callback.h"
+#include "gdb/callback.h"
#include "command.h"
#include <ctype.h>
#include <fcntl.h>
#include "regcache.h"
#include "serial.h"
+#include "arm-tdep.h"
+
#ifdef HAVE_TIME_H
#include <time.h>
#endif
static unsigned char
get_byte (void)
{
- int c = SERIAL_READCHAR (io, timeout);
+ int c = serial_readchar (io, timeout);
if (remote_debug)
fprintf_unfiltered (gdb_stdlog, "[%02x]\n", c);
{
if (remote_debug)
fprintf_unfiltered (gdb_stdlog, "(%02x)\n", val);
- SERIAL_WRITE (io, &val, 1);
+ serial_write (io, &val, 1);
}
static void
if (remote_debug)
fprintf_unfiltered (gdb_stdlog, "(%04x)", val);
- SERIAL_WRITE (io, b, 4);
+ serial_write (io, b, 4);
}
int restype;
QUIT;
- SERIAL_FLUSH_INPUT (io);
- SERIAL_FLUSH_OUTPUT (io);
+ serial_flush_input (io);
+ serial_flush_output (io);
if (tty)
printf_unfiltered ("Trying to connect at %d baud.\n", baudtry);
if (cold)
{
put_byte (RDP_RESET);
- while ((restype = SERIAL_READCHAR (io, 1)) > 0)
+ while ((restype = serial_readchar (io, 1)) > 0)
{
switch (restype)
{
put_byte (type | RDP_OPEN_TYPE_RETURN_SEX);
put_word (0);
- while (!sync && (restype = SERIAL_READCHAR (io, 1)) > 0)
+ while (!sync && (restype = serial_readchar (io, 1)) > 0)
{
if (remote_debug)
fprintf_unfiltered (gdb_stdlog, "[%02x]\n", restype);
break;
case RDP_RESET:
- while ((restype = SERIAL_READCHAR (io, 1)) == RDP_RESET)
+ while ((restype = serial_readchar (io, 1)) == RDP_RESET)
;
do
{
printf_unfiltered ("%c", isgraph (restype) ? restype : ' ');
}
- while ((restype = SERIAL_READCHAR (io, 1)) > 0);
+ while ((restype = serial_readchar (io, 1)) > 0);
if (tty)
{
case RDP_RES_VALUE:
{
- int resval = SERIAL_READCHAR (io, 1);
+ int resval = serial_readchar (io, 1);
if (remote_debug)
fprintf_unfiltered (gdb_stdlog, "[%02x]\n", resval);
case SERIAL_TIMEOUT:
break;
case RDP_RES_VALUE_LITTLE_ENDIAN:
- target_byte_order = LITTLE_ENDIAN;
+#if 0
+ /* FIXME: cagney/2003-11-22: Ever since the ARM
+ was multi-arched (in 2002-02-08), this
+ assignment has had no effect. There needs to
+ be some sort of check/decision based on the
+ current architecture's byte-order vs the remote
+ target's byte order. For the moment disable
+ the assignment to keep things building. */
+ target_byte_order = BFD_ENDIAN_LITTLE;
+#endif
sync = 1;
break;
case RDP_RES_VALUE_BIG_ENDIAN:
- target_byte_order = BIG_ENDIAN;
+#if 0
+ /* FIXME: cagney/2003-11-22: Ever since the ARM
+ was multi-arched (in 2002-02-08), this
+ assignment has had no effect. There needs to
+ be some sort of check/decision based on the
+ current architecture's byte-order vs the remote
+ target's byte order. For the moment disable
+ the assignment to keep things building. */
+ target_byte_order = BFD_ENDIAN_BIG;
+#endif
sync = 1;
break;
default:
}
-void
+static void
send_rdp (char *template,...)
{
char buf[200];
pc = va_arg (alist, char *);
val = va_arg (alist, int);
dst = buf;
- SERIAL_WRITE (io, pc, val);
+ serial_write (io, pc, val);
break;
case '-':
/* Send whats in the queue */
if (dst != buf)
{
- SERIAL_WRITE (io, buf, dst - buf);
+ serial_write (io, buf, dst - buf);
dst = buf;
}
break;
send_rdp ("bbw-SWWWWZ", RDP_COPRO_READ, FPU_COPRO_NUMBER, mask, buf + 0, buf + 4, buf + 8, &dummy);
}
#endif
- memset (buf, 0, MAX_REGISTER_RAW_SIZE);
+ memset (buf, 0, MAX_REGISTER_SIZE);
}
}
else
{
- char buf[MAX_REGISTER_RAW_SIZE];
+ char buf[ARM_MAX_REGISTER_RAW_SIZE];
if (regno < 15)
rdp_fetch_one_register (1 << regno, buf);
- else if (regno == PC_REGNUM)
+ else if (regno == ARM_PC_REGNUM)
rdp_fetch_one_register (RDP_CPU_READWRITE_MASK_PC, buf);
- else if (regno == PS_REGNUM)
+ else if (regno == ARM_PS_REGNUM)
rdp_fetch_one_register (RDP_CPU_READWRITE_MASK_CPSR, buf);
- else if (regno == FPS_REGNUM)
+ else if (regno == ARM_FPS_REGNUM)
rdp_fetch_one_fpu_register (RDP_FPU_READWRITE_MASK_FPS, buf);
- else if (regno >= F0_REGNUM && regno <= F7_REGNUM)
- rdp_fetch_one_fpu_register (1 << (regno - F0_REGNUM), buf);
+ else if (regno >= ARM_F0_REGNUM && regno <= ARM_F7_REGNUM)
+ rdp_fetch_one_fpu_register (1 << (regno - ARM_F0_REGNUM), buf);
else
{
printf ("Help me with fetch reg %d\n", regno);
}
else
{
- char tmp[MAX_REGISTER_RAW_SIZE];
- read_register_gen (regno, tmp);
+ char tmp[ARM_MAX_REGISTER_RAW_SIZE];
+ deprecated_read_register_gen (regno, tmp);
if (regno < 15)
rdp_store_one_register (1 << regno, tmp);
- else if (regno == PC_REGNUM)
+ else if (regno == ARM_PC_REGNUM)
rdp_store_one_register (RDP_CPU_READWRITE_MASK_PC, tmp);
- else if (regno == PS_REGNUM)
+ else if (regno == ARM_PS_REGNUM)
rdp_store_one_register (RDP_CPU_READWRITE_MASK_CPSR, tmp);
- else if (regno >= F0_REGNUM && regno <= F7_REGNUM)
- rdp_store_one_fpu_register (1 << (regno - F0_REGNUM), tmp);
+ else if (regno >= ARM_F0_REGNUM && regno <= ARM_F7_REGNUM)
+ rdp_store_one_fpu_register (1 << (regno - ARM_F0_REGNUM), tmp);
else
{
printf ("Help me with reg %d\n", regno);
while (running)
{
int res;
- res = SERIAL_READCHAR (io, 1);
+ res = serial_readchar (io, 1);
while (res == SERIAL_TIMEOUT)
{
QUIT;
printf_filtered ("Waiting for target..\n");
- res = SERIAL_READCHAR (io, 1);
+ res = serial_readchar (io, 1);
}
switch (res)
else
{
char handle[4];
- CORE_ADDR pc = read_register (PC_REGNUM);
+ CORE_ADDR pc = read_register (ARM_PC_REGNUM);
pc = arm_get_next_pc (pc);
remote_rdp_insert_breakpoint (pc, handle);
rdp_execute ();
target_preopen (from_tty);
- io = SERIAL_OPEN (args);
+ io = serial_open (args);
if (!io)
perror_with_name (args);
- SERIAL_RAW (io);
+ serial_raw (io);
rdp_init (1, from_tty);
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);
}
{
callback->shutdown (callback);
if (io)
- SERIAL_CLOSE (io);
+ serial_close (io);
io = 0;
}
static int
remote_rdp_xfer_inferior_memory (CORE_ADDR memaddr, char *myaddr, int len,
- int write,
- struct mem_attrib *attrib ATTRIBUTE_UNUSED,
- struct target_ops *target ATTRIBUTE_UNUSED)
+ int write, struct mem_attrib *attrib,
+ struct target_ops *target)
{
/* I infer from D Taylor's code that there's a limit on the amount
we can transfer in one chunk.. */
proceed (entry_point, TARGET_SIGNAL_DEFAULT, 0);
}
-/* Accept any stray run/attach commands */
-static int
-remote_rdp_can_run (void)
-{
- return 1;
-}
-
/* Attach doesn't need to do anything */
static void
remote_rdp_attach (char *args, int from_tty)
remote_rdp_ops.to_open = remote_rdp_open;
remote_rdp_ops.to_close = remote_rdp_close;
remote_rdp_ops.to_attach = remote_rdp_attach;
- remote_rdp_ops.to_post_attach = NULL;
- remote_rdp_ops.to_require_attach = NULL;
- remote_rdp_ops.to_detach = NULL;
- remote_rdp_ops.to_require_detach = NULL;
remote_rdp_ops.to_resume = remote_rdp_resume;
remote_rdp_ops.to_wait = remote_rdp_wait;
- remote_rdp_ops.to_post_wait = NULL;
remote_rdp_ops.to_fetch_registers = remote_rdp_fetch_register;
remote_rdp_ops.to_store_registers = remote_rdp_store_register;
remote_rdp_ops.to_prepare_to_store = remote_rdp_prepare_to_store;
remote_rdp_ops.to_files_info = remote_rdp_files_info;
remote_rdp_ops.to_insert_breakpoint = remote_rdp_insert_breakpoint;
remote_rdp_ops.to_remove_breakpoint = remote_rdp_remove_breakpoint;
- remote_rdp_ops.to_terminal_init = NULL;
- remote_rdp_ops.to_terminal_inferior = NULL;
- remote_rdp_ops.to_terminal_ours_for_output = NULL;
- remote_rdp_ops.to_terminal_ours = NULL;
- remote_rdp_ops.to_terminal_info = NULL;
remote_rdp_ops.to_kill = remote_rdp_kill;
remote_rdp_ops.to_load = generic_load;
- remote_rdp_ops.to_lookup_symbol = NULL;
remote_rdp_ops.to_create_inferior = remote_rdp_create_inferior;
- remote_rdp_ops.to_post_startup_inferior = NULL;
- remote_rdp_ops.to_acknowledge_created_inferior = NULL;
- remote_rdp_ops.to_clone_and_follow_inferior = NULL;
- remote_rdp_ops.to_post_follow_inferior_by_clone = NULL;
- remote_rdp_ops.to_insert_fork_catchpoint = NULL;
- remote_rdp_ops.to_remove_fork_catchpoint = NULL;
- remote_rdp_ops.to_insert_vfork_catchpoint = NULL;
- remote_rdp_ops.to_remove_vfork_catchpoint = NULL;
- remote_rdp_ops.to_has_forked = NULL;
- remote_rdp_ops.to_has_vforked = NULL;
- remote_rdp_ops.to_can_follow_vfork_prior_to_exec = NULL;
- remote_rdp_ops.to_post_follow_vfork = NULL;
- remote_rdp_ops.to_insert_exec_catchpoint = NULL;
- remote_rdp_ops.to_remove_exec_catchpoint = NULL;
- remote_rdp_ops.to_has_execd = NULL;
- remote_rdp_ops.to_reported_exec_events_per_exec_call = NULL;
- remote_rdp_ops.to_has_exited = NULL;
remote_rdp_ops.to_mourn_inferior = generic_mourn_inferior;
- remote_rdp_ops.to_can_run = remote_rdp_can_run;
- remote_rdp_ops.to_notice_signals = 0;
- remote_rdp_ops.to_thread_alive = 0;
- remote_rdp_ops.to_stop = 0;
- remote_rdp_ops.to_pid_to_exec_file = NULL;
remote_rdp_ops.to_stratum = process_stratum;
- remote_rdp_ops.DONT_USE = NULL;
remote_rdp_ops.to_has_all_memory = 1;
remote_rdp_ops.to_has_memory = 1;
remote_rdp_ops.to_has_stack = 1;
remote_rdp_ops.to_has_registers = 1;
remote_rdp_ops.to_has_execution = 1;
- remote_rdp_ops.to_sections = NULL;
- remote_rdp_ops.to_sections_end = NULL;
remote_rdp_ops.to_magic = OPS_MAGIC;
}
+extern initialize_file_ftype _initialize_remote_rdp; /* -Wmissing-prototypes */
+
void
_initialize_remote_rdp (void)
{
projects / deliverable / binutils-gdb.git / blobdiff