/* Remote debugging interface for M32R/SDI.
- Copyright 2003, 2004 Free Software Foundation, Inc.
+ Copyright (C) 2003-2015 Free Software Foundation, Inc.
Contributed by Renesas Technology Co.
Written by Kei Sakamoto <sakamoto.kei@renesas.com>.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
+ the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
GNU General Public License for more details.
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., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA. */
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "defs.h"
#include "gdbcmd.h"
#include "gdbcore.h"
#include "inferior.h"
+#include "infrun.h"
#include "target.h"
#include "regcache.h"
-#include "gdb_string.h"
+#include "gdbthread.h"
#include <ctype.h>
#include <signal.h>
+#ifdef __MINGW32__
+#include <winsock2.h>
+#else
#include <netinet/in.h>
+#endif
#include <sys/types.h>
-#include <sys/time.h>
-#include <signal.h>
+#include "gdb_sys_time.h"
#include <time.h>
-
-
+#include "gdb_bfd.h"
+#include "cli/cli-utils.h"
+#include "symfile.h"
#include "serial.h"
/* Descriptor for I/O to remote machine. */
static int max_ib_breakpoints;
static unsigned long bp_address[MAX_BREAKPOINTS];
static unsigned char bp_data[MAX_BREAKPOINTS][4];
-static const unsigned char ib_bp_entry_enable[] = {
- 0x00, 0x00, 0x00, 0x06
-};
-static const unsigned char ib_bp_entry_disable[] = {
- 0x00, 0x00, 0x00, 0x00
-};
/* dbt -> nop */
static const unsigned char dbt_bp_entry[] = {
/* 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
#define SDI_REG_ACC1L 35
-/* Low level communication functions */
+/* Low level communication functions. */
-/* Check an ack packet from the target */
+/* Check an ack packet from the target. */
static int
get_ack (void)
{
return 0;
}
-/* Send data to the target and check an ack packet */
+/* Send data to the target and check an ack packet. */
static int
-send_data (void *buf, int len)
+send_data (const void *buf, int len)
{
- int ret;
-
if (!sdi_desc)
return -1;
return len;
}
-/* Receive data from the target */
+/* Receive data from the target. */
static int
recv_data (void *buf, int len)
{
return len;
}
-/* Store unsigned long parameter on packet */
+/* Store unsigned long parameter on packet. */
static void
store_long_parameter (void *buf, long val)
{
memcpy (buf, &val, 4);
}
-/* Check if MMU is on */
+static int
+send_cmd (unsigned char cmd)
+{
+ unsigned char buf[1];
+
+ buf[0] = cmd;
+ return send_data (buf, 1);
+}
+
+static int
+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);
+}
+
+static int
+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);
+ return send_data (buf, 6);
+}
+
+static int
+send_three_arg_cmd (unsigned char cmd, unsigned long arg1, unsigned long arg2,
+ unsigned long arg3)
+{
+ unsigned char buf[13];
+
+ buf[0] = cmd;
+ store_long_parameter (buf + 1, arg1);
+ store_long_parameter (buf + 5, arg2);
+ store_long_parameter (buf + 9, arg3);
+ return send_data (buf, 13);
+}
+
+static unsigned char
+recv_char_data (void)
+{
+ unsigned char val;
+
+ recv_data (&val, 1);
+ return val;
+}
+
+static unsigned long
+recv_long_data (void)
+{
+ unsigned long val;
+
+ recv_data (&val, 4);
+ return ntohl (val);
+}
+
+
+/* Check if MMU is on. */
static void
check_mmu_status (void)
{
unsigned long val;
- unsigned char buf[2];
- /* Read PC address */
- buf[0] = SDI_READ_CPU_REG;
- buf[1] = SDI_REG_BPC;
- if (send_data (buf, 2) == -1)
+ /* Read PC address. */
+ if (send_one_arg_cmd (SDI_READ_CPU_REG, SDI_REG_BPC) == -1)
return;
- recv_data (&val, 4);
- val = ntohl (val);
+ val = recv_long_data ();
if ((val & 0xc0000000) == 0x80000000)
{
mmu_on = 1;
return;
}
- /* Read EVB address */
- buf[0] = SDI_READ_CPU_REG;
- buf[1] = SDI_REG_EVB;
- if (send_data (buf, 2) == -1)
+ /* Read EVB address. */
+ if (send_one_arg_cmd (SDI_READ_CPU_REG, SDI_REG_EVB) == -1)
return;
- recv_data (&val, 4);
- val = ntohl (val);
+ val = recv_long_data ();
if ((val & 0xc0000000) == 0x80000000)
{
mmu_on = 1;
/* 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;
if (args && *args)
- error ("Cannot pass arguments to remote STDEBUG process");
+ error (_("Cannot pass arguments to remote STDEBUG process"));
if (execfile == 0 || exec_bfd == 0)
- error ("No executable file specified");
+ error (_("No executable file specified"));
if (remote_debug)
fprintf_unfiltered (gdb_stdlog, "m32r_create_inferior(%s,%s)\n", execfile,
/* The "process" (board) is already stopped awaiting our commands, and
the program is already downloaded. We just set its PC and go. */
- clear_proceed_status ();
+ clear_proceed_status (0);
/* Tell wait_for_inferior that we've started a new process. */
init_wait_for_inferior ();
/* Install inferior's terminal modes. */
target_terminal_inferior ();
- proceed (entry_pt, TARGET_SIGNAL_DEFAULT, 0);
+ regcache_write_pc (get_current_regcache (), entry_pt);
}
/* Open a connection to a remote debugger.
NAME is the filename used for communication. */
static void
-m32r_open (char *args, int from_tty)
+m32r_open (const char *args, int from_tty)
{
struct hostent *host_ent;
struct sockaddr_in server_addr;
- char *port_str, hostname[256];
+ char hostname[256];
+ const char *port_str;
int port;
- unsigned char buf[2];
int i, n;
int yes = 1;
push_target (&m32r_ops);
if (args == NULL)
- sprintf (hostname, "localhost:%d", SDIPORT);
+ xsnprintf (hostname, sizeof (hostname), "localhost:%d", SDIPORT);
else
{
port_str = strchr (args, ':');
if (port_str == NULL)
- sprintf (hostname, "%s:%d", args, SDIPORT);
+ xsnprintf (hostname, sizeof (hostname), "%s:%d", args, SDIPORT);
else
- strcpy (hostname, args);
+ xsnprintf (hostname, sizeof (hostname), "%s", args);
}
sdi_desc = serial_open (hostname);
if (!sdi_desc)
- error ("Connection refused\n");
+ error (_("Connection refused."));
if (get_ack () == -1)
- error ("Cannot connect to SDI target\n");
-
- buf[0] = SDI_OPEN;
- if (send_data (buf, 1) == -1)
- error ("Cannot connect to SDI target\n");
-
- /* Get maximum number of ib breakpoints */
- buf[0] = SDI_GET_ATTR;
- buf[1] = SDI_ATTR_BRK;
- send_data (buf, 2);
- recv_data (buf, 1);
- max_ib_breakpoints = buf[0];
+ error (_("Cannot connect to SDI target."));
+
+ if (send_cmd (SDI_OPEN) == -1)
+ error (_("Cannot connect to SDI target."));
+
+ /* Get maximum number of ib breakpoints. */
+ send_one_arg_cmd (SDI_GET_ATTR, SDI_ATTR_BRK);
+ max_ib_breakpoints = recv_char_data ();
if (remote_debug)
printf_filtered ("Max IB Breakpoints = %d\n", max_ib_breakpoints);
- /* Initialize breakpoints. */
+ /* Initialize breakpoints. */
for (i = 0; i < MAX_BREAKPOINTS; i++)
bp_address[i] = 0xffffffff;
- /* Get maximum number of access breaks. */
- buf[0] = SDI_GET_ATTR;
- buf[1] = SDI_ATTR_ABRK;
- send_data (buf, 2);
- recv_data (buf, 1);
- max_access_breaks = buf[0];
+ /* Get maximum number of access breaks. */
+ send_one_arg_cmd (SDI_GET_ATTR, SDI_ATTR_ABRK);
+ max_access_breaks = recv_char_data ();
if (remote_debug)
printf_filtered ("Max Access Breaks = %d\n", max_access_breaks);
- /* Initialize access breask. */
+ /* Initialize access breask. */
for (i = 0; i < MAX_ACCESS_BREAKS; i++)
ab_address[i] = 0x00000000;
check_mmu_status ();
- /* Get the name of chip on target board. */
- buf[0] = SDI_GET_ATTR;
- buf[1] = SDI_ATTR_NAME;
- send_data (buf, 2);
+ /* Get the name of chip on target board. */
+ send_one_arg_cmd (SDI_GET_ATTR, SDI_ATTR_NAME);
recv_data (chip_name, 64);
if (from_tty)
chip_name);
}
-/* Close out all files and local state before this target loses control. */
+/* Close out all files and local state before this target loses control. */
static void
-m32r_close (int quitting)
+m32r_close (struct target_ops *self)
{
- unsigned char buf[1];
-
if (remote_debug)
- fprintf_unfiltered (gdb_stdlog, "m32r_close(%d)\n", quitting);
+ fprintf_unfiltered (gdb_stdlog, "m32r_close()\n");
if (sdi_desc)
{
- buf[0] = SDI_CLOSE;
- send_data (buf, 1);
+ send_cmd (SDI_CLOSE);
serial_close (sdi_desc);
sdi_desc = NULL;
}
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 gdb_signal sig)
{
unsigned long pc_addr, bp_addr, ab_addr;
+ int ib_breakpoints;
unsigned char buf[13];
int i;
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);
/* At pc address there is a parallel instruction with +2 offset,
- so we have to make it a serial instruction or avoid it. */
+ so we have to make it a serial instruction or avoid it. */
if (pc_addr == last_pc_addr)
{
- /* Avoid a parallel nop. */
+ /* Avoid a parallel nop. */
if (last_pc_addr_data[0] == 0xf0 && last_pc_addr_data[1] == 0x00)
{
pc_addr += 2;
- /* Now we can forget this instruction. */
+ /* Now we can forget this instruction. */
last_pc_addr = 0xffffffff;
}
- /* Clear a parallel bit. */
+ /* Clear a parallel bit. */
else
{
buf[0] = SDI_WRITE_MEMORY;
- if (TARGET_BYTE_ORDER == 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);
}
}
- /* Set PC. */
- buf[0] = SDI_WRITE_CPU_REG;
- buf[1] = SDI_REG_BPC;
- store_long_parameter (buf + 2, pc_addr);
- send_data (buf, 6);
+ /* Set PC. */
+ send_two_arg_cmd (SDI_WRITE_CPU_REG, SDI_REG_BPC, pc_addr);
- /* step mode. */
+ /* step mode. */
step_mode = step;
if (step)
{
- /* Set PBP. */
- buf[0] = SDI_WRITE_CPU_REG;
- buf[1] = SDI_REG_PBP;
- store_long_parameter (buf + 2, pc_addr | 1);
- send_data (buf, 6);
+ /* Set PBP. */
+ send_two_arg_cmd (SDI_WRITE_CPU_REG, SDI_REG_PBP, pc_addr | 1);
}
else
{
- int ib_breakpoints;
+ /* Unset PBP. */
+ send_two_arg_cmd (SDI_WRITE_CPU_REG, SDI_REG_PBP, 0x00000000);
+ }
+
+ if (use_ib_breakpoints)
+ ib_breakpoints = max_ib_breakpoints;
+ else
+ ib_breakpoints = 0;
+
+ /* Set ib breakpoints. */
+ for (i = 0; i < ib_breakpoints; i++)
+ {
+ bp_addr = bp_address[i];
- if (use_ib_breakpoints)
- ib_breakpoints = max_ib_breakpoints;
+ if (bp_addr == 0xffffffff)
+ continue;
+
+ /* Set PBP. */
+ if (gdbarch_byte_order (target_gdbarch ()) == BFD_ENDIAN_BIG)
+ send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8000 + 4 * i, 4,
+ 0x00000006);
else
- ib_breakpoints = 0;
+ send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8000 + 4 * i, 4,
+ 0x06000000);
+
+ send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8080 + 4 * i, 4, bp_addr);
+ }
+
+ /* Set dbt breakpoints. */
+ for (i = ib_breakpoints; i < MAX_BREAKPOINTS; i++)
+ {
+ bp_addr = bp_address[i];
+
+ if (bp_addr == 0xffffffff)
+ continue;
- /* Set ib breakpoints. */
- for (i = 0; i < ib_breakpoints; i++)
+ if (!mmu_on)
+ bp_addr &= 0x7fffffff;
+
+ /* Write DBT instruction. */
+ buf[0] = SDI_WRITE_MEMORY;
+ store_long_parameter (buf + 1, (bp_addr & 0xfffffffc));
+ store_long_parameter (buf + 5, 4);
+ if ((bp_addr & 2) == 0 && bp_addr != (pc_addr & 0xfffffffc))
{
- bp_addr = bp_address[i];
- if (bp_addr != 0xffffffff && bp_addr != pc_addr)
+ if (gdbarch_byte_order (target_gdbarch ()) == BFD_ENDIAN_BIG)
{
- /* Set PBP. */
- buf[0] = SDI_WRITE_MEMORY;
- store_long_parameter (buf + 1, 0xffff8000 + 4 * i);
- store_long_parameter (buf + 5, 4);
- if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
- {
- buf[9] = ib_bp_entry_enable[0];
- buf[10] = ib_bp_entry_enable[1];
- buf[11] = ib_bp_entry_enable[2];
- buf[12] = ib_bp_entry_enable[3];
- }
- else
- {
- buf[9] = ib_bp_entry_enable[3];
- buf[10] = ib_bp_entry_enable[2];
- buf[11] = ib_bp_entry_enable[1];
- buf[12] = ib_bp_entry_enable[0];
- }
- send_data (buf, 13);
-
- buf[0] = SDI_WRITE_MEMORY;
- store_long_parameter (buf + 1, 0xffff8080 + 4 * i);
- store_long_parameter (buf + 5, 4);
- store_unsigned_integer (buf + 9, 4, bp_addr);
- send_data (buf, 13);
+ buf[9] = dbt_bp_entry[0];
+ buf[10] = dbt_bp_entry[1];
+ buf[11] = dbt_bp_entry[2];
+ buf[12] = dbt_bp_entry[3];
+ }
+ else
+ {
+ buf[9] = dbt_bp_entry[3];
+ buf[10] = dbt_bp_entry[2];
+ buf[11] = dbt_bp_entry[1];
+ buf[12] = dbt_bp_entry[0];
}
}
-
- /* Set dbt breakpoints. */
- for (i = ib_breakpoints; i < MAX_BREAKPOINTS; i++)
+ else
{
- bp_addr = bp_address[i];
- if (bp_addr != 0xffffffff && bp_addr != pc_addr)
+ if (gdbarch_byte_order (target_gdbarch ()) == BFD_ENDIAN_BIG)
{
- if (!mmu_on)
- bp_addr &= 0x7fffffff;
-
- /* Write DBT instruction. */
- buf[0] = SDI_WRITE_MEMORY;
- if ((bp_addr & 2) == 0 && bp_addr != (pc_addr & 0xfffffffc))
+ if ((bp_addr & 2) == 0)
{
- store_long_parameter (buf + 1, bp_addr);
- store_long_parameter (buf + 5, 4);
- if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
- {
- buf[9] = dbt_bp_entry[0];
- buf[10] = dbt_bp_entry[1];
- buf[11] = dbt_bp_entry[2];
- buf[12] = dbt_bp_entry[3];
- }
- else
- {
- buf[9] = dbt_bp_entry[3];
- buf[10] = dbt_bp_entry[2];
- buf[11] = dbt_bp_entry[1];
- buf[12] = dbt_bp_entry[0];
- }
- send_data (buf, 13);
+ buf[9] = dbt_bp_entry[0];
+ buf[10] = dbt_bp_entry[1];
+ buf[11] = bp_data[i][2] & 0x7f;
+ buf[12] = bp_data[i][3];
}
else
{
- if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
- store_long_parameter (buf + 1, bp_addr);
- else if ((bp_addr & 2) == 0)
- store_long_parameter (buf + 1, bp_addr + 2);
- else
- store_long_parameter (buf + 1, bp_addr - 2);
- store_long_parameter (buf + 5, 2);
- if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
- {
- buf[9] = dbt_bp_entry[0];
- buf[10] = dbt_bp_entry[1];
- }
- else
- {
- buf[9] = dbt_bp_entry[1];
- buf[10] = dbt_bp_entry[0];
- }
- send_data (buf, 11);
+ buf[9] = bp_data[i][0];
+ buf[10] = bp_data[i][1];
+ buf[11] = dbt_bp_entry[0];
+ buf[12] = dbt_bp_entry[1];
}
}
- }
-
- /* Set access breaks. */
- for (i = 0; i < max_access_breaks; i++)
- {
- ab_addr = ab_address[i];
- if (ab_addr != 0x00000000)
+ else
{
- /* DBC register */
- buf[0] = SDI_WRITE_MEMORY;
- store_long_parameter (buf + 1, 0xffff8100 + 4 * i);
- store_long_parameter (buf + 5, 4);
- if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
+ if ((bp_addr & 2) == 0)
{
- buf[9] = 0x00;
- buf[10] = 0x00;
- buf[11] = 0x00;
- switch (ab_type[i])
- {
- case 0: /* write watch */
- buf[12] = 0x86;
- break;
- case 1: /* read watch */
- buf[12] = 0x46;
- break;
- case 2: /* access watch */
- buf[12] = 0x06;
- break;
- }
+ buf[9] = bp_data[i][0];
+ buf[10] = bp_data[i][1] & 0x7f;
+ buf[11] = dbt_bp_entry[1];
+ buf[12] = dbt_bp_entry[0];
}
else
{
- switch (ab_type[i])
- {
- case 0: /* write watch */
- buf[9] = 0x86;
- break;
- case 1: /* read watch */
- buf[9] = 0x46;
- break;
- case 2: /* access watch */
- buf[9] = 0x06;
- break;
- }
- buf[10] = 0x00;
- buf[11] = 0x00;
- buf[12] = 0x00;
+ buf[9] = dbt_bp_entry[1];
+ buf[10] = dbt_bp_entry[0];
+ buf[11] = bp_data[i][2];
+ buf[12] = bp_data[i][3];
}
- send_data (buf, 13);
-
- /* DBAH register */
- buf[0] = SDI_WRITE_MEMORY;
- store_long_parameter (buf + 1, 0xffff8180 + 4 * i);
- store_long_parameter (buf + 5, 4);
- store_unsigned_integer (buf + 9, 4, ab_addr);
- send_data (buf, 13);
+ }
+ }
+ send_data (buf, 13);
+ }
- /* DBAL register */
- buf[0] = SDI_WRITE_MEMORY;
- store_long_parameter (buf + 1, 0xffff8200 + 4 * i);
- store_long_parameter (buf + 5, 4);
- store_long_parameter (buf + 9, 0xffffffff);
- send_data (buf, 13);
+ /* Set access breaks. */
+ for (i = 0; i < max_access_breaks; i++)
+ {
+ ab_addr = ab_address[i];
- /* DBD register */
- buf[0] = SDI_WRITE_MEMORY;
- store_long_parameter (buf + 1, 0xffff8280 + 4 * i);
- store_long_parameter (buf + 5, 4);
- store_long_parameter (buf + 9, 0x00000000);
- send_data (buf, 13);
+ if (ab_addr == 0x00000000)
+ continue;
- /* DBDM register */
- buf[0] = SDI_WRITE_MEMORY;
- store_long_parameter (buf + 1, 0xffff8300 + 4 * i);
- store_long_parameter (buf + 5, 4);
- store_long_parameter (buf + 9, 0x00000000);
- send_data (buf, 13);
+ /* DBC register. */
+ if (gdbarch_byte_order (target_gdbarch ()) == BFD_ENDIAN_BIG)
+ {
+ switch (ab_type[i])
+ {
+ case 0: /* write watch */
+ send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8100 + 4 * i, 4,
+ 0x00000086);
+ break;
+ case 1: /* read watch */
+ send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8100 + 4 * i, 4,
+ 0x00000046);
+ break;
+ case 2: /* access watch */
+ send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8100 + 4 * i, 4,
+ 0x00000006);
+ break;
+ }
+ }
+ else
+ {
+ switch (ab_type[i])
+ {
+ case 0: /* write watch */
+ send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8100 + 4 * i, 4,
+ 0x86000000);
+ break;
+ case 1: /* read watch */
+ send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8100 + 4 * i, 4,
+ 0x46000000);
+ break;
+ case 2: /* access watch */
+ send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8100 + 4 * i, 4,
+ 0x06000000);
+ break;
}
}
- /* Unset PBP. */
- buf[0] = SDI_WRITE_CPU_REG;
- buf[1] = SDI_REG_PBP;
- store_long_parameter (buf + 2, 0x00000000);
- send_data (buf, 6);
+ /* DBAH register. */
+ send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8180 + 4 * i, 4, ab_addr);
+
+ /* DBAL register. */
+ send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8200 + 4 * i, 4,
+ 0xffffffff);
+
+ /* DBD register. */
+ send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8280 + 4 * i, 4,
+ 0x00000000);
+
+ /* DBDM register. */
+ send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8300 + 4 * i, 4,
+ 0x00000000);
}
- buf[0] = SDI_EXEC_CPU;
- send_data (buf, 1);
+ /* Resume program. */
+ send_cmd (SDI_EXEC_CPU);
/* Without this, some commands which require an active target (such as kill)
won't work. This variable serves (at least) double duty as both the pid
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) ();
+ static sighandler_t prev_sigint;
unsigned long bp_addr, pc_addr;
+ int ib_breakpoints;
long i;
unsigned char buf[13];
- unsigned long val;
int ret, c;
if (remote_debug)
fprintf_unfiltered (gdb_stdlog, "m32r_wait()\n");
status->kind = TARGET_WAITKIND_EXITED;
- status->value.sig = 0;
+ status->value.sig = GDB_SIGNAL_0;
interrupted = 0;
prev_sigint = signal (SIGINT, gdb_cntrl_c);
- /* Wait for ready */
+ /* Wait for ready. */
buf[0] = SDI_WAIT_FOR_READY;
if (serial_write (sdi_desc, buf, 1) != 0)
- error ("Remote connection closed");
+ error (_("Remote connection closed"));
while (1)
{
c = serial_readchar (sdi_desc, SDI_TIMEOUT);
if (c < 0)
- error ("Remote connection closed");
+ error (_("Remote connection closed"));
if (c == '-') /* error */
{
status->kind = TARGET_WAITKIND_STOPPED;
- status->value.sig = TARGET_SIGNAL_HUP;
+ status->value.sig = GDB_SIGNAL_HUP;
return inferior_ptid;
}
else if (c == '+') /* stopped */
else
ret = serial_write (sdi_desc, ".", 1); /* packet to wait */
if (ret != 0)
- error ("Remote connection closed");
+ error (_("Remote connection closed"));
}
status->kind = TARGET_WAITKIND_STOPPED;
if (interrupted)
- status->value.sig = TARGET_SIGNAL_INT;
+ status->value.sig = GDB_SIGNAL_INT;
else
- status->value.sig = TARGET_SIGNAL_TRAP;
+ status->value.sig = GDB_SIGNAL_TRAP;
interrupted = 0;
signal (SIGINT, prev_sigint);
check_mmu_status ();
- /* Recover parallel bit. */
+ /* Recover parallel bit. */
if (last_pc_addr != 0xffffffff)
{
buf[0] = SDI_WRITE_MEMORY;
- if (TARGET_BYTE_ORDER == 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);
last_pc_addr = 0xffffffff;
}
- /* Breakpoints are inserted only for "next" command */
- if (!step_mode)
- {
- int ib_breakpoints;
+ if (use_ib_breakpoints)
+ ib_breakpoints = max_ib_breakpoints;
+ else
+ ib_breakpoints = 0;
- if (use_ib_breakpoints)
- ib_breakpoints = max_ib_breakpoints;
- else
- ib_breakpoints = 0;
-
- /* Set back pc by 2 if m32r is stopped with dbt. */
- buf[0] = SDI_READ_CPU_REG;
- buf[1] = SDI_REG_BPC;
- send_data (buf, 2);
- recv_data (&val, 4);
- pc_addr = ntohl (val) - 2;
- for (i = ib_breakpoints; i < MAX_BREAKPOINTS; i++)
+ /* Set back pc by 2 if m32r is stopped with dbt. */
+ last_pc_addr = 0xffffffff;
+ send_one_arg_cmd (SDI_READ_CPU_REG, SDI_REG_BPC);
+ pc_addr = recv_long_data () - 2;
+ for (i = ib_breakpoints; i < MAX_BREAKPOINTS; i++)
+ {
+ if (pc_addr == bp_address[i])
{
- if (pc_addr == bp_address[i])
+ send_two_arg_cmd (SDI_WRITE_CPU_REG, SDI_REG_BPC, pc_addr);
+
+ /* If there is a parallel instruction with +2 offset at pc
+ address, we have to take care of it later. */
+ if ((pc_addr & 0x2) != 0)
{
- buf[0] = SDI_WRITE_CPU_REG;
- buf[1] = SDI_REG_BPC;
- store_long_parameter (buf + 2, pc_addr);
- send_data (buf, 6);
-
- /* If there is a parallel instruction with +2 offset at pc
- address, we have to take care of it later. */
- if ((pc_addr & 0x2) != 0)
+ if (gdbarch_byte_order (target_gdbarch ()) == BFD_ENDIAN_BIG)
{
- if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
+ if ((bp_data[i][2] & 0x80) != 0)
{
- if ((bp_data[i][2] & 0x80) != 0)
- {
- last_pc_addr = pc_addr;
- last_pc_addr_data[0] = bp_data[i][2];
- last_pc_addr_data[1] = bp_data[i][3];
- }
+ last_pc_addr = pc_addr;
+ last_pc_addr_data[0] = bp_data[i][2];
+ last_pc_addr_data[1] = bp_data[i][3];
}
- else
+ }
+ else
+ {
+ if ((bp_data[i][1] & 0x80) != 0)
{
- if ((bp_data[i][1] & 0x80) != 0)
- {
- last_pc_addr = pc_addr;
- last_pc_addr_data[0] = bp_data[i][1];
- last_pc_addr_data[1] = bp_data[i][0];
- }
+ last_pc_addr = pc_addr;
+ last_pc_addr_data[0] = bp_data[i][1];
+ last_pc_addr_data[1] = bp_data[i][0];
}
}
- break;
}
+ break;
}
+ }
- /* Remove ib breakpoints. */
- for (i = 0; i < ib_breakpoints; i++)
- {
- if (bp_address[i] != 0xffffffff)
- {
- buf[0] = SDI_WRITE_MEMORY;
- store_long_parameter (buf + 1, 0xffff8000 + 4 * i);
- store_long_parameter (buf + 5, 4);
- buf[9] = ib_bp_entry_disable[0];
- buf[10] = ib_bp_entry_disable[1];
- buf[11] = ib_bp_entry_disable[2];
- buf[12] = ib_bp_entry_disable[3];
- send_data (buf, 13);
- }
- }
- /* Remove dbt breakpoints. */
- for (i = ib_breakpoints; i < MAX_BREAKPOINTS; i++)
+ /* Remove ib breakpoints. */
+ for (i = 0; i < ib_breakpoints; i++)
+ {
+ if (bp_address[i] != 0xffffffff)
+ send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8000 + 4 * i, 4,
+ 0x00000000);
+ }
+ /* Remove dbt breakpoints. */
+ for (i = ib_breakpoints; i < MAX_BREAKPOINTS; i++)
+ {
+ bp_addr = bp_address[i];
+ if (bp_addr != 0xffffffff)
{
- bp_addr = bp_address[i];
- if (bp_addr != 0xffffffff)
- {
- if (!mmu_on)
- bp_addr &= 0x7fffffff;
- buf[0] = SDI_WRITE_MEMORY;
- store_long_parameter (buf + 1, bp_addr & 0xfffffffc);
- store_long_parameter (buf + 5, 4);
- buf[9] = bp_data[i][0];
- buf[10] = bp_data[i][1];
- buf[11] = bp_data[i][2];
- buf[12] = bp_data[i][3];
- send_data (buf, 13);
- }
+ if (!mmu_on)
+ bp_addr &= 0x7fffffff;
+ buf[0] = SDI_WRITE_MEMORY;
+ store_long_parameter (buf + 1, bp_addr & 0xfffffffc);
+ store_long_parameter (buf + 5, 4);
+ buf[9] = bp_data[i][0];
+ buf[10] = bp_data[i][1];
+ buf[11] = bp_data[i][2];
+ buf[12] = bp_data[i][3];
+ send_data (buf, 13);
}
+ }
- /* Remove access breaks. */
- hit_watchpoint_addr = 0;
- for (i = 0; i < max_access_breaks; i++)
+ /* Remove access breaks. */
+ hit_watchpoint_addr = 0;
+ for (i = 0; i < max_access_breaks; i++)
+ {
+ if (ab_address[i] != 0x00000000)
{
- if (ab_address[i] != 0x00000000)
+ buf[0] = SDI_READ_MEMORY;
+ store_long_parameter (buf + 1, 0xffff8100 + 4 * i);
+ store_long_parameter (buf + 5, 4);
+ serial_write (sdi_desc, buf, 9);
+ c = serial_readchar (sdi_desc, SDI_TIMEOUT);
+ if (c != '-' && recv_data (buf, 4) != -1)
{
- buf[0] = SDI_READ_MEMORY;
- store_long_parameter (buf + 1, 0xffff8100 + 4 * i);
- store_long_parameter (buf + 5, 4);
- serial_write (sdi_desc, buf, 9);
- c = serial_readchar (sdi_desc, SDI_TIMEOUT);
- if (c != '-' && recv_data (buf, 4) != -1)
+ if (gdbarch_byte_order (target_gdbarch ()) == BFD_ENDIAN_BIG)
{
- if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
- {
- if ((buf[3] & 0x1) == 0x1)
- hit_watchpoint_addr = ab_address[i];
- }
- else
- {
- if ((buf[0] & 0x1) == 0x1)
- hit_watchpoint_addr = ab_address[i];
- }
+ if ((buf[3] & 0x1) == 0x1)
+ hit_watchpoint_addr = ab_address[i];
+ }
+ else
+ {
+ if ((buf[0] & 0x1) == 0x1)
+ hit_watchpoint_addr = ab_address[i];
}
-
- buf[0] = SDI_WRITE_MEMORY;
- store_long_parameter (buf + 1, 0xffff8100 + 4 * i);
- store_long_parameter (buf + 5, 4);
- store_long_parameter (buf + 9, 0x00000000);
- send_data (buf, 13);
}
- }
- if (remote_debug)
- fprintf_unfiltered (gdb_stdlog, "pc => 0x%lx\n", pc_addr);
+ send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8100 + 4 * i, 4,
+ 0x00000000);
+ }
}
- else
- last_pc_addr = 0xffffffff;
+
+ if (remote_debug)
+ fprintf_unfiltered (gdb_stdlog, "pc => 0x%lx\n", pc_addr);
return inferior_ptid;
}
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, const 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, GDB_SIGNAL_0);
- /* calls m32r_close to do the real work */
- pop_target ();
+ /* Calls m32r_close to do the real work. */
+ unpush_target (ops);
if (from_tty)
fprintf_unfiltered (gdb_stdlog, "Ending remote %s debugging\n",
target_shortname);
}
-/* Return the id of register number REGNO. */
+/* Return the id of register number REGNO. */
static int
get_reg_id (int regno)
return regno;
}
-/* Read the remote registers into the block REGS. */
-
-static void m32r_fetch_register (int);
-
-static void
-m32r_fetch_registers (void)
-{
- int regno;
-
- for (regno = 0; regno < NUM_REGS; regno++)
- m32r_fetch_register (regno);
-}
-
/* Fetch register REGNO, or all registers if REGNO is -1.
Returns errno value. */
static void
-m32r_fetch_register (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;
- unsigned char buf[2];
if (regno == -1)
- m32r_fetch_registers ();
+ {
+ for (regno = 0;
+ regno < gdbarch_num_regs (get_regcache_arch (regcache));
+ regno++)
+ m32r_fetch_register (ops, regcache, regno);
+ }
else
{
- char buffer[MAX_REGISTER_SIZE];
+ gdb_byte buffer[MAX_REGISTER_SIZE];
regid = get_reg_id (regno);
- buf[0] = SDI_READ_CPU_REG;
- buf[1] = regid;
- send_data (buf, 2);
- recv_data (&val, 4);
- val = ntohl (val);
+ send_one_arg_cmd (SDI_READ_CPU_REG, regid);
+ val = recv_long_data ();
if (regid == SDI_REG_PSW)
{
- buf[0] = SDI_READ_CPU_REG;
- buf[1] = SDI_REG_BBPSW;
- send_data (buf, 2);
- recv_data (&val2, 4);
- val2 = ntohl (val2);
- val = ((0x00c1 & val2) << 8) | ((0xc100 & val) >> 8);
+ send_one_arg_cmd (SDI_READ_CPU_REG, SDI_REG_BBPSW);
+ val2 = recv_long_data ();
+ val = ((0x00cf & val2) << 8) | ((0xcf00 & val) >> 8);
}
if (remote_debug)
/* 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);
- regcache_raw_supply (current_regcache, regno, buffer);
+ 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 (int);
-
-static void
-m32r_store_registers (void)
-{
- int regno;
-
- for (regno = 0; regno < NUM_REGS; regno++)
- m32r_store_register (regno);
-
- registers_changed ();
-}
-
/* Store register REGNO, or all if REGNO == 0.
Return errno value. */
static void
-m32r_store_register (int regno)
+m32r_store_register (struct target_ops *ops,
+ struct regcache *regcache, int regno)
{
int regid;
ULONGEST regval, tmp;
- unsigned char buf[6];
if (regno == -1)
- m32r_store_registers ();
+ {
+ for (regno = 0;
+ regno < gdbarch_num_regs (get_regcache_arch (regcache));
+ regno++)
+ m32r_store_register (ops, regcache, regno);
+ }
else
{
- regcache_cooked_read_unsigned (current_regcache, regno, ®val);
+ regcache_cooked_read_unsigned (regcache, regno, ®val);
regid = get_reg_id (regno);
if (regid == SDI_REG_PSW)
{
unsigned long psw, bbpsw;
- buf[0] = SDI_READ_CPU_REG;
- buf[1] = SDI_REG_PSW;
- send_data (buf, 2);
- recv_data (&psw, 4);
- psw = ntohl (psw);
-
- buf[0] = SDI_READ_CPU_REG;
- buf[1] = SDI_REG_BBPSW;
- send_data (buf, 2);
- recv_data (&bbpsw, 4);
- bbpsw = ntohl (bbpsw);
-
- tmp = (0x00c1 & psw) | ((0x00c1 & regval) << 8);
- buf[0] = SDI_WRITE_CPU_REG;
- buf[1] = SDI_REG_PSW;
- store_long_parameter (buf + 2, tmp);
- send_data (buf, 6);
-
- tmp = (0x0030 & bbpsw) | ((0xc100 & regval) >> 8);
- buf[0] = SDI_WRITE_CPU_REG;
- buf[1] = SDI_REG_BBPSW;
- store_long_parameter (buf + 2, tmp);
- send_data (buf, 6);
+ send_one_arg_cmd (SDI_READ_CPU_REG, SDI_REG_PSW);
+ psw = recv_long_data ();
+
+ send_one_arg_cmd (SDI_READ_CPU_REG, SDI_REG_BBPSW);
+ bbpsw = recv_long_data ();
+
+ tmp = (0x00cf & psw) | ((0x00cf & regval) << 8);
+ send_two_arg_cmd (SDI_WRITE_CPU_REG, SDI_REG_PSW, tmp);
+
+ tmp = (0x0030 & bbpsw) | ((0xcf00 & regval) >> 8);
+ send_two_arg_cmd (SDI_WRITE_CPU_REG, SDI_REG_BBPSW, tmp);
}
else
{
- buf[0] = SDI_WRITE_CPU_REG;
- buf[1] = regid;
- store_long_parameter (buf + 2, regval);
- send_data (buf, 6);
+ send_two_arg_cmd (SDI_WRITE_CPU_REG, regid, regval);
}
if (remote_debug)
debugged. */
static void
-m32r_prepare_to_store (void)
+m32r_prepare_to_store (struct target_ops *self, struct regcache *regcache)
{
- /* Do nothing, since we can store individual regs */
+ /* Do nothing, since we can store individual regs. */
if (remote_debug)
fprintf_unfiltered (gdb_stdlog, "m32r_prepare_to_store()\n");
}
static void
m32r_files_info (struct target_ops *target)
{
- char *file = "nothing";
+ const char *file = "nothing";
if (exec_bfd)
{
}
}
-/* Read/Write memory. */
-static int
-m32r_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len,
- int write,
- struct mem_attrib *attrib, struct target_ops *target)
+/* Helper for m32r_xfer_partial that handles memory transfers.
+ Arguments are like target_xfer_partial. */
+
+static enum target_xfer_status
+m32r_xfer_memory (gdb_byte *readbuf, const gdb_byte *writebuf,
+ ULONGEST memaddr, ULONGEST len, ULONGEST *xfered_len)
{
unsigned long taddr;
unsigned char buf[0x2000];
if (remote_debug)
{
- if (write)
- fprintf_unfiltered (gdb_stdlog, "m32r_xfer_memory(%08lx,%d,write)\n",
- memaddr, len);
+ if (writebuf != NULL)
+ fprintf_unfiltered (gdb_stdlog, "m32r_xfer_memory(%s,%s,write)\n",
+ paddress (target_gdbarch (), memaddr),
+ plongest (len));
else
- fprintf_unfiltered (gdb_stdlog, "m32r_xfer_memory(%08lx,%d,read)\n",
- memaddr, len);
+ fprintf_unfiltered (gdb_stdlog, "m32r_xfer_memory(%s,%s,read)\n",
+ paddress (target_gdbarch (), memaddr),
+ plongest (len));
}
- if (write)
+ if (writebuf != NULL)
{
buf[0] = SDI_WRITE_MEMORY;
store_long_parameter (buf + 1, taddr);
store_long_parameter (buf + 5, len);
if (len < 0x1000)
{
- memcpy (buf + 9, myaddr, len);
+ memcpy (buf + 9, writebuf, len);
ret = send_data (buf, len + 9) - 9;
}
else
if (remote_debug)
fprintf_unfiltered (gdb_stdlog,
"m32r_xfer_memory() failed\n");
- return 0;
+ return TARGET_XFER_EOF;
}
- ret = send_data (myaddr, len);
+ ret = send_data (writebuf, len);
}
}
else
{
if (remote_debug)
fprintf_unfiltered (gdb_stdlog, "m32r_xfer_memory() failed\n");
- return 0;
+ return TARGET_XFER_EOF;
}
c = serial_readchar (sdi_desc, SDI_TIMEOUT);
{
if (remote_debug)
fprintf_unfiltered (gdb_stdlog, "m32r_xfer_memory() failed\n");
- return 0;
+ return TARGET_XFER_EOF;
}
- ret = recv_data (myaddr, len);
+ ret = recv_data (readbuf, len);
}
if (ret <= 0)
{
if (remote_debug)
fprintf_unfiltered (gdb_stdlog, "m32r_xfer_memory() fails\n");
- return 0;
+ return TARGET_XFER_E_IO;
}
- return ret;
+ *xfered_len = ret;
+ return TARGET_XFER_OK;
+}
+
+/* Target to_xfer_partial implementation. */
+
+static enum target_xfer_status
+m32r_xfer_partial (struct target_ops *ops, enum target_object object,
+ const char *annex, gdb_byte *readbuf,
+ const gdb_byte *writebuf, ULONGEST offset, ULONGEST len,
+ ULONGEST *xfered_len)
+{
+ switch (object)
+ {
+ case TARGET_OBJECT_MEMORY:
+ return m32r_xfer_memory (readbuf, writebuf, offset, len, xfered_len);
+
+ default:
+ return ops->beneath->to_xfer_partial (ops->beneath, object, annex,
+ readbuf, writebuf, offset, len,
+ xfered_len);
+ }
}
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 (CORE_ADDR addr, char *shadow)
+m32r_insert_breakpoint (struct target_ops *ops,
+ struct gdbarch *gdbarch,
+ struct bp_target_info *bp_tgt)
{
+ CORE_ADDR addr = bp_tgt->placed_address = bp_tgt->reqstd_address;
int ib_breakpoints;
unsigned char buf[13];
int i, c;
if (remote_debug)
- fprintf_unfiltered (gdb_stdlog, "m32r_insert_breakpoint(%08lx,\"%s\")\n",
- addr, shadow);
+ fprintf_unfiltered (gdb_stdlog, "m32r_insert_breakpoint(%s,...)\n",
+ paddress (gdbarch, addr));
if (use_ib_breakpoints)
ib_breakpoints = max_ib_breakpoints;
}
}
- error ("Too many breakpoints");
+ error (_("Too many breakpoints"));
return 1;
}
static int
-m32r_remove_breakpoint (CORE_ADDR addr, char *shadow)
+m32r_remove_breakpoint (struct target_ops *ops,
+ 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(%08lx,\"%s\")\n",
- addr, shadow);
+ fprintf_unfiltered (gdb_stdlog, "m32r_remove_breakpoint(%s)\n",
+ paddress (gdbarch, addr));
for (i = 0; i < MAX_BREAKPOINTS; i++)
{
}
static void
-m32r_load (char *args, int from_tty)
+m32r_load (struct target_ops *self, const char *args, int from_tty)
{
- struct cleanup *old_chain;
+ struct cleanup *old_chain = make_cleanup (null_cleanup, NULL);
asection *section;
bfd *pbfd;
bfd_vma entry;
char *filename;
int quiet;
int nostart;
- time_t start_time, end_time; /* Start and end times of download */
- unsigned long data_count; /* Number of bytes transferred to memory */
- int ret;
- static RETSIGTYPE (*prev_sigint) ();
+ struct timeval start_time, end_time;
+ unsigned long data_count; /* Number of bytes transferred to memory. */
+ static sighandler_t prev_sigint;
- /* for direct tcp connections, we can do a fast binary download */
+ /* for direct tcp connections, we can do a fast binary download. */
quiet = 0;
nostart = 0;
filename = NULL;
while (*args != '\000')
{
- char *arg;
-
- while (isspace (*args))
- args++;
+ char *arg = extract_arg_const (&args);
- arg = args;
-
- while ((*args != '\000') && !isspace (*args))
- args++;
-
- if (*args != '\000')
- *args++ = '\000';
+ if (arg == NULL)
+ break;
+ make_cleanup (xfree, arg);
if (*arg != '-')
filename = arg;
- else if (strncmp (arg, "-quiet", strlen (arg)) == 0)
+ else if (startswith ("-quiet", arg))
quiet = 1;
- else if (strncmp (arg, "-nostart", strlen (arg)) == 0)
+ else if (startswith ("-nostart", arg))
nostart = 1;
else
- error ("Unknown option `%s'", arg);
+ error (_("Unknown option `%s'"), arg);
}
if (!filename)
filename = get_exec_file (1);
- pbfd = bfd_openr (filename, gnutarget);
+ pbfd = gdb_bfd_open (filename, gnutarget, -1);
if (pbfd == NULL)
- {
- perror_with_name (filename);
- return;
- }
- old_chain = make_cleanup_bfd_close (pbfd);
+ perror_with_name (filename);
+ make_cleanup_bfd_unref (pbfd);
if (!bfd_check_format (pbfd, bfd_object))
- error ("\"%s\" is not an object file: %s", filename,
+ error (_("\"%s\" is not an object file: %s"), filename,
bfd_errmsg (bfd_get_error ()));
- start_time = time (NULL);
+ gettimeofday (&start_time, NULL);
data_count = 0;
interrupted = 0;
if (!quiet)
printf_filtered ("[Loading section %s at 0x%lx (%d bytes)]\n",
bfd_get_section_name (pbfd, section),
- section_address, (int) section_size);
+ (unsigned long) section_address,
+ (int) section_size);
fptr = 0;
bfd_get_section_contents (pbfd, section, buf + 9, fptr, count);
if (send_data (buf, count + 9) <= 0)
- error ("Error while downloading %s section.",
+ error (_("Error while downloading %s section."),
bfd_get_section_name (pbfd, section));
if (!quiet)
interrupted = 0;
signal (SIGINT, prev_sigint);
- end_time = time (NULL);
+ gettimeofday (&end_time, NULL);
- /* Make the PC point at the start address */
+ /* 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 */
+ 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
have loaded new code (and just changed the PC). Another way to do this
might be to call normal_stop, except that the stack may not be valid,
- and things would get horribly confused... */
+ and things would get horribly confused... */
- clear_symtab_users ();
+ clear_symtab_users (0);
if (!nostart)
{
entry = bfd_get_start_address (pbfd);
if (!quiet)
- printf_unfiltered ("[Starting %s at 0x%lx]\n", filename, entry);
+ printf_unfiltered ("[Starting %s at 0x%lx]\n", filename,
+ (unsigned long) entry);
}
- print_transfer_performance (gdb_stdout, data_count, 0,
- end_time - start_time);
+ print_transfer_performance (gdb_stdout, data_count, 0, &start_time,
+ &end_time);
do_cleanups (old_chain);
}
static void
-m32r_stop (void)
+m32r_interrupt (struct target_ops *self, ptid_t ptid)
{
- unsigned char buf[1];
-
if (remote_debug)
- fprintf_unfiltered (gdb_stdlog, "m32r_stop()\n");
+ fprintf_unfiltered (gdb_stdlog, "m32r_interrupt()\n");
- buf[0] = SDI_STOP_CPU;
- send_data (buf, 1);
+ send_cmd (SDI_STOP_CPU);
return;
}
/* 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
-m32r_can_use_hw_watchpoint (int type, int cnt, int othertype)
+static int
+m32r_can_use_hw_watchpoint (struct target_ops *self,
+ enum bptype type,
+ int cnt, int othertype)
{
return sdi_desc != NULL && cnt < max_access_breaks;
}
/* Set a data watchpoint. ADDR and LEN should be obvious. TYPE is 0
for a write watchpoint, 1 for a read watchpoint, or 2 for a read/write
- watchpoint. */
+ watchpoint. */
-int
-m32r_insert_watchpoint (CORE_ADDR addr, int len, int type)
+static int
+m32r_insert_watchpoint (struct target_ops *self,
+ CORE_ADDR addr, int len, enum target_hw_bp_type type,
+ struct expression *cond)
{
int i;
if (remote_debug)
- fprintf_unfiltered (gdb_stdlog, "m32r_insert_watchpoint(%08lx,%d,%d)\n",
- addr, len, type);
+ fprintf_unfiltered (gdb_stdlog, "m32r_insert_watchpoint(%s,%d,%d)\n",
+ paddress (target_gdbarch (), addr), len, type);
for (i = 0; i < MAX_ACCESS_BREAKS; i++)
{
}
}
- error ("Too many watchpoints");
+ error (_("Too many watchpoints"));
return 1;
}
-int
-m32r_remove_watchpoint (CORE_ADDR addr, int len, int type)
+static int
+m32r_remove_watchpoint (struct target_ops *self, CORE_ADDR addr, int len,
+ enum target_hw_bp_type type, struct expression *cond)
{
int i;
if (remote_debug)
- fprintf_unfiltered (gdb_stdlog, "m32r_remove_watchpoint(%08lx,%d,%d)\n",
- addr, len, type);
+ fprintf_unfiltered (gdb_stdlog, "m32r_remove_watchpoint(%s,%d,%d)\n",
+ paddress (target_gdbarch (), addr), len, type);
for (i = 0; i < MAX_ACCESS_BREAKS; i++)
{
return 0;
}
-CORE_ADDR
-m32r_stopped_data_address (void)
+static int
+m32r_stopped_data_address (struct target_ops *target, CORE_ADDR *addr_p)
{
- return hit_watchpoint_addr;
+ int rc = 0;
+
+ if (hit_watchpoint_addr != 0x00000000)
+ {
+ *addr_p = hit_watchpoint_addr;
+ rc = 1;
+ }
+ return rc;
+}
+
+static int
+m32r_stopped_by_watchpoint (struct target_ops *ops)
+{
+ CORE_ADDR addr;
+
+ return m32r_stopped_data_address (¤t_target, &addr);
}
-int
-m32r_stopped_by_watchpoint (void)
+/* Check to see if a thread is still alive. */
+
+static int
+m32r_thread_alive (struct target_ops *ops, ptid_t ptid)
{
- return (hit_watchpoint_addr != 0x00000000);
+ 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)
{
- unsigned char buf[1];
-
if (remote_debug)
fprintf_unfiltered (gdb_stdlog, "m32r_sdireset()\n");
- buf[0] = SDI_OPEN;
- send_data (buf, 1);
+ send_cmd (SDI_OPEN);
inferior_ptid = null_ptid;
+ delete_thread_silent (remote_m32r_ptid);
}
if (!sdi_desc)
return;
- buf[0] = SDI_STATUS;
- send_data (buf, 1);
+ send_cmd (SDI_STATUS);
for (i = 0; i < 4096; i++)
{
c = serial_readchar (sdi_desc, SDI_TIMEOUT);
use_ib_breakpoints = 0;
}
+static int
+m32r_return_one (struct target_ops *target)
+{
+ return 1;
+}
+
+/* Implementation of the to_has_execution method. */
+
+static int
+m32r_has_execution (struct target_ops *target, ptid_t the_ptid)
+{
+ return 1;
+}
-/* Define the target subroutine names */
+/* Define the target subroutine names. */
struct target_ops m32r_ops;
m32r_ops.to_fetch_registers = m32r_fetch_register;
m32r_ops.to_store_registers = m32r_store_register;
m32r_ops.to_prepare_to_store = m32r_prepare_to_store;
- m32r_ops.to_xfer_memory = m32r_xfer_memory;
+ m32r_ops.to_xfer_partial = m32r_xfer_partial;
m32r_ops.to_files_info = m32r_files_info;
m32r_ops.to_insert_breakpoint = m32r_insert_breakpoint;
m32r_ops.to_remove_breakpoint = m32r_remove_breakpoint;
m32r_ops.to_load = m32r_load;
m32r_ops.to_create_inferior = m32r_create_inferior;
m32r_ops.to_mourn_inferior = m32r_mourn_inferior;
- m32r_ops.to_stop = m32r_stop;
+ m32r_ops.to_interrupt = m32r_interrupt;
+ 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_has_execution;
m32r_ops.to_magic = OPS_MAGIC;
};
init_m32r_ops ();
- /* Initialize breakpoints. */
+ /* Initialize breakpoints. */
for (i = 0; i < MAX_BREAKPOINTS; i++)
bp_address[i] = 0xffffffff;
- /* Initialize access breaks. */
+ /* Initialize access breaks. */
for (i = 0; i < MAX_ACCESS_BREAKS; i++)
ab_address[i] = 0x00000000;
add_target (&m32r_ops);
add_com ("sdireset", class_obscure, sdireset_command,
- "Reset SDI connection.");
+ _("Reset SDI connection."));
add_com ("sdistatus", class_obscure, sdistatus_command,
- "Show status of SDI connection.");
+ _("Show status of SDI connection."));
add_com ("debug_chaos", class_obscure, debug_chaos_command,
- "Debug M32R/Chaos.");
+ _("Debug M32R/Chaos."));
add_com ("use_debug_dma", class_obscure, use_debug_dma_command,
- "Use debug DMA mem access.");
+ _("Use debug DMA mem access."));
add_com ("use_mon_code", class_obscure, use_mon_code_command,
- "Use mon code mem access.");
+ _("Use mon code mem access."));
add_com ("use_ib_break", class_obscure, use_ib_breakpoints_command,
- "Set breakpoints by IB break.");
+ _("Set breakpoints by IB break."));
add_com ("use_dbt_break", class_obscure, use_dbt_breakpoints_command,
- "Set breakpoints by dbt.");
+ _("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);
}