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 LONGEST offset_to_top
;
199 /* We only have RTTI for class objects. */
200 if (TYPE_CODE (value_type
) != TYPE_CODE_CLASS
)
203 /* If we can't find the virtual table pointer for value_type, we
204 can't find the RTTI. */
205 fill_in_vptr_fieldno (value_type
);
206 if (TYPE_VPTR_FIELDNO (value_type
) == -1)
209 /* Fetch VALUE's virtual table pointer, and tweak it to point at
210 an instance of our imaginary gdb_gnu_v3_abi_vtable structure. */
212 = value_as_pointer (value_field (value
, TYPE_VPTR_FIELDNO (value_type
)));
213 vtable
= value_at_lazy (vtable_type
,
214 vtable_address
- vtable_address_point_offset (),
215 VALUE_BFD_SECTION (value
));
217 /* Find the linker symbol for this vtable. */
219 = lookup_minimal_symbol_by_pc (VALUE_ADDRESS (vtable
)
220 + VALUE_OFFSET (vtable
)
221 + VALUE_EMBEDDED_OFFSET (vtable
));
225 /* The symbol's demangled name should be something like "vtable for
226 CLASS", where CLASS is the name of the run-time type of VALUE.
227 If we didn't like this approach, we could instead look in the
228 type_info object itself to get the class name. But this way
229 should work just as well, and doesn't read target memory. */
230 vtable_symbol_name
= SYMBOL_DEMANGLED_NAME (vtable_symbol
);
231 if (strncmp (vtable_symbol_name
, "vtable for ", 11))
232 error ("can't find linker symbol for virtual table for `%s' value",
233 TYPE_NAME (value_type
));
234 class_name
= vtable_symbol_name
+ 11;
236 /* Try to look up the class name as a type name. */
237 class_symbol
= lookup_symbol (class_name
, 0, STRUCT_NAMESPACE
, 0, 0);
239 error ("can't find class named `%s', as given by C++ RTTI", class_name
);
241 /* Make sure the type symbol is sane. (An earlier version of this
242 code would find constructor functions, who have the same name as
244 if (SYMBOL_CLASS (class_symbol
) != LOC_TYPEDEF
245 || TYPE_CODE (SYMBOL_TYPE (class_symbol
)) != TYPE_CODE_CLASS
)
246 error ("C++ RTTI gives a class name of `%s', but that isn't a type name",
249 /* This is the object's run-time type! */
250 run_time_type
= SYMBOL_TYPE (class_symbol
);
252 /* Get the offset from VALUE to the top of the complete object.
253 NOTE: this is the reverse of the meaning of *TOP_P. */
255 = value_as_long (value_field (vtable
, vtable_field_offset_to_top
));
258 *full_p
= (- offset_to_top
== VALUE_EMBEDDED_OFFSET (value
)
259 && (TYPE_LENGTH (VALUE_ENCLOSING_TYPE (value
))
260 >= TYPE_LENGTH (run_time_type
)));
262 *top_p
= - offset_to_top
;
266 return run_time_type
;
270 static struct value
*
271 gnuv3_virtual_fn_field (struct value
**value_p
,
272 struct fn_field
*f
, int j
,
273 struct type
*type
, int offset
)
275 struct type
*vtable_type
= gdbarch_data (vtable_type_gdbarch_data
);
276 struct value
*value
= *value_p
;
277 struct type
*value_type
= check_typedef (VALUE_TYPE (value
));
278 struct type
*vfn_base
;
279 CORE_ADDR vtable_address
;
280 struct value
*vtable
;
283 /* Some simple sanity checks. */
284 if (TYPE_CODE (value_type
) != TYPE_CODE_CLASS
)
285 error ("Only classes can have virtual functions.");
287 /* Find the base class that defines this virtual function. */
288 vfn_base
= TYPE_FN_FIELD_FCONTEXT (f
, j
);
290 /* In programs compiled with G++ version 1, the debug info doesn't
291 say which base class defined the virtual function. We'll guess
292 it's the same base class that has our vtable; this is wrong for
293 multiple inheritance, but it's better than nothing. */
294 vfn_base
= TYPE_VPTR_BASETYPE (type
);
296 /* This type may have been defined before its virtual function table
297 was. If so, fill in the virtual function table entry for the
299 if (TYPE_VPTR_FIELDNO (vfn_base
) < 0)
300 fill_in_vptr_fieldno (vfn_base
);
302 /* Now that we know which base class is defining our virtual
303 function, cast our value to that baseclass. This takes care of
304 any necessary `this' adjustments. */
305 if (vfn_base
!= value_type
)
306 /* It would be nicer to simply cast the value to the appropriate
307 base class (and I think that is supposed to be legal), but
308 value_cast only does the right magic when casting pointers. */
309 value
= value_ind (value_cast (vfn_base
, value_addr (value
)));
311 /* Now value is an object of the appropriate base type. Fetch its
314 = value_as_pointer (value_field (value
, TYPE_VPTR_FIELDNO (vfn_base
)));
315 vtable
= value_at_lazy (vtable_type
,
316 vtable_address
- vtable_address_point_offset (),
317 VALUE_BFD_SECTION (value
));
319 /* Fetch the appropriate function pointer from the vtable. */
320 vfn
= value_subscript (value_field (vtable
, vtable_field_virtual_functions
),
321 value_from_longest (builtin_type_int
,
322 TYPE_FN_FIELD_VOFFSET (f
, j
)));
324 /* Cast the function pointer to the appropriate type. */
325 vfn
= value_cast (lookup_pointer_type (TYPE_FN_FIELD_TYPE (f
, j
)),
333 init_gnuv3_ops (void)
335 vtable_type_gdbarch_data
= register_gdbarch_data (build_gdb_vtable_type
, 0);
337 gnu_v3_abi_ops
.shortname
= "gnu-v3";
338 gnu_v3_abi_ops
.longname
= "GNU G++ Version 3 ABI";
339 gnu_v3_abi_ops
.doc
= "G++ Version 3 ABI";
340 gnu_v3_abi_ops
.is_destructor_name
= is_gnu_v3_mangled_dtor
;
341 gnu_v3_abi_ops
.is_constructor_name
= is_gnu_v3_mangled_ctor
;
342 gnu_v3_abi_ops
.is_vtable_name
= gnuv3_is_vtable_name
;
343 gnu_v3_abi_ops
.is_operator_name
= gnuv3_is_operator_name
;
344 gnu_v3_abi_ops
.rtti_type
= gnuv3_rtti_type
;
345 gnu_v3_abi_ops
.virtual_fn_field
= gnuv3_virtual_fn_field
;
350 _initialize_gnu_v3_abi (void)
354 register_cp_abi (gnu_v3_abi_ops
);