-/* Target-dependent code for the HP PA architecture, for GDB.
+/* Target-dependent code for the HP PA-RISC architecture.
Copyright 1986, 1987, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
- 1996, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005 Free Software
- Foundation, Inc.
+ 1996, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
+ Free Software Foundation, Inc.
Contributed by the Center for Software Science at the
University of Utah (pa-gdb-bugs@cs.utah.edu).
}
/* Now compute the size of the stub unwinds. Note the ELF tools do not
- use stub unwinds at the curren time. */
+ use stub unwinds at the current time. */
stub_unwind_sec = bfd_get_section_by_name (objfile->obfd, "$UNWIND_END$");
if (stub_unwind_sec)
read_unwind_info (objfile);
priv = objfile_data (objfile, hppa_objfile_priv_data);
if (priv == NULL)
- error ("Internal error reading unwind information.");
+ error (_("Internal error reading unwind information."));
ui = ((struct hppa_objfile_private *) priv)->unwind_info;
}
static enum return_value_convention
hppa32_return_value (struct gdbarch *gdbarch,
struct type *type, struct regcache *regcache,
- void *readbuf, const void *writebuf)
+ gdb_byte *readbuf, const gdb_byte *writebuf)
{
if (TYPE_LENGTH (type) <= 2 * 4)
{
for (b = part; b < TYPE_LENGTH (type); b += 4)
{
if (readbuf != NULL)
- regcache_cooked_read (regcache, reg, (char *) readbuf + b);
+ regcache_cooked_read (regcache, reg, readbuf + b);
if (writebuf != NULL)
- regcache_cooked_write (regcache, reg, (const char *) writebuf + b);
+ regcache_cooked_write (regcache, reg, writebuf + b);
reg++;
}
return RETURN_VALUE_REGISTER_CONVENTION;
static enum return_value_convention
hppa64_return_value (struct gdbarch *gdbarch,
struct type *type, struct regcache *regcache,
- void *readbuf, const void *writebuf)
+ gdb_byte *readbuf, const gdb_byte *writebuf)
{
int len = TYPE_LENGTH (type);
int regnum, offset;
if (readbuf)
{
- char *buf = readbuf;
while (len > 0)
{
regcache_cooked_read_part (regcache, regnum, offset,
- min (len, 8), buf);
- buf += min (len, 8);
+ min (len, 8), readbuf);
+ readbuf += min (len, 8);
len -= min (len, 8);
regnum++;
}
if (writebuf)
{
- const char *buf = writebuf;
while (len > 0)
{
regcache_cooked_write_part (regcache, regnum, offset,
- min (len, 8), buf);
- buf += min (len, 8);
+ min (len, 8), writebuf);
+ writebuf += min (len, 8);
len -= min (len, 8);
regnum++;
}
\f
static CORE_ADDR
-hppa32_convert_from_func_ptr_addr (struct gdbarch *gdbarch,
- CORE_ADDR addr,
+hppa32_convert_from_func_ptr_addr (struct gdbarch *gdbarch, CORE_ADDR addr,
struct target_ops *targ)
{
if (addr & 2)
{
- CORE_ADDR plabel;
-
- plabel = addr & ~3;
- target_read_memory(plabel, (char *)&addr, 4);
+ CORE_ADDR plabel = addr & ~3;
+ return read_memory_typed_address (plabel, builtin_type_void_func_ptr);
}
return addr;
if (!safe_frame_unwind_memory (next_frame, pc, buf4,
sizeof buf4))
{
- error ("Cannot read instruction at 0x%s\n", paddr_nz (pc));
+ error (_("Cannot read instruction at 0x%s."), paddr_nz (pc));
return (*this_cache);
}
void **this_cache,
int regnum, int *optimizedp,
enum lval_type *lvalp, CORE_ADDR *addrp,
- int *realnump, void *valuep)
+ int *realnump, gdb_byte *valuep)
{
struct hppa_frame_cache *info = hppa_frame_cache (next_frame, this_cache);
hppa_frame_prev_register_helper (next_frame, info->saved_regs, regnum,
hppa_fallback_frame_cache (struct frame_info *next_frame, void **this_cache)
{
struct hppa_frame_cache *cache;
- unsigned int frame_size;
- int found_rp;
- CORE_ADDR pc, start_pc, end_pc, cur_pc;
+ unsigned int frame_size = 0;
+ int found_rp = 0;
+ CORE_ADDR start_pc;
if (hppa_debug)
- fprintf_unfiltered (gdb_stdlog, "{ hppa_fallback_frame_cache (frame=%d)-> ",
- frame_relative_level(next_frame));
+ fprintf_unfiltered (gdb_stdlog,
+ "{ hppa_fallback_frame_cache (frame=%d) -> ",
+ frame_relative_level (next_frame));
cache = FRAME_OBSTACK_ZALLOC (struct hppa_frame_cache);
(*this_cache) = cache;
cache->saved_regs = trad_frame_alloc_saved_regs (next_frame);
- pc = frame_func_unwind (next_frame);
- cur_pc = frame_pc_unwind (next_frame);
- frame_size = 0;
- found_rp = 0;
-
- find_pc_partial_function (pc, NULL, &start_pc, &end_pc);
-
- if (start_pc == 0 || end_pc == 0)
- {
- error ("Cannot find bounds of current function (@0x%s), unwinding will "
- "fail.", paddr_nz (pc));
- return cache;
- }
-
- if (end_pc > cur_pc)
- end_pc = cur_pc;
-
- for (pc = start_pc; pc < end_pc; pc += 4)
+ start_pc = frame_func_unwind (next_frame);
+ if (start_pc)
{
- unsigned int insn;
+ CORE_ADDR cur_pc = frame_pc_unwind (next_frame);
+ CORE_ADDR pc;
- insn = read_memory_unsigned_integer (pc, 4);
+ for (pc = start_pc; pc < cur_pc; pc += 4)
+ {
+ unsigned int insn;
- frame_size += prologue_inst_adjust_sp (insn);
+ insn = read_memory_unsigned_integer (pc, 4);
+ frame_size += prologue_inst_adjust_sp (insn);
- /* There are limited ways to store the return pointer into the
- stack. */
- if (insn == 0x6bc23fd9) /* stw rp,-0x14(sr0,sp) */
- {
- cache->saved_regs[HPPA_RP_REGNUM].addr = -20;
- found_rp = 1;
- }
- else if (insn == 0x0fc212c1) /* std rp,-0x10(sr0,sp) */
- {
- cache->saved_regs[HPPA_RP_REGNUM].addr = -16;
- found_rp = 1;
- }
+ /* There are limited ways to store the return pointer into the
+ stack. */
+ if (insn == 0x6bc23fd9) /* stw rp,-0x14(sr0,sp) */
+ {
+ cache->saved_regs[HPPA_RP_REGNUM].addr = -20;
+ found_rp = 1;
+ }
+ else if (insn == 0x0fc212c1) /* std rp,-0x10(sr0,sp) */
+ {
+ cache->saved_regs[HPPA_RP_REGNUM].addr = -16;
+ found_rp = 1;
+ }
+ }
}
if (hppa_debug)
- fprintf_unfiltered (gdb_stdlog, " frame_size = %d, found_rp = %d }\n",
- frame_size, found_rp);
+ fprintf_unfiltered (gdb_stdlog, " frame_size=%d, found_rp=%d }\n",
+ frame_size, found_rp);
- cache->base = frame_unwind_register_unsigned (next_frame, HPPA_SP_REGNUM) - frame_size;
+ cache->base = frame_unwind_register_unsigned (next_frame, HPPA_SP_REGNUM);
+ cache->base -= frame_size;
trad_frame_set_value (cache->saved_regs, HPPA_SP_REGNUM, cache->base);
if (trad_frame_addr_p (cache->saved_regs, HPPA_RP_REGNUM))
{
cache->saved_regs[HPPA_RP_REGNUM].addr += cache->base;
- cache->saved_regs[HPPA_PCOQ_HEAD_REGNUM] = cache->saved_regs[HPPA_RP_REGNUM];
+ cache->saved_regs[HPPA_PCOQ_HEAD_REGNUM] =
+ cache->saved_regs[HPPA_RP_REGNUM];
}
else
{
- ULONGEST rp = frame_unwind_register_unsigned (next_frame, HPPA_RP_REGNUM);
+ ULONGEST rp;
+ rp = frame_unwind_register_unsigned (next_frame, HPPA_RP_REGNUM);
trad_frame_set_value (cache->saved_regs, HPPA_PCOQ_HEAD_REGNUM, rp);
}
void **this_cache,
int regnum, int *optimizedp,
enum lval_type *lvalp, CORE_ADDR *addrp,
- int *realnump, void *valuep)
+ int *realnump, gdb_byte *valuep)
{
struct hppa_frame_cache *info =
hppa_fallback_frame_cache (next_frame, this_cache);
void **this_prologue_cache,
int regnum, int *optimizedp,
enum lval_type *lvalp, CORE_ADDR *addrp,
- int *realnump, void *valuep)
+ int *realnump, gdb_byte *valuep)
{
struct hppa_stub_unwind_cache *info
= hppa_stub_frame_unwind_cache (next_frame, this_prologue_cache);
optimizedp, lvalp, addrp, realnump,
valuep);
else
- error ("Requesting registers from null frame.\n");
+ error (_("Requesting registers from null frame."));
}
static const struct frame_unwind hppa_stub_frame_unwind = {
return NULL;
}
-/* Instead of this nasty cast, add a method pvoid() that prints out a
- host VOID data type (remember %p isn't portable). */
-
-static CORE_ADDR
-hppa_pointer_to_address_hack (void *ptr)
-{
- gdb_assert (sizeof (ptr) == TYPE_LENGTH (builtin_type_void_data_ptr));
- return POINTER_TO_ADDRESS (builtin_type_void_data_ptr, &ptr);
-}
-
static void
unwind_command (char *exp, int from_tty)
{
return;
}
- printf_unfiltered ("unwind_table_entry (0x%s):\n",
- paddr_nz (hppa_pointer_to_address_hack (u)));
+ printf_unfiltered ("unwind_table_entry (0x%lx):\n", (unsigned long)u);
printf_unfiltered ("\tregion_start = ");
print_address (u->region_start, gdb_stdout);
minimal symbols, I'm resorting to the gross hack of checking the
top byte of the address for all 1's. Sigh. */
- return (!target_has_stack && (pc & 0xFF000000));
+ return (!target_has_stack && (pc & 0xFF000000) == 0xFF000000);
}
/* Return the GDB type object for the "standard" data type of data in
return (addr &= ~0x3);
}
-/* Get the ith function argument for the current function. */
+/* Get the ARGIth function argument for the current function. */
+
static CORE_ADDR
hppa_fetch_pointer_argument (struct frame_info *frame, int argi,
struct type *type)
{
- CORE_ADDR addr;
- get_frame_register (frame, HPPA_R0_REGNUM + 26 - argi, &addr);
- return addr;
+ return get_frame_register_unsigned (frame, HPPA_R0_REGNUM + 26 - argi);
}
static void
hppa_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
- int regnum, void *buf)
+ int regnum, gdb_byte *buf)
{
ULONGEST tmp;
regcache_raw_read_unsigned (regcache, regnum, &tmp);
if (regnum == HPPA_PCOQ_HEAD_REGNUM || regnum == HPPA_PCOQ_TAIL_REGNUM)
tmp &= ~0x3;
- store_unsigned_integer (buf, sizeof(tmp), tmp);
+ store_unsigned_integer (buf, sizeof tmp, tmp);
}
static CORE_ADDR
struct trad_frame_saved_reg saved_regs[],
int regnum, int *optimizedp,
enum lval_type *lvalp, CORE_ADDR *addrp,
- int *realnump, void *valuep)
+ int *realnump, gdb_byte *valuep)
{
struct gdbarch *arch = get_frame_arch (next_frame);
hppa64_cannot_store_register);
break;
default:
- internal_error (__FILE__, __LINE__, "Unsupported address size: %d",
+ internal_error (__FILE__, __LINE__, _("Unsupported address size: %d"),
tdep->bytes_per_address);
}
set_gdbarch_frame_align (gdbarch, hppa64_frame_align);
break;
default:
- internal_error (__FILE__, __LINE__, "bad switch");
+ internal_error (__FILE__, __LINE__, _("bad switch"));
}
/* Struct return methods. */
set_gdbarch_return_value (gdbarch, hppa64_return_value);
break;
default:
- internal_error (__FILE__, __LINE__, "bad switch");
+ internal_error (__FILE__, __LINE__, _("bad switch"));
}
set_gdbarch_breakpoint_from_pc (gdbarch, hppa_breakpoint_from_pc);
hppa_objfile_priv_data = register_objfile_data ();
add_cmd ("unwind", class_maintenance, unwind_command,
- "Print unwind table entry at given address.",
+ _("Print unwind table entry at given address."),
&maintenanceprintlist);
/* Debug this files internals. */
- add_setshow_boolean_cmd ("hppa", class_maintenance, &hppa_debug, "\
-Set whether hppa target specific debugging information should be displayed.", "\
-Show whether hppa target specific debugging information is displayed.", "\
+ add_setshow_boolean_cmd ("hppa", class_maintenance, &hppa_debug, _("\
+Set whether hppa target specific debugging information should be displayed."),
+ _("\
+Show whether hppa target specific debugging information is displayed."), _("\
This flag controls whether hppa target specific debugging information is\n\
displayed. This information is particularly useful for debugging frame\n\
-unwinding problems.", "hppa debug flag is %s.",
- NULL, NULL, &setdebuglist, &showdebuglist);
+unwinding problems."),
+ NULL,
+ NULL, /* FIXME: i18n: hppa debug flag is %s. */
+ &setdebuglist, &showdebuglist);
}