monitor_printable_string (safe_string, string, real_len);
if (final_char)
- error (_("%s (0x%s): %s: %s%c"), function, paddr_nz (memaddr), message, safe_string, final_char);
+ error (_("%s (%s): %s: %s%c"),
+ function, paddress (target_gdbarch, memaddr),
+ message, safe_string, final_char);
else
- error (_("%s (0x%s): %s: %s"), function, paddr_nz (memaddr), message, safe_string);
+ error (_("%s (%s): %s: %s"),
+ function, paddress (target_gdbarch, memaddr),
+ message, safe_string);
}
/* Convert hex digit A to a number. */
static void
monitor_vsprintf (char *sndbuf, char *pattern, va_list args)
{
+ int addr_bit = gdbarch_addr_bit (target_gdbarch);
char format[10];
char fmt;
char *p;
break;
case 'A':
arg_addr = va_arg (args, CORE_ADDR);
- strcpy (sndbuf, paddr_nz (arg_addr));
+ strcpy (sndbuf, phex_nz (arg_addr, addr_bit / 8));
break;
case 's':
arg_string = va_arg (args, char *);
char *
monitor_supply_register (struct regcache *regcache, int regno, char *valstr)
{
+ struct gdbarch *gdbarch = get_regcache_arch (regcache);
+ enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
ULONGEST val;
unsigned char regbuf[MAX_REGISTER_SIZE];
char *p;
/* supply register stores in target byte order, so swap here */
- store_unsigned_integer (regbuf,
- register_size (get_regcache_arch (regcache), regno),
+ store_unsigned_integer (regbuf, register_size (gdbarch, regno), byte_order,
val);
regcache_raw_supply (regcache, regno, regbuf);
static ptid_t
monitor_wait (struct target_ops *ops,
- ptid_t ptid, struct target_waitstatus *status)
+ ptid_t ptid, struct target_waitstatus *status, int options)
{
int old_timeout = timeout;
char buf[TARGET_BUF_SIZE];
static void
monitor_store_register (struct regcache *regcache, int regno)
{
+ int reg_size = register_size (get_regcache_arch (regcache), regno);
const char *name;
ULONGEST val;
}
regcache_cooked_read_unsigned (regcache, regno, &val);
- monitor_debug ("MON storeg %d %s\n", regno,
- phex (val,
- register_size (get_regcache_arch (regcache), regno)));
+ monitor_debug ("MON storeg %d %s\n", regno, phex (val, reg_size));
/* send the register deposit command */
monitor_debug ("EXP setreg.resp_delim\n");
monitor_expect_regexp (&setreg_resp_delim_pattern, NULL, 0);
if (current_monitor->flags & MO_SETREG_INTERACTIVE)
- monitor_printf ("%s\r", paddr_nz (val));
+ monitor_printf ("%s\r", phex_nz (val, reg_size));
}
if (current_monitor->setreg.term)
{
monitor_debug ("EXP setreg.term\n");
monitor_expect (current_monitor->setreg.term, NULL, 0);
if (current_monitor->flags & MO_SETREG_INTERACTIVE)
- monitor_printf ("%s\r", paddr_nz (val));
+ monitor_printf ("%s\r", phex_nz (val, reg_size));
monitor_expect_prompt (NULL, 0);
}
else
static int
monitor_write_memory (CORE_ADDR memaddr, char *myaddr, int len)
{
+ enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
unsigned int val, hostval;
char *cmd;
int i;
- monitor_debug ("MON write %d %s\n", len, paddr (memaddr));
+ monitor_debug ("MON write %d %s\n", len, paddress (target_gdbarch, memaddr));
if (current_monitor->flags & MO_ADDR_BITS_REMOVE)
- memaddr = gdbarch_addr_bits_remove (current_gdbarch, memaddr);
+ memaddr = gdbarch_addr_bits_remove (target_gdbarch, memaddr);
/* Use memory fill command for leading 0 bytes. */
cmd = current_monitor->setmem.cmdb;
}
- val = extract_unsigned_integer (myaddr, len);
+ val = extract_unsigned_integer (myaddr, len, byte_order);
if (len == 4)
{
static int
monitor_read_memory_single (CORE_ADDR memaddr, char *myaddr, int len)
{
+ enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
unsigned int val;
char membuf[sizeof (int) * 2 + 1];
char *p;
/* supply register stores in target byte order, so swap here */
- store_unsigned_integer (myaddr, len, val);
+ store_unsigned_integer (myaddr, len, byte_order, val);
return len;
}
}
monitor_debug ("MON read block ta(%s) ha(%lx) %d\n",
- paddr_nz (memaddr), (long) myaddr, len);
+ paddress (target_gdbarch, memaddr), (long) myaddr, len);
if (current_monitor->flags & MO_ADDR_BITS_REMOVE)
- memaddr = gdbarch_addr_bits_remove (current_gdbarch, memaddr);
+ memaddr = gdbarch_addr_bits_remove (target_gdbarch, memaddr);
if (current_monitor->flags & MO_GETMEM_READ_SINGLE)
return monitor_read_memory_single (memaddr, myaddr, len);
/* Tell the monitor to add a breakpoint. */
static int
-monitor_insert_breakpoint (struct bp_target_info *bp_tgt)
+monitor_insert_breakpoint (struct gdbarch *gdbarch,
+ struct bp_target_info *bp_tgt)
{
CORE_ADDR addr = bp_tgt->placed_address;
int i;
int bplen;
- monitor_debug ("MON inst bkpt %s\n", paddr (addr));
+ monitor_debug ("MON inst bkpt %s\n", paddress (gdbarch, addr));
if (current_monitor->set_break == NULL)
error (_("No set_break defined for this monitor"));
if (current_monitor->flags & MO_ADDR_BITS_REMOVE)
- addr = gdbarch_addr_bits_remove (current_gdbarch, addr);
+ addr = gdbarch_addr_bits_remove (gdbarch, addr);
/* Determine appropriate breakpoint size for this address. */
- gdbarch_breakpoint_from_pc (current_gdbarch, &addr, &bplen);
+ gdbarch_breakpoint_from_pc (gdbarch, &addr, &bplen);
bp_tgt->placed_address = addr;
bp_tgt->placed_size = bplen;
/* Tell the monitor to remove a breakpoint. */
static int
-monitor_remove_breakpoint (struct bp_target_info *bp_tgt)
+monitor_remove_breakpoint (struct gdbarch *gdbarch,
+ struct bp_target_info *bp_tgt)
{
CORE_ADDR addr = bp_tgt->placed_address;
int i;
- monitor_debug ("MON rmbkpt %s\n", paddr (addr));
+ monitor_debug ("MON rmbkpt %s\n", paddress (gdbarch, addr));
if (current_monitor->clr_break == NULL)
error (_("No clr_break defined for this monitor"));
}
}
fprintf_unfiltered (gdb_stderr,
- "Can't find breakpoint associated with 0x%s\n",
- paddr_nz (addr));
+ "Can't find breakpoint associated with %s\n",
+ paddress (gdbarch, addr));
return 1;
}
monitor_ops.to_thread_alive = monitor_thread_alive;
monitor_ops.to_pid_to_str = monitor_pid_to_str;
monitor_ops.to_stratum = process_stratum;
- monitor_ops.to_has_all_memory = 1;
- monitor_ops.to_has_memory = 1;
- monitor_ops.to_has_stack = 1;
- monitor_ops.to_has_registers = 1;
- monitor_ops.to_has_execution = 1;
+ monitor_ops.to_has_all_memory = default_child_has_all_memory;
+ monitor_ops.to_has_memory = default_child_has_memory;
+ monitor_ops.to_has_stack = default_child_has_stack;
+ monitor_ops.to_has_registers = default_child_has_registers;
+ monitor_ops.to_has_execution = default_child_has_execution;
monitor_ops.to_magic = OPS_MAGIC;
} /* init_base_monitor_ops */
projects / deliverable / binutils-gdb.git / blobdiff