1 /* Abstraction of GNU v3 abi.
2 Contributed by Jim Blandy <jimb@redhat.com>
4 Copyright (C) 2001-2014 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include "cp-support.h"
29 #include "typeprint.h"
31 static struct cp_abi_ops gnu_v3_abi_ops;
33 /* A gdbarch key for std::type_info, in the event that it can't be
34 found in the debug info. */
36 static struct gdbarch_data *std_type_info_gdbarch_data;
40 gnuv3_is_vtable_name (const char *name)
42 return strncmp (name, "_ZTV", 4) == 0;
46 gnuv3_is_operator_name (const char *name)
48 return strncmp (name, "operator", 8) == 0;
52 /* To help us find the components of a vtable, we build ourselves a
53 GDB type object representing the vtable structure. Following the
54 V3 ABI, it goes something like this:
56 struct gdb_gnu_v3_abi_vtable {
58 / * An array of virtual call and virtual base offsets. The real
59 length of this array depends on the class hierarchy; we use
60 negative subscripts to access the elements. Yucky, but
61 better than the alternatives. * /
62 ptrdiff_t vcall_and_vbase_offsets[0];
64 / * The offset from a virtual pointer referring to this table
65 to the top of the complete object. * /
66 ptrdiff_t offset_to_top;
68 / * The type_info pointer for this class. This is really a
69 std::type_info *, but GDB doesn't really look at the
70 type_info object itself, so we don't bother to get the type
74 / * Virtual table pointers in objects point here. * /
76 / * Virtual function pointers. Like the vcall/vbase array, the
77 real length of this table depends on the class hierarchy. * /
78 void (*virtual_functions[0]) ();
82 The catch, of course, is that the exact layout of this table
83 depends on the ABI --- word size, endianness, alignment, etc. So
84 the GDB type object is actually a per-architecture kind of thing.
86 vtable_type_gdbarch_data is a gdbarch per-architecture data pointer
87 which refers to the struct type * for this structure, laid out
88 appropriately for the architecture. */
89 static struct gdbarch_data *vtable_type_gdbarch_data;
92 /* Human-readable names for the numbers of the fields above. */
94 vtable_field_vcall_and_vbase_offsets,
95 vtable_field_offset_to_top,
96 vtable_field_type_info,
97 vtable_field_virtual_functions
101 /* Return a GDB type representing `struct gdb_gnu_v3_abi_vtable',
102 described above, laid out appropriately for ARCH.
104 We use this function as the gdbarch per-architecture data
105 initialization function. */
107 build_gdb_vtable_type (struct gdbarch *arch)
110 struct field *field_list, *field;
113 struct type *void_ptr_type
114 = builtin_type (arch)->builtin_data_ptr;
115 struct type *ptr_to_void_fn_type
116 = builtin_type (arch)->builtin_func_ptr;
118 /* ARCH can't give us the true ptrdiff_t type, so we guess. */
119 struct type *ptrdiff_type
120 = arch_integer_type (arch, gdbarch_ptr_bit (arch), 0, "ptrdiff_t");
122 /* We assume no padding is necessary, since GDB doesn't know
123 anything about alignment at the moment. If this assumption bites
124 us, we should add a gdbarch method which, given a type, returns
125 the alignment that type requires, and then use that here. */
127 /* Build the field list. */
128 field_list = xmalloc (sizeof (struct field [4]));
129 memset (field_list, 0, sizeof (struct field [4]));
130 field = &field_list[0];
133 /* ptrdiff_t vcall_and_vbase_offsets[0]; */
134 FIELD_NAME (*field) = "vcall_and_vbase_offsets";
135 FIELD_TYPE (*field) = lookup_array_range_type (ptrdiff_type, 0, -1);
136 SET_FIELD_BITPOS (*field, offset * TARGET_CHAR_BIT);
137 offset += TYPE_LENGTH (FIELD_TYPE (*field));
140 /* ptrdiff_t offset_to_top; */
141 FIELD_NAME (*field) = "offset_to_top";
142 FIELD_TYPE (*field) = ptrdiff_type;
143 SET_FIELD_BITPOS (*field, offset * TARGET_CHAR_BIT);
144 offset += TYPE_LENGTH (FIELD_TYPE (*field));
147 /* void *type_info; */
148 FIELD_NAME (*field) = "type_info";
149 FIELD_TYPE (*field) = void_ptr_type;
150 SET_FIELD_BITPOS (*field, offset * TARGET_CHAR_BIT);
151 offset += TYPE_LENGTH (FIELD_TYPE (*field));
154 /* void (*virtual_functions[0]) (); */
155 FIELD_NAME (*field) = "virtual_functions";
156 FIELD_TYPE (*field) = lookup_array_range_type (ptr_to_void_fn_type, 0, -1);
157 SET_FIELD_BITPOS (*field, offset * TARGET_CHAR_BIT);
158 offset += TYPE_LENGTH (FIELD_TYPE (*field));
161 /* We assumed in the allocation above that there were four fields. */
162 gdb_assert (field == (field_list + 4));
164 t = arch_type (arch, TYPE_CODE_STRUCT, offset, NULL);
165 TYPE_NFIELDS (t) = field - field_list;
166 TYPE_FIELDS (t) = field_list;
167 TYPE_TAG_NAME (t) = "gdb_gnu_v3_abi_vtable";
168 INIT_CPLUS_SPECIFIC (t);
170 return make_type_with_address_space (t, TYPE_INSTANCE_FLAG_CODE_SPACE);
174 /* Return the ptrdiff_t type used in the vtable type. */
176 vtable_ptrdiff_type (struct gdbarch *gdbarch)
178 struct type *vtable_type = gdbarch_data (gdbarch, vtable_type_gdbarch_data);
180 /* The "offset_to_top" field has the appropriate (ptrdiff_t) type. */
181 return TYPE_FIELD_TYPE (vtable_type, vtable_field_offset_to_top);
184 /* Return the offset from the start of the imaginary `struct
185 gdb_gnu_v3_abi_vtable' object to the vtable's "address point"
186 (i.e., where objects' virtual table pointers point). */
188 vtable_address_point_offset (struct gdbarch *gdbarch)
190 struct type *vtable_type = gdbarch_data (gdbarch, vtable_type_gdbarch_data);
192 return (TYPE_FIELD_BITPOS (vtable_type, vtable_field_virtual_functions)
197 /* Determine whether structure TYPE is a dynamic class. Cache the
201 gnuv3_dynamic_class (struct type *type)
203 int fieldnum, fieldelem;
205 if (TYPE_CPLUS_DYNAMIC (type))
206 return TYPE_CPLUS_DYNAMIC (type) == 1;
208 ALLOCATE_CPLUS_STRUCT_TYPE (type);
210 for (fieldnum = 0; fieldnum < TYPE_N_BASECLASSES (type); fieldnum++)
211 if (BASETYPE_VIA_VIRTUAL (type, fieldnum)
212 || gnuv3_dynamic_class (TYPE_FIELD_TYPE (type, fieldnum)))
214 TYPE_CPLUS_DYNAMIC (type) = 1;
218 for (fieldnum = 0; fieldnum < TYPE_NFN_FIELDS (type); fieldnum++)
219 for (fieldelem = 0; fieldelem < TYPE_FN_FIELDLIST_LENGTH (type, fieldnum);
222 struct fn_field *f = TYPE_FN_FIELDLIST1 (type, fieldnum);
224 if (TYPE_FN_FIELD_VIRTUAL_P (f, fieldelem))
226 TYPE_CPLUS_DYNAMIC (type) = 1;
231 TYPE_CPLUS_DYNAMIC (type) = -1;
235 /* Find the vtable for a value of CONTAINER_TYPE located at
236 CONTAINER_ADDR. Return a value of the correct vtable type for this
237 architecture, or NULL if CONTAINER does not have a vtable. */
239 static struct value *
240 gnuv3_get_vtable (struct gdbarch *gdbarch,
241 struct type *container_type, CORE_ADDR container_addr)
243 struct type *vtable_type = gdbarch_data (gdbarch,
244 vtable_type_gdbarch_data);
245 struct type *vtable_pointer_type;
246 struct value *vtable_pointer;
247 CORE_ADDR vtable_address;
249 /* If this type does not have a virtual table, don't read the first
251 if (!gnuv3_dynamic_class (check_typedef (container_type)))
254 /* We do not consult the debug information to find the virtual table.
255 The ABI specifies that it is always at offset zero in any class,
256 and debug information may not represent it.
258 We avoid using value_contents on principle, because the object might
261 /* Find the type "pointer to virtual table". */
262 vtable_pointer_type = lookup_pointer_type (vtable_type);
264 /* Load it from the start of the class. */
265 vtable_pointer = value_at (vtable_pointer_type, container_addr);
266 vtable_address = value_as_address (vtable_pointer);
268 /* Correct it to point at the start of the virtual table, rather
269 than the address point. */
270 return value_at_lazy (vtable_type,
272 - vtable_address_point_offset (gdbarch));
277 gnuv3_rtti_type (struct value *value,
278 int *full_p, int *top_p, int *using_enc_p)
280 struct gdbarch *gdbarch;
281 struct type *values_type = check_typedef (value_type (value));
282 struct value *vtable;
283 struct minimal_symbol *vtable_symbol;
284 const char *vtable_symbol_name;
285 const char *class_name;
286 struct type *run_time_type;
287 LONGEST offset_to_top;
290 /* We only have RTTI for class objects. */
291 if (TYPE_CODE (values_type) != TYPE_CODE_CLASS)
294 /* Java doesn't have RTTI following the C++ ABI. */
295 if (TYPE_CPLUS_REALLY_JAVA (values_type))
298 /* Determine architecture. */
299 gdbarch = get_type_arch (values_type);
304 vtable = gnuv3_get_vtable (gdbarch, value_type (value),
305 value_as_address (value_addr (value)));
309 /* Find the linker symbol for this vtable. */
311 = lookup_minimal_symbol_by_pc (value_address (vtable)
312 + value_embedded_offset (vtable)).minsym;
316 /* The symbol's demangled name should be something like "vtable for
317 CLASS", where CLASS is the name of the run-time type of VALUE.
318 If we didn't like this approach, we could instead look in the
319 type_info object itself to get the class name. But this way
320 should work just as well, and doesn't read target memory. */
321 vtable_symbol_name = MSYMBOL_DEMANGLED_NAME (vtable_symbol);
322 if (vtable_symbol_name == NULL
323 || strncmp (vtable_symbol_name, "vtable for ", 11))
325 warning (_("can't find linker symbol for virtual table for `%s' value"),
326 TYPE_SAFE_NAME (values_type));
327 if (vtable_symbol_name)
328 warning (_(" found `%s' instead"), vtable_symbol_name);
331 class_name = vtable_symbol_name + 11;
333 /* Strip off @plt and version suffixes. */
334 atsign = strchr (class_name, '@');
339 copy = alloca (atsign - class_name + 1);
340 memcpy (copy, class_name, atsign - class_name);
341 copy[atsign - class_name] = '\0';
345 /* Try to look up the class name as a type name. */
346 /* FIXME: chastain/2003-11-26: block=NULL is bogus. See pr gdb/1465. */
347 run_time_type = cp_lookup_rtti_type (class_name, NULL);
348 if (run_time_type == NULL)
351 /* Get the offset from VALUE to the top of the complete object.
352 NOTE: this is the reverse of the meaning of *TOP_P. */
354 = value_as_long (value_field (vtable, vtable_field_offset_to_top));
357 *full_p = (- offset_to_top == value_embedded_offset (value)
358 && (TYPE_LENGTH (value_enclosing_type (value))
359 >= TYPE_LENGTH (run_time_type)));
361 *top_p = - offset_to_top;
362 return run_time_type;
365 /* Return a function pointer for CONTAINER's VTABLE_INDEX'th virtual
366 function, of type FNTYPE. */
368 static struct value *
369 gnuv3_get_virtual_fn (struct gdbarch *gdbarch, struct value *container,
370 struct type *fntype, int vtable_index)
372 struct value *vtable, *vfn;
374 /* Every class with virtual functions must have a vtable. */
375 vtable = gnuv3_get_vtable (gdbarch, value_type (container),
376 value_as_address (value_addr (container)));
377 gdb_assert (vtable != NULL);
379 /* Fetch the appropriate function pointer from the vtable. */
380 vfn = value_subscript (value_field (vtable, vtable_field_virtual_functions),
383 /* If this architecture uses function descriptors directly in the vtable,
384 then the address of the vtable entry is actually a "function pointer"
385 (i.e. points to the descriptor). We don't need to scale the index
386 by the size of a function descriptor; GCC does that before outputing
387 debug information. */
388 if (gdbarch_vtable_function_descriptors (gdbarch))
389 vfn = value_addr (vfn);
391 /* Cast the function pointer to the appropriate type. */
392 vfn = value_cast (lookup_pointer_type (fntype), vfn);
397 /* GNU v3 implementation of value_virtual_fn_field. See cp-abi.h
398 for a description of the arguments. */
400 static struct value *
401 gnuv3_virtual_fn_field (struct value **value_p,
402 struct fn_field *f, int j,
403 struct type *vfn_base, int offset)
405 struct type *values_type = check_typedef (value_type (*value_p));
406 struct gdbarch *gdbarch;
408 /* Some simple sanity checks. */
409 if (TYPE_CODE (values_type) != TYPE_CODE_CLASS)
410 error (_("Only classes can have virtual functions."));
412 /* Determine architecture. */
413 gdbarch = get_type_arch (values_type);
415 /* Cast our value to the base class which defines this virtual
416 function. This takes care of any necessary `this'
418 if (vfn_base != values_type)
419 *value_p = value_cast (vfn_base, *value_p);
421 return gnuv3_get_virtual_fn (gdbarch, *value_p, TYPE_FN_FIELD_TYPE (f, j),
422 TYPE_FN_FIELD_VOFFSET (f, j));
425 /* Compute the offset of the baseclass which is
426 the INDEXth baseclass of class TYPE,
427 for value at VALADDR (in host) at ADDRESS (in target).
428 The result is the offset of the baseclass value relative
429 to (the address of)(ARG) + OFFSET.
431 -1 is returned on error. */
434 gnuv3_baseclass_offset (struct type *type, int index,
435 const bfd_byte *valaddr, int embedded_offset,
436 CORE_ADDR address, const struct value *val)
438 struct gdbarch *gdbarch;
439 struct type *ptr_type;
440 struct value *vtable;
441 struct value *vbase_array;
442 long int cur_base_offset, base_offset;
444 /* Determine architecture. */
445 gdbarch = get_type_arch (type);
446 ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
448 /* If it isn't a virtual base, this is easy. The offset is in the
449 type definition. Likewise for Java, which doesn't really have
450 virtual inheritance in the C++ sense. */
451 if (!BASETYPE_VIA_VIRTUAL (type, index) || TYPE_CPLUS_REALLY_JAVA (type))
452 return TYPE_BASECLASS_BITPOS (type, index) / 8;
454 /* To access a virtual base, we need to use the vbase offset stored in
455 our vtable. Recent GCC versions provide this information. If it isn't
456 available, we could get what we needed from RTTI, or from drawing the
457 complete inheritance graph based on the debug info. Neither is
459 cur_base_offset = TYPE_BASECLASS_BITPOS (type, index) / 8;
460 if (cur_base_offset >= - vtable_address_point_offset (gdbarch))
461 error (_("Expected a negative vbase offset (old compiler?)"));
463 cur_base_offset = cur_base_offset + vtable_address_point_offset (gdbarch);
464 if ((- cur_base_offset) % TYPE_LENGTH (ptr_type) != 0)
465 error (_("Misaligned vbase offset."));
466 cur_base_offset = cur_base_offset / ((int) TYPE_LENGTH (ptr_type));
468 vtable = gnuv3_get_vtable (gdbarch, type, address + embedded_offset);
469 gdb_assert (vtable != NULL);
470 vbase_array = value_field (vtable, vtable_field_vcall_and_vbase_offsets);
471 base_offset = value_as_long (value_subscript (vbase_array, cur_base_offset));
475 /* Locate a virtual method in DOMAIN or its non-virtual base classes
476 which has virtual table index VOFFSET. The method has an associated
477 "this" adjustment of ADJUSTMENT bytes. */
480 gnuv3_find_method_in (struct type *domain, CORE_ADDR voffset,
485 /* Search this class first. */
490 len = TYPE_NFN_FIELDS (domain);
491 for (i = 0; i < len; i++)
496 f = TYPE_FN_FIELDLIST1 (domain, i);
497 len2 = TYPE_FN_FIELDLIST_LENGTH (domain, i);
499 check_stub_method_group (domain, i);
500 for (j = 0; j < len2; j++)
501 if (TYPE_FN_FIELD_VOFFSET (f, j) == voffset)
502 return TYPE_FN_FIELD_PHYSNAME (f, j);
506 /* Next search non-virtual bases. If it's in a virtual base,
507 we're out of luck. */
508 for (i = 0; i < TYPE_N_BASECLASSES (domain); i++)
511 struct type *basetype;
513 if (BASETYPE_VIA_VIRTUAL (domain, i))
516 pos = TYPE_BASECLASS_BITPOS (domain, i) / 8;
517 basetype = TYPE_FIELD_TYPE (domain, i);
518 /* Recurse with a modified adjustment. We don't need to adjust
520 if (adjustment >= pos && adjustment < pos + TYPE_LENGTH (basetype))
521 return gnuv3_find_method_in (basetype, voffset, adjustment - pos);
527 /* Decode GNU v3 method pointer. */
530 gnuv3_decode_method_ptr (struct gdbarch *gdbarch,
531 const gdb_byte *contents,
533 LONGEST *adjustment_p)
535 struct type *funcptr_type = builtin_type (gdbarch)->builtin_func_ptr;
536 struct type *offset_type = vtable_ptrdiff_type (gdbarch);
537 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
539 LONGEST voffset, adjustment;
542 /* Extract the pointer to member. The first element is either a pointer
543 or a vtable offset. For pointers, we need to use extract_typed_address
544 to allow the back-end to convert the pointer to a GDB address -- but
545 vtable offsets we must handle as integers. At this point, we do not
546 yet know which case we have, so we extract the value under both
547 interpretations and choose the right one later on. */
548 ptr_value = extract_typed_address (contents, funcptr_type);
549 voffset = extract_signed_integer (contents,
550 TYPE_LENGTH (funcptr_type), byte_order);
551 contents += TYPE_LENGTH (funcptr_type);
552 adjustment = extract_signed_integer (contents,
553 TYPE_LENGTH (offset_type), byte_order);
555 if (!gdbarch_vbit_in_delta (gdbarch))
558 voffset = voffset ^ vbit;
562 vbit = adjustment & 1;
563 adjustment = adjustment >> 1;
566 *value_p = vbit? voffset : ptr_value;
567 *adjustment_p = adjustment;
571 /* GNU v3 implementation of cplus_print_method_ptr. */
574 gnuv3_print_method_ptr (const gdb_byte *contents,
576 struct ui_file *stream)
578 struct type *domain = TYPE_DOMAIN_TYPE (type);
579 struct gdbarch *gdbarch = get_type_arch (domain);
584 /* Extract the pointer to member. */
585 vbit = gnuv3_decode_method_ptr (gdbarch, contents, &ptr_value, &adjustment);
587 /* Check for NULL. */
588 if (ptr_value == 0 && vbit == 0)
590 fprintf_filtered (stream, "NULL");
594 /* Search for a virtual method. */
598 const char *physname;
600 /* It's a virtual table offset, maybe in this class. Search
601 for a field with the correct vtable offset. First convert it
602 to an index, as used in TYPE_FN_FIELD_VOFFSET. */
603 voffset = ptr_value / TYPE_LENGTH (vtable_ptrdiff_type (gdbarch));
605 physname = gnuv3_find_method_in (domain, voffset, adjustment);
607 /* If we found a method, print that. We don't bother to disambiguate
608 possible paths to the method based on the adjustment. */
611 char *demangled_name = gdb_demangle (physname,
612 DMGL_ANSI | DMGL_PARAMS);
614 fprintf_filtered (stream, "&virtual ");
615 if (demangled_name == NULL)
616 fputs_filtered (physname, stream);
619 fputs_filtered (demangled_name, stream);
620 xfree (demangled_name);
625 else if (ptr_value != 0)
627 /* Found a non-virtual function: print out the type. */
628 fputs_filtered ("(", stream);
629 c_print_type (type, "", stream, -1, 0, &type_print_raw_options);
630 fputs_filtered (") ", stream);
633 /* We didn't find it; print the raw data. */
636 fprintf_filtered (stream, "&virtual table offset ");
637 print_longest (stream, 'd', 1, ptr_value);
641 struct value_print_options opts;
643 get_user_print_options (&opts);
644 print_address_demangle (&opts, gdbarch, ptr_value, stream, demangle);
649 fprintf_filtered (stream, ", this adjustment ");
650 print_longest (stream, 'd', 1, adjustment);
654 /* GNU v3 implementation of cplus_method_ptr_size. */
657 gnuv3_method_ptr_size (struct type *type)
659 struct gdbarch *gdbarch = get_type_arch (type);
661 return 2 * TYPE_LENGTH (builtin_type (gdbarch)->builtin_data_ptr);
664 /* GNU v3 implementation of cplus_make_method_ptr. */
667 gnuv3_make_method_ptr (struct type *type, gdb_byte *contents,
668 CORE_ADDR value, int is_virtual)
670 struct gdbarch *gdbarch = get_type_arch (type);
671 int size = TYPE_LENGTH (builtin_type (gdbarch)->builtin_data_ptr);
672 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
674 /* FIXME drow/2006-12-24: The adjustment of "this" is currently
675 always zero, since the method pointer is of the correct type.
676 But if the method pointer came from a base class, this is
677 incorrect - it should be the offset to the base. The best
678 fix might be to create the pointer to member pointing at the
679 base class and cast it to the derived class, but that requires
680 support for adjusting pointers to members when casting them -
681 not currently supported by GDB. */
683 if (!gdbarch_vbit_in_delta (gdbarch))
685 store_unsigned_integer (contents, size, byte_order, value | is_virtual);
686 store_unsigned_integer (contents + size, size, byte_order, 0);
690 store_unsigned_integer (contents, size, byte_order, value);
691 store_unsigned_integer (contents + size, size, byte_order, is_virtual);
695 /* GNU v3 implementation of cplus_method_ptr_to_value. */
697 static struct value *
698 gnuv3_method_ptr_to_value (struct value **this_p, struct value *method_ptr)
700 struct gdbarch *gdbarch;
701 const gdb_byte *contents = value_contents (method_ptr);
703 struct type *domain_type, *final_type, *method_type;
707 domain_type = TYPE_DOMAIN_TYPE (check_typedef (value_type (method_ptr)));
708 final_type = lookup_pointer_type (domain_type);
710 method_type = TYPE_TARGET_TYPE (check_typedef (value_type (method_ptr)));
712 /* Extract the pointer to member. */
713 gdbarch = get_type_arch (domain_type);
714 vbit = gnuv3_decode_method_ptr (gdbarch, contents, &ptr_value, &adjustment);
716 /* First convert THIS to match the containing type of the pointer to
717 member. This cast may adjust the value of THIS. */
718 *this_p = value_cast (final_type, *this_p);
720 /* Then apply whatever adjustment is necessary. This creates a somewhat
721 strange pointer: it claims to have type FINAL_TYPE, but in fact it
722 might not be a valid FINAL_TYPE. For instance, it might be a
723 base class of FINAL_TYPE. And if it's not the primary base class,
724 then printing it out as a FINAL_TYPE object would produce some pretty
727 But we don't really know the type of the first argument in
728 METHOD_TYPE either, which is why this happens. We can't
729 dereference this later as a FINAL_TYPE, but once we arrive in the
730 called method we'll have debugging information for the type of
731 "this" - and that'll match the value we produce here.
733 You can provoke this case by casting a Base::* to a Derived::*, for
735 *this_p = value_cast (builtin_type (gdbarch)->builtin_data_ptr, *this_p);
736 *this_p = value_ptradd (*this_p, adjustment);
737 *this_p = value_cast (final_type, *this_p);
743 voffset = ptr_value / TYPE_LENGTH (vtable_ptrdiff_type (gdbarch));
744 return gnuv3_get_virtual_fn (gdbarch, value_ind (*this_p),
745 method_type, voffset);
748 return value_from_pointer (lookup_pointer_type (method_type), ptr_value);
751 /* Objects of this type are stored in a hash table and a vector when
752 printing the vtables for a class. */
754 struct value_and_voffset
756 /* The value representing the object. */
759 /* The maximum vtable offset we've found for any object at this
760 offset in the outermost object. */
764 typedef struct value_and_voffset *value_and_voffset_p;
765 DEF_VEC_P (value_and_voffset_p);
767 /* Hash function for value_and_voffset. */
770 hash_value_and_voffset (const void *p)
772 const struct value_and_voffset *o = p;
774 return value_address (o->value) + value_embedded_offset (o->value);
777 /* Equality function for value_and_voffset. */
780 eq_value_and_voffset (const void *a, const void *b)
782 const struct value_and_voffset *ova = a;
783 const struct value_and_voffset *ovb = b;
785 return (value_address (ova->value) + value_embedded_offset (ova->value)
786 == value_address (ovb->value) + value_embedded_offset (ovb->value));
789 /* qsort comparison function for value_and_voffset. */
792 compare_value_and_voffset (const void *a, const void *b)
794 const struct value_and_voffset * const *ova = a;
795 CORE_ADDR addra = (value_address ((*ova)->value)
796 + value_embedded_offset ((*ova)->value));
797 const struct value_and_voffset * const *ovb = b;
798 CORE_ADDR addrb = (value_address ((*ovb)->value)
799 + value_embedded_offset ((*ovb)->value));
808 /* A helper function used when printing vtables. This determines the
809 key (most derived) sub-object at each address and also computes the
810 maximum vtable offset seen for the corresponding vtable. Updates
811 OFFSET_HASH and OFFSET_VEC with a new value_and_voffset object, if
812 needed. VALUE is the object to examine. */
815 compute_vtable_size (htab_t offset_hash,
816 VEC (value_and_voffset_p) **offset_vec,
820 struct type *type = check_typedef (value_type (value));
822 struct value_and_voffset search_vo, *current_vo;
824 /* If the object is not dynamic, then we are done; as it cannot have
825 dynamic base types either. */
826 if (!gnuv3_dynamic_class (type))
829 /* Update the hash and the vec, if needed. */
830 search_vo.value = value;
831 slot = htab_find_slot (offset_hash, &search_vo, INSERT);
836 current_vo = XNEW (struct value_and_voffset);
837 current_vo->value = value;
838 current_vo->max_voffset = -1;
840 VEC_safe_push (value_and_voffset_p, *offset_vec, current_vo);
843 /* Update the value_and_voffset object with the highest vtable
844 offset from this class. */
845 for (i = 0; i < TYPE_NFN_FIELDS (type); ++i)
848 struct fn_field *fn = TYPE_FN_FIELDLIST1 (type, i);
850 for (j = 0; j < TYPE_FN_FIELDLIST_LENGTH (type, i); ++j)
852 if (TYPE_FN_FIELD_VIRTUAL_P (fn, j))
854 int voffset = TYPE_FN_FIELD_VOFFSET (fn, j);
856 if (voffset > current_vo->max_voffset)
857 current_vo->max_voffset = voffset;
862 /* Recurse into base classes. */
863 for (i = 0; i < TYPE_N_BASECLASSES (type); ++i)
864 compute_vtable_size (offset_hash, offset_vec, value_field (value, i));
867 /* Helper for gnuv3_print_vtable that prints a single vtable. */
870 print_one_vtable (struct gdbarch *gdbarch, struct value *value,
872 struct value_print_options *opts)
875 struct type *type = check_typedef (value_type (value));
876 struct value *vtable;
879 vtable = gnuv3_get_vtable (gdbarch, type,
880 value_address (value)
881 + value_embedded_offset (value));
882 vt_addr = value_address (value_field (vtable,
883 vtable_field_virtual_functions));
885 printf_filtered (_("vtable for '%s' @ %s (subobject @ %s):\n"),
886 TYPE_SAFE_NAME (type),
887 paddress (gdbarch, vt_addr),
888 paddress (gdbarch, (value_address (value)
889 + value_embedded_offset (value))));
891 for (i = 0; i <= max_voffset; ++i)
893 /* Initialize it just to avoid a GCC false warning. */
896 volatile struct gdb_exception ex;
898 printf_filtered ("[%d]: ", i);
900 vfn = value_subscript (value_field (vtable,
901 vtable_field_virtual_functions),
904 if (gdbarch_vtable_function_descriptors (gdbarch))
905 vfn = value_addr (vfn);
907 TRY_CATCH (ex, RETURN_MASK_ERROR)
909 addr = value_as_address (vfn);
912 printf_filtered (_("<error: %s>"), ex.message);
914 print_function_pointer_address (opts, gdbarch, addr, gdb_stdout);
915 printf_filtered ("\n");
919 /* Implementation of the print_vtable method. */
922 gnuv3_print_vtable (struct value *value)
924 struct gdbarch *gdbarch;
926 struct value *vtable;
927 struct value_print_options opts;
929 struct cleanup *cleanup;
930 VEC (value_and_voffset_p) *result_vec = NULL;
931 struct value_and_voffset *iter;
934 value = coerce_ref (value);
935 type = check_typedef (value_type (value));
936 if (TYPE_CODE (type) == TYPE_CODE_PTR)
938 value = value_ind (value);
939 type = check_typedef (value_type (value));
942 get_user_print_options (&opts);
944 /* Respect 'set print object'. */
945 if (opts.objectprint)
947 value = value_full_object (value, NULL, 0, 0, 0);
948 type = check_typedef (value_type (value));
951 gdbarch = get_type_arch (type);
952 vtable = gnuv3_get_vtable (gdbarch, type,
953 value_as_address (value_addr (value)));
957 printf_filtered (_("This object does not have a virtual function table\n"));
961 offset_hash = htab_create_alloc (1, hash_value_and_voffset,
962 eq_value_and_voffset,
963 xfree, xcalloc, xfree);
964 cleanup = make_cleanup_htab_delete (offset_hash);
965 make_cleanup (VEC_cleanup (value_and_voffset_p), &result_vec);
967 compute_vtable_size (offset_hash, &result_vec, value);
969 qsort (VEC_address (value_and_voffset_p, result_vec),
970 VEC_length (value_and_voffset_p, result_vec),
971 sizeof (value_and_voffset_p),
972 compare_value_and_voffset);
975 for (i = 0; VEC_iterate (value_and_voffset_p, result_vec, i, iter); ++i)
977 if (iter->max_voffset >= 0)
980 printf_filtered ("\n");
981 print_one_vtable (gdbarch, iter->value, iter->max_voffset, &opts);
986 do_cleanups (cleanup);
989 /* Return a GDB type representing `struct std::type_info', laid out
990 appropriately for ARCH.
992 We use this function as the gdbarch per-architecture data
993 initialization function. */
996 build_std_type_info_type (struct gdbarch *arch)
999 struct field *field_list, *field;
1001 struct type *void_ptr_type
1002 = builtin_type (arch)->builtin_data_ptr;
1003 struct type *char_type
1004 = builtin_type (arch)->builtin_char;
1005 struct type *char_ptr_type
1006 = make_pointer_type (make_cv_type (1, 0, char_type, NULL), NULL);
1008 field_list = xmalloc (sizeof (struct field [2]));
1009 memset (field_list, 0, sizeof (struct field [2]));
1010 field = &field_list[0];
1014 FIELD_NAME (*field) = "_vptr.type_info";
1015 FIELD_TYPE (*field) = void_ptr_type;
1016 SET_FIELD_BITPOS (*field, offset * TARGET_CHAR_BIT);
1017 offset += TYPE_LENGTH (FIELD_TYPE (*field));
1021 FIELD_NAME (*field) = "__name";
1022 FIELD_TYPE (*field) = char_ptr_type;
1023 SET_FIELD_BITPOS (*field, offset * TARGET_CHAR_BIT);
1024 offset += TYPE_LENGTH (FIELD_TYPE (*field));
1027 gdb_assert (field == (field_list + 2));
1029 t = arch_type (arch, TYPE_CODE_STRUCT, offset, NULL);
1030 TYPE_NFIELDS (t) = field - field_list;
1031 TYPE_FIELDS (t) = field_list;
1032 TYPE_TAG_NAME (t) = "gdb_gnu_v3_type_info";
1033 INIT_CPLUS_SPECIFIC (t);
1038 /* Implement the 'get_typeid_type' method. */
1040 static struct type *
1041 gnuv3_get_typeid_type (struct gdbarch *gdbarch)
1043 struct symbol *typeinfo;
1044 struct type *typeinfo_type;
1046 typeinfo = lookup_symbol ("std::type_info", NULL, STRUCT_DOMAIN, NULL);
1047 if (typeinfo == NULL)
1048 typeinfo_type = gdbarch_data (gdbarch, std_type_info_gdbarch_data);
1050 typeinfo_type = SYMBOL_TYPE (typeinfo);
1052 return typeinfo_type;
1055 /* Implement the 'get_typeid' method. */
1057 static struct value *
1058 gnuv3_get_typeid (struct value *value)
1060 struct type *typeinfo_type;
1062 struct gdbarch *gdbarch;
1063 struct cleanup *cleanup;
1064 struct value *result;
1065 char *typename, *canonical;
1067 /* We have to handle values a bit trickily here, to allow this code
1068 to work properly with non_lvalue values that are really just
1070 if (value_lval_const (value) == lval_memory)
1071 value = coerce_ref (value);
1073 type = check_typedef (value_type (value));
1075 /* In the non_lvalue case, a reference might have slipped through
1077 if (TYPE_CODE (type) == TYPE_CODE_REF)
1078 type = check_typedef (TYPE_TARGET_TYPE (type));
1080 /* Ignore top-level cv-qualifiers. */
1081 type = make_cv_type (0, 0, type, NULL);
1082 gdbarch = get_type_arch (type);
1084 typename = type_to_string (type);
1085 if (typename == NULL)
1086 error (_("cannot find typeinfo for unnamed type"));
1087 cleanup = make_cleanup (xfree, typename);
1089 /* We need to canonicalize the type name here, because we do lookups
1090 using the demangled name, and so we must match the format it
1091 uses. E.g., GDB tends to use "const char *" as a type name, but
1092 the demangler uses "char const *". */
1093 canonical = cp_canonicalize_string (typename);
1094 if (canonical != NULL)
1096 make_cleanup (xfree, canonical);
1097 typename = canonical;
1100 typeinfo_type = gnuv3_get_typeid_type (gdbarch);
1102 /* We check for lval_memory because in the "typeid (type-id)" case,
1103 the type is passed via a not_lval value object. */
1104 if (TYPE_CODE (type) == TYPE_CODE_CLASS
1105 && value_lval_const (value) == lval_memory
1106 && gnuv3_dynamic_class (type))
1108 struct value *vtable, *typeinfo_value;
1109 CORE_ADDR address = value_address (value) + value_embedded_offset (value);
1111 vtable = gnuv3_get_vtable (gdbarch, type, address);
1113 error (_("cannot find typeinfo for object of type '%s'"), typename);
1114 typeinfo_value = value_field (vtable, vtable_field_type_info);
1115 result = value_ind (value_cast (make_pointer_type (typeinfo_type, NULL),
1121 struct bound_minimal_symbol minsym;
1123 sym_name = concat ("typeinfo for ", typename, (char *) NULL);
1124 make_cleanup (xfree, sym_name);
1125 minsym = lookup_minimal_symbol (sym_name, NULL, NULL);
1127 if (minsym.minsym == NULL)
1128 error (_("could not find typeinfo symbol for '%s'"), typename);
1130 result = value_at_lazy (typeinfo_type, BMSYMBOL_VALUE_ADDRESS (minsym));
1133 do_cleanups (cleanup);
1137 /* Implement the 'get_typename_from_type_info' method. */
1140 gnuv3_get_typename_from_type_info (struct value *type_info_ptr)
1142 struct gdbarch *gdbarch = get_type_arch (value_type (type_info_ptr));
1143 struct bound_minimal_symbol typeinfo_sym;
1145 const char *symname;
1146 const char *class_name;
1149 addr = value_as_address (type_info_ptr);
1150 typeinfo_sym = lookup_minimal_symbol_by_pc (addr);
1151 if (typeinfo_sym.minsym == NULL)
1152 error (_("could not find minimal symbol for typeinfo address %s"),
1153 paddress (gdbarch, addr));
1155 #define TYPEINFO_PREFIX "typeinfo for "
1156 #define TYPEINFO_PREFIX_LEN (sizeof (TYPEINFO_PREFIX) - 1)
1157 symname = MSYMBOL_DEMANGLED_NAME (typeinfo_sym.minsym);
1158 if (symname == NULL || strncmp (symname, TYPEINFO_PREFIX,
1159 TYPEINFO_PREFIX_LEN))
1160 error (_("typeinfo symbol '%s' has unexpected name"),
1161 MSYMBOL_LINKAGE_NAME (typeinfo_sym.minsym));
1162 class_name = symname + TYPEINFO_PREFIX_LEN;
1164 /* Strip off @plt and version suffixes. */
1165 atsign = strchr (class_name, '@');
1167 return savestring (class_name, atsign - class_name);
1168 return xstrdup (class_name);
1171 /* Implement the 'get_type_from_type_info' method. */
1173 static struct type *
1174 gnuv3_get_type_from_type_info (struct value *type_info_ptr)
1177 struct cleanup *cleanup;
1178 struct value *type_val;
1179 struct expression *expr;
1180 struct type *result;
1182 typename = gnuv3_get_typename_from_type_info (type_info_ptr);
1183 cleanup = make_cleanup (xfree, typename);
1185 /* We have to parse the type name, since in general there is not a
1186 symbol for a type. This is somewhat bogus since there may be a
1187 mis-parse. Another approach might be to re-use the demangler's
1188 internal form to reconstruct the type somehow. */
1190 expr = parse_expression (typename);
1191 make_cleanup (xfree, expr);
1193 type_val = evaluate_type (expr);
1194 result = value_type (type_val);
1196 do_cleanups (cleanup);
1200 /* Determine if we are currently in a C++ thunk. If so, get the address
1201 of the routine we are thunking to and continue to there instead. */
1204 gnuv3_skip_trampoline (struct frame_info *frame, CORE_ADDR stop_pc)
1206 CORE_ADDR real_stop_pc, method_stop_pc, func_addr;
1207 struct gdbarch *gdbarch = get_frame_arch (frame);
1208 struct bound_minimal_symbol thunk_sym, fn_sym;
1209 struct obj_section *section;
1210 const char *thunk_name, *fn_name;
1212 real_stop_pc = gdbarch_skip_trampoline_code (gdbarch, frame, stop_pc);
1213 if (real_stop_pc == 0)
1214 real_stop_pc = stop_pc;
1216 /* Find the linker symbol for this potential thunk. */
1217 thunk_sym = lookup_minimal_symbol_by_pc (real_stop_pc);
1218 section = find_pc_section (real_stop_pc);
1219 if (thunk_sym.minsym == NULL || section == NULL)
1222 /* The symbol's demangled name should be something like "virtual
1223 thunk to FUNCTION", where FUNCTION is the name of the function
1224 being thunked to. */
1225 thunk_name = MSYMBOL_DEMANGLED_NAME (thunk_sym.minsym);
1226 if (thunk_name == NULL || strstr (thunk_name, " thunk to ") == NULL)
1229 fn_name = strstr (thunk_name, " thunk to ") + strlen (" thunk to ");
1230 fn_sym = lookup_minimal_symbol (fn_name, NULL, section->objfile);
1231 if (fn_sym.minsym == NULL)
1234 method_stop_pc = BMSYMBOL_VALUE_ADDRESS (fn_sym);
1236 /* Some targets have minimal symbols pointing to function descriptors
1237 (powerpc 64 for example). Make sure to retrieve the address
1238 of the real function from the function descriptor before passing on
1239 the address to other layers of GDB. */
1240 func_addr = gdbarch_convert_from_func_ptr_addr (gdbarch, method_stop_pc,
1243 method_stop_pc = func_addr;
1245 real_stop_pc = gdbarch_skip_trampoline_code
1246 (gdbarch, frame, method_stop_pc);
1247 if (real_stop_pc == 0)
1248 real_stop_pc = method_stop_pc;
1250 return real_stop_pc;
1253 /* Return nonzero if a type should be passed by reference.
1255 The rule in the v3 ABI document comes from section 3.1.1. If the
1256 type has a non-trivial copy constructor or destructor, then the
1257 caller must make a copy (by calling the copy constructor if there
1258 is one or perform the copy itself otherwise), pass the address of
1259 the copy, and then destroy the temporary (if necessary).
1261 For return values with non-trivial copy constructors or
1262 destructors, space will be allocated in the caller, and a pointer
1263 will be passed as the first argument (preceding "this").
1265 We don't have a bulletproof mechanism for determining whether a
1266 constructor or destructor is trivial. For GCC and DWARF2 debug
1267 information, we can check the artificial flag.
1269 We don't do anything with the constructors or destructors,
1270 but we have to get the argument passing right anyway. */
1272 gnuv3_pass_by_reference (struct type *type)
1274 int fieldnum, fieldelem;
1276 CHECK_TYPEDEF (type);
1278 /* We're only interested in things that can have methods. */
1279 if (TYPE_CODE (type) != TYPE_CODE_STRUCT
1280 && TYPE_CODE (type) != TYPE_CODE_CLASS
1281 && TYPE_CODE (type) != TYPE_CODE_UNION)
1284 /* A dynamic class has a non-trivial copy constructor.
1285 See c++98 section 12.8 Copying class objects [class.copy]. */
1286 if (gnuv3_dynamic_class (type))
1289 for (fieldnum = 0; fieldnum < TYPE_NFN_FIELDS (type); fieldnum++)
1290 for (fieldelem = 0; fieldelem < TYPE_FN_FIELDLIST_LENGTH (type, fieldnum);
1293 struct fn_field *fn = TYPE_FN_FIELDLIST1 (type, fieldnum);
1294 const char *name = TYPE_FN_FIELDLIST_NAME (type, fieldnum);
1295 struct type *fieldtype = TYPE_FN_FIELD_TYPE (fn, fieldelem);
1297 /* If this function is marked as artificial, it is compiler-generated,
1298 and we assume it is trivial. */
1299 if (TYPE_FN_FIELD_ARTIFICIAL (fn, fieldelem))
1302 /* If we've found a destructor, we must pass this by reference. */
1306 /* If the mangled name of this method doesn't indicate that it
1307 is a constructor, we're not interested.
1309 FIXME drow/2007-09-23: We could do this using the name of
1310 the method and the name of the class instead of dealing
1311 with the mangled name. We don't have a convenient function
1312 to strip off both leading scope qualifiers and trailing
1313 template arguments yet. */
1314 if (!is_constructor_name (TYPE_FN_FIELD_PHYSNAME (fn, fieldelem))
1315 && !TYPE_FN_FIELD_CONSTRUCTOR (fn, fieldelem))
1318 /* If this method takes two arguments, and the second argument is
1319 a reference to this class, then it is a copy constructor. */
1320 if (TYPE_NFIELDS (fieldtype) == 2)
1322 struct type *arg_type = TYPE_FIELD_TYPE (fieldtype, 1);
1323 struct type *arg_target_type;
1325 arg_target_type = check_typedef (TYPE_TARGET_TYPE (arg_type));
1327 if (TYPE_CODE (arg_type) == TYPE_CODE_REF
1328 && class_types_same_p (arg_target_type, type))
1333 /* Even if all the constructors and destructors were artificial, one
1334 of them may have invoked a non-artificial constructor or
1335 destructor in a base class. If any base class needs to be passed
1336 by reference, so does this class. Similarly for members, which
1337 are constructed whenever this class is. We do not need to worry
1338 about recursive loops here, since we are only looking at members
1339 of complete class type. Also ignore any static members. */
1340 for (fieldnum = 0; fieldnum < TYPE_NFIELDS (type); fieldnum++)
1341 if (! field_is_static (&TYPE_FIELD (type, fieldnum))
1342 && gnuv3_pass_by_reference (TYPE_FIELD_TYPE (type, fieldnum)))
1349 init_gnuv3_ops (void)
1351 vtable_type_gdbarch_data
1352 = gdbarch_data_register_post_init (build_gdb_vtable_type);
1353 std_type_info_gdbarch_data
1354 = gdbarch_data_register_post_init (build_std_type_info_type);
1356 gnu_v3_abi_ops.shortname = "gnu-v3";
1357 gnu_v3_abi_ops.longname = "GNU G++ Version 3 ABI";
1358 gnu_v3_abi_ops.doc = "G++ Version 3 ABI";
1359 gnu_v3_abi_ops.is_destructor_name =
1360 (enum dtor_kinds (*) (const char *))is_gnu_v3_mangled_dtor;
1361 gnu_v3_abi_ops.is_constructor_name =
1362 (enum ctor_kinds (*) (const char *))is_gnu_v3_mangled_ctor;
1363 gnu_v3_abi_ops.is_vtable_name = gnuv3_is_vtable_name;
1364 gnu_v3_abi_ops.is_operator_name = gnuv3_is_operator_name;
1365 gnu_v3_abi_ops.rtti_type = gnuv3_rtti_type;
1366 gnu_v3_abi_ops.virtual_fn_field = gnuv3_virtual_fn_field;
1367 gnu_v3_abi_ops.baseclass_offset = gnuv3_baseclass_offset;
1368 gnu_v3_abi_ops.print_method_ptr = gnuv3_print_method_ptr;
1369 gnu_v3_abi_ops.method_ptr_size = gnuv3_method_ptr_size;
1370 gnu_v3_abi_ops.make_method_ptr = gnuv3_make_method_ptr;
1371 gnu_v3_abi_ops.method_ptr_to_value = gnuv3_method_ptr_to_value;
1372 gnu_v3_abi_ops.print_vtable = gnuv3_print_vtable;
1373 gnu_v3_abi_ops.get_typeid = gnuv3_get_typeid;
1374 gnu_v3_abi_ops.get_typeid_type = gnuv3_get_typeid_type;
1375 gnu_v3_abi_ops.get_type_from_type_info = gnuv3_get_type_from_type_info;
1376 gnu_v3_abi_ops.get_typename_from_type_info
1377 = gnuv3_get_typename_from_type_info;
1378 gnu_v3_abi_ops.skip_trampoline = gnuv3_skip_trampoline;
1379 gnu_v3_abi_ops.pass_by_reference = gnuv3_pass_by_reference;
1382 extern initialize_file_ftype _initialize_gnu_v3_abi; /* -Wmissing-prototypes */
1385 _initialize_gnu_v3_abi (void)
1389 register_cp_abi (&gnu_v3_abi_ops);
1390 set_cp_abi_as_auto_default (gnu_v3_abi_ops.shortname);