/* Remote debugging interface for M32R/SDI.
- Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008
+ Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
Free Software Foundation, Inc.
Contributed by Renesas Technology Co.
#include "target.h"
#include "regcache.h"
#include "gdb_string.h"
+#include "gdbthread.h"
#include <ctype.h>
#include <signal.h>
#ifdef __MINGW32__
/* Forward data declarations */
extern struct target_ops m32r_ops;
+/* This is the ptid we use while we're connected to the remote. Its
+ value is arbitrary, as the target doesn't have a notion of
+ processes or threads, but we need something non-null to place in
+ inferior_ptid. */
+static ptid_t remote_m32r_ptid;
/* Commands */
#define SDI_OPEN 1
send_cmd (unsigned char cmd)
{
unsigned char buf[1];
+
buf[0] = cmd;
return send_data (buf, 1);
}
send_one_arg_cmd (unsigned char cmd, unsigned char arg1)
{
unsigned char buf[2];
+
buf[0] = cmd;
buf[1] = arg1;
return send_data (buf, 2);
send_two_arg_cmd (unsigned char cmd, unsigned char arg1, unsigned long arg2)
{
unsigned char buf[6];
+
buf[0] = cmd;
buf[1] = arg1;
store_long_parameter (buf + 2, arg2);
unsigned long arg3)
{
unsigned char buf[13];
+
buf[0] = cmd;
store_long_parameter (buf + 1, arg1);
store_long_parameter (buf + 5, arg2);
recv_char_data (void)
{
unsigned char val;
+
recv_data (&val, 1);
return val;
}
recv_long_data (void)
{
unsigned long val;
+
recv_data (&val, 4);
return ntohl (val);
}
/* This is called not only when we first attach, but also when the
user types "run" after having attached. */
static void
-m32r_create_inferior (char *execfile, char *args, char **env, int from_tty)
+m32r_create_inferior (struct target_ops *ops, char *execfile,
+ char *args, char **env, int from_tty)
{
CORE_ADDR entry_pt;
/* Install inferior's terminal modes. */
target_terminal_inferior ();
- write_pc (entry_pt);
+ regcache_write_pc (get_current_regcache (), entry_pt);
}
/* Open a connection to a remote debugger.
}
inferior_ptid = null_ptid;
+ delete_thread_silent (remote_m32r_ptid);
return;
}
/* Tell the remote machine to resume. */
static void
-m32r_resume (ptid_t ptid, int step, enum target_signal sig)
+m32r_resume (struct target_ops *ops,
+ ptid_t ptid, int step, enum target_signal sig)
{
unsigned long pc_addr, bp_addr, ab_addr;
int ib_breakpoints;
check_mmu_status ();
- pc_addr = read_pc ();
+ pc_addr = regcache_read_pc (get_current_regcache ());
if (remote_debug)
fprintf_unfiltered (gdb_stdlog, "pc <= 0x%lx\n", pc_addr);
else
{
buf[0] = SDI_WRITE_MEMORY;
- if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
+ if (gdbarch_byte_order (target_gdbarch) == BFD_ENDIAN_BIG)
store_long_parameter (buf + 1, pc_addr);
else
store_long_parameter (buf + 1, pc_addr - 1);
continue;
/* Set PBP. */
- if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
+ if (gdbarch_byte_order (target_gdbarch) == BFD_ENDIAN_BIG)
send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8000 + 4 * i, 4,
0x00000006);
else
store_long_parameter (buf + 5, 4);
if ((bp_addr & 2) == 0 && bp_addr != (pc_addr & 0xfffffffc))
{
- if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
+ if (gdbarch_byte_order (target_gdbarch) == BFD_ENDIAN_BIG)
{
buf[9] = dbt_bp_entry[0];
buf[10] = dbt_bp_entry[1];
}
else
{
- if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
+ if (gdbarch_byte_order (target_gdbarch) == BFD_ENDIAN_BIG)
{
if ((bp_addr & 2) == 0)
{
continue;
/* DBC register */
- if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
+ if (gdbarch_byte_order (target_gdbarch) == BFD_ENDIAN_BIG)
{
switch (ab_type[i])
{
target is active. These functions should be split out into seperate
variables, especially since GDB will someday have a notion of debugging
several processes. */
- inferior_ptid = pid_to_ptid (32);
+ inferior_ptid = remote_m32r_ptid;
+ add_thread_silent (remote_m32r_ptid);
return;
}
}
static ptid_t
-m32r_wait (ptid_t ptid, struct target_waitstatus *status)
+m32r_wait (struct target_ops *ops,
+ ptid_t ptid, struct target_waitstatus *status, int options)
{
static RETSIGTYPE (*prev_sigint) ();
unsigned long bp_addr, pc_addr;
if (last_pc_addr != 0xffffffff)
{
buf[0] = SDI_WRITE_MEMORY;
- if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
+ if (gdbarch_byte_order (target_gdbarch) == BFD_ENDIAN_BIG)
store_long_parameter (buf + 1, last_pc_addr);
else
store_long_parameter (buf + 1, last_pc_addr - 1);
address, we have to take care of it later. */
if ((pc_addr & 0x2) != 0)
{
- if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
+ if (gdbarch_byte_order (target_gdbarch) == BFD_ENDIAN_BIG)
{
if ((bp_data[i][2] & 0x80) != 0)
{
c = serial_readchar (sdi_desc, SDI_TIMEOUT);
if (c != '-' && recv_data (buf, 4) != -1)
{
- if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
+ if (gdbarch_byte_order (target_gdbarch) == BFD_ENDIAN_BIG)
{
if ((buf[3] & 0x1) == 0x1)
hit_watchpoint_addr = ab_address[i];
Use this when you want to detach and do something else
with your gdb. */
static void
-m32r_detach (char *args, int from_tty)
+m32r_detach (struct target_ops *ops, char *args, int from_tty)
{
if (remote_debug)
fprintf_unfiltered (gdb_stdlog, "m32r_detach(%d)\n", from_tty);
- m32r_resume (inferior_ptid, 0, 0);
+ m32r_resume (ops, inferior_ptid, 0, 0);
/* calls m32r_close to do the real work */
pop_target ();
return regno;
}
-/* Read the remote registers into the block REGS. */
-
-static void m32r_fetch_register (struct regcache *, int);
-
-static void
-m32r_fetch_registers (struct regcache *regcache)
-{
- int regno;
-
- for (regno = 0;
- regno < gdbarch_num_regs (get_regcache_arch (regcache));
- regno++)
- m32r_fetch_register (regcache, regno);
-}
-
/* Fetch register REGNO, or all registers if REGNO is -1.
Returns errno value. */
static void
-m32r_fetch_register (struct regcache *regcache, int regno)
+m32r_fetch_register (struct target_ops *ops,
+ struct regcache *regcache, int regno)
{
+ struct gdbarch *gdbarch = get_regcache_arch (regcache);
+ enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
unsigned long val, val2, regid;
if (regno == -1)
- m32r_fetch_registers (regcache);
+ {
+ for (regno = 0;
+ regno < gdbarch_num_regs (get_regcache_arch (regcache));
+ regno++)
+ m32r_fetch_register (ops, regcache, regno);
+ }
else
{
char buffer[MAX_REGISTER_SIZE];
/* We got the number the register holds, but gdb expects to see a
value in the target byte ordering. */
- store_unsigned_integer (buffer, 4, val);
+ store_unsigned_integer (buffer, 4, byte_order, val);
regcache_raw_supply (regcache, regno, buffer);
}
return;
}
-/* Store the remote registers from the contents of the block REGS. */
-
-static void m32r_store_register (struct regcache *, int);
-
-static void
-m32r_store_registers (struct regcache *regcache)
-{
- int regno;
-
- for (regno = 0;
- regno < gdbarch_num_regs (get_regcache_arch (regcache));
- regno++)
- m32r_store_register (regcache, regno);
-
- registers_changed ();
-}
-
/* Store register REGNO, or all if REGNO == 0.
Return errno value. */
static void
-m32r_store_register (struct regcache *regcache, int regno)
+m32r_store_register (struct target_ops *ops,
+ struct regcache *regcache, int regno)
{
int regid;
ULONGEST regval, tmp;
if (regno == -1)
- m32r_store_registers (regcache);
+ {
+ for (regno = 0;
+ regno < gdbarch_num_regs (get_regcache_arch (regcache));
+ regno++)
+ m32r_store_register (ops, regcache, regno);
+ }
else
{
regcache_cooked_read_unsigned (regcache, regno, ®val);
static void
m32r_files_info (struct target_ops *target)
{
- char *file = "nothing";
+ const char *file = "nothing";
if (exec_bfd)
{
{
if (write)
fprintf_unfiltered (gdb_stdlog, "m32r_xfer_memory(%s,%d,write)\n",
- paddr (memaddr), len);
+ paddress (target_gdbarch, memaddr), len);
else
fprintf_unfiltered (gdb_stdlog, "m32r_xfer_memory(%s,%d,read)\n",
- paddr (memaddr), len);
+ paddress (target_gdbarch, memaddr), len);
}
if (write)
}
static void
-m32r_kill (void)
+m32r_kill (struct target_ops *ops)
{
if (remote_debug)
fprintf_unfiltered (gdb_stdlog, "m32r_kill()\n");
inferior_ptid = null_ptid;
+ delete_thread_silent (remote_m32r_ptid);
return;
}
instructions. */
static void
-m32r_mourn_inferior (void)
+m32r_mourn_inferior (struct target_ops *ops)
{
if (remote_debug)
fprintf_unfiltered (gdb_stdlog, "m32r_mourn_inferior()\n");
}
static int
-m32r_insert_breakpoint (struct bp_target_info *bp_tgt)
+m32r_insert_breakpoint (struct gdbarch *gdbarch,
+ struct bp_target_info *bp_tgt)
{
CORE_ADDR addr = bp_tgt->placed_address;
int ib_breakpoints;
if (remote_debug)
fprintf_unfiltered (gdb_stdlog, "m32r_insert_breakpoint(%s,...)\n",
- paddr (addr));
+ paddress (gdbarch, addr));
if (use_ib_breakpoints)
ib_breakpoints = max_ib_breakpoints;
}
static int
-m32r_remove_breakpoint (struct bp_target_info *bp_tgt)
+m32r_remove_breakpoint (struct gdbarch *gdbarch,
+ struct bp_target_info *bp_tgt)
{
CORE_ADDR addr = bp_tgt->placed_address;
int i;
if (remote_debug)
fprintf_unfiltered (gdb_stdlog, "m32r_remove_breakpoint(%s)\n",
- paddr (addr));
+ paddress (gdbarch, addr));
for (i = 0; i < MAX_BREAKPOINTS; i++)
{
/* Make the PC point at the start address */
if (exec_bfd)
- write_pc (bfd_get_start_address (exec_bfd));
+ regcache_write_pc (get_current_regcache (),
+ bfd_get_start_address (exec_bfd));
inferior_ptid = null_ptid; /* No process now */
+ delete_thread_silent (remote_m32r_ptid);
/* This is necessary because many things were based on the PC at the time
that we attached to the monitor, which is no longer valid now that we
}
static void
-m32r_stop (void)
+m32r_stop (ptid_t ptid)
{
if (remote_debug)
fprintf_unfiltered (gdb_stdlog, "m32r_stop()\n");
/* Tell whether this target can support a hardware breakpoint. CNT
is the number of hardware breakpoints already installed. This
- implements the TARGET_CAN_USE_HARDWARE_WATCHPOINT macro. */
+ implements the target_can_use_hardware_watchpoint macro. */
-int
+static int
m32r_can_use_hw_watchpoint (int type, int cnt, int othertype)
{
return sdi_desc != NULL && cnt < max_access_breaks;
for a write watchpoint, 1 for a read watchpoint, or 2 for a read/write
watchpoint. */
-int
-m32r_insert_watchpoint (CORE_ADDR addr, int len, int type)
+static int
+m32r_insert_watchpoint (CORE_ADDR addr, int len, int type,
+ struct expression *cond)
{
int i;
if (remote_debug)
fprintf_unfiltered (gdb_stdlog, "m32r_insert_watchpoint(%s,%d,%d)\n",
- paddr (addr), len, type);
+ paddress (target_gdbarch, addr), len, type);
for (i = 0; i < MAX_ACCESS_BREAKS; i++)
{
return 1;
}
-int
-m32r_remove_watchpoint (CORE_ADDR addr, int len, int type)
+static int
+m32r_remove_watchpoint (CORE_ADDR addr, int len, int type,
+ struct expression *cond)
{
int i;
if (remote_debug)
fprintf_unfiltered (gdb_stdlog, "m32r_remove_watchpoint(%s,%d,%d)\n",
- paddr (addr), len, type);
+ paddress (target_gdbarch, addr), len, type);
for (i = 0; i < MAX_ACCESS_BREAKS; i++)
{
return 0;
}
-int
+static int
m32r_stopped_data_address (struct target_ops *target, CORE_ADDR *addr_p)
{
int rc = 0;
+
if (hit_watchpoint_addr != 0x00000000)
{
*addr_p = hit_watchpoint_addr;
return rc;
}
-int
+static int
m32r_stopped_by_watchpoint (void)
{
CORE_ADDR addr;
+
return m32r_stopped_data_address (¤t_target, &addr);
}
+/* Check to see if a thread is still alive. */
+
+static int
+m32r_thread_alive (struct target_ops *ops, ptid_t ptid)
+{
+ if (ptid_equal (ptid, remote_m32r_ptid))
+ /* The main task is always alive. */
+ return 1;
+
+ return 0;
+}
+
+/* Convert a thread ID to a string. Returns the string in a static
+ buffer. */
+
+static char *
+m32r_pid_to_str (struct target_ops *ops, ptid_t ptid)
+{
+ static char buf[64];
+
+ if (ptid_equal (remote_m32r_ptid, ptid))
+ {
+ xsnprintf (buf, sizeof buf, "Thread <main>");
+ return buf;
+ }
+
+ return normal_pid_to_str (ptid);
+}
static void
sdireset_command (char *args, int from_tty)
send_cmd (SDI_OPEN);
inferior_ptid = null_ptid;
+ delete_thread_silent (remote_m32r_ptid);
}
use_ib_breakpoints = 0;
}
+static int
+m32r_return_one (struct target_ops *target)
+{
+ return 1;
+}
/* Define the target subroutine names */
m32r_ops.to_mourn_inferior = m32r_mourn_inferior;
m32r_ops.to_stop = m32r_stop;
m32r_ops.to_log_command = serial_log_command;
+ m32r_ops.to_thread_alive = m32r_thread_alive;
+ m32r_ops.to_pid_to_str = m32r_pid_to_str;
m32r_ops.to_stratum = process_stratum;
- m32r_ops.to_has_all_memory = 1;
- m32r_ops.to_has_memory = 1;
- m32r_ops.to_has_stack = 1;
- m32r_ops.to_has_registers = 1;
- m32r_ops.to_has_execution = 1;
+ m32r_ops.to_has_all_memory = m32r_return_one;
+ m32r_ops.to_has_memory = m32r_return_one;
+ m32r_ops.to_has_stack = m32r_return_one;
+ m32r_ops.to_has_registers = m32r_return_one;
+ m32r_ops.to_has_execution = m32r_return_one;
m32r_ops.to_magic = OPS_MAGIC;
};
_("Set breakpoints by IB break."));
add_com ("use_dbt_break", class_obscure, use_dbt_breakpoints_command,
_("Set breakpoints by dbt."));
+
+ /* Yes, 42000 is arbitrary. The only sense out of it, is that it
+ isn't 0. */
+ remote_m32r_ptid = ptid_build (42000, 0, 42000);
}