/* Abstraction of GNU v3 abi.
Contributed by Jim Blandy <jimb@redhat.com>
- Copyright (C) 2001-2021 Free Software Foundation, Inc.
+ Copyright (C) 2001-2022 Free Software Foundation, Inc.
This file is part of GDB.
#include <algorithm>
#include "cli/cli-style.h"
#include "dwarf2/loc.h"
+#include "inferior.h"
static struct cp_abi_ops gnu_v3_abi_ops;
offset = 0;
/* ptrdiff_t vcall_and_vbase_offsets[0]; */
- FIELD_NAME (*field) = "vcall_and_vbase_offsets";
+ field->set_name ("vcall_and_vbase_offsets");
field->set_type (lookup_array_range_type (ptrdiff_type, 0, -1));
- SET_FIELD_BITPOS (*field, offset * TARGET_CHAR_BIT);
+ field->set_loc_bitpos (offset * TARGET_CHAR_BIT);
offset += TYPE_LENGTH (field->type ());
field++;
/* ptrdiff_t offset_to_top; */
- FIELD_NAME (*field) = "offset_to_top";
+ field->set_name ("offset_to_top");
field->set_type (ptrdiff_type);
- SET_FIELD_BITPOS (*field, offset * TARGET_CHAR_BIT);
+ field->set_loc_bitpos (offset * TARGET_CHAR_BIT);
offset += TYPE_LENGTH (field->type ());
field++;
/* void *type_info; */
- FIELD_NAME (*field) = "type_info";
+ field->set_name ("type_info");
field->set_type (void_ptr_type);
- SET_FIELD_BITPOS (*field, offset * TARGET_CHAR_BIT);
+ field->set_loc_bitpos (offset * TARGET_CHAR_BIT);
offset += TYPE_LENGTH (field->type ());
field++;
/* void (*virtual_functions[0]) (); */
- FIELD_NAME (*field) = "virtual_functions";
+ field->set_name ("virtual_functions");
field->set_type (lookup_array_range_type (ptr_to_void_fn_type, 0, -1));
- SET_FIELD_BITPOS (*field, offset * TARGET_CHAR_BIT);
+ field->set_loc_bitpos (offset * TARGET_CHAR_BIT);
offset += TYPE_LENGTH (field->type ());
field++;
struct type *vtable_type
= (struct type *) gdbarch_data (gdbarch, vtable_type_gdbarch_data);
- return (TYPE_FIELD_BITPOS (vtable_type, vtable_field_virtual_functions)
+ return (vtable_type->field (vtable_field_virtual_functions).loc_bitpos ()
/ TARGET_CHAR_BIT);
}
return NULL;
/* Determine architecture. */
- gdbarch = get_type_arch (values_type);
+ gdbarch = values_type->arch ();
if (using_enc_p)
*using_enc_p = 0;
error (_("Only classes can have virtual functions."));
/* Determine architecture. */
- gdbarch = get_type_arch (values_type);
+ gdbarch = values_type->arch ();
/* Cast our value to the base class which defines this virtual
function. This takes care of any necessary `this'
long int cur_base_offset, base_offset;
/* Determine architecture. */
- gdbarch = get_type_arch (type);
+ gdbarch = type->arch ();
ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
/* If it isn't a virtual base, this is easy. The offset is in the
return TYPE_BASECLASS_BITPOS (type, index) / 8;
/* If we have a DWARF expression for the offset, evaluate it. */
- if (TYPE_FIELD_LOC_KIND (type, index) == FIELD_LOC_KIND_DWARF_BLOCK)
+ if (type->field (index).loc_kind () == FIELD_LOC_KIND_DWARF_BLOCK)
{
struct dwarf2_property_baton baton;
baton.property_type
= lookup_pointer_type (type->field (index).type ());
- baton.locexpr = *TYPE_FIELD_DWARF_BLOCK (type, index);
+ baton.locexpr = *type->field (index).loc_dwarf_block ();
struct dynamic_prop prop;
prop.set_locexpr (&baton);
CORE_ADDR result;
if (dwarf2_evaluate_property (&prop, nullptr, &addr_stack, &result,
- true))
+ {addr_stack.addr}))
return (int) (result - addr_stack.addr);
}
struct ui_file *stream)
{
struct type *self_type = TYPE_SELF_TYPE (type);
- struct gdbarch *gdbarch = get_type_arch (self_type);
+ struct gdbarch *gdbarch = self_type->arch ();
CORE_ADDR ptr_value;
LONGEST adjustment;
int vbit;
/* Check for NULL. */
if (ptr_value == 0 && vbit == 0)
{
- fprintf_filtered (stream, "NULL");
+ gdb_printf (stream, "NULL");
return;
}
possible paths to the method based on the adjustment. */
if (physname)
{
- char *demangled_name = gdb_demangle (physname,
- DMGL_ANSI | DMGL_PARAMS);
+ gdb::unique_xmalloc_ptr<char> demangled_name
+ = gdb_demangle (physname, DMGL_ANSI | DMGL_PARAMS);
- fprintf_filtered (stream, "&virtual ");
+ gdb_printf (stream, "&virtual ");
if (demangled_name == NULL)
- fputs_filtered (physname, stream);
+ gdb_puts (physname, stream);
else
- {
- fputs_filtered (demangled_name, stream);
- xfree (demangled_name);
- }
+ gdb_puts (demangled_name.get (), stream);
return;
}
}
else if (ptr_value != 0)
{
/* Found a non-virtual function: print out the type. */
- fputs_filtered ("(", stream);
- c_print_type (type, "", stream, -1, 0, &type_print_raw_options);
- fputs_filtered (") ", stream);
+ gdb_puts ("(", stream);
+ c_print_type (type, "", stream, -1, 0, current_language->la_language,
+ &type_print_raw_options);
+ gdb_puts (") ", stream);
}
/* We didn't find it; print the raw data. */
if (vbit)
{
- fprintf_filtered (stream, "&virtual table offset ");
+ gdb_printf (stream, "&virtual table offset ");
print_longest (stream, 'd', 1, ptr_value);
}
else
if (adjustment)
{
- fprintf_filtered (stream, ", this adjustment ");
+ gdb_printf (stream, ", this adjustment ");
print_longest (stream, 'd', 1, adjustment);
}
}
static int
gnuv3_method_ptr_size (struct type *type)
{
- struct gdbarch *gdbarch = get_type_arch (type);
-
- return 2 * TYPE_LENGTH (builtin_type (gdbarch)->builtin_data_ptr);
+ return 2 * TYPE_LENGTH (builtin_type (type->arch ())->builtin_data_ptr);
}
/* GNU v3 implementation of cplus_make_method_ptr. */
gnuv3_make_method_ptr (struct type *type, gdb_byte *contents,
CORE_ADDR value, int is_virtual)
{
- struct gdbarch *gdbarch = get_type_arch (type);
+ struct gdbarch *gdbarch = type->arch ();
int size = TYPE_LENGTH (builtin_type (gdbarch)->builtin_data_ptr);
enum bfd_endian byte_order = type_byte_order (type);
gnuv3_method_ptr_to_value (struct value **this_p, struct value *method_ptr)
{
struct gdbarch *gdbarch;
- const gdb_byte *contents = value_contents (method_ptr);
+ const gdb_byte *contents = value_contents (method_ptr).data ();
CORE_ADDR ptr_value;
struct type *self_type, *final_type, *method_type;
LONGEST adjustment;
method_type = TYPE_TARGET_TYPE (check_typedef (value_type (method_ptr)));
/* Extract the pointer to member. */
- gdbarch = get_type_arch (self_type);
+ gdbarch = self_type->arch ();
vbit = gnuv3_decode_method_ptr (gdbarch, contents, &ptr_value, &adjustment);
/* First convert THIS to match the containing type of the pointer to
vt_addr = value_address (value_field (vtable,
vtable_field_virtual_functions));
- printf_filtered (_("vtable for '%s' @ %s (subobject @ %s):\n"),
- TYPE_SAFE_NAME (type),
- paddress (gdbarch, vt_addr),
- paddress (gdbarch, (value_address (value)
- + value_embedded_offset (value))));
+ gdb_printf (_("vtable for '%s' @ %s (subobject @ %s):\n"),
+ TYPE_SAFE_NAME (type),
+ paddress (gdbarch, vt_addr),
+ paddress (gdbarch, (value_address (value)
+ + value_embedded_offset (value))));
for (i = 0; i <= max_voffset; ++i)
{
int got_error = 0;
struct value *vfn;
- printf_filtered ("[%d]: ", i);
+ gdb_printf ("[%d]: ", i);
vfn = value_subscript (value_field (vtable,
vtable_field_virtual_functions),
if (!got_error)
print_function_pointer_address (opts, gdbarch, addr, gdb_stdout);
- printf_filtered ("\n");
+ gdb_printf ("\n");
}
}
type = check_typedef (value_type (value));
}
- gdbarch = get_type_arch (type);
+ gdbarch = type->arch ();
vtable = NULL;
if (type->code () == TYPE_CODE_STRUCT)
if (!vtable)
{
- printf_filtered (_("This object does not have a virtual function table\n"));
+ gdb_printf (_("This object does not have a virtual function table\n"));
return;
}
if (iter->max_voffset >= 0)
{
if (count > 0)
- printf_filtered ("\n");
+ gdb_printf ("\n");
print_one_vtable (gdbarch, iter->value, iter->max_voffset, &opts);
++count;
}
offset = 0;
/* The vtable. */
- FIELD_NAME (*field) = "_vptr.type_info";
+ field->set_name ("_vptr.type_info");
field->set_type (void_ptr_type);
- SET_FIELD_BITPOS (*field, offset * TARGET_CHAR_BIT);
+ field->set_loc_bitpos (offset * TARGET_CHAR_BIT);
offset += TYPE_LENGTH (field->type ());
field++;
/* The name. */
- FIELD_NAME (*field) = "__name";
+ field->set_name ("__name");
field->set_type (char_ptr_type);
- SET_FIELD_BITPOS (*field, offset * TARGET_CHAR_BIT);
+ field->set_loc_bitpos (offset * TARGET_CHAR_BIT);
offset += TYPE_LENGTH (field->type ());
field++;
typeinfo_type
= (struct type *) gdbarch_data (gdbarch, std_type_info_gdbarch_data);
else
- typeinfo_type = SYMBOL_TYPE (typeinfo);
+ typeinfo_type = typeinfo->type ();
return typeinfo_type;
}
/* Ignore top-level cv-qualifiers. */
type = make_cv_type (0, 0, type, NULL);
- gdbarch = get_type_arch (type);
+ gdbarch = type->arch ();
type_name = type_to_string (type);
if (type_name.empty ())
if (minsym.minsym == NULL)
error (_("could not find typeinfo symbol for '%s'"), name);
- result = value_at_lazy (typeinfo_type, BMSYMBOL_VALUE_ADDRESS (minsym));
+ result = value_at_lazy (typeinfo_type, minsym.value_address ());
}
return result;
static std::string
gnuv3_get_typename_from_type_info (struct value *type_info_ptr)
{
- struct gdbarch *gdbarch = get_type_arch (value_type (type_info_ptr));
+ struct gdbarch *gdbarch = value_type (type_info_ptr)->arch ();
struct bound_minimal_symbol typeinfo_sym;
CORE_ADDR addr;
const char *symname;
if (fn_sym.minsym == NULL)
return 0;
- method_stop_pc = BMSYMBOL_VALUE_ADDRESS (fn_sym);
+ method_stop_pc = fn_sym.value_address ();
/* Some targets have minimal symbols pointing to function descriptors
(powerpc 64 for example). Make sure to retrieve the address
of the real function from the function descriptor before passing on
the address to other layers of GDB. */
- func_addr = gdbarch_convert_from_func_ptr_addr (gdbarch, method_stop_pc,
- current_top_target ());
+ func_addr = gdbarch_convert_from_func_ptr_addr
+ (gdbarch, method_stop_pc, current_inferior ()->top_target ());
if (func_addr != 0)
method_stop_pc = func_addr;