GDB, the GNU debugger.
Copyright 1997 Free Software Foundation, Inc.
-This file is part of GDB.
+ This file is part of GDB.
-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
-(at your option) any later version.
+ 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
+ (at your option) any later version.
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-GNU General Public License for more details.
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ 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. */
+ 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. */
#include "defs.h"
#include "gdbcore.h"
/* Type of function passed to bfd_map_over_sections. */
-typedef void (*section_map_func) PARAMS ((bfd *abfd, asection *sect, PTR obj));
+typedef void (*section_map_func) PARAMS ((bfd * abfd, asection * sect, PTR obj));
/* Packet escape character used by Densan monitor. */
This structure describes a field in a bitmapped register. */
struct bit_field
-{
- char *prefix; /* string appearing before the value */
- char *suffix; /* string appearing after the value */
- char *user_name; /* name used by human when entering field value */
- int length; /* number of bits in the field */
- int start; /* starting (least significant) bit number of field */
-};
-
+ {
+ char *prefix; /* string appearing before the value */
+ char *suffix; /* string appearing after the value */
+ char *user_name; /* name used by human when entering field value */
+ int length; /* number of bits in the field */
+ int start; /* starting (least significant) bit number of field */
+ };
+
/* Local functions for register manipulation. */
static void r3900_supply_register PARAMS ((char *regname, int regnamelen,
char *val, int vallen));
static void fetch_bad_vaddr PARAMS ((void));
-static unsigned long fetch_fields PARAMS ((struct bit_field *bf));
+static unsigned long fetch_fields PARAMS ((struct bit_field * bf));
static void fetch_bitmapped_register PARAMS ((int regno,
- struct bit_field *bf));
+ struct bit_field * bf));
static void r3900_fetch_registers PARAMS ((int regno));
static void store_bitmapped_register PARAMS ((int regno,
- struct bit_field *bf));
+ struct bit_field * bf));
static void r3900_store_registers PARAMS ((int regno));
/* Local functions for fast binary loading. */
static void write_long PARAMS ((char *buf, long n));
static void write_long_le PARAMS ((char *buf, long n));
-static int debug_readchar PARAMS ((int hex));
+static int debug_readchar PARAMS ((int hex));
static void debug_write PARAMS ((unsigned char *buf, int buflen));
static void ignore_packet PARAMS ((void));
static void send_packet PARAMS ((char type, unsigned char *buf, int buflen,
int seq));
static void process_read_request PARAMS ((unsigned char *buf, int buflen));
-static void count_section PARAMS ((bfd *abfd, asection *s,
+static void count_section PARAMS ((bfd * abfd, asection * s,
unsigned int *section_count));
-static void load_section PARAMS ((bfd *abfd, asection *s,
+static void load_section PARAMS ((bfd * abfd, asection * s,
unsigned int *data_count));
static void r3900_load PARAMS ((char *filename, int from_tty));
static char *r3900_regnames[NUM_REGS] =
{
- "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
- "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
- "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
- "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
-
- "S", /* PS_REGNUM */
- "l", /* LO_REGNUM */
- "h", /* HI_REGNUM */
- "B", /* BADVADDR_REGNUM */
- "Pcause", /* CAUSE_REGNUM */
- "p" /* PC_REGNUM */
+ "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
+ "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
+ "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
+ "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
+
+ "S", /* PS_REGNUM */
+ "l", /* LO_REGNUM */
+ "h", /* HI_REGNUM */
+ "B", /* BADVADDR_REGNUM */
+ "Pcause", /* CAUSE_REGNUM */
+ "p" /* PC_REGNUM */
};
/* Table of register names produced by monitor's register dump command. */
static struct reg_entry
+ {
+ char *name;
+ int regno;
+ }
+reg_table[] =
{
- char *name;
- int regno;
-} reg_table[] =
-{
- { "r0_zero", 0 }, { "r1_at", 1 }, { "r2_v0", 2 }, { "r3_v1", 3 },
- { "r4_a0", 4 }, { "r5_a1", 5 }, { "r6_a2", 6 }, { "r7_a3", 7 },
- { "r8_t0", 8 }, { "r9_t1", 9 }, { "r10_t2", 10 }, { "r11_t3", 11 },
- { "r12_t4", 12 }, { "r13_t5", 13 }, { "r14_t6", 14 }, { "r15_t7", 15 },
- { "r16_s0", 16 }, { "r17_s1", 17 }, { "r18_s2", 18 }, { "r19_s3", 19 },
- { "r20_s4", 20 }, { "r21_s5", 21 }, { "r22_s6", 22 }, { "r23_s7", 23 },
- { "r24_t8", 24 }, { "r25_t9", 25 }, { "r26_k0", 26 }, { "r27_k1", 27 },
- { "r28_gp", 28 }, { "r29_sp", 29 }, { "r30_fp", 30 }, { "r31_ra", 31 },
- { "HI", HI_REGNUM },
- { "LO", LO_REGNUM },
- { "PC", PC_REGNUM },
- { "BadV", BADVADDR_REGNUM },
- { NULL, 0 }
+ {
+ "r0_zero", 0
+ }
+ ,
+ {
+ "r1_at", 1
+ }
+ ,
+ {
+ "r2_v0", 2
+ }
+ ,
+ {
+ "r3_v1", 3
+ }
+ ,
+ {
+ "r4_a0", 4
+ }
+ ,
+ {
+ "r5_a1", 5
+ }
+ ,
+ {
+ "r6_a2", 6
+ }
+ ,
+ {
+ "r7_a3", 7
+ }
+ ,
+ {
+ "r8_t0", 8
+ }
+ ,
+ {
+ "r9_t1", 9
+ }
+ ,
+ {
+ "r10_t2", 10
+ }
+ ,
+ {
+ "r11_t3", 11
+ }
+ ,
+ {
+ "r12_t4", 12
+ }
+ ,
+ {
+ "r13_t5", 13
+ }
+ ,
+ {
+ "r14_t6", 14
+ }
+ ,
+ {
+ "r15_t7", 15
+ }
+ ,
+ {
+ "r16_s0", 16
+ }
+ ,
+ {
+ "r17_s1", 17
+ }
+ ,
+ {
+ "r18_s2", 18
+ }
+ ,
+ {
+ "r19_s3", 19
+ }
+ ,
+ {
+ "r20_s4", 20
+ }
+ ,
+ {
+ "r21_s5", 21
+ }
+ ,
+ {
+ "r22_s6", 22
+ }
+ ,
+ {
+ "r23_s7", 23
+ }
+ ,
+ {
+ "r24_t8", 24
+ }
+ ,
+ {
+ "r25_t9", 25
+ }
+ ,
+ {
+ "r26_k0", 26
+ }
+ ,
+ {
+ "r27_k1", 27
+ }
+ ,
+ {
+ "r28_gp", 28
+ }
+ ,
+ {
+ "r29_sp", 29
+ }
+ ,
+ {
+ "r30_fp", 30
+ }
+ ,
+ {
+ "r31_ra", 31
+ }
+ ,
+ {
+ "HI", HI_REGNUM
+ }
+ ,
+ {
+ "LO", LO_REGNUM
+ }
+ ,
+ {
+ "PC", PC_REGNUM
+ }
+ ,
+ {
+ "BadV", BADVADDR_REGNUM
+ }
+ ,
+ {
+ NULL, 0
+ }
};
cache register that the monitor displays. Register fields that should
be ignored have a length of zero in the tables below. */
-static struct bit_field status_fields [] =
+static struct bit_field status_fields[] =
{
/* Status register portion */
- { "SR[<CU=", " ", "cu", 4, 28 },
- { "RE=", " ", "re", 1, 25 },
- { "BEV=", " ", "bev", 1, 22 },
- { "TS=", " ", "ts", 1, 21 },
- { "Nmi=", " ", "nmi", 1, 20 },
- { "INT=", " ", "int", 6, 10 },
- { "SW=", ">]", "sw", 2, 8 },
- { "[<KUO=", " ", "kuo", 1, 5 },
- { "IEO=", " ", "ieo", 1, 4 },
- { "KUP=", " ", "kup", 1, 3 },
- { "IEP=", " ", "iep", 1, 2 },
- { "KUC=", " ", "kuc", 1, 1 },
- { "IEC=", ">]", "iec", 1, 0 },
+ {"SR[<CU=", " ", "cu", 4, 28},
+ {"RE=", " ", "re", 1, 25},
+ {"BEV=", " ", "bev", 1, 22},
+ {"TS=", " ", "ts", 1, 21},
+ {"Nmi=", " ", "nmi", 1, 20},
+ {"INT=", " ", "int", 6, 10},
+ {"SW=", ">]", "sw", 2, 8},
+ {"[<KUO=", " ", "kuo", 1, 5},
+ {"IEO=", " ", "ieo", 1, 4},
+ {"KUP=", " ", "kup", 1, 3},
+ {"IEP=", " ", "iep", 1, 2},
+ {"KUC=", " ", "kuc", 1, 1},
+ {"IEC=", ">]", "iec", 1, 0},
/* Cache register portion (dummy for parsing only) */
- { "CR[<IalO="," ", "ialo", 0, 13 },
- { "DalO=", " ", "dalo", 0, 12 },
- { "IalP=", " ", "ialp", 0, 11 },
- { "DalP=", " ", "dalp", 0, 10 },
- { "IalC=", " ", "ialc", 0, 9 },
- { "DalC=", ">] ", "dalc", 0, 8 },
-
- { NULL, NULL, 0, 0 } /* end of table marker */
+ {"CR[<IalO=", " ", "ialo", 0, 13},
+ {"DalO=", " ", "dalo", 0, 12},
+ {"IalP=", " ", "ialp", 0, 11},
+ {"DalP=", " ", "dalp", 0, 10},
+ {"IalC=", " ", "ialc", 0, 9},
+ {"DalC=", ">] ", "dalc", 0, 8},
+
+ {NULL, NULL, 0, 0} /* end of table marker */
};
-#if 0 /* FIXME: Enable when we add support for modifying cache register. */
-static struct bit_field cache_fields [] =
+#if 0 /* FIXME: Enable when we add support for modifying cache register. */
+static struct bit_field cache_fields[] =
{
/* Status register portion (dummy for parsing only) */
- { "SR[<CU=", " ", "cu", 0, 28 },
- { "RE=", " ", "re", 0, 25 },
- { "BEV=", " ", "bev", 0, 22 },
- { "TS=", " ", "ts", 0, 21 },
- { "Nmi=", " ", "nmi", 0, 20 },
- { "INT=", " ", "int", 0, 10 },
- { "SW=", ">]", "sw", 0, 8 },
- { "[<KUO=", " ", "kuo", 0, 5 },
- { "IEO=", " ", "ieo", 0, 4 },
- { "KUP=", " ", "kup", 0, 3 },
- { "IEP=", " ", "iep", 0, 2 },
- { "KUC=", " ", "kuc", 0, 1 },
- { "IEC=", ">]", "iec", 0, 0 },
+ {"SR[<CU=", " ", "cu", 0, 28},
+ {"RE=", " ", "re", 0, 25},
+ {"BEV=", " ", "bev", 0, 22},
+ {"TS=", " ", "ts", 0, 21},
+ {"Nmi=", " ", "nmi", 0, 20},
+ {"INT=", " ", "int", 0, 10},
+ {"SW=", ">]", "sw", 0, 8},
+ {"[<KUO=", " ", "kuo", 0, 5},
+ {"IEO=", " ", "ieo", 0, 4},
+ {"KUP=", " ", "kup", 0, 3},
+ {"IEP=", " ", "iep", 0, 2},
+ {"KUC=", " ", "kuc", 0, 1},
+ {"IEC=", ">]", "iec", 0, 0},
/* Cache register portion */
- { "CR[<IalO="," ", "ialo", 1, 13 },
- { "DalO=", " ", "dalo", 1, 12 },
- { "IalP=", " ", "ialp", 1, 11 },
- { "DalP=", " ", "dalp", 1, 10 },
- { "IalC=", " ", "ialc", 1, 9 },
- { "DalC=", ">] ", "dalc", 1, 8 },
-
- { NULL, NULL, NULL, 0, 0 } /* end of table marker */
+ {"CR[<IalO=", " ", "ialo", 1, 13},
+ {"DalO=", " ", "dalo", 1, 12},
+ {"IalP=", " ", "ialp", 1, 11},
+ {"DalP=", " ", "dalp", 1, 10},
+ {"IalC=", " ", "ialc", 1, 9},
+ {"DalC=", ">] ", "dalc", 1, 8},
+
+ {NULL, NULL, NULL, 0, 0} /* end of table marker */
};
#endif
-static struct bit_field cause_fields[] =
+static struct bit_field cause_fields[] =
{
- { "<BD=", " ", "bd", 1, 31 },
- { "CE=", " ", "ce", 2, 28 },
- { "IP=", " ", "ip", 6, 10 },
- { "SW=", " ", "sw", 2, 8 },
- { "EC=", ">]" , "ec", 5, 2 },
+ {"<BD=", " ", "bd", 1, 31},
+ {"CE=", " ", "ce", 2, 28},
+ {"IP=", " ", "ip", 6, 10},
+ {"SW=", " ", "sw", 2, 8},
+ {"EC=", ">]", "ec", 5, 2},
- { NULL, NULL, NULL, 0, 0 } /* end of table marker */
+ {NULL, NULL, NULL, 0, 0} /* end of table marker */
};
/* The monitor prints register values in the form
- regname = xxxx xxxx
+ regname = xxxx xxxx
We look up the register name in a table, and remove the embedded space in
the hex value before passing it to monitor_supply_register. */
you modify it. */
static void
-fetch_bad_vaddr()
+fetch_bad_vaddr ()
{
char buf[20];
monitor_printf ("xB\r");
monitor_expect ("BadV=", NULL, 0);
- monitor_expect_prompt (buf, sizeof(buf));
+ monitor_expect_prompt (buf, sizeof (buf));
monitor_supply_register (BADVADDR_REGNUM, buf);
}
-
+
/* Read a series of bit fields from the monitor, and return their
combined binary value. */
unsigned long val = 0;
unsigned long bits;
- for ( ; bf->prefix != NULL; bf++)
+ for (; bf->prefix != NULL; bf++)
{
- monitor_expect (bf->prefix, NULL, 0); /* get prefix */
+ monitor_expect (bf->prefix, NULL, 0); /* get prefix */
monitor_expect (bf->suffix, buf, sizeof (buf)); /* hex value, suffix */
if (bf->length != 0)
- {
+ {
bits = strtoul (buf, NULL, 16); /* get field value */
bits &= ((1 << bf->length) - 1); /* mask out useless bits */
- val |= bits << bf->start; /* insert into register */
+ val |= bits << bf->start; /* insert into register */
}
-
+
}
return val;
newval = read_register (regno);
/* To save time, write just the fields that have changed. */
- for ( ; bf->prefix != NULL; bf++)
+ for (; bf->prefix != NULL; bf++)
{
if (bf->length != 0)
- {
+ {
unsigned long oldbits, newbits, mask;
mask = (1 << bf->length) - 1;
debug_readchar (hex)
int hex;
{
- char buf [10];
+ char buf[10];
int c = monitor_readchar ();
if (remote_debug > 0)
sprintf (buf, "[%02x]", c & 0xff);
else if (c == '\0')
strcpy (buf, "\\0");
- else
+ else
{
buf[0] = c;
buf[1] = '\0';
when its console is in "communications interface" mode. A packet
is of this form:
- start of packet flag (one byte: 0xdc)
- packet type (one byte)
- length (low byte)
- length (high byte)
- data (length bytes)
+ start of packet flag (one byte: 0xdc)
+ packet type (one byte)
+ length (low byte)
+ length (high byte)
+ data (length bytes)
The last two bytes of the data field are a checksum, but we don't
bother to verify it.
-*/
+ */
static void
ignore_packet ()
{
int c;
- int len;
+ int len;
/* Ignore lots of trash (messages about section addresses, for example)
until we see the start of a packet. */
error ("Packet header byte not found; %02x seen instead.", c);
/* Read the packet type and length. */
- c = debug_readchar (1); /* type */
+ c = debug_readchar (1); /* type */
- c = debug_readchar (1); /* low byte of length */
+ c = debug_readchar (1); /* low byte of length */
len = c & 0xff;
- c = debug_readchar (1); /* high byte of length */
+ c = debug_readchar (1); /* high byte of length */
len += (c & 0xff) << 8;
/* Ignore the rest of the packet. */
The 'p' packet is a special case. This is a packet we send
in response to a read ('r') packet from the monitor. This function
appends a one-byte sequence number to the data field of such a packet.
-*/
+ */
static void
send_packet (type, buf, buflen, seq)
sum += tmp << 8;
}
if (type == 'p')
- {
+ {
if (buflen & 1)
sum += (seq & 0xff);
else
}
sum = (sum & 0xffff) + ((sum >> 16) & 0xffff);
sum += (sum >> 16) & 1;
- sum = ~sum;
+ sum = ~sum;
hdr[0] = (sum >> 8) & 0xff;
hdr[1] = sum & 0xff;
static void
count_section (abfd, s, section_count)
- bfd *abfd;
+ bfd *abfd;
asection *s;
unsigned int *section_count;
{
packets containing read requests, but rather than respond
to them in an general way, we expect them to following
a certain pattern.
-
+
For example, we know that the monitor will start loading by
issuing an 8-byte read request for the binary file header.
We know this is coming and ignore the actual contents
of the read request packet.
-*/
+ */
static void
load_section (abfd, s, data_count)
- bfd *abfd;
+ bfd *abfd;
asection *s;
unsigned int *data_count;
{
if (s->flags & SEC_LOAD)
{
bfd_size_type section_size = bfd_section_size (abfd, s);
- bfd_vma section_base = bfd_section_lma (abfd, s);
+ bfd_vma section_base = bfd_section_lma (abfd, s);
unsigned char *buffer;
unsigned char header[8];
/* Don't output zero-length sections. */
if (section_size == 0)
- return;
+ return;
if (data_count)
*data_count += section_size;
/* Print some fluff about the section being loaded. */
printf_filtered ("Loading section %s, size 0x%lx lma ",
- bfd_section_name (abfd, s), (long)section_size);
+ bfd_section_name (abfd, s), (long) section_size);
print_address_numeric (section_base, 1, gdb_stdout);
printf_filtered ("\n");
gdb_flush (gdb_stdout);
/* Write the section header (location and size). */
- write_long (&header[0], (long)section_base);
- write_long (&header[4], (long)section_size);
+ write_long (&header[0], (long) section_base);
+ write_long (&header[4], (long) section_size);
process_read_request (header, sizeof (header));
/* Read the section contents into a buffer, write it out,
bfd_get_section_contents (abfd, s, buffer, 0, section_size);
process_read_request (buffer, section_size);
free (buffer);
- }
+ }
}
we can use the "Rm" command to do a fast binary load. The format
of the download data is:
- number of sections (4 bytes)
- starting address (4 bytes)
- repeat for each section:
- location address (4 bytes)
- section size (4 bytes)
- binary data
+ number of sections (4 bytes)
+ starting address (4 bytes)
+ repeat for each section:
+ location address (4 bytes)
+ section size (4 bytes)
+ binary data
The 4-byte fields are all in big-endian order.
*/
static void
-r3900_load (filename, from_tty)
- char *filename;
- int from_tty;
+r3900_load (filename, from_tty)
+ char *filename;
+ int from_tty;
{
bfd *abfd;
unsigned int data_count = 0;
monitor_printf ("Rm\r");
ignore_packet ();
send_packet ('a', "", 0, 0);
-
+
/* Output the fast load header (number of sections and starting address). */
bfd_map_over_sections ((bfd *) abfd, (section_map_func) count_section,
§ion_count);
- write_long (&buffer[0], (long)section_count);
+ write_long (&buffer[0], (long) section_count);
if (exec_bfd)
- write_long (&buffer[4], (long)bfd_get_start_address (exec_bfd));
+ write_long (&buffer[4], (long) bfd_get_start_address (exec_bfd));
else
write_long (&buffer[4], 0);
process_read_request (buffer, sizeof (buffer));
monitor_expect_prompt (NULL, 0);
/* Print start address and download performance information. */
- printf_filtered ("Start address 0x%lx\n", (long)bfd_get_start_address (abfd));
+ printf_filtered ("Start address 0x%lx\n", (long) bfd_get_start_address (abfd));
report_transfer_performance (data_count, start_time, end_time);
/* Finally, make the PC point at the start address */
if (exec_bfd)
write_pc (bfd_get_start_address (exec_bfd));
- inferior_pid = 0; /* No process now */
+ inferior_pid = 0; /* No process now */
/* 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
/* Commands to send to the monitor when first connecting:
- * The bare carriage return forces a prompt from the monitor
- (monitor doesn't prompt immediately after a reset).
- * The "vconsx" switches the monitor back to interactive mode
- in case an aborted download had left it in packet mode.
- * The "Xtr" command causes subsequent "t" (trace) commands to display
- the general registers only.
- * The "Xxr" command does the same thing for the "x" (examine
- registers) command.
- * The "bx" command clears all breakpoints.
-*/
-
-static char *r3900_inits[] = {"\r", "vconsx\r", "Xtr\r", "Xxr\r", "bx\r", NULL};
-static char *dummy_inits[] = { NULL };
+ * The bare carriage return forces a prompt from the monitor
+ (monitor doesn't prompt immediately after a reset).
+ * The "vconsx" switches the monitor back to interactive mode
+ in case an aborted download had left it in packet mode.
+ * The "Xtr" command causes subsequent "t" (trace) commands to display
+ the general registers only.
+ * The "Xxr" command does the same thing for the "x" (examine
+ registers) command.
+ * The "bx" command clears all breakpoints.
+ */
+
+static char *r3900_inits[] =
+{"\r", "vconsx\r", "Xtr\r", "Xxr\r", "bx\r", NULL};
+static char *dummy_inits[] =
+{NULL};
static struct target_ops r3900_ops;
static struct monitor_ops r3900_cmds;
ethernet = 0;
monitor_printf ("v\r");
if (monitor_expect ("console device :", NULL, 0) != -1)
- if (monitor_expect ("\n", buf, sizeof (buf)) != -1)
- if (strstr (buf, "ethernet") != NULL)
- ethernet = 1;
+ if (monitor_expect ("\n", buf, sizeof (buf)) != -1)
+ if (strstr (buf, "ethernet") != NULL)
+ ethernet = 1;
monitor_expect_prompt (NULL, 0);
}
_initialize_r3900_rom ()
{
r3900_cmds.flags = MO_NO_ECHO_ON_OPEN |
- MO_ADDR_BITS_REMOVE |
- MO_CLR_BREAK_USES_ADDR |
- MO_GETMEM_READ_SINGLE |
- MO_PRINT_PROGRAM_OUTPUT;
+ MO_ADDR_BITS_REMOVE |
+ MO_CLR_BREAK_USES_ADDR |
+ MO_GETMEM_READ_SINGLE |
+ MO_PRINT_PROGRAM_OUTPUT;
r3900_cmds.init = dummy_inits;
r3900_cmds.cont = "g\r";
r3900_cmds.step = "t\r";
- r3900_cmds.set_break = "b %A\r"; /* COREADDR */
- r3900_cmds.clr_break = "b %A,0\r"; /* COREADDR */
- r3900_cmds.fill = "fx %A s %x %x\r"; /* COREADDR, len, val */
+ r3900_cmds.set_break = "b %A\r"; /* COREADDR */
+ r3900_cmds.clr_break = "b %A,0\r"; /* COREADDR */
+ r3900_cmds.fill = "fx %A s %x %x\r"; /* COREADDR, len, val */
r3900_cmds.setmem.cmdb = "sx %A %x\r"; /* COREADDR, val */
r3900_cmds.setmem.cmdw = "sh %A %x\r"; /* COREADDR, val */
r3900_cmds.setmem.cmdl = "sw %A %x\r"; /* COREADDR, val */
- r3900_cmds.getmem.cmdb = "sx %A\r"; /* COREADDR */
- r3900_cmds.getmem.cmdw = "sh %A\r"; /* COREADDR */
- r3900_cmds.getmem.cmdl = "sw %A\r"; /* COREADDR */
+ r3900_cmds.getmem.cmdb = "sx %A\r"; /* COREADDR */
+ r3900_cmds.getmem.cmdw = "sh %A\r"; /* COREADDR */
+ r3900_cmds.getmem.cmdl = "sw %A\r"; /* COREADDR */
r3900_cmds.getmem.resp_delim = " : ";
r3900_cmds.getmem.term = " ";
r3900_cmds.getmem.term_cmd = ".\r";
- r3900_cmds.setreg.cmd = "x%s %x\r"; /* regname, val */
+ r3900_cmds.setreg.cmd = "x%s %x\r"; /* regname, val */
- r3900_cmds.getreg.cmd = "x%s\r"; /* regname */
+ r3900_cmds.getreg.cmd = "x%s\r"; /* regname */
r3900_cmds.getreg.resp_delim = "=";
r3900_cmds.getreg.term = " ";
r3900_cmds.getreg.term_cmd = ".\r";
r3900_cmds.dump_registers = "x\r";
r3900_cmds.register_pattern =
- "\\([a-zA-Z0-9_]+\\) *=\\([0-9a-f]+ [0-9a-f]+\\b\\)";
+ "\\([a-zA-Z0-9_]+\\) *=\\([0-9a-f]+ [0-9a-f]+\\b\\)";
r3900_cmds.supply_register = r3900_supply_register;
/* S-record download, via "keyboard port". */
r3900_cmds.load = "r0\r";
projects / thirdparty / binutils-gdb.git / blobdiff