/* Target-dependent code for the HP PA-RISC architecture.
- Copyright (C) 1986-2021 Free Software Foundation, Inc.
+ Copyright (C) 1986-2022 Free Software Foundation, Inc.
Contributed by the Center for Software Science at the
University of Utah (pa-gdb-bugs@cs.utah.edu).
struct hppa_objfile_private
{
- struct hppa_unwind_info *unwind_info; /* a pointer */
- struct so_list *so_info; /* a pointer */
- CORE_ADDR dp;
+ struct hppa_unwind_info *unwind_info = nullptr; /* a pointer */
+ struct so_list *so_info = nullptr; /* a pointer */
+ CORE_ADDR dp = 0;
- int dummy_call_sequence_reg;
- CORE_ADDR dummy_call_sequence_addr;
+ int dummy_call_sequence_reg = 0;
+ CORE_ADDR dummy_call_sequence_addr = 0;
};
/* hppa-specific object data -- unwind and solib info.
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_key<hppa_objfile_private,
- gdb::noop_deleter<hppa_objfile_private>>
- hppa_objfile_priv_data;
+static const struct objfile_key<hppa_objfile_private> hppa_objfile_priv_data;
/* Get at various relevant fields of an instruction word. */
#define MASK_5 0x1f
return (CORE_ADDR)-1;
}
-static struct hppa_objfile_private *
-hppa_init_objfile_priv_data (struct objfile *objfile)
-{
- hppa_objfile_private *priv
- = OBSTACK_ZALLOC (&objfile->objfile_obstack, hppa_objfile_private);
-
- hppa_objfile_priv_data.set (objfile, priv);
-
- return priv;
-}
\f
/* Compare the start address for two unwind entries returning 1 if
if (size > 0)
{
struct gdbarch *gdbarch = objfile->arch ();
+ hppa_gdbarch_tdep *tdep = (hppa_gdbarch_tdep *) gdbarch_tdep (gdbarch);
unsigned long tmp;
unsigned i;
char *buf = (char *) alloca (size);
Note that when loading a shared library (text_offset != 0) the
unwinds are already relative to the text_offset that will be
passed in. */
- if (gdbarch_tdep (gdbarch)->is_elf && text_offset == 0)
+ if (tdep->is_elf && text_offset == 0)
{
low_text_segment_address = -1;
text_offset = low_text_segment_address;
}
- else if (gdbarch_tdep (gdbarch)->solib_get_text_base)
+ else if (tdep->solib_get_text_base)
{
- text_offset = gdbarch_tdep (gdbarch)->solib_get_text_base (objfile);
+ text_offset = tdep->solib_get_text_base (objfile);
}
bfd_get_section_contents (objfile->obfd, section, buf, 0, size);
/* Keep a pointer to the unwind information. */
obj_private = hppa_objfile_priv_data.get (objfile);
if (obj_private == NULL)
- obj_private = hppa_init_objfile_priv_data (objfile);
+ obj_private = hppa_objfile_priv_data.emplace (objfile);
obj_private->unwind_info = ui;
}
find_unwind_entry (CORE_ADDR pc)
{
int first, middle, last;
- struct hppa_objfile_private *priv;
if (hppa_debug)
- fprintf_unfiltered (gdb_stdlog, "{ find_unwind_entry %s -> ",
- hex_string (pc));
+ gdb_printf (gdb_stdlog, "{ find_unwind_entry %s -> ",
+ hex_string (pc));
/* A function at address 0? Not in HP-UX! */
if (pc == (CORE_ADDR) 0)
{
if (hppa_debug)
- fprintf_unfiltered (gdb_stdlog, "NULL }\n");
+ gdb_printf (gdb_stdlog, "NULL }\n");
return NULL;
}
{
struct hppa_unwind_info *ui;
ui = NULL;
- priv = hppa_objfile_priv_data.get (objfile);
+ struct hppa_objfile_private *priv = hppa_objfile_priv_data.get (objfile);
if (priv)
- ui = ((struct hppa_objfile_private *) priv)->unwind_info;
+ ui = priv->unwind_info;
if (!ui)
{
priv = hppa_objfile_priv_data.get (objfile);
if (priv == NULL)
error (_("Internal error reading unwind information."));
- ui = ((struct hppa_objfile_private *) priv)->unwind_info;
+ ui = priv->unwind_info;
}
/* First, check the cache. */
&& pc <= ui->cache->region_end)
{
if (hppa_debug)
- fprintf_unfiltered (gdb_stdlog, "%s (cached) }\n",
- hex_string ((uintptr_t) ui->cache));
+ gdb_printf (gdb_stdlog, "%s (cached) }\n",
+ hex_string ((uintptr_t) ui->cache));
return ui->cache;
}
{
ui->cache = &ui->table[middle];
if (hppa_debug)
- fprintf_unfiltered (gdb_stdlog, "%s }\n",
- hex_string ((uintptr_t) ui->cache));
+ gdb_printf (gdb_stdlog, "%s }\n",
+ hex_string ((uintptr_t) ui->cache));
return &ui->table[middle];
}
}
if (hppa_debug)
- fprintf_unfiltered (gdb_stdlog, "NULL (not found) }\n");
+ gdb_printf (gdb_stdlog, "NULL (not found) }\n");
return NULL;
}
/* Global pointer (r19) of the function we are trying to call. */
CORE_ADDR gp;
- struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
+ hppa_gdbarch_tdep *tdep = (hppa_gdbarch_tdep *) gdbarch_tdep (gdbarch);
for (write_pass = 0; write_pass < 2; write_pass++)
{
param_len = 4;
struct_ptr += align_up (TYPE_LENGTH (type), 8);
if (write_pass)
- write_memory (struct_end - struct_ptr, value_contents (arg),
- TYPE_LENGTH (type));
+ write_memory (struct_end - struct_ptr,
+ value_contents (arg).data (), TYPE_LENGTH (type));
store_unsigned_integer (param_val, 4, byte_order,
struct_end - struct_ptr);
}
/* Integer value store, right aligned. "unpack_long"
takes care of any sign-extension problems. */
param_len = align_up (TYPE_LENGTH (type), 4);
- store_unsigned_integer (param_val, param_len, byte_order,
- unpack_long (type,
- value_contents (arg)));
+ store_unsigned_integer
+ (param_val, param_len, byte_order,
+ unpack_long (type, value_contents (arg).data ()));
}
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);
+ memcpy (param_val, value_contents (arg).data (), param_len);
}
else
{
/* Small struct value are stored right-aligned. */
memcpy (param_val + param_len - TYPE_LENGTH (type),
- value_contents (arg), TYPE_LENGTH (type));
+ value_contents (arg).data (), 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
if (opd < sec->objfile->sections_end)
{
- CORE_ADDR addr;
-
- for (addr = obj_section_addr (opd);
- addr < obj_section_endaddr (opd);
- addr += 2 * 8)
+ for (CORE_ADDR addr = opd->addr (); addr < opd->endaddr (); addr += 2 * 8)
{
ULONGEST opdaddr;
gdb_byte tmp[8];
function_call_return_method return_method,
CORE_ADDR struct_addr)
{
- struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
+ hppa_gdbarch_tdep *tdep = (hppa_gdbarch_tdep *) gdbarch_tdep (gdbarch);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
int i, offset = 0;
CORE_ADDR gp;
the right halves of the floating point registers;
the left halves are unused." */
regcache->cooked_write_part (regnum, offset % 8, len,
- value_contents (arg));
+ value_contents (arg).data ());
}
}
}
{
ULONGEST codeptr, fptr;
- codeptr = unpack_long (type, value_contents (arg));
+ codeptr = unpack_long (type, value_contents (arg).data ());
fptr = hppa64_convert_code_addr_to_fptr (gdbarch, codeptr);
store_unsigned_integer (fptrbuf, TYPE_LENGTH (type), byte_order,
fptr);
}
else
{
- valbuf = value_contents (arg);
+ valbuf = value_contents (arg).data ();
}
/* Always store the argument in memory. */
int i;
if (hppa_debug)
- fprintf_unfiltered (gdb_stdlog, "{ hppa_frame_cache (frame=%d) -> ",
- frame_relative_level(this_frame));
+ gdb_printf (gdb_stdlog, "{ hppa_frame_cache (frame=%d) -> ",
+ frame_relative_level(this_frame));
if ((*this_cache) != NULL)
{
if (hppa_debug)
- fprintf_unfiltered (gdb_stdlog, "base=%s (cached) }",
- paddress (gdbarch, ((struct hppa_frame_cache *)*this_cache)->base));
+ gdb_printf (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) }");
+ gdb_printf (gdb_stdlog, "base=NULL (no unwind entry) }");
return (struct hppa_frame_cache *) (*this_cache);
}
CORE_ADDR fp;
if (hppa_debug)
- fprintf_unfiltered (gdb_stdlog, " (this_sp=%s, pc=%s, "
- "prologue_end=%s) ",
- paddress (gdbarch, this_sp),
- paddress (gdbarch, get_frame_pc (this_frame)),
- paddress (gdbarch, prologue_end));
+ gdb_printf (gdb_stdlog, " (this_sp=%s, pc=%s, "
+ "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.
if (get_frame_pc (this_frame) >= prologue_end
&& (u->Save_SP || u->alloca_frame) && fp != 0)
{
- cache->base = fp;
+ cache->base = fp;
- if (hppa_debug)
- fprintf_unfiltered (gdb_stdlog, " (base=%s) [frame pointer]",
- paddress (gdbarch, cache->base));
+ if (hppa_debug)
+ gdb_printf (gdb_stdlog, " (base=%s) [frame pointer]",
+ paddress (gdbarch, cache->base));
}
else if (u->Save_SP
&& cache->saved_regs[HPPA_SP_REGNUM].is_addr ())
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));
+ gdb_printf (gdb_stdlog, " (base=%s) [saved]",
+ paddress (gdbarch, cache->base));
}
- else
+ else
{
/* The prologue has been slowly allocating stack space. Adjust
the SP back. */
cache->base = this_sp - frame_size;
if (hppa_debug)
- fprintf_unfiltered (gdb_stdlog, " (base=%s) [unwind adjust]",
- paddress (gdbarch, cache->base));
+ gdb_printf (gdb_stdlog, " (base=%s) [unwind adjust]",
+ paddress (gdbarch, cache->base));
}
cache->saved_regs[HPPA_SP_REGNUM].set_value (cache->base);
{
cache->saved_regs[HPPA_PCOQ_HEAD_REGNUM] = cache->saved_regs[31];
if (hppa_debug)
- fprintf_unfiltered (gdb_stdlog, " (pc=r31) [stack] } ");
+ gdb_printf (gdb_stdlog, " (pc=r31) [stack] } ");
}
else
{
ULONGEST r31 = get_frame_register_unsigned (this_frame, 31);
cache->saved_regs[HPPA_PCOQ_HEAD_REGNUM].set_value (r31);
if (hppa_debug)
- fprintf_unfiltered (gdb_stdlog, " (pc=r31) [frame] } ");
+ gdb_printf (gdb_stdlog, " (pc=r31) [frame] } ");
}
}
else
cache->saved_regs[HPPA_PCOQ_HEAD_REGNUM] =
cache->saved_regs[HPPA_RP_REGNUM];
if (hppa_debug)
- fprintf_unfiltered (gdb_stdlog, " (pc=rp) [stack] } ");
+ gdb_printf (gdb_stdlog, " (pc=rp) [stack] } ");
}
else
{
HPPA_RP_REGNUM);
cache->saved_regs[HPPA_PCOQ_HEAD_REGNUM].set_value (rp);
if (hppa_debug)
- fprintf_unfiltered (gdb_stdlog, " (pc=rp) [frame] } ");
+ gdb_printf (gdb_stdlog, " (pc=rp) [frame] } ");
}
}
}
{
- struct gdbarch_tdep *tdep;
-
- tdep = gdbarch_tdep (gdbarch);
+ hppa_gdbarch_tdep *tdep = (hppa_gdbarch_tdep *) gdbarch_tdep (gdbarch);
if (tdep->unwind_adjust_stub)
tdep->unwind_adjust_stub (this_frame, cache->base, cache->saved_regs);
}
if (hppa_debug)
- fprintf_unfiltered (gdb_stdlog, "base=%s }",
- paddress (gdbarch, ((struct hppa_frame_cache *)*this_cache)->base));
+ gdb_printf (gdb_stdlog, "base=%s }",
+ paddress (gdbarch, ((struct hppa_frame_cache *)*this_cache)->base));
return (struct hppa_frame_cache *) (*this_cache);
}
static const struct frame_unwind hppa_frame_unwind =
{
+ "hppa unwind table",
NORMAL_FRAME,
default_frame_unwind_stop_reason,
hppa_frame_this_id,
CORE_ADDR start_pc;
if (hppa_debug)
- fprintf_unfiltered (gdb_stdlog,
- "{ hppa_fallback_frame_cache (frame=%d) -> ",
- frame_relative_level (this_frame));
+ gdb_printf (gdb_stdlog,
+ "{ hppa_fallback_frame_cache (frame=%d) -> ",
+ frame_relative_level (this_frame));
cache = FRAME_OBSTACK_ZALLOC (struct hppa_frame_cache);
(*this_cache) = cache;
}
if (hppa_debug)
- fprintf_unfiltered (gdb_stdlog, " frame_size=%d, found_rp=%d }\n",
- frame_size, found_rp);
+ gdb_printf (gdb_stdlog, " frame_size=%d, found_rp=%d }\n",
+ frame_size, found_rp);
cache->base = get_frame_register_unsigned (this_frame, HPPA_SP_REGNUM);
cache->base -= frame_size;
static const struct frame_unwind hppa_fallback_frame_unwind =
{
+ "hppa prologue",
NORMAL_FRAME,
default_frame_unwind_stop_reason,
hppa_fallback_frame_this_id,
{
CORE_ADDR pc = get_frame_address_in_block (this_frame);
struct gdbarch *gdbarch = get_frame_arch (this_frame);
- struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
+ hppa_gdbarch_tdep *tdep = (hppa_gdbarch_tdep *) gdbarch_tdep (gdbarch);
if (pc == 0
|| (tdep->in_solib_call_trampoline != NULL
}
static const struct frame_unwind hppa_stub_frame_unwind = {
+ "hppa stub",
NORMAL_FRAME,
default_frame_unwind_stop_reason,
hppa_stub_frame_this_id,
hppa_lookup_stub_minimal_symbol (const char *name,
enum unwind_stub_types stub_type)
{
- struct bound_minimal_symbol result = { NULL, NULL };
+ struct bound_minimal_symbol result;
for (objfile *objfile : current_program_space->objfiles ())
{
if (!u)
{
- printf_unfiltered ("Can't find unwind table entry for %s\n", exp);
+ gdb_printf ("Can't find unwind table entry for %s\n", exp);
return;
}
- printf_unfiltered ("unwind_table_entry (%s):\n", host_address_to_string (u));
+ gdb_printf ("unwind_table_entry (%s):\n", host_address_to_string (u));
- printf_unfiltered ("\tregion_start = %s\n", hex_string (u->region_start));
+ gdb_printf ("\tregion_start = %s\n", hex_string (u->region_start));
- printf_unfiltered ("\tregion_end = %s\n", hex_string (u->region_end));
+ gdb_printf ("\tregion_end = %s\n", hex_string (u->region_end));
-#define pif(FLD) if (u->FLD) printf_unfiltered (" "#FLD);
+#define pif(FLD) if (u->FLD) gdb_printf (" "#FLD);
- printf_unfiltered ("\n\tflags =");
+ gdb_printf ("\n\tflags =");
pif (Cannot_unwind);
pif (Millicode);
pif (Millicode_save_sr0);
pif (Large_frame);
pif (alloca_frame);
- putchar_unfiltered ('\n');
+ gdb_putc ('\n');
-#define pin(FLD) printf_unfiltered ("\t"#FLD" = 0x%x\n", u->FLD);
+#define pin(FLD) gdb_printf ("\t"#FLD" = 0x%x\n", u->FLD);
pin (Region_description);
pin (Entry_FR);
if (u->stub_unwind.stub_type)
{
- printf_unfiltered ("\tstub type = ");
+ gdb_printf ("\tstub type = ");
switch (u->stub_unwind.stub_type)
{
case LONG_BRANCH:
- printf_unfiltered ("long branch\n");
+ gdb_printf ("long branch\n");
break;
case PARAMETER_RELOCATION:
- printf_unfiltered ("parameter relocation\n");
+ gdb_printf ("parameter relocation\n");
break;
case EXPORT:
- printf_unfiltered ("export\n");
+ gdb_printf ("export\n");
break;
case IMPORT:
- printf_unfiltered ("import\n");
+ gdb_printf ("import\n");
break;
case IMPORT_SHLIB:
- printf_unfiltered ("import shlib\n");
+ gdb_printf ("import shlib\n");
break;
default:
- printf_unfiltered ("unknown (%d)\n", u->stub_unwind.stub_type);
+ gdb_printf ("unknown (%d)\n", u->stub_unwind.stub_type);
}
}
}
trad_frame_get_prev_register (this_frame, saved_regs,
HPPA_PCOQ_HEAD_REGNUM);
- pc = extract_unsigned_integer (value_contents_all (pcoq_val),
+ pc = extract_unsigned_integer (value_contents_all (pcoq_val).data (),
size, byte_order);
return frame_unwind_got_constant (this_frame, regnum, pc + 4);
}
if (in_plt_section (pc))
{
/* Sanity check: are we pointing to the PLT stub? */
- if (!hppa_match_insns (gdbarch, pc, hppa_plt_stub, insn))
+ if (!hppa_match_insns (gdbarch, pc, hppa_plt_stub, insn))
{
warning (_("Cannot resolve PLT stub at %s."),
paddress (gdbarch, pc));
static struct gdbarch *
hppa_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
{
- struct gdbarch_tdep *tdep;
struct gdbarch *gdbarch;
/* find a candidate among the list of pre-declared architectures. */
return (arches->gdbarch);
/* If none found, then allocate and initialize one. */
- tdep = XCNEW (struct gdbarch_tdep);
+ hppa_gdbarch_tdep *tdep = new hppa_gdbarch_tdep;
gdbarch = gdbarch_alloc (&info, tdep);
/* Determine from the bfd_arch_info structure if we are dealing with
and LP64, but might show differences some day. */
set_gdbarch_long_long_bit (gdbarch, 64);
set_gdbarch_long_double_bit (gdbarch, 128);
- set_gdbarch_long_double_format (gdbarch, floatformats_ia64_quad);
+ set_gdbarch_long_double_format (gdbarch, floatformats_ieee_quad);
/* The following gdbarch vector elements do not depend on the address
size, or in any other gdbarch element previously set. */
static void
hppa_dump_tdep (struct gdbarch *gdbarch, struct ui_file *file)
{
- struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
+ hppa_gdbarch_tdep *tdep = (hppa_gdbarch_tdep *) gdbarch_tdep (gdbarch);
- fprintf_unfiltered (file, "bytes_per_address = %d\n",
- tdep->bytes_per_address);
- fprintf_unfiltered (file, "elf = %s\n", tdep->is_elf ? "yes" : "no");
+ gdb_printf (file, "bytes_per_address = %d\n",
+ tdep->bytes_per_address);
+ gdb_printf (file, "elf = %s\n", tdep->is_elf ? "yes" : "no");
}
void _initialize_hppa_tdep ();