/* Abstraction of GNU v3 abi.
Contributed by Jim Blandy <jimb@redhat.com>
- Copyright 2001 Free Software Foundation, Inc.
+
+ Copyright (C) 2001, 2002, 2003, 2005 Free Software Foundation, Inc.
This file is part of GDB.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA. */
+ Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA. */
#include "defs.h"
#include "value.h"
#include "cp-abi.h"
+#include "cp-support.h"
#include "demangle.h"
#include "gdb_assert.h"
+#include "gdb_string.h"
static struct cp_abi_ops gnu_v3_abi_ops;
gdb_gnu_v3_abi_vtable' object to the vtable's "address point"
(i.e., where objects' virtual table pointers point). */
static int
-vtable_address_point_offset ()
+vtable_address_point_offset (void)
{
- struct type *vtable_type = gdbarch_data (vtable_type_gdbarch_data);
+ struct type *vtable_type = gdbarch_data (current_gdbarch,
+ vtable_type_gdbarch_data);
return (TYPE_FIELD_BITPOS (vtable_type, vtable_field_virtual_functions)
/ TARGET_CHAR_BIT);
gnuv3_rtti_type (struct value *value,
int *full_p, int *top_p, int *using_enc_p)
{
- struct type *vtable_type = gdbarch_data (vtable_type_gdbarch_data);
- struct type *value_type = check_typedef (VALUE_TYPE (value));
+ struct type *vtable_type = gdbarch_data (current_gdbarch,
+ vtable_type_gdbarch_data);
+ struct type *values_type = check_typedef (value_type (value));
CORE_ADDR vtable_address;
struct value *vtable;
struct minimal_symbol *vtable_symbol;
const char *vtable_symbol_name;
const char *class_name;
- struct symbol *class_symbol;
struct type *run_time_type;
struct type *base_type;
LONGEST offset_to_top;
/* We only have RTTI for class objects. */
- if (TYPE_CODE (value_type) != TYPE_CODE_CLASS)
+ if (TYPE_CODE (values_type) != TYPE_CODE_CLASS)
return NULL;
- /* If we can't find the virtual table pointer for value_type, we
+ /* If we can't find the virtual table pointer for values_type, we
can't find the RTTI. */
- fill_in_vptr_fieldno (value_type);
- if (TYPE_VPTR_FIELDNO (value_type) == -1)
+ fill_in_vptr_fieldno (values_type);
+ if (TYPE_VPTR_FIELDNO (values_type) == -1)
return NULL;
if (using_enc_p)
/* Fetch VALUE's virtual table pointer, and tweak it to point at
an instance of our imaginary gdb_gnu_v3_abi_vtable structure. */
- base_type = check_typedef (TYPE_VPTR_BASETYPE (value_type));
- if (value_type != base_type)
+ base_type = check_typedef (TYPE_VPTR_BASETYPE (values_type));
+ if (values_type != base_type)
{
value = value_cast (base_type, value);
if (using_enc_p)
*using_enc_p = 1;
}
vtable_address
- = value_as_address (value_field (value, TYPE_VPTR_FIELDNO (value_type)));
+ = value_as_address (value_field (value, TYPE_VPTR_FIELDNO (values_type)));
vtable = value_at_lazy (vtable_type,
- vtable_address - vtable_address_point_offset (),
- VALUE_BFD_SECTION (value));
+ vtable_address - vtable_address_point_offset ());
/* Find the linker symbol for this vtable. */
vtable_symbol
= lookup_minimal_symbol_by_pc (VALUE_ADDRESS (vtable)
- + VALUE_OFFSET (vtable)
- + VALUE_EMBEDDED_OFFSET (vtable));
+ + value_offset (vtable)
+ + value_embedded_offset (vtable));
if (! vtable_symbol)
return NULL;
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);
- if (strncmp (vtable_symbol_name, "vtable for ", 11))
- error ("can't find linker symbol for virtual table for `%s' value",
- TYPE_NAME (value_type));
+ if (vtable_symbol_name == NULL
+ || strncmp (vtable_symbol_name, "vtable for ", 11))
+ {
+ warning (_("can't find linker symbol for virtual table for `%s' value"),
+ TYPE_NAME (values_type));
+ if (vtable_symbol_name)
+ warning (_(" found `%s' instead"), vtable_symbol_name);
+ return NULL;
+ }
class_name = vtable_symbol_name + 11;
/* Try to look up the class name as a type name. */
- class_symbol = lookup_symbol (class_name, 0, STRUCT_NAMESPACE, 0, 0);
- if (! class_symbol)
- error ("can't find class named `%s', as given by C++ RTTI", class_name);
-
- /* Make sure the type symbol is sane. (An earlier version of this
- code would find constructor functions, who have the same name as
- the class.) */
- if (SYMBOL_CLASS (class_symbol) != LOC_TYPEDEF
- || TYPE_CODE (SYMBOL_TYPE (class_symbol)) != TYPE_CODE_CLASS)
- error ("C++ RTTI gives a class name of `%s', but that isn't a type name",
- class_name);
-
- /* This is the object's run-time type! */
- run_time_type = SYMBOL_TYPE (class_symbol);
+ /* FIXME: chastain/2003-11-26: block=NULL is bogus. See pr gdb/1465. */
+ run_time_type = cp_lookup_rtti_type (class_name, NULL);
+ if (run_time_type == NULL)
+ return NULL;
/* Get the offset from VALUE to the top of the complete object.
NOTE: this is the reverse of the meaning of *TOP_P. */
= value_as_long (value_field (vtable, vtable_field_offset_to_top));
if (full_p)
- *full_p = (- offset_to_top == VALUE_EMBEDDED_OFFSET (value)
- && (TYPE_LENGTH (VALUE_ENCLOSING_TYPE (value))
+ *full_p = (- offset_to_top == value_embedded_offset (value)
+ && (TYPE_LENGTH (value_enclosing_type (value))
>= TYPE_LENGTH (run_time_type)));
if (top_p)
*top_p = - offset_to_top;
struct fn_field *f, int j,
struct type *type, int offset)
{
- struct type *vtable_type = gdbarch_data (vtable_type_gdbarch_data);
+ struct type *vtable_type = gdbarch_data (current_gdbarch,
+ vtable_type_gdbarch_data);
struct value *value = *value_p;
- struct type *value_type = check_typedef (VALUE_TYPE (value));
+ struct type *values_type = check_typedef (value_type (value));
struct type *vfn_base;
CORE_ADDR vtable_address;
struct value *vtable;
struct value *vfn;
/* Some simple sanity checks. */
- if (TYPE_CODE (value_type) != TYPE_CODE_CLASS)
- error ("Only classes can have virtual functions.");
+ if (TYPE_CODE (values_type) != TYPE_CODE_CLASS)
+ error (_("Only classes can have virtual functions."));
/* Find the base class that defines this virtual function. */
vfn_base = TYPE_FN_FIELD_FCONTEXT (f, j);
type now. */
if (TYPE_VPTR_FIELDNO (vfn_base) < 0)
fill_in_vptr_fieldno (vfn_base);
+ if (TYPE_VPTR_FIELDNO (vfn_base) < 0)
+ error (_("Could not find virtual table pointer for class \"%s\"."),
+ TYPE_TAG_NAME (vfn_base) ? TYPE_TAG_NAME (vfn_base) : "<unknown>");
/* Now that we know which base class is defining our virtual
function, cast our value to that baseclass. This takes care of
any necessary `this' adjustments. */
- if (vfn_base != value_type)
+ if (vfn_base != values_type)
value = value_cast (vfn_base, value);
/* Now value is an object of the appropriate base type. Fetch its
virtual table. */
/* It might be possible to do this cast at the same time as the above.
- Does multiple inheritance affect this? */
+ Does multiple inheritance affect this?
+ Can this even trigger, or is TYPE_VPTR_BASETYPE idempotent?
+ */
if (TYPE_VPTR_BASETYPE (vfn_base) != vfn_base)
value = value_cast (TYPE_VPTR_BASETYPE (vfn_base), value);
vtable_address
= value_as_address (value_field (value, TYPE_VPTR_FIELDNO (vfn_base)));
vtable = value_at_lazy (vtable_type,
- vtable_address - vtable_address_point_offset (),
- VALUE_BFD_SECTION (value));
+ vtable_address - vtable_address_point_offset ());
/* Fetch the appropriate function pointer from the vtable. */
vfn = value_subscript (value_field (vtable, vtable_field_virtual_functions),
vfn = value_cast (lookup_pointer_type (TYPE_FN_FIELD_TYPE (f, j)),
vfn);
+ /* Is (type)value always numerically the same as (vfn_base)value?
+ If so we can spare this cast and use one of the ones above. */
+ *value_p = value_addr (value_cast (type, *value_p));
+
return vfn;
}
to (the address of)(ARG) + OFFSET.
-1 is returned on error. */
-int
-gnuv3_baseclass_offset (struct type *type, int index, char *valaddr,
+static int
+gnuv3_baseclass_offset (struct type *type, int index, const bfd_byte *valaddr,
CORE_ADDR address)
{
- struct type *vtable_type = gdbarch_data (vtable_type_gdbarch_data);
- struct type *basetype = TYPE_BASECLASS (type, index);
- struct value *full_object, *vbase_object, *orig_object;
- struct value *vtable, *orig_typeinfo, *orig_base_info;
- struct type *orig_type, *vbasetype;
+ struct type *vtable_type = gdbarch_data (current_gdbarch,
+ vtable_type_gdbarch_data);
+ struct value *vtable;
+ struct type *vbasetype;
struct value *offset_val, *vbase_array;
CORE_ADDR vtable_address;
long int cur_base_offset, base_offset;
- int to_top;
- int baseclasses, i;
/* If it isn't a virtual base, this is easy. The offset is in the
type definition. */
worthwhile. */
cur_base_offset = TYPE_BASECLASS_BITPOS (type, index) / 8;
if (cur_base_offset >= - vtable_address_point_offset ())
- error ("Expected a negative vbase offset (old compiler?)");
+ error (_("Expected a negative vbase offset (old compiler?)"));
cur_base_offset = cur_base_offset + vtable_address_point_offset ();
if ((- cur_base_offset) % TYPE_LENGTH (builtin_type_void_data_ptr) != 0)
- error ("Misaligned vbase offset.");
+ error (_("Misaligned vbase offset."));
cur_base_offset = cur_base_offset
/ ((int) TYPE_LENGTH (builtin_type_void_data_ptr));
/* We're now looking for the cur_base_offset'th entry (negative index)
- in the vcall_and_vbase_offsets array. */
-
- orig_object = value_at_lazy (type, address, NULL);
- vbasetype = TYPE_VPTR_BASETYPE (VALUE_TYPE (orig_object));
- vbase_object = value_cast (vbasetype, orig_object);
-
- vtable_address
- = value_as_address (value_field (vbase_object,
- TYPE_VPTR_FIELDNO (vbasetype)));
+ in the vcall_and_vbase_offsets array. We used to cast the object to
+ its TYPE_VPTR_BASETYPE, and reference the vtable as TYPE_VPTR_FIELDNO;
+ however, that cast can not be done without calling baseclass_offset again
+ if the TYPE_VPTR_BASETYPE is a virtual base class, as described in the
+ v3 C++ ABI Section 2.4.I.2.b. Fortunately the ABI guarantees that the
+ vtable pointer will be located at the beginning of the object, so we can
+ bypass the casting. Verify that the TYPE_VPTR_FIELDNO is in fact at the
+ start of whichever baseclass it resides in, as a sanity measure - iff
+ we have debugging information for that baseclass. */
+
+ vbasetype = TYPE_VPTR_BASETYPE (type);
+ if (TYPE_VPTR_FIELDNO (vbasetype) < 0)
+ fill_in_vptr_fieldno (vbasetype);
+
+ if (TYPE_VPTR_FIELDNO (vbasetype) >= 0
+ && TYPE_FIELD_BITPOS (vbasetype, TYPE_VPTR_FIELDNO (vbasetype)) != 0)
+ error (_("Illegal vptr offset in class %s"),
+ TYPE_NAME (vbasetype) ? TYPE_NAME (vbasetype) : "<unknown>");
+
+ vtable_address = value_as_address (value_at_lazy (builtin_type_void_data_ptr,
+ address));
vtable = value_at_lazy (vtable_type,
- vtable_address - vtable_address_point_offset (),
- NULL);
+ vtable_address - vtable_address_point_offset ());
offset_val = value_from_longest(builtin_type_int, cur_base_offset);
vbase_array = value_field (vtable, vtable_field_vcall_and_vbase_offsets);
base_offset = value_as_long (value_subscript (vbase_array, offset_val));
static void
init_gnuv3_ops (void)
{
- vtable_type_gdbarch_data = register_gdbarch_data (build_gdb_vtable_type, 0);
+ vtable_type_gdbarch_data = gdbarch_data_register_post_init (build_gdb_vtable_type);
gnu_v3_abi_ops.shortname = "gnu-v3";
gnu_v3_abi_ops.longname = "GNU G++ Version 3 ABI";
gnu_v3_abi_ops.doc = "G++ Version 3 ABI";
- gnu_v3_abi_ops.is_destructor_name = is_gnu_v3_mangled_dtor;
- gnu_v3_abi_ops.is_constructor_name = is_gnu_v3_mangled_ctor;
+ gnu_v3_abi_ops.is_destructor_name =
+ (enum dtor_kinds (*) (const char *))is_gnu_v3_mangled_dtor;
+ gnu_v3_abi_ops.is_constructor_name =
+ (enum ctor_kinds (*) (const char *))is_gnu_v3_mangled_ctor;
gnu_v3_abi_ops.is_vtable_name = gnuv3_is_vtable_name;
gnu_v3_abi_ops.is_operator_name = gnuv3_is_operator_name;
gnu_v3_abi_ops.rtti_type = gnuv3_rtti_type;
gnu_v3_abi_ops.baseclass_offset = gnuv3_baseclass_offset;
}
+extern initialize_file_ftype _initialize_gnu_v3_abi; /* -Wmissing-prototypes */
void
_initialize_gnu_v3_abi (void)
{
init_gnuv3_ops ();
- register_cp_abi (gnu_v3_abi_ops);
+ register_cp_abi (&gnu_v3_abi_ops);
}
projects / deliverable / binutils-gdb.git / blobdiff