/* Target-dependent code for the HP PA-RISC architecture.
- Copyright (C) 1986-2017 Free Software Foundation, Inc.
+ Copyright (C) 1986-2020 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
static struct hppa_objfile_private *
hppa_init_objfile_priv_data (struct objfile *objfile)
{
- struct hppa_objfile_private *priv;
+ hppa_objfile_private *priv
+ = OBSTACK_ZALLOC (&objfile->objfile_obstack, hppa_objfile_private);
- priv = (struct hppa_objfile_private *)
- obstack_alloc (&objfile->objfile_obstack,
- sizeof (struct hppa_objfile_private));
- set_objfile_data (objfile, hppa_objfile_priv_data, priv);
- memset (priv, 0, sizeof (*priv));
+ hppa_objfile_priv_data.set (objfile, priv);
return priv;
}
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);
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);
find_unwind_entry (CORE_ADDR pc)
{
int first, middle, last;
- struct objfile *objfile;
struct hppa_objfile_private *priv;
if (hppa_debug)
return NULL;
}
- ALL_OBJFILES (objfile)
- {
- struct hppa_unwind_info *ui;
- ui = NULL;
- priv = ((struct hppa_objfile_private *)
- objfile_data (objfile, hppa_objfile_priv_data));
- 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));
- if (priv == NULL)
- error (_("Internal error reading unwind information."));
- ui = ((struct hppa_objfile_private *) priv)->unwind_info;
- }
+ for (objfile *objfile : current_program_space->objfiles ())
+ {
+ struct hppa_unwind_info *ui;
+ ui = NULL;
+ priv = hppa_objfile_priv_data.get (objfile);
+ if (priv)
+ ui = ((struct hppa_objfile_private *) priv)->unwind_info;
- /* First, check the cache. */
+ if (!ui)
+ {
+ read_unwind_info (objfile);
+ priv = hppa_objfile_priv_data.get (objfile);
+ if (priv == NULL)
+ error (_("Internal error reading unwind information."));
+ ui = ((struct hppa_objfile_private *) priv)->unwind_info;
+ }
- if (ui->cache
- && pc >= ui->cache->region_start
- && pc <= ui->cache->region_end)
- {
- if (hppa_debug)
- fprintf_unfiltered (gdb_stdlog, "%s (cached) }\n",
- hex_string ((uintptr_t) ui->cache));
- return ui->cache;
- }
+ /* First, check the cache. */
+
+ if (ui->cache
+ && pc >= ui->cache->region_start
+ && pc <= ui->cache->region_end)
+ {
+ if (hppa_debug)
+ fprintf_unfiltered (gdb_stdlog, "%s (cached) }\n",
+ hex_string ((uintptr_t) ui->cache));
+ return ui->cache;
+ }
- /* Not in the cache, do a binary search. */
+ /* Not in the cache, do a binary search. */
- first = 0;
- last = ui->last;
+ first = 0;
+ last = ui->last;
- while (first <= last)
- {
- middle = (first + last) / 2;
- if (pc >= ui->table[middle].region_start
- && pc <= ui->table[middle].region_end)
- {
- ui->cache = &ui->table[middle];
- if (hppa_debug)
- fprintf_unfiltered (gdb_stdlog, "%s }\n",
- hex_string ((uintptr_t) ui->cache));
- return &ui->table[middle];
- }
+ while (first <= last)
+ {
+ middle = (first + last) / 2;
+ if (pc >= ui->table[middle].region_start
+ && pc <= ui->table[middle].region_end)
+ {
+ ui->cache = &ui->table[middle];
+ if (hppa_debug)
+ fprintf_unfiltered (gdb_stdlog, "%s }\n",
+ hex_string ((uintptr_t) ui->cache));
+ return &ui->table[middle];
+ }
- if (pc < ui->table[middle].region_start)
- last = middle - 1;
- else
- first = middle + 1;
- }
- } /* ALL_OBJFILES() */
+ if (pc < ui->table[middle].region_start)
+ last = middle - 1;
+ else
+ first = middle + 1;
+ }
+ }
if (hppa_debug)
fprintf_unfiltered (gdb_stdlog, "NULL (not found) }\n");
hppa32_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
struct regcache *regcache, CORE_ADDR bp_addr,
int nargs, struct value **args, CORE_ADDR sp,
- int struct_return, CORE_ADDR struct_addr)
+ function_call_return_method return_method,
+ CORE_ADDR struct_addr)
{
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
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);
int fpLreg = 72 + (param_ptr - 36) / 4 * 2;
int fpreg = 74 + (param_ptr - 32) / 8 * 4;
- regcache_cooked_write (regcache, grreg, param_val);
- regcache_cooked_write (regcache, fpLreg, param_val);
+ regcache->cooked_write (grreg, param_val);
+ regcache->cooked_write (fpLreg, param_val);
if (param_len > 4)
{
- regcache_cooked_write (regcache, grreg + 1,
- param_val + 4);
+ regcache->cooked_write (grreg + 1, param_val + 4);
- regcache_cooked_write (regcache, fpreg, param_val);
- regcache_cooked_write (regcache, fpreg + 1,
- param_val + 4);
+ regcache->cooked_write (fpreg, param_val);
+ regcache->cooked_write (fpreg + 1, param_val + 4);
}
}
}
/* If a structure has to be returned, set up register 28 to hold its
address. */
- if (struct_return)
+ if (return_method == return_method_struct)
regcache_cooked_write_unsigned (regcache, 28, struct_addr);
gp = tdep->find_global_pointer (gdbarch, function);
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:
{
hppa64_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
struct regcache *regcache, CORE_ADDR bp_addr,
int nargs, struct value **args, CORE_ADDR sp,
- int struct_return, CORE_ADDR struct_addr)
+ function_call_return_method return_method,
+ CORE_ADDR struct_addr)
{
struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
passed in floating-point registers, are passed in
the right halves of the floating point registers;
the left halves are unused." */
- regcache_cooked_write_part (regcache, regnum, offset % 8,
- len, value_contents (arg));
+ regcache->cooked_write_part (regnum, offset % 8, len,
+ value_contents (arg));
}
}
}
/* 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)
+ if (type->code () == TYPE_CODE_PTR
+ && TYPE_TARGET_TYPE (type)->code () == TYPE_CODE_FUNC)
{
ULONGEST codeptr, fptr;
regnum = HPPA_ARG0_REGNUM - offset / 8;
while (regnum > HPPA_ARG0_REGNUM - 8 && len > 0)
{
- regcache_cooked_write_part (regcache, regnum,
- offset % 8, std::min (len, 8), valbuf);
+ regcache->cooked_write_part (regnum, offset % 8, std::min (len, 8),
+ valbuf);
offset += std::min (len, 8);
valbuf += std::min (len, 8);
len -= std::min (len, 8);
/* If a structure has to be returned, set up GR 28 (%ret0) to hold
its address. */
- if (struct_return)
+ if (return_method == return_method_struct)
regcache_cooked_write_unsigned (regcache, HPPA_RET0_REGNUM, struct_addr);
/* Set up GR27 (%dp) to hold the global pointer (gp). */
/* 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 (part > 0)
{
if (readbuf != NULL)
- regcache_cooked_read_part (regcache, reg, 4 - part,
- part, readbuf);
+ regcache->cooked_read_part (reg, 4 - part, part, readbuf);
if (writebuf != NULL)
- regcache_cooked_write_part (regcache, reg, 4 - part,
- part, writebuf);
+ regcache->cooked_write_part (reg, 4 - part, part, writebuf);
reg++;
}
/* Now transfer the remaining register values. */
for (b = part; b < TYPE_LENGTH (type); b += 4)
{
if (readbuf != NULL)
- regcache_cooked_read (regcache, reg, readbuf + b);
+ regcache->cooked_read (reg, readbuf + b);
if (writebuf != NULL)
- regcache_cooked_write (regcache, reg, writebuf + b);
+ regcache->cooked_write (reg, writebuf + b);
reg++;
}
return RETURN_VALUE_REGISTER_CONVENTION;
if (len > 16)
{
- /* All return values larget than 128 bits must be aggregate
+ /* 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));
{
while (len > 0)
{
- regcache_cooked_read_part (regcache, regnum, offset,
- std::min (len, 8), readbuf);
+ regcache->cooked_read_part (regnum, offset, std::min (len, 8),
+ readbuf);
readbuf += std::min (len, 8);
len -= std::min (len, 8);
regnum++;
{
while (len > 0)
{
- regcache_cooked_write_part (regcache, regnum, offset,
- std::min (len, 8), writebuf);
+ regcache->cooked_write_part (regnum, offset, std::min (len, 8),
+ writebuf);
writebuf += std::min (len, 8);
len -= std::min (len, 8);
regnum++;
return align_up (addr, 16);
}
-CORE_ADDR
-hppa_read_pc (struct regcache *regcache)
+static CORE_ADDR
+hppa_read_pc (readable_regcache *regcache)
{
ULONGEST ipsw;
ULONGEST pc;
- regcache_cooked_read_unsigned (regcache, HPPA_IPSW_REGNUM, &ipsw);
- regcache_cooked_read_unsigned (regcache, HPPA_PCOQ_HEAD_REGNUM, &pc);
+ regcache->cooked_read (HPPA_IPSW_REGNUM, &ipsw);
+ regcache->cooked_read (HPPA_PCOQ_HEAD_REGNUM, &pc);
/* If the current instruction is nullified, then we are effectively
still executing the previous instruction. Pretend we are still
- 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
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
hppa_stub_frame_unwind_cache (struct frame_info *this_frame,
void **this_cache)
{
- struct gdbarch *gdbarch = get_frame_arch (this_frame);
struct hppa_stub_unwind_cache *info;
- struct unwind_table_entry *u;
if (*this_cache)
return (struct hppa_stub_unwind_cache *) *this_cache;
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)
{
hppa_lookup_stub_minimal_symbol (const char *name,
enum unwind_stub_types stub_type)
{
- struct objfile *objfile;
- struct minimal_symbol *msym;
struct bound_minimal_symbol result = { NULL, NULL };
- ALL_MSYMBOLS (objfile, msym)
+ for (objfile *objfile : current_program_space->objfiles ())
{
- if (strcmp (MSYMBOL_LINKAGE_NAME (msym), name) == 0)
- {
- struct unwind_table_entry *u;
-
- u = find_unwind_entry (MSYMBOL_VALUE (msym));
- if (u != NULL && u->stub_unwind.stub_type == stub_type)
+ for (minimal_symbol *msym : objfile->msymbols ())
+ {
+ if (strcmp (msym->linkage_name (), name) == 0)
{
- result.objfile = objfile;
- result.minsym = msym;
- return result;
+ struct unwind_table_entry *u;
+
+ u = find_unwind_entry (MSYMBOL_VALUE (msym));
+ if (u != NULL && u->stub_unwind.stub_type == stub_type)
+ {
+ result.objfile = objfile;
+ result.minsym = msym;
+ return result;
+ }
}
- }
+ }
}
return result;
}
static void
-unwind_command (char *exp, int from_tty)
+unwind_command (const char *exp, int from_tty)
{
CORE_ADDR address;
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);
}
static enum register_status
-hppa_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
+hppa_pseudo_register_read (struct gdbarch *gdbarch, readable_regcache *regcache,
int regnum, gdb_byte *buf)
{
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
ULONGEST tmp;
enum register_status status;
- status = regcache_raw_read_unsigned (regcache, regnum, &tmp);
+ status = regcache->raw_read (regnum, &tmp);
if (status == REG_VALID)
{
if (regnum == HPPA_PCOQ_HEAD_REGNUM || regnum == HPPA_PCOQ_TAIL_REGNUM)
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. */
/* Helper for function argument information. */
set_gdbarch_fetch_pointer_argument (gdbarch, hppa_fetch_pointer_argument);
- set_gdbarch_print_insn (gdbarch, print_insn_hppa);
-
/* When a hardware watchpoint triggers, we'll move the inferior past
it by removing all eventpoints; stepping past the instruction
that caused the trigger; reinserting eventpoints; and checking
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. */
fprintf_unfiltered (file, "elf = %s\n", tdep->is_elf ? "yes" : "no");
}
-/* Provide a prototype to silence -Wmissing-prototypes. */
-extern initialize_file_ftype _initialize_hppa_tdep;
-
+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);
projects / deliverable / binutils-gdb.git / blobdiff