/* Abstraction of GNU v3 abi.
Contributed by Jim Blandy <jimb@redhat.com>
- Copyright (C) 2001-2013 Free Software Foundation, Inc.
+ Copyright (C) 2001-2019 Free Software Foundation, Inc.
This file is part of GDB.
#include "objfiles.h"
#include "valprint.h"
#include "c-lang.h"
-#include "exceptions.h"
#include "typeprint.h"
-
-#include "gdb_assert.h"
-#include "gdb_string.h"
+#include <algorithm>
static struct cp_abi_ops gnu_v3_abi_ops;
static int
gnuv3_is_vtable_name (const char *name)
{
- return strncmp (name, "_ZTV", 4) == 0;
+ return startswith (name, "_ZTV");
}
static int
gnuv3_is_operator_name (const char *name)
{
- return strncmp (name, "operator", 8) == 0;
+ return startswith (name, CP_OPERATOR_STR);
}
the alignment that type requires, and then use that here. */
/* Build the field list. */
- field_list = xmalloc (sizeof (struct field [4]));
- memset (field_list, 0, sizeof (struct field [4]));
+ field_list = XCNEWVEC (struct field, 4);
field = &field_list[0];
offset = 0;
/* We assumed in the allocation above that there were four fields. */
gdb_assert (field == (field_list + 4));
- t = arch_type (arch, TYPE_CODE_STRUCT, offset, NULL);
+ t = arch_type (arch, TYPE_CODE_STRUCT, offset * TARGET_CHAR_BIT, NULL);
TYPE_NFIELDS (t) = field - field_list;
TYPE_FIELDS (t) = field_list;
- TYPE_TAG_NAME (t) = "gdb_gnu_v3_abi_vtable";
+ TYPE_NAME (t) = "gdb_gnu_v3_abi_vtable";
INIT_CPLUS_SPECIFIC (t);
- return t;
+ return make_type_with_address_space (t, TYPE_INSTANCE_FLAG_CODE_SPACE);
}
static struct type *
vtable_ptrdiff_type (struct gdbarch *gdbarch)
{
- struct type *vtable_type = gdbarch_data (gdbarch, vtable_type_gdbarch_data);
+ struct type *vtable_type
+ = (struct type *) gdbarch_data (gdbarch, vtable_type_gdbarch_data);
/* The "offset_to_top" field has the appropriate (ptrdiff_t) type. */
return TYPE_FIELD_TYPE (vtable_type, vtable_field_offset_to_top);
static int
vtable_address_point_offset (struct gdbarch *gdbarch)
{
- struct type *vtable_type = gdbarch_data (gdbarch, vtable_type_gdbarch_data);
+ struct type *vtable_type
+ = (struct type *) gdbarch_data (gdbarch, vtable_type_gdbarch_data);
return (TYPE_FIELD_BITPOS (vtable_type, vtable_field_virtual_functions)
/ TARGET_CHAR_BIT);
{
int fieldnum, fieldelem;
+ type = check_typedef (type);
+ gdb_assert (TYPE_CODE (type) == TYPE_CODE_STRUCT
+ || TYPE_CODE (type) == TYPE_CODE_UNION);
+
+ if (TYPE_CODE (type) == TYPE_CODE_UNION)
+ return 0;
+
if (TYPE_CPLUS_DYNAMIC (type))
return TYPE_CPLUS_DYNAMIC (type) == 1;
gnuv3_get_vtable (struct gdbarch *gdbarch,
struct type *container_type, CORE_ADDR container_addr)
{
- struct type *vtable_type = gdbarch_data (gdbarch,
- vtable_type_gdbarch_data);
+ struct type *vtable_type
+ = (struct type *) gdbarch_data (gdbarch, vtable_type_gdbarch_data);
struct type *vtable_pointer_type;
struct value *vtable_pointer;
CORE_ADDR vtable_address;
+ container_type = check_typedef (container_type);
+ gdb_assert (TYPE_CODE (container_type) == TYPE_CODE_STRUCT);
+
/* If this type does not have a virtual table, don't read the first
field. */
- if (!gnuv3_dynamic_class (check_typedef (container_type)))
+ if (!gnuv3_dynamic_class (container_type))
return NULL;
/* We do not consult the debug information to find the virtual table.
static struct type *
gnuv3_rtti_type (struct value *value,
- int *full_p, int *top_p, int *using_enc_p)
+ int *full_p, LONGEST *top_p, int *using_enc_p)
{
struct gdbarch *gdbarch;
struct type *values_type = check_typedef (value_type (value));
const char *class_name;
struct type *run_time_type;
LONGEST offset_to_top;
- char *atsign;
-
- /* We only have RTTI for class objects. */
- if (TYPE_CODE (values_type) != TYPE_CODE_CLASS)
- return NULL;
+ const char *atsign;
- /* Java doesn't have RTTI following the C++ ABI. */
- if (TYPE_CPLUS_REALLY_JAVA (values_type))
+ /* We only have RTTI for dynamic class objects. */
+ if (TYPE_CODE (values_type) != TYPE_CODE_STRUCT
+ || !gnuv3_dynamic_class (values_type))
return NULL;
/* Determine architecture. */
if (using_enc_p)
*using_enc_p = 0;
- vtable = gnuv3_get_vtable (gdbarch, value_type (value),
+ vtable = gnuv3_get_vtable (gdbarch, values_type,
value_as_address (value_addr (value)));
if (vtable == NULL)
return NULL;
If we didn't like this approach, we could instead look in the
type_info object itself to get the class name. But this way
should work just as well, and doesn't read target memory. */
- vtable_symbol_name = SYMBOL_DEMANGLED_NAME (vtable_symbol);
+ vtable_symbol_name = MSYMBOL_DEMANGLED_NAME (vtable_symbol);
if (vtable_symbol_name == NULL
- || strncmp (vtable_symbol_name, "vtable for ", 11))
+ || !startswith (vtable_symbol_name, "vtable for "))
{
warning (_("can't find linker symbol for virtual table for `%s' value"),
TYPE_SAFE_NAME (values_type));
{
char *copy;
- copy = alloca (atsign - class_name + 1);
+ copy = (char *) alloca (atsign - class_name + 1);
memcpy (copy, class_name, atsign - class_name);
copy[atsign - class_name] = '\0';
class_name = copy;
struct gdbarch *gdbarch;
/* Some simple sanity checks. */
- if (TYPE_CODE (values_type) != TYPE_CODE_CLASS)
+ if (TYPE_CODE (values_type) != TYPE_CODE_STRUCT)
error (_("Only classes can have virtual functions."));
/* Determine architecture. */
static int
gnuv3_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 gdbarch *gdbarch;
ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
/* If it isn't a virtual base, this is easy. The offset is in the
- type definition. Likewise for Java, which doesn't really have
- virtual inheritance in the C++ sense. */
- if (!BASETYPE_VIA_VIRTUAL (type, index) || TYPE_CPLUS_REALLY_JAVA (type))
+ type definition. */
+ if (!BASETYPE_VIA_VIRTUAL (type, index))
return TYPE_BASECLASS_BITPOS (type, index) / 8;
/* To access a virtual base, we need to use the vbase offset stored in
struct type *type,
struct ui_file *stream)
{
- struct type *domain = TYPE_DOMAIN_TYPE (type);
- struct gdbarch *gdbarch = get_type_arch (domain);
+ struct type *self_type = TYPE_SELF_TYPE (type);
+ struct gdbarch *gdbarch = get_type_arch (self_type);
CORE_ADDR ptr_value;
LONGEST adjustment;
int vbit;
to an index, as used in TYPE_FN_FIELD_VOFFSET. */
voffset = ptr_value / TYPE_LENGTH (vtable_ptrdiff_type (gdbarch));
- physname = gnuv3_find_method_in (domain, voffset, adjustment);
+ physname = gnuv3_find_method_in (self_type, voffset, adjustment);
/* If we found a method, print that. We don't bother to disambiguate
possible paths to the method based on the adjustment. */
struct gdbarch *gdbarch;
const gdb_byte *contents = value_contents (method_ptr);
CORE_ADDR ptr_value;
- struct type *domain_type, *final_type, *method_type;
+ struct type *self_type, *final_type, *method_type;
LONGEST adjustment;
int vbit;
- domain_type = TYPE_DOMAIN_TYPE (check_typedef (value_type (method_ptr)));
- final_type = lookup_pointer_type (domain_type);
+ self_type = TYPE_SELF_TYPE (check_typedef (value_type (method_ptr)));
+ final_type = lookup_pointer_type (self_type);
method_type = TYPE_TARGET_TYPE (check_typedef (value_type (method_ptr)));
/* Extract the pointer to member. */
- gdbarch = get_type_arch (domain_type);
+ gdbarch = get_type_arch (self_type);
vbit = gnuv3_decode_method_ptr (gdbarch, contents, &ptr_value, &adjustment);
/* First convert THIS to match the containing type of the pointer to
int max_voffset;
};
-typedef struct value_and_voffset *value_and_voffset_p;
-DEF_VEC_P (value_and_voffset_p);
-
/* Hash function for value_and_voffset. */
static hashval_t
hash_value_and_voffset (const void *p)
{
- const struct value_and_voffset *o = p;
+ const struct value_and_voffset *o = (const struct value_and_voffset *) p;
return value_address (o->value) + value_embedded_offset (o->value);
}
static int
eq_value_and_voffset (const void *a, const void *b)
{
- const struct value_and_voffset *ova = a;
- const struct value_and_voffset *ovb = b;
+ const struct value_and_voffset *ova = (const struct value_and_voffset *) a;
+ const struct value_and_voffset *ovb = (const struct value_and_voffset *) b;
return (value_address (ova->value) + value_embedded_offset (ova->value)
== value_address (ovb->value) + value_embedded_offset (ovb->value));
}
-/* qsort comparison function for value_and_voffset. */
+/* Comparison function for value_and_voffset. */
-static int
-compare_value_and_voffset (const void *a, const void *b)
+static bool
+compare_value_and_voffset (const struct value_and_voffset *va,
+ const struct value_and_voffset *vb)
{
- const struct value_and_voffset * const *ova = a;
- CORE_ADDR addra = (value_address ((*ova)->value)
- + value_embedded_offset ((*ova)->value));
- const struct value_and_voffset * const *ovb = b;
- CORE_ADDR addrb = (value_address ((*ovb)->value)
- + value_embedded_offset ((*ovb)->value));
-
- if (addra < addrb)
- return -1;
- if (addra > addrb)
- return 1;
- return 0;
+ CORE_ADDR addra = (value_address (va->value)
+ + value_embedded_offset (va->value));
+ CORE_ADDR addrb = (value_address (vb->value)
+ + value_embedded_offset (vb->value));
+
+ return addra < addrb;
}
/* A helper function used when printing vtables. This determines the
static void
compute_vtable_size (htab_t offset_hash,
- VEC (value_and_voffset_p) **offset_vec,
+ std::vector<value_and_voffset *> *offset_vec,
struct value *value)
{
int i;
void **slot;
struct value_and_voffset search_vo, *current_vo;
+ gdb_assert (TYPE_CODE (type) == TYPE_CODE_STRUCT);
+
/* If the object is not dynamic, then we are done; as it cannot have
dynamic base types either. */
if (!gnuv3_dynamic_class (type))
search_vo.value = value;
slot = htab_find_slot (offset_hash, &search_vo, INSERT);
if (*slot)
- current_vo = *slot;
+ current_vo = (struct value_and_voffset *) *slot;
else
{
current_vo = XNEW (struct value_and_voffset);
current_vo->value = value;
current_vo->max_voffset = -1;
*slot = current_vo;
- VEC_safe_push (value_and_voffset_p, *offset_vec, current_vo);
+ offset_vec->push_back (current_vo);
}
/* Update the value_and_voffset object with the highest vtable
{
/* Initialize it just to avoid a GCC false warning. */
CORE_ADDR addr = 0;
+ int got_error = 0;
struct value *vfn;
- volatile struct gdb_exception ex;
printf_filtered ("[%d]: ", i);
if (gdbarch_vtable_function_descriptors (gdbarch))
vfn = value_addr (vfn);
- TRY_CATCH (ex, RETURN_MASK_ERROR)
+ try
{
addr = value_as_address (vfn);
}
- if (ex.reason < 0)
- printf_filtered (_("<error: %s>"), ex.message);
- else
+ catch (const gdb_exception_error &ex)
+ {
+ printf_filtered (_("<error: %s>"), ex.what ());
+ got_error = 1;
+ }
+
+ if (!got_error)
print_function_pointer_address (opts, gdbarch, addr, gdb_stdout);
printf_filtered ("\n");
}
struct type *type;
struct value *vtable;
struct value_print_options opts;
- htab_t offset_hash;
- struct cleanup *cleanup;
- VEC (value_and_voffset_p) *result_vec = NULL;
- struct value_and_voffset *iter;
- int i, count;
+ int count;
value = coerce_ref (value);
type = check_typedef (value_type (value));
}
gdbarch = get_type_arch (type);
- vtable = gnuv3_get_vtable (gdbarch, type,
- value_as_address (value_addr (value)));
+
+ vtable = NULL;
+ if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
+ vtable = gnuv3_get_vtable (gdbarch, type,
+ value_as_address (value_addr (value)));
if (!vtable)
{
return;
}
- offset_hash = htab_create_alloc (1, hash_value_and_voffset,
- eq_value_and_voffset,
- xfree, xcalloc, xfree);
- cleanup = make_cleanup_htab_delete (offset_hash);
- make_cleanup (VEC_cleanup (value_and_voffset_p), &result_vec);
+ htab_up offset_hash (htab_create_alloc (1, hash_value_and_voffset,
+ eq_value_and_voffset,
+ xfree, xcalloc, xfree));
+ std::vector<value_and_voffset *> result_vec;
- compute_vtable_size (offset_hash, &result_vec, value);
-
- qsort (VEC_address (value_and_voffset_p, result_vec),
- VEC_length (value_and_voffset_p, result_vec),
- sizeof (value_and_voffset_p),
- compare_value_and_voffset);
+ compute_vtable_size (offset_hash.get (), &result_vec, value);
+ std::sort (result_vec.begin (), result_vec.end (),
+ compare_value_and_voffset);
count = 0;
- for (i = 0; VEC_iterate (value_and_voffset_p, result_vec, i, iter); ++i)
+ for (value_and_voffset *iter : result_vec)
{
if (iter->max_voffset >= 0)
{
++count;
}
}
-
- do_cleanups (cleanup);
}
/* Return a GDB type representing `struct std::type_info', laid out
struct type *char_ptr_type
= make_pointer_type (make_cv_type (1, 0, char_type, NULL), NULL);
- field_list = xmalloc (sizeof (struct field [2]));
- memset (field_list, 0, sizeof (struct field [2]));
+ field_list = XCNEWVEC (struct field, 2);
field = &field_list[0];
offset = 0;
gdb_assert (field == (field_list + 2));
- t = arch_type (arch, TYPE_CODE_STRUCT, offset, NULL);
+ t = arch_type (arch, TYPE_CODE_STRUCT, offset * TARGET_CHAR_BIT, NULL);
TYPE_NFIELDS (t) = field - field_list;
TYPE_FIELDS (t) = field_list;
- TYPE_TAG_NAME (t) = "gdb_gnu_v3_type_info";
+ TYPE_NAME (t) = "gdb_gnu_v3_type_info";
INIT_CPLUS_SPECIFIC (t);
return t;
struct symbol *typeinfo;
struct type *typeinfo_type;
- typeinfo = lookup_symbol ("std::type_info", NULL, STRUCT_DOMAIN, NULL);
+ typeinfo = lookup_symbol ("std::type_info", NULL, STRUCT_DOMAIN,
+ NULL).symbol;
if (typeinfo == NULL)
- typeinfo_type = gdbarch_data (gdbarch, std_type_info_gdbarch_data);
+ typeinfo_type
+ = (struct type *) gdbarch_data (gdbarch, std_type_info_gdbarch_data);
else
typeinfo_type = SYMBOL_TYPE (typeinfo);
struct type *typeinfo_type;
struct type *type;
struct gdbarch *gdbarch;
- struct cleanup *cleanup;
struct value *result;
- char *typename, *canonical;
+ std::string type_name, canonical;
/* We have to handle values a bit trickily here, to allow this code
to work properly with non_lvalue values that are really just
type = make_cv_type (0, 0, type, NULL);
gdbarch = get_type_arch (type);
- typename = type_to_string (type);
- if (typename == NULL)
+ type_name = type_to_string (type);
+ if (type_name.empty ())
error (_("cannot find typeinfo for unnamed type"));
- cleanup = make_cleanup (xfree, typename);
/* We need to canonicalize the type name here, because we do lookups
using the demangled name, and so we must match the format it
uses. E.g., GDB tends to use "const char *" as a type name, but
the demangler uses "char const *". */
- canonical = cp_canonicalize_string (typename);
- if (canonical != NULL)
- {
- make_cleanup (xfree, canonical);
- typename = canonical;
- }
+ canonical = cp_canonicalize_string (type_name.c_str ());
+ if (!canonical.empty ())
+ type_name = canonical;
typeinfo_type = gnuv3_get_typeid_type (gdbarch);
/* We check for lval_memory because in the "typeid (type-id)" case,
the type is passed via a not_lval value object. */
- if (TYPE_CODE (type) == TYPE_CODE_CLASS
+ if (TYPE_CODE (type) == TYPE_CODE_STRUCT
&& value_lval_const (value) == lval_memory
&& gnuv3_dynamic_class (type))
{
vtable = gnuv3_get_vtable (gdbarch, type, address);
if (vtable == NULL)
- error (_("cannot find typeinfo for object of type '%s'"), typename);
+ error (_("cannot find typeinfo for object of type '%s'"),
+ type_name.c_str ());
typeinfo_value = value_field (vtable, vtable_field_type_info);
result = value_ind (value_cast (make_pointer_type (typeinfo_type, NULL),
typeinfo_value));
}
else
{
- char *sym_name;
- struct minimal_symbol *minsym;
-
- sym_name = concat ("typeinfo for ", typename, (char *) NULL);
- make_cleanup (xfree, sym_name);
- minsym = lookup_minimal_symbol (sym_name, NULL, NULL);
+ std::string sym_name = std::string ("typeinfo for ") + type_name;
+ bound_minimal_symbol minsym
+ = lookup_minimal_symbol (sym_name.c_str (), NULL, NULL);
- if (minsym == NULL)
- error (_("could not find typeinfo symbol for '%s'"), typename);
+ if (minsym.minsym == NULL)
+ error (_("could not find typeinfo symbol for '%s'"), type_name.c_str ());
- result = value_at_lazy (typeinfo_type, SYMBOL_VALUE_ADDRESS (minsym));
+ result = value_at_lazy (typeinfo_type, BMSYMBOL_VALUE_ADDRESS (minsym));
}
- do_cleanups (cleanup);
return result;
}
/* Implement the 'get_typename_from_type_info' method. */
-static char *
+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));
#define TYPEINFO_PREFIX "typeinfo for "
#define TYPEINFO_PREFIX_LEN (sizeof (TYPEINFO_PREFIX) - 1)
- symname = SYMBOL_DEMANGLED_NAME (typeinfo_sym.minsym);
+ symname = MSYMBOL_DEMANGLED_NAME (typeinfo_sym.minsym);
if (symname == NULL || strncmp (symname, TYPEINFO_PREFIX,
TYPEINFO_PREFIX_LEN))
error (_("typeinfo symbol '%s' has unexpected name"),
- SYMBOL_LINKAGE_NAME (typeinfo_sym.minsym));
+ MSYMBOL_LINKAGE_NAME (typeinfo_sym.minsym));
class_name = symname + TYPEINFO_PREFIX_LEN;
/* Strip off @plt and version suffixes. */
atsign = strchr (class_name, '@');
if (atsign != NULL)
- return savestring (class_name, atsign - class_name);
- return xstrdup (class_name);
+ return std::string (class_name, atsign - class_name);
+ return class_name;
}
/* Implement the 'get_type_from_type_info' method. */
static struct type *
gnuv3_get_type_from_type_info (struct value *type_info_ptr)
{
- char *typename;
- struct cleanup *cleanup;
- struct value *type_val;
- struct expression *expr;
- struct type *result;
-
- typename = gnuv3_get_typename_from_type_info (type_info_ptr);
- cleanup = make_cleanup (xfree, typename);
-
/* We have to parse the type name, since in general there is not a
symbol for a type. This is somewhat bogus since there may be a
mis-parse. Another approach might be to re-use the demangler's
internal form to reconstruct the type somehow. */
-
- expr = parse_expression (typename);
- make_cleanup (xfree, expr);
-
- type_val = evaluate_type (expr);
- result = value_type (type_val);
-
- do_cleanups (cleanup);
- return result;
+ std::string type_name = gnuv3_get_typename_from_type_info (type_info_ptr);
+ expression_up expr (parse_expression (type_name.c_str ()));
+ struct value *type_val = evaluate_type (expr.get ());
+ return value_type (type_val);
}
/* Determine if we are currently in a C++ thunk. If so, get the address
static CORE_ADDR
gnuv3_skip_trampoline (struct frame_info *frame, CORE_ADDR stop_pc)
{
- CORE_ADDR real_stop_pc, method_stop_pc;
+ CORE_ADDR real_stop_pc, method_stop_pc, func_addr;
struct gdbarch *gdbarch = get_frame_arch (frame);
- struct minimal_symbol *thunk_sym, *fn_sym;
+ struct bound_minimal_symbol thunk_sym, fn_sym;
struct obj_section *section;
const char *thunk_name, *fn_name;
real_stop_pc = stop_pc;
/* Find the linker symbol for this potential thunk. */
- thunk_sym = lookup_minimal_symbol_by_pc (real_stop_pc).minsym;
+ thunk_sym = lookup_minimal_symbol_by_pc (real_stop_pc);
section = find_pc_section (real_stop_pc);
- if (thunk_sym == NULL || section == NULL)
+ if (thunk_sym.minsym == NULL || section == NULL)
return 0;
/* The symbol's demangled name should be something like "virtual
thunk to FUNCTION", where FUNCTION is the name of the function
being thunked to. */
- thunk_name = SYMBOL_DEMANGLED_NAME (thunk_sym);
+ thunk_name = MSYMBOL_DEMANGLED_NAME (thunk_sym.minsym);
if (thunk_name == NULL || strstr (thunk_name, " thunk to ") == NULL)
return 0;
fn_name = strstr (thunk_name, " thunk to ") + strlen (" thunk to ");
fn_sym = lookup_minimal_symbol (fn_name, NULL, section->objfile);
- if (fn_sym == NULL)
+ if (fn_sym.minsym == NULL)
return 0;
- method_stop_pc = SYMBOL_VALUE_ADDRESS (fn_sym);
+ method_stop_pc = BMSYMBOL_VALUE_ADDRESS (fn_sym);
+
+ /* 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 ());
+ if (func_addr != 0)
+ method_stop_pc = func_addr;
+
real_stop_pc = gdbarch_skip_trampoline_code
(gdbarch, frame, method_stop_pc);
if (real_stop_pc == 0)
{
int fieldnum, fieldelem;
- CHECK_TYPEDEF (type);
+ type = check_typedef (type);
/* We're only interested in things that can have methods. */
if (TYPE_CODE (type) != TYPE_CODE_STRUCT
- && TYPE_CODE (type) != TYPE_CODE_CLASS
&& TYPE_CODE (type) != TYPE_CODE_UNION)
return 0;
+ /* A dynamic class has a non-trivial copy constructor.
+ See c++98 section 12.8 Copying class objects [class.copy]. */
+ if (gnuv3_dynamic_class (type))
+ return 1;
+
for (fieldnum = 0; fieldnum < TYPE_NFN_FIELDS (type); fieldnum++)
for (fieldelem = 0; fieldelem < TYPE_FN_FIELDLIST_LENGTH (type, fieldnum);
fieldelem++)
/* If this method takes two arguments, and the second argument is
a reference to this class, then it is a copy constructor. */
- if (TYPE_NFIELDS (fieldtype) == 2
- && TYPE_CODE (TYPE_FIELD_TYPE (fieldtype, 1)) == TYPE_CODE_REF
- && check_typedef (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (fieldtype,
- 1))) == type)
- return 1;
+ if (TYPE_NFIELDS (fieldtype) == 2)
+ {
+ struct type *arg_type = TYPE_FIELD_TYPE (fieldtype, 1);
+
+ if (TYPE_CODE (arg_type) == TYPE_CODE_REF)
+ {
+ struct type *arg_target_type;
+
+ arg_target_type = check_typedef (TYPE_TARGET_TYPE (arg_type));
+ if (class_types_same_p (arg_target_type, type))
+ return 1;
+ }
+ }
}
/* Even if all the constructors and destructors were artificial, one
gnu_v3_abi_ops.pass_by_reference = gnuv3_pass_by_reference;
}
-extern initialize_file_ftype _initialize_gnu_v3_abi; /* -Wmissing-prototypes */
-
void
_initialize_gnu_v3_abi (void)
{
projects / thirdparty / binutils-gdb.git / blobdiff