1 /* Abstraction of GNU v3 abi.
2 Contributed by Jim Blandy <jimb@redhat.com>
3 Copyright 2001 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or
8 modify it under the terms of the GNU General Public License as
9 published by the Free Software Foundation; either version 2 of the
10 License, or (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
26 #include "gdb_assert.h"
28 static struct cp_abi_ops gnu_v3_abi_ops;
31 gnuv3_is_vtable_name (const char *name)
33 return strncmp (name, "_ZTV", 4) == 0;
37 gnuv3_is_operator_name (const char *name)
39 return strncmp (name, "operator", 8) == 0;
43 /* To help us find the components of a vtable, we build ourselves a
44 GDB type object representing the vtable structure. Following the
45 V3 ABI, it goes something like this:
47 struct gdb_gnu_v3_abi_vtable {
49 / * An array of virtual call and virtual base offsets. The real
50 length of this array depends on the class hierarchy; we use
51 negative subscripts to access the elements. Yucky, but
52 better than the alternatives. * /
53 ptrdiff_t vcall_and_vbase_offsets[0];
55 / * The offset from a virtual pointer referring to this table
56 to the top of the complete object. * /
57 ptrdiff_t offset_to_top;
59 / * The type_info pointer for this class. This is really a
60 std::type_info *, but GDB doesn't really look at the
61 type_info object itself, so we don't bother to get the type
65 / * Virtual table pointers in objects point here. * /
67 / * Virtual function pointers. Like the vcall/vbase array, the
68 real length of this table depends on the class hierarchy. * /
69 void (*virtual_functions[0]) ();
73 The catch, of course, is that the exact layout of this table
74 depends on the ABI --- word size, endianness, alignment, etc. So
75 the GDB type object is actually a per-architecture kind of thing.
77 vtable_type_gdbarch_data is a gdbarch per-architecture data pointer
78 which refers to the struct type * for this structure, laid out
79 appropriately for the architecture. */
80 static struct gdbarch_data *vtable_type_gdbarch_data;
83 /* Human-readable names for the numbers of the fields above. */
85 vtable_field_vcall_and_vbase_offsets,
86 vtable_field_offset_to_top,
87 vtable_field_type_info,
88 vtable_field_virtual_functions
92 /* Return a GDB type representing `struct gdb_gnu_v3_abi_vtable',
93 described above, laid out appropriately for ARCH.
95 We use this function as the gdbarch per-architecture data
96 initialization function. We assume that the gdbarch framework
97 calls the per-architecture data initialization functions after it
98 sets current_gdbarch to the new architecture. */
100 build_gdb_vtable_type (struct gdbarch *arch)
103 struct field *field_list, *field;
106 struct type *void_ptr_type
107 = lookup_pointer_type (builtin_type_void);
108 struct type *ptr_to_void_fn_type
109 = lookup_pointer_type (lookup_function_type (builtin_type_void));
111 /* ARCH can't give us the true ptrdiff_t type, so we guess. */
112 struct type *ptrdiff_type
113 = init_type (TYPE_CODE_INT, TARGET_PTR_BIT / TARGET_CHAR_BIT, 0,
116 /* We assume no padding is necessary, since GDB doesn't know
117 anything about alignment at the moment. If this assumption bites
118 us, we should add a gdbarch method which, given a type, returns
119 the alignment that type requires, and then use that here. */
121 /* Build the field list. */
122 field_list = xmalloc (sizeof (struct field [4]));
123 memset (field_list, 0, sizeof (struct field [4]));
124 field = &field_list[0];
127 /* ptrdiff_t vcall_and_vbase_offsets[0]; */
128 FIELD_NAME (*field) = "vcall_and_vbase_offsets";
130 = create_array_type (0, ptrdiff_type,
131 create_range_type (0, builtin_type_int, 0, -1));
132 FIELD_BITPOS (*field) = offset * TARGET_CHAR_BIT;
133 offset += TYPE_LENGTH (FIELD_TYPE (*field));
136 /* ptrdiff_t offset_to_top; */
137 FIELD_NAME (*field) = "offset_to_top";
138 FIELD_TYPE (*field) = ptrdiff_type;
139 FIELD_BITPOS (*field) = offset * TARGET_CHAR_BIT;
140 offset += TYPE_LENGTH (FIELD_TYPE (*field));
143 /* void *type_info; */
144 FIELD_NAME (*field) = "type_info";
145 FIELD_TYPE (*field) = void_ptr_type;
146 FIELD_BITPOS (*field) = offset * TARGET_CHAR_BIT;
147 offset += TYPE_LENGTH (FIELD_TYPE (*field));
150 /* void (*virtual_functions[0]) (); */
151 FIELD_NAME (*field) = "virtual_functions";
153 = create_array_type (0, ptr_to_void_fn_type,
154 create_range_type (0, builtin_type_int, 0, -1));
155 FIELD_BITPOS (*field) = offset * TARGET_CHAR_BIT;
156 offset += TYPE_LENGTH (FIELD_TYPE (*field));
159 /* We assumed in the allocation above that there were four fields. */
160 gdb_assert (field == (field_list + 4));
162 t = init_type (TYPE_CODE_STRUCT, offset, 0, 0, 0);
163 TYPE_NFIELDS (t) = field - field_list;
164 TYPE_FIELDS (t) = field_list;
165 TYPE_TAG_NAME (t) = "gdb_gnu_v3_abi_vtable";
171 /* Return the offset from the start of the imaginary `struct
172 gdb_gnu_v3_abi_vtable' object to the vtable's "address point"
173 (i.e., where objects' virtual table pointers point). */
175 vtable_address_point_offset ()
177 struct type *vtable_type = gdbarch_data (vtable_type_gdbarch_data);
179 return (TYPE_FIELD_BITPOS (vtable_type, vtable_field_virtual_functions)
185 gnuv3_rtti_type (struct value *value,
186 int *full_p, int *top_p, int *using_enc_p)
188 struct type *vtable_type = gdbarch_data (vtable_type_gdbarch_data);
189 struct type *value_type = check_typedef (VALUE_TYPE (value));
190 CORE_ADDR vtable_address;
191 struct value *vtable;
192 struct minimal_symbol *vtable_symbol;
193 const char *vtable_symbol_name;
194 const char *class_name;
195 struct symbol *class_symbol;
196 struct type *run_time_type;
197 struct type *base_type;
198 LONGEST offset_to_top;
200 /* We only have RTTI for class objects. */
201 if (TYPE_CODE (value_type) != TYPE_CODE_CLASS)
204 /* If we can't find the virtual table pointer for value_type, we
205 can't find the RTTI. */
206 fill_in_vptr_fieldno (value_type);
207 if (TYPE_VPTR_FIELDNO (value_type) == -1)
213 /* Fetch VALUE's virtual table pointer, and tweak it to point at
214 an instance of our imaginary gdb_gnu_v3_abi_vtable structure. */
215 base_type = check_typedef (TYPE_VPTR_BASETYPE (value_type));
216 if (value_type != base_type)
218 value = value_cast (base_type, value);
223 = value_as_address (value_field (value, TYPE_VPTR_FIELDNO (value_type)));
224 vtable = value_at_lazy (vtable_type,
225 vtable_address - vtable_address_point_offset (),
226 VALUE_BFD_SECTION (value));
228 /* Find the linker symbol for this vtable. */
230 = lookup_minimal_symbol_by_pc (VALUE_ADDRESS (vtable)
231 + VALUE_OFFSET (vtable)
232 + VALUE_EMBEDDED_OFFSET (vtable));
236 /* The symbol's demangled name should be something like "vtable for
237 CLASS", where CLASS is the name of the run-time type of VALUE.
238 If we didn't like this approach, we could instead look in the
239 type_info object itself to get the class name. But this way
240 should work just as well, and doesn't read target memory. */
241 vtable_symbol_name = SYMBOL_DEMANGLED_NAME (vtable_symbol);
242 if (vtable_symbol_name == NULL
243 || strncmp (vtable_symbol_name, "vtable for ", 11))
244 error ("can't find linker symbol for virtual table for `%s' value",
245 TYPE_NAME (value_type));
246 class_name = vtable_symbol_name + 11;
248 /* Try to look up the class name as a type name. */
249 class_symbol = lookup_symbol (class_name, 0, STRUCT_NAMESPACE, 0, 0);
251 error ("can't find class named `%s', as given by C++ RTTI", class_name);
253 /* Make sure the type symbol is sane. (An earlier version of this
254 code would find constructor functions, who have the same name as
256 if (SYMBOL_CLASS (class_symbol) != LOC_TYPEDEF
257 || TYPE_CODE (SYMBOL_TYPE (class_symbol)) != TYPE_CODE_CLASS)
258 error ("C++ RTTI gives a class name of `%s', but that isn't a type name",
261 /* This is the object's run-time type! */
262 run_time_type = SYMBOL_TYPE (class_symbol);
264 /* Get the offset from VALUE to the top of the complete object.
265 NOTE: this is the reverse of the meaning of *TOP_P. */
267 = value_as_long (value_field (vtable, vtable_field_offset_to_top));
270 *full_p = (- offset_to_top == VALUE_EMBEDDED_OFFSET (value)
271 && (TYPE_LENGTH (VALUE_ENCLOSING_TYPE (value))
272 >= TYPE_LENGTH (run_time_type)));
274 *top_p = - offset_to_top;
276 return run_time_type;
280 static struct value *
281 gnuv3_virtual_fn_field (struct value **value_p,
282 struct fn_field *f, int j,
283 struct type *type, int offset)
285 struct type *vtable_type = gdbarch_data (vtable_type_gdbarch_data);
286 struct value *value = *value_p;
287 struct type *value_type = check_typedef (VALUE_TYPE (value));
288 struct type *vfn_base;
289 CORE_ADDR vtable_address;
290 struct value *vtable;
293 /* Some simple sanity checks. */
294 if (TYPE_CODE (value_type) != TYPE_CODE_CLASS)
295 error ("Only classes can have virtual functions.");
297 /* Find the base class that defines this virtual function. */
298 vfn_base = TYPE_FN_FIELD_FCONTEXT (f, j);
300 /* In programs compiled with G++ version 1, the debug info doesn't
301 say which base class defined the virtual function. We'll guess
302 it's the same base class that has our vtable; this is wrong for
303 multiple inheritance, but it's better than nothing. */
304 vfn_base = TYPE_VPTR_BASETYPE (type);
306 /* This type may have been defined before its virtual function table
307 was. If so, fill in the virtual function table entry for the
309 if (TYPE_VPTR_FIELDNO (vfn_base) < 0)
310 fill_in_vptr_fieldno (vfn_base);
312 /* Now that we know which base class is defining our virtual
313 function, cast our value to that baseclass. This takes care of
314 any necessary `this' adjustments. */
315 if (vfn_base != value_type)
316 value = value_cast (vfn_base, value);
318 /* Now value is an object of the appropriate base type. Fetch its
320 /* It might be possible to do this cast at the same time as the above.
321 Does multiple inheritance affect this? */
322 if (TYPE_VPTR_BASETYPE (vfn_base) != vfn_base)
323 value = value_cast (TYPE_VPTR_BASETYPE (vfn_base), value);
325 = value_as_address (value_field (value, TYPE_VPTR_FIELDNO (vfn_base)));
327 vtable = value_at_lazy (vtable_type,
328 vtable_address - vtable_address_point_offset (),
329 VALUE_BFD_SECTION (value));
331 /* Fetch the appropriate function pointer from the vtable. */
332 vfn = value_subscript (value_field (vtable, vtable_field_virtual_functions),
333 value_from_longest (builtin_type_int,
334 TYPE_FN_FIELD_VOFFSET (f, j)));
336 /* Cast the function pointer to the appropriate type. */
337 vfn = value_cast (lookup_pointer_type (TYPE_FN_FIELD_TYPE (f, j)),
343 /* Compute the offset of the baseclass which is
344 the INDEXth baseclass of class TYPE,
345 for value at VALADDR (in host) at ADDRESS (in target).
346 The result is the offset of the baseclass value relative
347 to (the address of)(ARG) + OFFSET.
349 -1 is returned on error. */
351 gnuv3_baseclass_offset (struct type *type, int index, char *valaddr,
354 struct type *vtable_type = gdbarch_data (vtable_type_gdbarch_data);
355 struct type *basetype = TYPE_BASECLASS (type, index);
356 struct value *full_object, *vbase_object, *orig_object;
357 struct value *vtable, *orig_typeinfo, *orig_base_info;
358 struct type *orig_type, *vbasetype;
359 struct value *offset_val, *vbase_array;
360 CORE_ADDR vtable_address;
361 long int cur_base_offset, base_offset;
365 /* If it isn't a virtual base, this is easy. The offset is in the
367 if (!BASETYPE_VIA_VIRTUAL (type, index))
368 return TYPE_BASECLASS_BITPOS (type, index) / 8;
370 /* To access a virtual base, we need to use the vbase offset stored in
371 our vtable. Recent GCC versions provide this information. If it isn't
372 available, we could get what we needed from RTTI, or from drawing the
373 complete inheritance graph based on the debug info. Neither is
375 cur_base_offset = TYPE_BASECLASS_BITPOS (type, index) / 8;
376 if (cur_base_offset >= - vtable_address_point_offset ())
377 error ("Expected a negative vbase offset (old compiler?)");
379 cur_base_offset = cur_base_offset + vtable_address_point_offset ();
380 if ((- cur_base_offset) % TYPE_LENGTH (builtin_type_void_data_ptr) != 0)
381 error ("Misaligned vbase offset.");
382 cur_base_offset = cur_base_offset
383 / ((int) TYPE_LENGTH (builtin_type_void_data_ptr));
385 /* We're now looking for the cur_base_offset'th entry (negative index)
386 in the vcall_and_vbase_offsets array. */
388 orig_object = value_at_lazy (type, address, NULL);
389 vbasetype = TYPE_VPTR_BASETYPE (VALUE_TYPE (orig_object));
390 vbase_object = value_cast (vbasetype, orig_object);
393 = value_as_address (value_field (vbase_object,
394 TYPE_VPTR_FIELDNO (vbasetype)));
395 vtable = value_at_lazy (vtable_type,
396 vtable_address - vtable_address_point_offset (),
398 offset_val = value_from_longest(builtin_type_int, cur_base_offset);
399 vbase_array = value_field (vtable, vtable_field_vcall_and_vbase_offsets);
400 base_offset = value_as_long (value_subscript (vbase_array, offset_val));
405 init_gnuv3_ops (void)
407 vtable_type_gdbarch_data = register_gdbarch_data (build_gdb_vtable_type, 0);
409 gnu_v3_abi_ops.shortname = "gnu-v3";
410 gnu_v3_abi_ops.longname = "GNU G++ Version 3 ABI";
411 gnu_v3_abi_ops.doc = "G++ Version 3 ABI";
412 gnu_v3_abi_ops.is_destructor_name = is_gnu_v3_mangled_dtor;
413 gnu_v3_abi_ops.is_constructor_name = is_gnu_v3_mangled_ctor;
414 gnu_v3_abi_ops.is_vtable_name = gnuv3_is_vtable_name;
415 gnu_v3_abi_ops.is_operator_name = gnuv3_is_operator_name;
416 gnu_v3_abi_ops.rtti_type = gnuv3_rtti_type;
417 gnu_v3_abi_ops.virtual_fn_field = gnuv3_virtual_fn_field;
418 gnu_v3_abi_ops.baseclass_offset = gnuv3_baseclass_offset;
423 _initialize_gnu_v3_abi (void)
427 register_cp_abi (gnu_v3_abi_ops);