/* Target-dependent code for GNU/Linux running on PA-RISC, for GDB.
- Copyright (C) 2004, 2006, 2007, 2008, 2009, 2010, 2011
- Free Software Foundation, Inc.
+ Copyright (C) 2004-2020 Free Software Foundation, Inc.
This file is part of GDB.
hppa_dwarf_reg_to_regnum (struct gdbarch *gdbarch, int reg)
{
/* The general registers and the sar are the same in both sets. */
- if (reg <= 32)
+ if (reg >= 0 && reg <= 32)
return reg;
/* fr4-fr31 (left and right halves) are mapped from 72. */
if (reg >= 72 && reg <= 72 + 28 * 2)
return HPPA_FP4_REGNUM + (reg - 72);
- warning (_("Unmapped DWARF DBX Register #%d encountered."), reg);
return -1;
}
for (i = 0; pattern[i].mask; i++)
{
- char buf[4];
+ gdb_byte buf[4];
target_read_memory (npc, buf, 4);
insn[i] = extract_unsigned_integer (buf, 4, byte_order);
{
unsigned int dummy[HPPA_MAX_INSN_PATTERN_LEN];
int offs = 0;
- int try;
+ int attempt;
/* offsets to try to find the trampoline */
static int pcoffs[] = { 0, 4*4, 5*4 };
/* offsets to the rt_sigframe structure */
e4008200 be,l 0x100(%sr2, %r0), %sr0, %r31
08000240 nop */
- for (try = 0; try < ARRAY_SIZE (pcoffs); try++)
+ for (attempt = 0; attempt < ARRAY_SIZE (pcoffs); attempt++)
{
- if (insns_match_pattern (gdbarch, sp + pcoffs[try],
+ if (insns_match_pattern (gdbarch, sp + pcoffs[attempt],
hppa_sigtramp, dummy))
{
- offs = sfoffs[try];
+ offs = sfoffs[attempt];
break;
}
}
/* sigaltstack case: we have no way of knowing which offset to
use in this case; default to new kernel handling. If this is
wrong the unwinding will fail. */
- try = 2;
- sp = pc - pcoffs[try];
+ attempt = 2;
+ sp = pc - pcoffs[attempt];
}
else
{
bad we cannot include system specific headers :-(.
sizeof(struct siginfo) == 128
offsetof(struct ucontext, uc_mcontext) == 24. */
- return sp + sfoffs[try] + 128 + 24;
+ return sp + sfoffs[attempt] + 128 + 24;
}
struct hppa_linux_sigtramp_unwind_cache
int i;
if (*this_cache)
- return *this_cache;
+ return (struct hppa_linux_sigtramp_unwind_cache *) *this_cache;
info = FRAME_OBSTACK_ZALLOC (struct hppa_linux_sigtramp_unwind_cache);
*this_cache = info;
if (faddr & 2)
{
int status;
- char buf[4];
+ gdb_byte buf[4];
faddr &= ~3;
/* If the address is in the plt section, then the real function hasn't
yet been fixed up by the linker so we cannot determine the gp of
that function. */
- if (in_plt_section (faddr, NULL))
+ if (in_plt_section (faddr))
return 0;
faddr_sect = find_pc_section (faddr);
{
int status;
LONGEST tag;
- char buf[4];
+ gdb_byte buf[4];
status = target_read_memory (addr, buf, sizeof (buf));
if (status != 0)
* cr10, cr15
*/
-#define GR_REGNUM(_n) (HPPA_R0_REGNUM+_n)
-#define TR_REGNUM(_n) (HPPA_TR0_REGNUM+_n)
-static const int greg_map[] =
+static const struct regcache_map_entry hppa_linux_gregmap[] =
{
- GR_REGNUM(0), GR_REGNUM(1), GR_REGNUM(2), GR_REGNUM(3),
- GR_REGNUM(4), GR_REGNUM(5), GR_REGNUM(6), GR_REGNUM(7),
- GR_REGNUM(8), GR_REGNUM(9), GR_REGNUM(10), GR_REGNUM(11),
- GR_REGNUM(12), GR_REGNUM(13), GR_REGNUM(14), GR_REGNUM(15),
- GR_REGNUM(16), GR_REGNUM(17), GR_REGNUM(18), GR_REGNUM(19),
- GR_REGNUM(20), GR_REGNUM(21), GR_REGNUM(22), GR_REGNUM(23),
- GR_REGNUM(24), GR_REGNUM(25), GR_REGNUM(26), GR_REGNUM(27),
- GR_REGNUM(28), GR_REGNUM(29), GR_REGNUM(30), GR_REGNUM(31),
-
- HPPA_SR4_REGNUM+1, HPPA_SR4_REGNUM+2, HPPA_SR4_REGNUM+3, HPPA_SR4_REGNUM+4,
- HPPA_SR4_REGNUM, HPPA_SR4_REGNUM+5, HPPA_SR4_REGNUM+6, HPPA_SR4_REGNUM+7,
-
- HPPA_PCOQ_HEAD_REGNUM, HPPA_PCOQ_TAIL_REGNUM,
- HPPA_PCSQ_HEAD_REGNUM, HPPA_PCSQ_TAIL_REGNUM,
-
- HPPA_SAR_REGNUM, HPPA_IIR_REGNUM, HPPA_ISR_REGNUM, HPPA_IOR_REGNUM,
- HPPA_IPSW_REGNUM, HPPA_RCR_REGNUM,
-
- TR_REGNUM(0), TR_REGNUM(1), TR_REGNUM(2), TR_REGNUM(3),
- TR_REGNUM(4), TR_REGNUM(5), TR_REGNUM(6), TR_REGNUM(7),
-
- HPPA_PID0_REGNUM, HPPA_PID1_REGNUM, HPPA_PID2_REGNUM, HPPA_PID3_REGNUM,
- HPPA_CCR_REGNUM, HPPA_EIEM_REGNUM,
+ { 32, HPPA_R0_REGNUM },
+ { 1, HPPA_SR4_REGNUM+1 },
+ { 1, HPPA_SR4_REGNUM+2 },
+ { 1, HPPA_SR4_REGNUM+3 },
+ { 1, HPPA_SR4_REGNUM+4 },
+ { 1, HPPA_SR4_REGNUM },
+ { 1, HPPA_SR4_REGNUM+5 },
+ { 1, HPPA_SR4_REGNUM+6 },
+ { 1, HPPA_SR4_REGNUM+7 },
+ { 1, HPPA_PCOQ_HEAD_REGNUM },
+ { 1, HPPA_PCOQ_TAIL_REGNUM },
+ { 1, HPPA_PCSQ_HEAD_REGNUM },
+ { 1, HPPA_PCSQ_TAIL_REGNUM },
+ { 1, HPPA_SAR_REGNUM },
+ { 1, HPPA_IIR_REGNUM },
+ { 1, HPPA_ISR_REGNUM },
+ { 1, HPPA_IOR_REGNUM },
+ { 1, HPPA_IPSW_REGNUM },
+ { 1, HPPA_RCR_REGNUM },
+ { 8, HPPA_TR0_REGNUM },
+ { 4, HPPA_PID0_REGNUM },
+ { 1, HPPA_CCR_REGNUM },
+ { 1, HPPA_EIEM_REGNUM },
+ { 0 }
};
-static void
-hppa_linux_supply_regset (const struct regset *regset,
- struct regcache *regcache,
- int regnum, const void *regs, size_t len)
-{
- struct gdbarch *arch = get_regcache_arch (regcache);
- struct gdbarch_tdep *tdep = gdbarch_tdep (arch);
- const char *buf = regs;
- int i, offset;
-
- offset = 0;
- for (i = 0; i < ARRAY_SIZE (greg_map); i++)
- {
- if (regnum == greg_map[i] || regnum == -1)
- regcache_raw_supply (regcache, greg_map[i], buf + offset);
-
- offset += tdep->bytes_per_address;
- }
-}
-
-static void
-hppa_linux_supply_fpregset (const struct regset *regset,
- struct regcache *regcache,
- int regnum, const void *regs, size_t len)
-{
- const char *buf = regs;
- int i, offset;
-
- offset = 0;
- for (i = 0; i < 64; i++)
- {
- if (regnum == HPPA_FP0_REGNUM + i || regnum == -1)
- regcache_raw_supply (regcache, HPPA_FP0_REGNUM + i,
- buf + offset);
- offset += 4;
- }
-}
+static const struct regcache_map_entry hppa_linux_fpregmap[] =
+ {
+ /* FIXME: Only works for 32-bit mode. In 64-bit mode there should
+ be 32 fpregs, 8 bytes each. */
+ { 64, HPPA_FP0_REGNUM, 4 },
+ { 0 }
+ };
/* HPPA Linux kernel register set. */
-static struct regset hppa_linux_regset =
+static const struct regset hppa_linux_regset =
{
- NULL,
- hppa_linux_supply_regset
+ hppa_linux_gregmap,
+ regcache_supply_regset, regcache_collect_regset
};
-static struct regset hppa_linux_fpregset =
+static const struct regset hppa_linux_fpregset =
{
- NULL,
- hppa_linux_supply_fpregset
+ hppa_linux_fpregmap,
+ regcache_supply_regset, regcache_collect_regset
};
-static const struct regset *
-hppa_linux_regset_from_core_section (struct gdbarch *gdbarch,
- const char *sect_name,
- size_t sect_size)
+static void
+hppa_linux_iterate_over_regset_sections (struct gdbarch *gdbarch,
+ iterate_over_regset_sections_cb *cb,
+ void *cb_data,
+ const struct regcache *regcache)
{
- if (strcmp (sect_name, ".reg") == 0)
- return &hppa_linux_regset;
- else if (strcmp (sect_name, ".reg2") == 0)
- return &hppa_linux_fpregset;
+ struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
- return NULL;
+ cb (".reg", 80 * tdep->bytes_per_address, 80 * tdep->bytes_per_address,
+ &hppa_linux_regset, NULL, cb_data);
+ cb (".reg2", 64 * 4, 64 * 4, &hppa_linux_fpregset, NULL, cb_data);
}
-\f
-
-/* Forward declarations. */
-extern initialize_file_ftype _initialize_hppa_linux_tdep;
static void
hppa_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
some discussions to support 128-bit long double, but it requires some
more work in gcc and glibc first. */
set_gdbarch_long_double_bit (gdbarch, 64);
+ set_gdbarch_long_double_format (gdbarch, floatformats_ieee_double);
- set_gdbarch_regset_from_core_section
- (gdbarch, hppa_linux_regset_from_core_section);
+ set_gdbarch_iterate_over_regset_sections
+ (gdbarch, hppa_linux_iterate_over_regset_sections);
set_gdbarch_dwarf2_reg_to_regnum (gdbarch, hppa_dwarf_reg_to_regnum);