/* Target-dependent code for the IA-64 for GDB, the GNU debugger.
- Copyright (C) 1999-2021 Free Software Foundation, Inc.
+ Copyright (C) 1999-2022 Free Software Foundation, Inc.
This file is part of GDB.
/* An enumeration of the different IA-64 instruction types. */
-typedef enum instruction_type
+enum ia64_instruction_type
{
A, /* Integer ALU ; I-unit or M-unit */
I, /* Non-ALU integer; I-unit */
L, /* Extended (L+X) ; I-unit */
X, /* Extended (L+X) ; I-unit */
undefined /* undefined or reserved */
-} instruction_type;
+};
/* We represent IA-64 PC addresses as the value of the instruction
pointer or'd with some bit combination in the low nibble which
static struct type *
ia64_ext_type (struct gdbarch *gdbarch)
{
- struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
+ ia64_gdbarch_tdep *tdep = (ia64_gdbarch_tdep *) gdbarch_tdep (gdbarch);
if (!tdep->ia64_ext_type)
tdep->ia64_ext_type
static int
ia64_register_reggroup_p (struct gdbarch *gdbarch, int regnum,
- struct reggroup *group)
+ const struct reggroup *group)
{
int vector_p;
int float_p;
replace_bit_field (bundle, instr, 5+41*slotnum, 41);
}
-static const enum instruction_type template_encoding_table[32][3] =
+static const enum ia64_instruction_type template_encoding_table[32][3] =
{
{ M, I, I }, /* 00 */
{ M, I, I }, /* 01 */
address of the next instruction to fetch. */
static CORE_ADDR
-fetch_instruction (CORE_ADDR addr, instruction_type *it, long long *instr)
+fetch_instruction (CORE_ADDR addr, ia64_instruction_type *it, long long *instr)
{
gdb_byte bundle[BUNDLE_LEN];
int slotnum = (int) (addr & 0x0f) / SLOT_MULTIPLIER;
{
CORE_ADDR next_pc;
CORE_ADDR last_prologue_pc = pc;
- instruction_type it;
+ ia64_instruction_type it;
long long instr;
int cfm_reg = 0;
int ret_reg = 0;
if (cache->base != 0)
(*this_id) = frame_id_build_special (cache->base, cache->pc, cache->bsp);
if (gdbarch_debug >= 1)
- fprintf_unfiltered (gdb_stdlog,
- "regular frame id: code %s, stack %s, "
- "special %s, this_frame %s\n",
- paddress (gdbarch, this_id->code_addr),
- paddress (gdbarch, this_id->stack_addr),
- paddress (gdbarch, cache->bsp),
- host_address_to_string (this_frame));
+ gdb_printf (gdb_stdlog,
+ "regular frame id: code %s, stack %s, "
+ "special %s, this_frame %s\n",
+ paddress (gdbarch, this_id->code_addr),
+ paddress (gdbarch, this_id->stack_addr),
+ paddress (gdbarch, cache->bsp),
+ host_address_to_string (this_frame));
}
static struct value *
that frame by adding the size of output:
(sof (size of frame) - sol (size of locals)). */
val = ia64_frame_prev_register (this_frame, this_cache, IA64_CFM_REGNUM);
- prev_cfm = extract_unsigned_integer (value_contents_all (val),
+ prev_cfm = extract_unsigned_integer (value_contents_all (val).data (),
8, byte_order);
bsp = rse_address_add (cache->bsp, -(cache->sof));
prev_bsp =
/* Adjust the register number to account for register rotation. */
regnum = VP16_REGNUM + ((regnum - VP16_REGNUM) + rrb_pr) % 48;
}
- prN = extract_bit_field (value_contents_all (pr_val),
+ prN = extract_bit_field (value_contents_all (pr_val).data (),
regnum - VP0_REGNUM, 1);
return frame_unwind_got_constant (this_frame, regnum, prN);
}
ULONGEST unatN;
unat_val = ia64_frame_prev_register (this_frame, this_cache,
IA64_UNAT_REGNUM);
- unatN = extract_bit_field (value_contents_all (unat_val),
+ unatN = extract_bit_field (value_contents_all (unat_val).data (),
regnum - IA64_NAT0_REGNUM, 1);
return frame_unwind_got_constant (this_frame, regnum, unatN);
}
regnum = IA64_GR32_REGNUM + (regnum - V32_REGNUM);
reg_val = ia64_frame_prev_register (this_frame, this_cache,
IA64_CFM_REGNUM);
- prev_cfm = extract_unsigned_integer (value_contents_all (reg_val),
- 8, byte_order);
+ prev_cfm = extract_unsigned_integer
+ (value_contents_all (reg_val).data (), 8, byte_order);
reg_val = ia64_frame_prev_register (this_frame, this_cache,
IA64_BSP_REGNUM);
- prev_bsp = extract_unsigned_integer (value_contents_all (reg_val),
- 8, byte_order);
+ prev_bsp = extract_unsigned_integer
+ (value_contents_all (reg_val).data (), 8, byte_order);
prev_bof = rse_address_add (prev_bsp, -(prev_cfm & 0x7f));
addr = rse_address_add (prev_bof, (regnum - IA64_GR32_REGNUM));
static const struct frame_unwind ia64_frame_unwind =
{
+ "ia64 prologue",
NORMAL_FRAME,
default_frame_unwind_stop_reason,
&ia64_frame_this_id,
struct ia64_frame_cache *cache)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
- struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
+ ia64_gdbarch_tdep *tdep = (ia64_gdbarch_tdep *) gdbarch_tdep (gdbarch);
if (tdep->sigcontext_register_address)
{
get_frame_pc (this_frame),
cache->bsp);
if (gdbarch_debug >= 1)
- fprintf_unfiltered (gdb_stdlog,
- "sigtramp frame id: code %s, stack %s, "
- "special %s, this_frame %s\n",
- paddress (gdbarch, this_id->code_addr),
- paddress (gdbarch, this_id->stack_addr),
- paddress (gdbarch, cache->bsp),
- host_address_to_string (this_frame));
+ gdb_printf (gdb_stdlog,
+ "sigtramp frame id: code %s, stack %s, "
+ "special %s, this_frame %s\n",
+ paddress (gdbarch, this_id->code_addr),
+ paddress (gdbarch, this_id->stack_addr),
+ paddress (gdbarch, cache->bsp),
+ host_address_to_string (this_frame));
}
static struct value *
struct frame_info *this_frame,
void **this_cache)
{
- struct gdbarch_tdep *tdep = gdbarch_tdep (get_frame_arch (this_frame));
+ gdbarch *arch = get_frame_arch (this_frame);
+ ia64_gdbarch_tdep *tdep = (ia64_gdbarch_tdep *) gdbarch_tdep (arch);
if (tdep->pc_in_sigtramp)
{
CORE_ADDR pc = get_frame_pc (this_frame);
static const struct frame_unwind ia64_sigtramp_frame_unwind =
{
+ "ia64 sigtramp",
SIGTRAMP_FRAME,
default_frame_unwind_stop_reason,
ia64_sigtramp_frame_this_id,
unw_word_t bsp, sof, cfm, psr, ip;
struct frame_info *this_frame = (struct frame_info *) arg;
struct gdbarch *gdbarch = get_frame_arch (this_frame);
+ ia64_gdbarch_tdep *tdep = (ia64_gdbarch_tdep *) gdbarch_tdep (gdbarch);
/* We never call any libunwind routines that need to write registers. */
gdb_assert (!write);
the current register frame. */
bsp = get_frame_register_unsigned (this_frame, IA64_BSP_REGNUM);
cfm = get_frame_register_unsigned (this_frame, IA64_CFM_REGNUM);
- sof = gdbarch_tdep (gdbarch)->size_of_register_frame (this_frame, cfm);
+ sof = tdep->size_of_register_frame (this_frame, cfm);
*val = ia64_rse_skip_regs (bsp, -sof);
break;
}
if (gdbarch_debug >= 1)
- fprintf_unfiltered (gdb_stdlog,
- " access_reg: from cache: %4s=%s\n",
- (((unsigned) regnum <= IA64_NAT127_REGNUM)
- ? ia64_register_names[regnum] : "r??"),
- paddress (gdbarch, *val));
+ gdb_printf (gdb_stdlog,
+ " access_reg: from cache: %4s=%s\n",
+ (((unsigned) regnum <= IA64_NAT127_REGNUM)
+ ? ia64_register_names[regnum] : "r??"),
+ paddress (gdbarch, *val));
return 0;
}
}
if (gdbarch_debug >= 1)
- fprintf_unfiltered (gdb_stdlog,
- " access_rse_reg: from cache: %4s=%s\n",
- (((unsigned) regnum <= IA64_NAT127_REGNUM)
- ? ia64_register_names[regnum] : "r??"),
- paddress (gdbarch, *val));
+ gdb_printf (gdb_stdlog,
+ " access_rse_reg: from cache: %4s=%s\n",
+ (((unsigned) regnum <= IA64_NAT127_REGNUM)
+ ? ia64_register_names[regnum] : "r??"),
+ paddress (gdbarch, *val));
return 0;
}
di->u.ti.table_data = (unw_word_t *) ktab;
if (gdbarch_debug >= 1)
- fprintf_unfiltered (gdb_stdlog, "get_kernel_table: found table `%s': "
- "segbase=%s, length=%s, gp=%s\n",
- (char *) di->u.ti.name_ptr,
- hex_string (di->u.ti.segbase),
- pulongest (di->u.ti.table_len),
- hex_string (di->gp));
+ gdb_printf (gdb_stdlog, "get_kernel_table: found table `%s': "
+ "segbase=%s, length=%s, gp=%s\n",
+ (char *) di->u.ti.name_ptr,
+ hex_string (di->u.ti.segbase),
+ pulongest (di->u.ti.table_len),
+ hex_string (di->gp));
return 0;
}
return -UNW_ENOINFO;
if (gdbarch_debug >= 1)
- fprintf_unfiltered (gdb_stdlog, "ia64_find_proc_info_x: %s -> "
- "(name=`%s',segbase=%s,start=%s,end=%s,gp=%s,"
- "length=%s,data=%s)\n",
- hex_string (ip), (char *)di.u.ti.name_ptr,
- hex_string (di.u.ti.segbase),
- hex_string (di.start_ip), hex_string (di.end_ip),
- hex_string (di.gp),
- pulongest (di.u.ti.table_len),
- hex_string ((CORE_ADDR)di.u.ti.table_data));
+ gdb_printf (gdb_stdlog, "ia64_find_proc_info_x: %s -> "
+ "(name=`%s',segbase=%s,start=%s,end=%s,gp=%s,"
+ "length=%s,data=%s)\n",
+ hex_string (ip), (char *)di.u.ti.name_ptr,
+ hex_string (di.u.ti.segbase),
+ hex_string (di.start_ip), hex_string (di.end_ip),
+ hex_string (di.gp),
+ pulongest (di.u.ti.table_len),
+ hex_string ((CORE_ADDR)di.u.ti.table_data));
}
else
{
return ret;
if (gdbarch_debug >= 1)
- fprintf_unfiltered (gdb_stdlog, "ia64_find_proc_info_x: %s -> "
- "(name=`%s',segbase=%s,start=%s,end=%s,gp=%s,"
- "length=%s,data=%s)\n",
- hex_string (ip), (char *)di.u.rti.name_ptr,
- hex_string (di.u.rti.segbase),
- hex_string (di.start_ip), hex_string (di.end_ip),
- hex_string (di.gp),
- pulongest (di.u.rti.table_len),
- hex_string (di.u.rti.table_data));
+ gdb_printf (gdb_stdlog, "ia64_find_proc_info_x: %s -> "
+ "(name=`%s',segbase=%s,start=%s,end=%s,gp=%s,"
+ "length=%s,data=%s)\n",
+ hex_string (ip), (char *)di.u.rti.name_ptr,
+ hex_string (di.u.rti.segbase),
+ hex_string (di.start_ip), hex_string (di.end_ip),
+ hex_string (di.gp),
+ pulongest (di.u.rti.table_len),
+ hex_string (di.u.rti.table_data));
}
ret = libunwind_search_unwind_table (&as, ip, &di, pi, need_unwind_info,
if (addr)
{
if (gdbarch_debug >= 1)
- fprintf_unfiltered (gdb_stdlog,
- "dynamic unwind table in objfile %s "
- "at %s (gp=%s)\n",
- bfd_get_filename (objfile->obfd),
- hex_string (addr), hex_string (di.gp));
+ gdb_printf (gdb_stdlog,
+ "dynamic unwind table in objfile %s "
+ "at %s (gp=%s)\n",
+ bfd_get_filename (objfile->obfd),
+ hex_string (addr), hex_string (di.gp));
*dilap = addr;
return 0;
}
(*this_id) = frame_id_build_special (id.stack_addr, id.code_addr, bsp);
if (gdbarch_debug >= 1)
- fprintf_unfiltered (gdb_stdlog,
- "libunwind frame id: code %s, stack %s, "
- "special %s, this_frame %s\n",
- paddress (gdbarch, id.code_addr),
- paddress (gdbarch, id.stack_addr),
- paddress (gdbarch, bsp),
- host_address_to_string (this_frame));
+ gdb_printf (gdb_stdlog,
+ "libunwind frame id: code %s, stack %s, "
+ "special %s, this_frame %s\n",
+ paddress (gdbarch, id.code_addr),
+ paddress (gdbarch, id.stack_addr),
+ paddress (gdbarch, bsp),
+ host_address_to_string (this_frame));
}
static struct value *
/* Adjust the register number to account for register rotation. */
regnum = VP16_REGNUM + ((regnum - VP16_REGNUM) + rrb_pr) % 48;
}
- prN_val = extract_bit_field (value_contents_all (val),
+ prN_val = extract_bit_field (value_contents_all (val).data (),
regnum - VP0_REGNUM, 1);
return frame_unwind_got_constant (this_frame, regnum, prN_val);
}
{
ULONGEST unatN_val;
- unatN_val = extract_bit_field (value_contents_all (val),
+ unatN_val = extract_bit_field (value_contents_all (val).data (),
regnum - IA64_NAT0_REGNUM, 1);
return frame_unwind_got_constant (this_frame, regnum, unatN_val);
}
register will be if we pop the frame back which is why we might
have been called. We know that libunwind will pass us back the
beginning of the current frame so we should just add sof to it. */
- prev_bsp = extract_unsigned_integer (value_contents_all (val),
+ prev_bsp = extract_unsigned_integer (value_contents_all (val).data (),
8, byte_order);
cfm_val = libunwind_frame_prev_register (this_frame, this_cache,
IA64_CFM_REGNUM);
- prev_cfm = extract_unsigned_integer (value_contents_all (cfm_val),
+ prev_cfm = extract_unsigned_integer (value_contents_all (cfm_val).data (),
8, byte_order);
prev_bsp = rse_address_add (prev_bsp, (prev_cfm & 0x7f));
static const struct frame_unwind ia64_libunwind_frame_unwind =
{
+ "ia64 libunwind",
NORMAL_FRAME,
default_frame_unwind_stop_reason,
ia64_libunwind_frame_this_id,
(*this_id) = frame_id_build_special (id.stack_addr, id.code_addr, bsp);
if (gdbarch_debug >= 1)
- fprintf_unfiltered (gdb_stdlog,
- "libunwind sigtramp frame id: code %s, "
- "stack %s, special %s, this_frame %s\n",
- paddress (gdbarch, id.code_addr),
- paddress (gdbarch, id.stack_addr),
- paddress (gdbarch, bsp),
- host_address_to_string (this_frame));
+ gdb_printf (gdb_stdlog,
+ "libunwind sigtramp frame id: code %s, "
+ "stack %s, special %s, this_frame %s\n",
+ paddress (gdbarch, id.code_addr),
+ paddress (gdbarch, id.stack_addr),
+ paddress (gdbarch, bsp),
+ host_address_to_string (this_frame));
}
static struct value *
method of getting previous registers. */
prev_ip_val = libunwind_frame_prev_register (this_frame, this_cache,
IA64_IP_REGNUM);
- prev_ip = extract_unsigned_integer (value_contents_all (prev_ip_val),
+ prev_ip = extract_unsigned_integer (value_contents_all (prev_ip_val).data (),
8, byte_order);
if (prev_ip == 0)
static const struct frame_unwind ia64_libunwind_sigtramp_frame_unwind =
{
+ "ia64 libunwind sigtramp",
SIGTRAMP_FRAME,
default_frame_unwind_stop_reason,
ia64_libunwind_sigtramp_frame_this_id,
status = target_read_memory (addr, buf, sizeof (buf));
if (status != 0)
break;
- tag = extract_signed_integer (buf, sizeof (buf), byte_order);
+ tag = extract_signed_integer (buf, byte_order);
if (tag == DT_PLTGOT)
{
static CORE_ADDR
ia64_find_global_pointer (struct gdbarch *gdbarch, CORE_ADDR faddr)
{
- struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
+ ia64_gdbarch_tdep *tdep = (ia64_gdbarch_tdep *) gdbarch_tdep (gdbarch);
CORE_ADDR addr = 0;
if (tdep->find_global_pointer_from_solib)
status = target_read_memory (addr, buf, sizeof (buf));
if (status != 0)
break;
- faddr2 = extract_signed_integer (buf, sizeof (buf), byte_order);
+ faddr2 = extract_signed_integer (buf, byte_order);
if (faddr == faddr2)
return addr;
function_call_return_method return_method,
CORE_ADDR struct_addr)
{
- struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
+ ia64_gdbarch_tdep *tdep = (ia64_gdbarch_tdep *) gdbarch_tdep (gdbarch);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
int argno;
struct value *arg;
&& TYPE_TARGET_TYPE (type)->code () == TYPE_CODE_FUNC)
{
gdb_byte val_buf[8];
- ULONGEST faddr = extract_unsigned_integer (value_contents (arg),
- 8, byte_order);
+ ULONGEST faddr = extract_unsigned_integer
+ (value_contents (arg).data (), 8, byte_order);
store_unsigned_integer (val_buf, 8, byte_order,
find_func_descr (regcache, faddr,
&funcdescaddr));
This is why we use store_unsigned_integer. */
store_unsigned_integer
(val_buf, 8, byte_order,
- extract_unsigned_integer (value_contents (arg), len,
+ extract_unsigned_integer (value_contents (arg).data (), len,
byte_order));
}
else
In this case, the data is Byte0-aligned. Happy news,
this means that we don't need to differentiate the
handling of 8byte blocks and less-than-8bytes blocks. */
- memcpy (val_buf, value_contents (arg) + argoffset,
+ memcpy (val_buf, value_contents (arg).data () + argoffset,
(len > 8) ? 8 : len);
}
while (len > 0 && floatreg < IA64_FR16_REGNUM)
{
gdb_byte to[IA64_FP_REGISTER_SIZE];
- target_float_convert (value_contents (arg) + argoffset,
+ target_float_convert (value_contents (arg).data () + argoffset,
float_elt_type, to,
ia64_ext_type (gdbarch));
regcache->cooked_write (floatreg, to);
bsp = extract_unsigned_integer (buf, 8, byte_order);
if (gdbarch_debug >= 1)
- fprintf_unfiltered (gdb_stdlog,
- "dummy frame id: code %s, stack %s, special %s\n",
- paddress (gdbarch, get_frame_pc (this_frame)),
- paddress (gdbarch, sp), paddress (gdbarch, bsp));
+ gdb_printf (gdb_stdlog,
+ "dummy frame id: code %s, stack %s, special %s\n",
+ paddress (gdbarch, get_frame_pc (this_frame)),
+ paddress (gdbarch, sp), paddress (gdbarch, bsp));
return frame_id_build_special (sp, get_frame_pc (this_frame), bsp);
}
ia64_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
{
struct gdbarch *gdbarch;
- struct gdbarch_tdep *tdep;
/* If there is already a candidate, use it. */
arches = gdbarch_list_lookup_by_info (arches, &info);
if (arches != NULL)
return arches->gdbarch;
- tdep = XCNEW (struct gdbarch_tdep);
+ ia64_gdbarch_tdep *tdep = new ia64_gdbarch_tdep;
gdbarch = gdbarch_alloc (&info, tdep);
tdep->size_of_register_frame = ia64_size_of_register_frame;
projects / binutils-gdb.git / blobdiff