/* Target-dependent code for the HP PA-RISC architecture.
- Copyright (C) 1986-2019 Free Software Foundation, Inc.
+ Copyright (C) 1986-2021 Free Software Foundation, Inc.
Contributed by the Center for Software Science at the
University of Utah (pa-gdb-bugs@cs.utah.edu).
#include "hppa-tdep.h"
#include <algorithm>
-static int hppa_debug = 0;
+static bool hppa_debug = false;
/* Some local constants. */
static const int hppa32_num_regs = 128;
that separately and make this static. The solib data is probably hpux-
specific, so we can create a separate extern objfile_data that is registered
by hppa-hpux-tdep.c and shared with pa64solib.c and somsolib.c. */
-static const struct objfile_data *hppa_objfile_priv_data = NULL;
+static const struct objfile_key<hppa_objfile_private,
+ gdb::noop_deleter<hppa_objfile_private>>
+ hppa_objfile_priv_data;
-/* Get at various relevent fields of an instruction word. */
+/* Get at various relevant fields of an instruction word. */
#define MASK_5 0x1f
#define MASK_11 0x7ff
#define MASK_14 0x3fff
hppa_objfile_private *priv
= OBSTACK_ZALLOC (&objfile->objfile_obstack, hppa_objfile_private);
- set_objfile_data (objfile, hppa_objfile_priv_data, priv);
+ hppa_objfile_priv_data.set (objfile, priv);
return priv;
}
CORE_ADDR *low_text_segment_address = (CORE_ADDR *)data;
if (value < *low_text_segment_address)
- *low_text_segment_address = value;
+ *low_text_segment_address = value;
}
}
if (size > 0)
{
- struct gdbarch *gdbarch = get_objfile_arch (objfile);
+ struct gdbarch *gdbarch = objfile->arch ();
unsigned long tmp;
unsigned i;
char *buf = (char *) alloca (size);
passed in. */
if (gdbarch_tdep (gdbarch)->is_elf && text_offset == 0)
{
- low_text_segment_address = -1;
+ low_text_segment_address = -1;
bfd_map_over_sections (objfile->obfd,
record_text_segment_lowaddr,
text_offset = low_text_segment_address;
}
else if (gdbarch_tdep (gdbarch)->solib_get_text_base)
- {
+ {
text_offset = gdbarch_tdep (gdbarch)->solib_get_text_base (objfile);
}
bfd_get_section_contents (objfile->obfd, section, buf, 0, size);
/* Now internalize the information being careful to handle host/target
- endian issues. */
+ endian issues. */
for (i = 0; i < entries; i++)
{
table[i].region_start = bfd_get_32 (objfile->obfd,
struct hppa_unwind_info *ui;
struct hppa_objfile_private *obj_private;
- text_offset = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
+ text_offset = objfile->text_section_offset ();
ui = (struct hppa_unwind_info *) obstack_alloc (&objfile->objfile_obstack,
sizeof (struct hppa_unwind_info));
/* For reasons unknown the HP PA64 tools generate multiple unwinder
sections in a single executable. So we just iterate over every
- section in the BFD looking for unwinder sections intead of trying
+ section in the BFD looking for unwinder sections instead of trying
to do a lookup with bfd_get_section_by_name.
First determine the total size of the unwind tables so that we
if (strcmp (unwind_sec->name, "$UNWIND_START$") == 0
|| strcmp (unwind_sec->name, ".PARISC.unwind") == 0)
{
- unwind_size = bfd_section_size (objfile->obfd, unwind_sec);
+ unwind_size = bfd_section_size (unwind_sec);
unwind_entries = unwind_size / UNWIND_ENTRY_SIZE;
total_entries += unwind_entries;
if (stub_unwind_sec)
{
- stub_unwind_size = bfd_section_size (objfile->obfd, stub_unwind_sec);
+ stub_unwind_size = bfd_section_size (stub_unwind_sec);
stub_entries = stub_unwind_size / STUB_UNWIND_ENTRY_SIZE;
}
else
if (strcmp (unwind_sec->name, "$UNWIND_START$") == 0
|| strcmp (unwind_sec->name, ".PARISC.unwind") == 0)
{
- unwind_size = bfd_section_size (objfile->obfd, unwind_sec);
+ unwind_size = bfd_section_size (unwind_sec);
unwind_entries = unwind_size / UNWIND_ENTRY_SIZE;
internalize_unwinds (objfile, &ui->table[index], unwind_sec,
compare_unwind_entries);
/* Keep a pointer to the unwind information. */
- obj_private = (struct hppa_objfile_private *)
- objfile_data (objfile, hppa_objfile_priv_data);
+ obj_private = hppa_objfile_priv_data.get (objfile);
if (obj_private == NULL)
obj_private = hppa_init_objfile_priv_data (objfile);
if (hppa_debug)
fprintf_unfiltered (gdb_stdlog, "{ find_unwind_entry %s -> ",
- hex_string (pc));
+ hex_string (pc));
/* A function at address 0? Not in HP-UX! */
if (pc == (CORE_ADDR) 0)
{
struct hppa_unwind_info *ui;
ui = NULL;
- priv = ((struct hppa_objfile_private *)
- objfile_data (objfile, hppa_objfile_priv_data));
+ priv = hppa_objfile_priv_data.get (objfile);
if (priv)
ui = ((struct hppa_objfile_private *) priv)->unwind_info;
if (!ui)
{
read_unwind_info (objfile);
- priv = ((struct hppa_objfile_private *)
- objfile_data (objfile, hppa_objfile_priv_data));
+ priv = hppa_objfile_priv_data.get (objfile);
if (priv == NULL)
error (_("Internal error reading unwind information."));
ui = ((struct hppa_objfile_private *) priv)->unwind_info;
{
CORE_ADDR struct_ptr = 0;
/* The first parameter goes into sp-36, each stack slot is 4-bytes.
- struct_ptr is adjusted for each argument below, so the first
+ struct_ptr is adjusted for each argument below, so the first
argument will end up at sp-36. */
CORE_ADDR param_ptr = 32;
int i;
store_unsigned_integer (param_val, 4, byte_order,
struct_end - struct_ptr);
}
- else if (TYPE_CODE (type) == TYPE_CODE_INT
- || TYPE_CODE (type) == TYPE_CODE_ENUM)
+ else if (type->code () == TYPE_CODE_INT
+ || type->code () == TYPE_CODE_ENUM)
{
/* Integer value store, right aligned. "unpack_long"
takes care of any sign-extension problems. */
unpack_long (type,
value_contents (arg)));
}
- else if (TYPE_CODE (type) == TYPE_CODE_FLT)
- {
+ else if (type->code () == TYPE_CODE_FLT)
+ {
/* Floating point value store, right aligned. */
param_len = align_up (TYPE_LENGTH (type), 4);
memcpy (param_val, value_contents (arg), param_len);
- }
+ }
else
{
param_len = align_up (TYPE_LENGTH (type), 4);
value_contents (arg), TYPE_LENGTH (type));
/* Structures of size 5, 6 and 7 bytes are special in that
- the higher-ordered word is stored in the lower-ordered
+ the higher-ordered word is stored in the lower-ordered
argument, and even though it is a 8-byte quantity the
registers need not be 8-byte aligned. */
if (param_len > 4 && param_len < 8)
param_ptr += param_len;
if (param_len == 8 && !small_struct)
- param_ptr = align_up (param_ptr, 8);
+ param_ptr = align_up (param_ptr, 8);
/* First 4 non-FP arguments are passed in gr26-gr23.
First 4 32-bit FP arguments are passed in fr4L-fr7L.
static int
hppa64_integral_or_pointer_p (const struct type *type)
{
- switch (TYPE_CODE (type))
+ switch (type->code ())
{
case TYPE_CODE_INT:
case TYPE_CODE_BOOL:
static int
hppa64_floating_p (const struct type *type)
{
- switch (TYPE_CODE (type))
+ switch (type->code ())
{
case TYPE_CODE_FLT:
{
if (hppa64_integral_or_pointer_p (type))
{
/* "Integral scalar parameters smaller than 64 bits are
- padded on the left (i.e., the value is in the
- least-significant bits of the 64-bit storage unit, and
- the high-order bits are undefined)." Therefore we can
- safely sign-extend them. */
+ padded on the left (i.e., the value is in the
+ least-significant bits of the 64-bit storage unit, and
+ the high-order bits are undefined)." Therefore we can
+ safely sign-extend them. */
if (len < 8)
{
arg = value_cast (builtin_type (gdbarch)->builtin_int64, arg);
offset = align_up (offset, 16);
/* "Double-extended- and quad-precision floating-point
- parameters within the first 64 bytes of the parameter
- list are always passed in general registers." */
+ parameters within the first 64 bytes of the parameter
+ list are always passed in general registers." */
}
else
{
}
/* "Single- and double-precision floating-point
- parameters in this area are passed according to the
- available formal parameter information in a function
- prototype. [...] If no prototype is in scope,
- floating-point parameters must be passed both in the
- corresponding general registers and in the
- corresponding floating-point registers." */
+ parameters in this area are passed according to the
+ available formal parameter information in a function
+ prototype. [...] If no prototype is in scope,
+ floating-point parameters must be passed both in the
+ corresponding general registers and in the
+ corresponding floating-point registers." */
regnum = HPPA64_FP4_REGNUM + offset / 8;
if (regnum < HPPA64_FP4_REGNUM + 8)
}
/* If we are passing a function pointer, make sure we pass a function
- descriptor instead of the function entry address. */
- if (TYPE_CODE (type) == TYPE_CODE_PTR
- && TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_FUNC)
- {
+ descriptor instead of the function entry address. */
+ if (type->code () == TYPE_CODE_PTR
+ && TYPE_TARGET_TYPE (type)->code () == TYPE_CODE_FUNC)
+ {
ULONGEST codeptr, fptr;
codeptr = unpack_long (type, value_contents (arg));
valbuf = fptrbuf;
}
else
- {
- valbuf = value_contents (arg);
+ {
+ valbuf = value_contents (arg);
}
/* Always store the argument in memory. */
/* The value always lives in the right hand end of the register
(or register pair)? */
int b;
- int reg = TYPE_CODE (type) == TYPE_CODE_FLT ? HPPA_FP4_REGNUM : 28;
+ int reg = type->code () == TYPE_CODE_FLT ? HPPA_FP4_REGNUM : 28;
int part = TYPE_LENGTH (type) % 4;
/* The left hand register contains only part of the value,
transfer that first so that the rest can be xfered as entire
if (len > 16)
{
- /* All return values larget than 128 bits must be aggregate
- return values. */
+ /* All return values larger than 128 bits must be aggregate
+ return values. */
gdb_assert (!hppa64_integral_or_pointer_p (type));
gdb_assert (!hppa64_floating_p (type));
if (hppa64_integral_or_pointer_p (type))
{
/* "Integral return values are returned in GR 28. Values
- smaller than 64 bits are padded on the left (with garbage)." */
+ smaller than 64 bits are padded on the left (with garbage)." */
regnum = HPPA_RET0_REGNUM;
offset = 8 - len;
}
else
{
/* "Aggregate return values up to 64 bits in size are returned
- in GR 28. Aggregates smaller than 64 bits are left aligned
- in the register; the pad bits on the right are undefined."
+ in GR 28. Aggregates smaller than 64 bits are left aligned
+ in the register; the pad bits on the right are undefined."
"Aggregate return values between 65 and 128 bits are returned
in GRs 28 and 29. The first 64 bits are placed in GR 28, and
return align_up (addr, 16);
}
-CORE_ADDR
+static CORE_ADDR
hppa_read_pc (readable_regcache *regcache)
{
ULONGEST ipsw;
the general registers are:
Store: stb, sth, stw, std (according to Chapter 7, they
- are only in both "inst >> 26" and "inst >> 6".
+ are only in both "inst >> 26" and "inst >> 6".
Store Absolute: stwa, stda (according to Chapter 7, they are only
- in "inst >> 6".
+ in "inst >> 6".
Store Bytes: stby, stdby (according to Chapter 7, they are
- only in "inst >> 6").
+ only in "inst >> 6").
For (inst >> 26), according to Chapter 7:
- stw: 0x1a, store a word from a general register.
- stwm: 0x1b, store a word from a general register and perform base
- register modification (2.0 will still treate it as stw).
+ register modification (2.0 will still treat it as stw).
- std: 0x1c, store a doubleword from a general register (2.0 only).
For unoptimized GCC code and for any HP CC code this will never ever
examine any user instructions.
- For optimzied GCC code we're faced with problems. GCC will schedule
+ For optimized GCC code we're faced with problems. GCC will schedule
its prologue and make prologue instructions available for delay slot
filling. The end result is user code gets mixed in with the prologue
and a prologue instruction may be in the delay slot of the first branch
unsigned long old_save_rp, old_save_sp, next_inst;
/* Save copies of all the triggers so we can compare them later
- (only for HPC). */
+ (only for HPC). */
old_save_gr = save_gr;
old_save_fr = save_fr;
old_save_rp = save_rp;
save_rp = 0;
/* These are the only ways we save SP into the stack. At this time
- the HP compilers never bother to save SP into the stack. */
+ the HP compilers never bother to save SP into the stack. */
if ((inst & 0xffffc000) == 0x6fc10000
|| (inst & 0xffffc00c) == 0x73c10008)
save_sp = 0;
/* Are we loading some register with an offset from the argument
- pointer? */
+ pointer? */
if ((inst & 0xffe00000) == 0x37a00000
|| (inst & 0xffffffe0) == 0x081d0240)
{
save_gr &= ~(1 << reg_num);
/* Ugh. Also account for argument stores into the stack.
- Unfortunately args_stored only tells us that some arguments
- where stored into the stack. Not how many or what kind!
+ Unfortunately args_stored only tells us that some arguments
+ where stored into the stack. Not how many or what kind!
- This is a kludge as on the HP compiler sets this bit and it
- never does prologue scheduling. So once we see one, skip past
- all of them. We have similar code for the fp arg stores below.
+ This is a kludge as on the HP compiler sets this bit and it
+ never does prologue scheduling. So once we see one, skip past
+ all of them. We have similar code for the fp arg stores below.
- FIXME. Can still die if we have a mix of GR and FR argument
- stores! */
+ FIXME. Can still die if we have a mix of GR and FR argument
+ stores! */
if (reg_num >= (gdbarch_ptr_bit (gdbarch) == 64 ? 19 : 23)
&& reg_num <= 26)
{
return pc;
/* We've got to be read to handle the ldo before the fp register
- save. */
+ save. */
if ((inst & 0xfc000000) == 0x34000000
&& inst_saves_fr (next_inst) >= 4
&& inst_saves_fr (next_inst)
}
/* Ugh. Also account for argument stores into the stack.
- This is a kludge as on the HP compiler sets this bit and it
- never does prologue scheduling. So once we see one, skip past
- all of them. */
+ This is a kludge as on the HP compiler sets this bit and it
+ never does prologue scheduling. So once we see one, skip past
+ all of them. */
if (reg_num >= 4
&& reg_num <= (gdbarch_ptr_bit (gdbarch) == 64 ? 11 : 7))
{
}
/* Quit if we hit any kind of branch. This can happen if a prologue
- instruction is in the delay slot of the first call/branch. */
+ instruction is in the delay slot of the first call/branch. */
if (is_branch (inst) && stop_before_branch)
break;
/* What a crock. The HP compilers set args_stored even if no
- arguments were stored into the stack (boo hiss). This could
- cause this code to then skip a bunch of user insns (up to the
- first branch).
-
- To combat this we try to identify when args_stored was bogusly
- set and clear it. We only do this when args_stored is nonzero,
- all other resources are accounted for, and nothing changed on
- this pass. */
+ arguments were stored into the stack (boo hiss). This could
+ cause this code to then skip a bunch of user insns (up to the
+ first branch).
+
+ To combat this we try to identify when args_stored was bogusly
+ set and clear it. We only do this when args_stored is nonzero,
+ all other resources are accounted for, and nothing changed on
+ this pass. */
if (args_stored
&& !(save_gr || save_fr || save_rp || save_sp || stack_remaining > 0)
&& old_save_gr == save_gr && old_save_fr == save_fr
pc += 4;
/* !stop_before_branch, so also look at the insn in the delay slot
- of the branch. */
+ of the branch. */
if (final_iteration)
break;
if (is_branch (inst))
final_iteration = 1;
}
- /* We've got a tenative location for the end of the prologue. However
+ /* We've got a tentative location for the end of the prologue. However
because of limitations in the unwind descriptor mechanism we may
have went too far into user code looking for the save of a register
that does not exist. So, if there registers we expected to be saved
struct hppa_frame_cache
{
CORE_ADDR base;
- struct trad_frame_saved_reg *saved_regs;
+ trad_frame_saved_reg *saved_regs;
};
static struct hppa_frame_cache *
if ((*this_cache) != NULL)
{
if (hppa_debug)
- fprintf_unfiltered (gdb_stdlog, "base=%s (cached) }",
- paddress (gdbarch, ((struct hppa_frame_cache *)*this_cache)->base));
+ fprintf_unfiltered (gdb_stdlog, "base=%s (cached) }",
+ paddress (gdbarch, ((struct hppa_frame_cache *)*this_cache)->base));
return (struct hppa_frame_cache *) (*this_cache);
}
cache = FRAME_OBSTACK_ZALLOC (struct hppa_frame_cache);
if (!u)
{
if (hppa_debug)
- fprintf_unfiltered (gdb_stdlog, "base=NULL (no unwind entry) }");
+ fprintf_unfiltered (gdb_stdlog, "base=NULL (no unwind entry) }");
return (struct hppa_frame_cache *) (*this_cache);
}
gdb_byte buf4[4];
long inst;
- if (!safe_frame_unwind_memory (this_frame, pc, buf4, sizeof buf4))
+ if (!safe_frame_unwind_memory (this_frame, pc, buf4))
{
error (_("Cannot read instruction at %s."),
paddress (gdbarch, pc));
if (inst == 0x6bc23fd9) /* stw rp,-0x14(sr0,sp) */
{
looking_for_rp = 0;
- cache->saved_regs[HPPA_RP_REGNUM].addr = -20;
+ cache->saved_regs[HPPA_RP_REGNUM].set_addr (-20);
}
else if (inst == 0x6bc23fd1) /* stw rp,-0x18(sr0,sp) */
{
looking_for_rp = 0;
- cache->saved_regs[HPPA_RP_REGNUM].addr = -24;
+ cache->saved_regs[HPPA_RP_REGNUM].set_addr (-24);
}
else if (inst == 0x0fc212c1
- || inst == 0x73c23fe1) /* std rp,-0x10(sr0,sp) */
+ || inst == 0x73c23fe1) /* std rp,-0x10(sr0,sp) */
{
looking_for_rp = 0;
- cache->saved_regs[HPPA_RP_REGNUM].addr = -16;
+ cache->saved_regs[HPPA_RP_REGNUM].set_addr (-16);
}
/* Check to see if we saved SP into the stack. This also
|| (inst & 0xffffc00c) == 0x73c10008) /* std,ma r1,N(sr0,sp) */
{
looking_for_sp = 0;
- cache->saved_regs[HPPA_FP_REGNUM].addr = 0;
+ cache->saved_regs[HPPA_FP_REGNUM].set_addr (0);
}
else if (inst == 0x08030241) /* copy %r3, %r1 */
{
if ((inst >> 26) == 0x1b && hppa_extract_14 (inst) >= 0)
/* stwm with a positive displacement is a _post_
_modify_. */
- cache->saved_regs[reg].addr = 0;
+ cache->saved_regs[reg].set_addr (0);
else if ((inst & 0xfc00000c) == 0x70000008)
/* A std has explicit post_modify forms. */
- cache->saved_regs[reg].addr = 0;
+ cache->saved_regs[reg].set_addr (0);
else
{
CORE_ADDR offset;
/* Handle code with and without frame pointers. */
if (u->Save_SP)
- cache->saved_regs[reg].addr = offset;
+ cache->saved_regs[reg].set_addr (offset);
else
- cache->saved_regs[reg].addr
- = (u->Total_frame_size << 3) + offset;
+ cache->saved_regs[reg].set_addr ((u->Total_frame_size << 3)
+ + offset);
}
}
/* 1st HP CC FP register store. After this
instruction we've set enough state that the GCC and
HPCC code are both handled in the same manner. */
- cache->saved_regs[reg + HPPA_FP4_REGNUM + 4].addr = 0;
+ cache->saved_regs[reg + HPPA_FP4_REGNUM + 4].set_addr (0);
fp_loc = 8;
}
else
{
- cache->saved_regs[reg + HPPA_FP0_REGNUM + 4].addr = fp_loc;
+ cache->saved_regs[reg + HPPA_FP0_REGNUM + 4].set_addr (fp_loc);
fp_loc += 8;
}
}
the current function (and is thus equivalent to the "saved"
stack pointer. */
CORE_ADDR this_sp = get_frame_register_unsigned (this_frame,
- HPPA_SP_REGNUM);
+ HPPA_SP_REGNUM);
CORE_ADDR fp;
if (hppa_debug)
fprintf_unfiltered (gdb_stdlog, " (this_sp=%s, pc=%s, "
- "prologue_end=%s) ",
- paddress (gdbarch, this_sp),
+ "prologue_end=%s) ",
+ paddress (gdbarch, this_sp),
paddress (gdbarch, get_frame_pc (this_frame)),
paddress (gdbarch, prologue_end));
/* Check to see if a frame pointer is available, and use it for
- frame unwinding if it is.
+ frame unwinding if it is.
- There are some situations where we need to rely on the frame
- pointer to do stack unwinding. For example, if a function calls
- alloca (), the stack pointer can get adjusted inside the body of
- the function. In this case, the ABI requires that the compiler
- maintain a frame pointer for the function.
+ There are some situations where we need to rely on the frame
+ pointer to do stack unwinding. For example, if a function calls
+ alloca (), the stack pointer can get adjusted inside the body of
+ the function. In this case, the ABI requires that the compiler
+ maintain a frame pointer for the function.
- The unwind record has a flag (alloca_frame) that indicates that
- a function has a variable frame; unfortunately, gcc/binutils
- does not set this flag. Instead, whenever a frame pointer is used
- and saved on the stack, the Save_SP flag is set. We use this to
- decide whether to use the frame pointer for unwinding.
+ The unwind record has a flag (alloca_frame) that indicates that
+ a function has a variable frame; unfortunately, gcc/binutils
+ does not set this flag. Instead, whenever a frame pointer is used
+ and saved on the stack, the Save_SP flag is set. We use this to
+ decide whether to use the frame pointer for unwinding.
- TODO: For the HP compiler, maybe we should use the alloca_frame flag
+ TODO: For the HP compiler, maybe we should use the alloca_frame flag
instead of Save_SP. */
fp = get_frame_register_unsigned (this_frame, HPPA_FP_REGNUM);
fp -= u->Total_frame_size << 3;
if (get_frame_pc (this_frame) >= prologue_end
- && (u->Save_SP || u->alloca_frame) && fp != 0)
+ && (u->Save_SP || u->alloca_frame) && fp != 0)
{
cache->base = fp;
paddress (gdbarch, cache->base));
}
else if (u->Save_SP
- && trad_frame_addr_p (cache->saved_regs, HPPA_SP_REGNUM))
+ && cache->saved_regs[HPPA_SP_REGNUM].is_addr ())
{
- /* Both we're expecting the SP to be saved and the SP has been
+ /* Both we're expecting the SP to be saved and the SP has been
saved. The entry SP value is saved at this frame's SP
address. */
- cache->base = read_memory_integer (this_sp, word_size, byte_order);
+ cache->base = read_memory_integer (this_sp, word_size, byte_order);
if (hppa_debug)
fprintf_unfiltered (gdb_stdlog, " (base=%s) [saved]",
- paddress (gdbarch, cache->base));
+ paddress (gdbarch, cache->base));
}
else
{
- /* The prologue has been slowly allocating stack space. Adjust
+ /* The prologue has been slowly allocating stack space. Adjust
the SP back. */
- cache->base = this_sp - frame_size;
+ cache->base = this_sp - frame_size;
if (hppa_debug)
fprintf_unfiltered (gdb_stdlog, " (base=%s) [unwind adjust]",
paddress (gdbarch, cache->base));
}
- trad_frame_set_value (cache->saved_regs, HPPA_SP_REGNUM, cache->base);
+ cache->saved_regs[HPPA_SP_REGNUM].set_value (cache->base);
}
/* The PC is found in the "return register", "Millicode" uses "r31"
as the return register while normal code uses "rp". */
if (u->Millicode)
{
- if (trad_frame_addr_p (cache->saved_regs, 31))
- {
- cache->saved_regs[HPPA_PCOQ_HEAD_REGNUM] = cache->saved_regs[31];
+ if (cache->saved_regs[31].is_addr ())
+ {
+ cache->saved_regs[HPPA_PCOQ_HEAD_REGNUM] = cache->saved_regs[31];
if (hppa_debug)
fprintf_unfiltered (gdb_stdlog, " (pc=r31) [stack] } ");
- }
+ }
else
{
ULONGEST r31 = get_frame_register_unsigned (this_frame, 31);
- trad_frame_set_value (cache->saved_regs, HPPA_PCOQ_HEAD_REGNUM, r31);
+ cache->saved_regs[HPPA_PCOQ_HEAD_REGNUM].set_value (r31);
if (hppa_debug)
fprintf_unfiltered (gdb_stdlog, " (pc=r31) [frame] } ");
- }
+ }
}
else
{
- if (trad_frame_addr_p (cache->saved_regs, HPPA_RP_REGNUM))
- {
- cache->saved_regs[HPPA_PCOQ_HEAD_REGNUM] =
+ if (cache->saved_regs[HPPA_RP_REGNUM].is_addr ())
+ {
+ cache->saved_regs[HPPA_PCOQ_HEAD_REGNUM] =
cache->saved_regs[HPPA_RP_REGNUM];
if (hppa_debug)
fprintf_unfiltered (gdb_stdlog, " (pc=rp) [stack] } ");
- }
+ }
else
{
ULONGEST rp = get_frame_register_unsigned (this_frame,
- HPPA_RP_REGNUM);
- trad_frame_set_value (cache->saved_regs, HPPA_PCOQ_HEAD_REGNUM, rp);
+ HPPA_RP_REGNUM);
+ cache->saved_regs[HPPA_PCOQ_HEAD_REGNUM].set_value (rp);
if (hppa_debug)
fprintf_unfiltered (gdb_stdlog, " (pc=rp) [frame] } ");
}
on the stack, but it's been overwritten. The prologue analyzer will
set fp_in_r1 when it sees the copy insn so we know to get the value
from r1 instead. */
- if (u->Save_SP && !trad_frame_addr_p (cache->saved_regs, HPPA_FP_REGNUM)
+ if (u->Save_SP && !cache->saved_regs[HPPA_FP_REGNUM].is_addr ()
&& fp_in_r1)
{
ULONGEST r1 = get_frame_register_unsigned (this_frame, 1);
- trad_frame_set_value (cache->saved_regs, HPPA_FP_REGNUM, r1);
+ cache->saved_regs[HPPA_FP_REGNUM].set_value (r1);
}
{
int reg;
for (reg = 0; reg < gdbarch_num_regs (gdbarch); reg++)
{
- if (trad_frame_addr_p (cache->saved_regs, reg))
- cache->saved_regs[reg].addr += cache->base;
+ if (cache->saved_regs[reg].is_addr ())
+ cache->saved_regs[reg].set_addr (cache->saved_regs[reg].addr ()
+ + cache->base);
}
}
static int
hppa_frame_unwind_sniffer (const struct frame_unwind *self,
- struct frame_info *this_frame, void **this_cache)
+ struct frame_info *this_frame, void **this_cache)
{
if (hppa_find_unwind_entry_in_block (this_frame))
return 1;
stack. */
if (insn == 0x6bc23fd9) /* stw rp,-0x14(sr0,sp) */
{
- cache->saved_regs[HPPA_RP_REGNUM].addr = -20;
+ cache->saved_regs[HPPA_RP_REGNUM].set_addr (-20);
found_rp = 1;
}
else if (insn == 0x0fc212c1
- || insn == 0x73c23fe1) /* std rp,-0x10(sr0,sp) */
+ || insn == 0x73c23fe1) /* std rp,-0x10(sr0,sp) */
{
- cache->saved_regs[HPPA_RP_REGNUM].addr = -16;
+ cache->saved_regs[HPPA_RP_REGNUM].set_addr (-16);
found_rp = 1;
}
}
cache->base = get_frame_register_unsigned (this_frame, HPPA_SP_REGNUM);
cache->base -= frame_size;
- trad_frame_set_value (cache->saved_regs, HPPA_SP_REGNUM, cache->base);
+ cache->saved_regs[HPPA_SP_REGNUM].set_value (cache->base);
- if (trad_frame_addr_p (cache->saved_regs, HPPA_RP_REGNUM))
+ if (cache->saved_regs[HPPA_RP_REGNUM].is_addr ())
{
- cache->saved_regs[HPPA_RP_REGNUM].addr += cache->base;
+ cache->saved_regs[HPPA_RP_REGNUM].set_addr (cache->saved_regs[HPPA_RP_REGNUM].addr ()
+ + cache->base);
cache->saved_regs[HPPA_PCOQ_HEAD_REGNUM] =
cache->saved_regs[HPPA_RP_REGNUM];
}
{
ULONGEST rp;
rp = get_frame_register_unsigned (this_frame, HPPA_RP_REGNUM);
- trad_frame_set_value (cache->saved_regs, HPPA_PCOQ_HEAD_REGNUM, rp);
+ cache->saved_regs[HPPA_PCOQ_HEAD_REGNUM].set_value (rp);
}
return cache;
static struct value *
hppa_fallback_frame_prev_register (struct frame_info *this_frame,
- void **this_cache, int regnum)
+ void **this_cache, int regnum)
{
struct hppa_frame_cache *info
= hppa_fallback_frame_cache (this_frame, this_cache);
struct hppa_stub_unwind_cache
{
CORE_ADDR base;
- struct trad_frame_saved_reg *saved_regs;
+ trad_frame_saved_reg *saved_regs;
};
static struct hppa_stub_unwind_cache *
info->base = get_frame_register_unsigned (this_frame, HPPA_SP_REGNUM);
/* By default we assume that stubs do not change the rp. */
- info->saved_regs[HPPA_PCOQ_HEAD_REGNUM].realreg = HPPA_RP_REGNUM;
+ info->saved_regs[HPPA_PCOQ_HEAD_REGNUM].set_realreg (HPPA_RP_REGNUM);
return info;
}
static int
hppa_stub_unwind_sniffer (const struct frame_unwind *self,
- struct frame_info *this_frame,
- void **this_cache)
+ struct frame_info *this_frame,
+ void **this_cache)
{
CORE_ADDR pc = get_frame_address_in_block (this_frame);
struct gdbarch *gdbarch = get_frame_arch (this_frame);
hppa_stub_unwind_sniffer
};
-static struct frame_id
-hppa_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
-{
- return frame_id_build (get_frame_register_unsigned (this_frame,
- HPPA_SP_REGNUM),
- get_frame_pc (this_frame));
-}
-
CORE_ADDR
hppa_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
{
struct bound_minimal_symbol
hppa_lookup_stub_minimal_symbol (const char *name,
- enum unwind_stub_types stub_type)
+ enum unwind_stub_types stub_type)
{
struct bound_minimal_symbol result = { NULL, NULL };
{
for (minimal_symbol *msym : objfile->msymbols ())
{
- if (strcmp (MSYMBOL_LINKAGE_NAME (msym), name) == 0)
+ if (strcmp (msym->linkage_name (), name) == 0)
{
struct unwind_table_entry *u;
printf_unfiltered ("unwind_table_entry (%s):\n", host_address_to_string (u));
printf_unfiltered ("\tregion_start = %s\n", hex_string (u->region_start));
- gdb_flush (gdb_stdout);
printf_unfiltered ("\tregion_end = %s\n", hex_string (u->region_end));
- gdb_flush (gdb_stdout);
#define pif(FLD) if (u->FLD) printf_unfiltered (" "#FLD);
{
printf_unfiltered ("\tstub type = ");
switch (u->stub_unwind.stub_type)
- {
+ {
case LONG_BRANCH:
printf_unfiltered ("long branch\n");
break;
hppa32_cannot_store_register (struct gdbarch *gdbarch, int regnum)
{
return (regnum == 0
- || regnum == HPPA_PCSQ_HEAD_REGNUM
- || (regnum >= HPPA_PCSQ_TAIL_REGNUM && regnum < HPPA_IPSW_REGNUM)
- || (regnum > HPPA_IPSW_REGNUM && regnum < HPPA_FP4_REGNUM));
+ || regnum == HPPA_PCSQ_HEAD_REGNUM
+ || (regnum >= HPPA_PCSQ_TAIL_REGNUM && regnum < HPPA_IPSW_REGNUM)
+ || (regnum > HPPA_IPSW_REGNUM && regnum < HPPA_FP4_REGNUM));
}
static int
hppa64_cannot_store_register (struct gdbarch *gdbarch, int regnum)
{
return (regnum == 0
- || regnum == HPPA_PCSQ_HEAD_REGNUM
- || (regnum >= HPPA_PCSQ_TAIL_REGNUM && regnum < HPPA_IPSW_REGNUM)
- || (regnum > HPPA_IPSW_REGNUM && regnum < HPPA64_FP4_REGNUM));
+ || regnum == HPPA_PCSQ_HEAD_REGNUM
+ || (regnum >= HPPA_PCSQ_TAIL_REGNUM && regnum < HPPA_IPSW_REGNUM)
+ || (regnum > HPPA_IPSW_REGNUM && regnum < HPPA64_FP4_REGNUM));
}
static int
struct value *
hppa_frame_prev_register_helper (struct frame_info *this_frame,
- struct trad_frame_saved_reg saved_regs[],
+ trad_frame_saved_reg saved_regs[],
int regnum)
{
struct gdbarch *arch = get_frame_arch (this_frame);
int size = register_size (arch, HPPA_PCOQ_HEAD_REGNUM);
CORE_ADDR pc;
struct value *pcoq_val =
- trad_frame_get_prev_register (this_frame, saved_regs,
- HPPA_PCOQ_HEAD_REGNUM);
+ trad_frame_get_prev_register (this_frame, saved_regs,
+ HPPA_PCOQ_HEAD_REGNUM);
pc = extract_unsigned_integer (value_contents_all (pcoq_val),
size, byte_order);
target_read_memory (npc, buf, HPPA_INSN_SIZE);
insn[i] = extract_unsigned_integer (buf, HPPA_INSN_SIZE, byte_order);
if ((insn[i] & pattern[i].mask) == pattern[i].data)
- npc += 4;
+ npc += 4;
else
- return 0;
+ return 0;
}
return 1;
}
-/* This relaxed version of the insstruction matcher allows us to match
+/* This relaxed version of the instruction matcher allows us to match
from somewhere inside the pattern, by looking backwards in the
instruction scheme. */
pc = hppa_extract_21 (insn[0]) + hppa_extract_14 (insn[1]);
if (dp_rel)
- pc += get_frame_register_unsigned (frame, HPPA_DP_REGNUM);
+ pc += get_frame_register_unsigned (frame, HPPA_DP_REGNUM);
else
- pc += get_frame_register_unsigned (frame, HPPA_R0_REGNUM + 19);
+ pc += get_frame_register_unsigned (frame, HPPA_R0_REGNUM + 19);
/* fallthrough */
}
pc = read_memory_typed_address (pc, func_ptr_type);
/* If the PLT slot has not yet been resolved, the target will be
- the PLT stub. */
+ the PLT stub. */
if (in_plt_section (pc))
{
/* Sanity check: are we pointing to the PLT stub? */
switch (tdep->bytes_per_address)
{
case 4:
- set_gdbarch_num_regs (gdbarch, hppa32_num_regs);
- set_gdbarch_register_name (gdbarch, hppa32_register_name);
- set_gdbarch_register_type (gdbarch, hppa32_register_type);
+ set_gdbarch_num_regs (gdbarch, hppa32_num_regs);
+ set_gdbarch_register_name (gdbarch, hppa32_register_name);
+ set_gdbarch_register_type (gdbarch, hppa32_register_type);
set_gdbarch_cannot_store_register (gdbarch,
hppa32_cannot_store_register);
set_gdbarch_cannot_fetch_register (gdbarch,
hppa32_cannot_fetch_register);
- break;
+ break;
case 8:
- set_gdbarch_num_regs (gdbarch, hppa64_num_regs);
- set_gdbarch_register_name (gdbarch, hppa64_register_name);
- set_gdbarch_register_type (gdbarch, hppa64_register_type);
- set_gdbarch_dwarf2_reg_to_regnum (gdbarch, hppa64_dwarf_reg_to_regnum);
+ set_gdbarch_num_regs (gdbarch, hppa64_num_regs);
+ set_gdbarch_register_name (gdbarch, hppa64_register_name);
+ set_gdbarch_register_type (gdbarch, hppa64_register_type);
+ set_gdbarch_dwarf2_reg_to_regnum (gdbarch, hppa64_dwarf_reg_to_regnum);
set_gdbarch_cannot_store_register (gdbarch,
hppa64_cannot_store_register);
set_gdbarch_cannot_fetch_register (gdbarch,
hppa64_cannot_fetch_register);
- break;
+ break;
default:
- internal_error (__FILE__, __LINE__, _("Unsupported address size: %d"),
- tdep->bytes_per_address);
+ internal_error (__FILE__, __LINE__, _("Unsupported address size: %d"),
+ tdep->bytes_per_address);
}
set_gdbarch_long_bit (gdbarch, tdep->bytes_per_address * TARGET_CHAR_BIT);
set_gdbarch_push_dummy_call (gdbarch, hppa32_push_dummy_call);
set_gdbarch_frame_align (gdbarch, hppa32_frame_align);
set_gdbarch_convert_from_func_ptr_addr
- (gdbarch, hppa32_convert_from_func_ptr_addr);
+ (gdbarch, hppa32_convert_from_func_ptr_addr);
break;
case 8:
set_gdbarch_push_dummy_call (gdbarch, hppa64_push_dummy_call);
set_gdbarch_pseudo_register_read (gdbarch, hppa_pseudo_register_read);
/* Frame unwind methods. */
- set_gdbarch_dummy_id (gdbarch, hppa_dummy_id);
set_gdbarch_unwind_pc (gdbarch, hppa_unwind_pc);
/* Hook in ABI-specific overrides, if they have been registered. */
struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
fprintf_unfiltered (file, "bytes_per_address = %d\n",
- tdep->bytes_per_address);
+ tdep->bytes_per_address);
fprintf_unfiltered (file, "elf = %s\n", tdep->is_elf ? "yes" : "no");
}
+void _initialize_hppa_tdep ();
void
-_initialize_hppa_tdep (void)
+_initialize_hppa_tdep ()
{
gdbarch_register (bfd_arch_hppa, hppa_gdbarch_init, hppa_dump_tdep);
- hppa_objfile_priv_data = register_objfile_data ();
-
add_cmd ("unwind", class_maintenance, unwind_command,
_("Print unwind table entry at given address."),
&maintenanceprintlist);