/* Abstraction of GNU v2 abi.
- Copyright (C) 2001-2013 Free Software Foundation, Inc.
+ Copyright (C) 2001-2020 Free Software Foundation, Inc.
Contributed by Daniel Berlin <dberlin@redhat.com>
along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "defs.h"
-#include "gdb_string.h"
#include "symtab.h"
#include "gdbtypes.h"
#include "value.h"
#include "gdb-demangle.h"
#include "cp-abi.h"
#include "cp-support.h"
-#include "exceptions.h"
-
#include <ctype.h>
struct cp_abi_ops gnu_v2_abi_ops;
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. */
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;
/* 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);
/* Try to find a symbol that is the vtable. */
minsym=lookup_minimal_symbol_by_pc(vtbl);
if (minsym.minsym==NULL
- || (linkage_name=SYMBOL_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=cplus_demangle(linkage_name,DMGL_PARAMS|DMGL_ANSI);
+ demangled_name=gdb_demangle(linkage_name,DMGL_PARAMS|DMGL_ANSI);
p = strchr (demangled_name, ' ');
if (p)
*p = '\0';
/* 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
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_type = check_typedef (type->field (i).type ());
field_offset = TYPE_FIELD_BITPOS (type, i) / 8;
field_length = TYPE_LENGTH (field_type);
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);