/* Abstraction of GNU v2 abi.
- Copyright (C) 2001-2014 Free Software Foundation, Inc.
+ Copyright (C) 2001-2022 Free Software Foundation, Inc.
Contributed by Daniel Berlin <dberlin@redhat.com>
#include "cp-support.h"
#include <ctype.h>
-struct cp_abi_ops gnu_v2_abi_ops;
+static cp_abi_ops gnu_v2_abi_ops;
static int vb_match (struct type *, int, struct type *);
gnuv2_is_destructor_name (const char *name)
{
if ((name[0] == '_' && is_cplus_marker (name[1]) && name[2] == '_')
- || strncmp (name, "__dt__", 6) == 0)
+ || startswith (name, "__dt__"))
return complete_object_dtor;
else
- return 0;
+ return (enum dtor_kinds) 0;
}
static enum ctor_kinds
{
if ((name[0] == '_' && name[1] == '_'
&& (isdigit (name[2]) || strchr ("Qt", name[2])))
- || strncmp (name, "__ct__", 6) == 0)
+ || startswith (name, "__ct__"))
return complete_object_ctor;
else
- return 0;
+ return (enum ctor_kinds) 0;
}
static int
static int
gnuv2_is_operator_name (const char *name)
{
- return strncmp (name, "operator", 8) == 0;
+ return startswith (name, CP_OPERATOR_STR);
}
\f
/* With older versions of g++, the vtbl field pointed to an array
of structures. Nowadays it points directly to the structure. */
- if (TYPE_CODE (value_type (vtbl)) == TYPE_CODE_PTR
- && TYPE_CODE (TYPE_TARGET_TYPE (value_type (vtbl))) == TYPE_CODE_ARRAY)
+ if (value_type (vtbl)->code () == TYPE_CODE_PTR
+ && TYPE_TARGET_TYPE (value_type (vtbl))->code () == TYPE_CODE_ARRAY)
{
/* Handle the case where the vtbl field points to an
- array of structures. */
+ array of structures. */
vtbl = value_ind (vtbl);
/* Index into the virtual function table. This is hard-coded because
- looking up a field is not cheap, and it may be important to save
- time, e.g. if the user has set a conditional breakpoint calling
- a virtual function. */
+ looking up a field is not cheap, and it may be important to save
+ time, e.g. if the user has set a conditional breakpoint calling
+ a virtual function. */
entry = value_subscript (vtbl, vi);
}
else
entry_type = check_typedef (value_type (entry));
- if (TYPE_CODE (entry_type) == TYPE_CODE_STRUCT)
+ if (entry_type->code () == TYPE_CODE_STRUCT)
{
/* Move the `this' pointer according to the virtual function table. */
set_value_offset (arg1, value_offset (arg1)
vfn = value_field (entry, 2);
}
- else if (TYPE_CODE (entry_type) == TYPE_CODE_PTR)
+ else if (entry_type->code () == TYPE_CODE_PTR)
vfn = entry;
else
error (_("I'm confused: virtual function table has bad type"));
static struct type *
-gnuv2_value_rtti_type (struct value *v, int *full, int *top, int *using_enc)
+gnuv2_value_rtti_type (struct value *v, int *full, LONGEST *top, int *using_enc)
{
struct type *known_type;
struct type *rtti_type;
CORE_ADDR vtbl;
struct bound_minimal_symbol minsym;
- char *demangled_name, *p;
+ char *p;
const char *linkage_name;
struct type *btype;
struct type *known_type_vptr_basetype;
/* Get declared type. */
known_type = value_type (v);
- CHECK_TYPEDEF (known_type);
+ known_type = check_typedef (known_type);
/* RTTI works only or class objects. */
- if (TYPE_CODE (known_type) != TYPE_CODE_CLASS)
+ if (known_type->code () != TYPE_CODE_STRUCT)
return NULL;
/* Plan on this changing in the future as i get around to setting
/* Make sure our basetype and known type match, otherwise, cast
so we can get at the vtable properly. */
btype = known_type_vptr_basetype;
- CHECK_TYPEDEF (btype);
+ btype = check_typedef (btype);
if (btype != known_type )
{
v = value_cast (btype, v);
if (using_enc)
- *using_enc=1;
+ *using_enc=1;
}
/* We can't use value_ind here, because it would want to use RTTI, and
we'd waste a bunch of time figuring out we already know the type.
/* Try to find a symbol that is the vtable. */
minsym=lookup_minimal_symbol_by_pc(vtbl);
if (minsym.minsym==NULL
- || (linkage_name=MSYMBOL_LINKAGE_NAME (minsym.minsym))==NULL
+ || (linkage_name=minsym.minsym->linkage_name ())==NULL
|| !is_vtable_name (linkage_name))
return NULL;
/* If we just skip the prefix, we get screwed by namespaces. */
- demangled_name=gdb_demangle(linkage_name,DMGL_PARAMS|DMGL_ANSI);
- p = strchr (demangled_name, ' ');
+ gdb::unique_xmalloc_ptr<char> demangled_name
+ = gdb_demangle(linkage_name,DMGL_PARAMS|DMGL_ANSI);
+ p = strchr (demangled_name.get (), ' ');
if (p)
*p = '\0';
/* Lookup the type for the name. */
/* FIXME: chastain/2003-11-26: block=NULL is bogus. See pr gdb/1465. */
- rtti_type = cp_lookup_rtti_type (demangled_name, NULL);
+ rtti_type = cp_lookup_rtti_type (demangled_name.get (), NULL);
if (rtti_type == NULL)
return NULL;
if (TYPE_N_BASECLASSES(rtti_type) > 1 && full && (*full) != 1)
{
if (top)
- *top = TYPE_BASECLASS_BITPOS (rtti_type,
+ *top = TYPE_BASECLASS_BITPOS (rtti_type,
TYPE_VPTR_FIELDNO(rtti_type)) / 8;
if (top && ((*top) >0))
- {
- if (TYPE_LENGTH(rtti_type) > TYPE_LENGTH(known_type))
- {
- if (full)
- *full=0;
- }
- else
- {
- if (full)
- *full=1;
- }
- }
+ {
+ if (TYPE_LENGTH(rtti_type) > TYPE_LENGTH(known_type))
+ {
+ if (full)
+ *full=0;
+ }
+ else
+ {
+ if (full)
+ *full=1;
+ }
+ }
}
else
{
if (full)
- *full=1;
+ *full=1;
}
return rtti_type;
vb_match (struct type *type, int index, struct type *basetype)
{
struct type *fieldtype;
- const char *name = TYPE_FIELD_NAME (type, index);
+ const char *name = type->field (index).name ();
const char *field_class_name = NULL;
if (*name != '_')
/* It's a virtual baseclass pointer, now we just need to find out whether
it is for this baseclass. */
- fieldtype = TYPE_FIELD_TYPE (type, index);
+ fieldtype = type->field (index).type ();
if (fieldtype == NULL
- || TYPE_CODE (fieldtype) != TYPE_CODE_PTR)
+ || fieldtype->code () != TYPE_CODE_PTR)
/* "Can't happen". */
return 0;
if (TYPE_TARGET_TYPE (fieldtype) == basetype)
return 1;
- if (TYPE_NAME (basetype) != NULL
- && TYPE_NAME (TYPE_TARGET_TYPE (fieldtype)) != NULL
- && strcmp (TYPE_NAME (basetype),
- TYPE_NAME (TYPE_TARGET_TYPE (fieldtype))) == 0)
+ if (basetype->name () != NULL
+ && TYPE_TARGET_TYPE (fieldtype)->name () != NULL
+ && strcmp (basetype->name (),
+ TYPE_TARGET_TYPE (fieldtype)->name ()) == 0)
return 1;
return 0;
}
static int
gnuv2_baseclass_offset (struct type *type, int index,
- const bfd_byte *valaddr, int embedded_offset,
+ const bfd_byte *valaddr, LONGEST embedded_offset,
CORE_ADDR address, const struct value *val)
{
struct type *basetype = TYPE_BASECLASS (type, index);
if (BASETYPE_VIA_VIRTUAL (type, index))
{
/* Must hunt for the pointer to this virtual baseclass. */
- int i, len = TYPE_NFIELDS (type);
+ int i, len = type->num_fields ();
int n_baseclasses = TYPE_N_BASECLASSES (type);
/* First look for the virtual baseclass pointer
- in the fields. */
+ in the fields. */
for (i = n_baseclasses; i < len; i++)
{
if (vb_match (type, i, basetype))
{
struct type *field_type;
- int field_offset;
+ LONGEST field_offset;
int field_length;
CORE_ADDR addr;
- field_type = check_typedef (TYPE_FIELD_TYPE (type, i));
- field_offset = TYPE_FIELD_BITPOS (type, i) / 8;
+ field_type = check_typedef (type->field (i).type ());
+ field_offset = type->field (i).loc_bitpos () / 8;
field_length = TYPE_LENGTH (field_type);
if (!value_bytes_available (val, embedded_offset + field_offset,
gnu_v2_abi_ops.baseclass_offset = gnuv2_baseclass_offset;
}
-extern initialize_file_ftype _initialize_gnu_v2_abi; /* -Wmissing-prototypes */
-
+void _initialize_gnu_v2_abi ();
void
-_initialize_gnu_v2_abi (void)
+_initialize_gnu_v2_abi ()
{
init_gnuv2_ops ();
register_cp_abi (&gnu_v2_abi_ops);
projects / binutils-gdb.git / blobdiff