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 "exceptions.h"
30 #include "typeprint.h"
32 static struct cp_abi_ops gnu_v3_abi_ops
;
34 /* A gdbarch key for std::type_info, in the event that it can't be
35 found in the debug info. */
37 static struct gdbarch_data
*std_type_info_gdbarch_data
;
41 gnuv3_is_vtable_name (const char *name
)
43 return strncmp (name
, "_ZTV", 4) == 0;
47 gnuv3_is_operator_name (const char *name
)
49 return strncmp (name
, "operator", 8) == 0;
53 /* To help us find the components of a vtable, we build ourselves a
54 GDB type object representing the vtable structure. Following the
55 V3 ABI, it goes something like this:
57 struct gdb_gnu_v3_abi_vtable {
59 / * An array of virtual call and virtual base offsets. The real
60 length of this array depends on the class hierarchy; we use
61 negative subscripts to access the elements. Yucky, but
62 better than the alternatives. * /
63 ptrdiff_t vcall_and_vbase_offsets[0];
65 / * The offset from a virtual pointer referring to this table
66 to the top of the complete object. * /
67 ptrdiff_t offset_to_top;
69 / * The type_info pointer for this class. This is really a
70 std::type_info *, but GDB doesn't really look at the
71 type_info object itself, so we don't bother to get the type
75 / * Virtual table pointers in objects point here. * /
77 / * Virtual function pointers. Like the vcall/vbase array, the
78 real length of this table depends on the class hierarchy. * /
79 void (*virtual_functions[0]) ();
83 The catch, of course, is that the exact layout of this table
84 depends on the ABI --- word size, endianness, alignment, etc. So
85 the GDB type object is actually a per-architecture kind of thing.
87 vtable_type_gdbarch_data is a gdbarch per-architecture data pointer
88 which refers to the struct type * for this structure, laid out
89 appropriately for the architecture. */
90 static struct gdbarch_data
*vtable_type_gdbarch_data
;
93 /* Human-readable names for the numbers of the fields above. */
95 vtable_field_vcall_and_vbase_offsets
,
96 vtable_field_offset_to_top
,
97 vtable_field_type_info
,
98 vtable_field_virtual_functions
102 /* Return a GDB type representing `struct gdb_gnu_v3_abi_vtable',
103 described above, laid out appropriately for ARCH.
105 We use this function as the gdbarch per-architecture data
106 initialization function. */
108 build_gdb_vtable_type (struct gdbarch
*arch
)
111 struct field
*field_list
, *field
;
114 struct type
*void_ptr_type
115 = builtin_type (arch
)->builtin_data_ptr
;
116 struct type
*ptr_to_void_fn_type
117 = builtin_type (arch
)->builtin_func_ptr
;
119 /* ARCH can't give us the true ptrdiff_t type, so we guess. */
120 struct type
*ptrdiff_type
121 = arch_integer_type (arch
, gdbarch_ptr_bit (arch
), 0, "ptrdiff_t");
123 /* We assume no padding is necessary, since GDB doesn't know
124 anything about alignment at the moment. If this assumption bites
125 us, we should add a gdbarch method which, given a type, returns
126 the alignment that type requires, and then use that here. */
128 /* Build the field list. */
129 field_list
= xmalloc (sizeof (struct field
[4]));
130 memset (field_list
, 0, sizeof (struct field
[4]));
131 field
= &field_list
[0];
134 /* ptrdiff_t vcall_and_vbase_offsets[0]; */
135 FIELD_NAME (*field
) = "vcall_and_vbase_offsets";
136 FIELD_TYPE (*field
) = lookup_array_range_type (ptrdiff_type
, 0, -1);
137 SET_FIELD_BITPOS (*field
, offset
* TARGET_CHAR_BIT
);
138 offset
+= TYPE_LENGTH (FIELD_TYPE (*field
));
141 /* ptrdiff_t offset_to_top; */
142 FIELD_NAME (*field
) = "offset_to_top";
143 FIELD_TYPE (*field
) = ptrdiff_type
;
144 SET_FIELD_BITPOS (*field
, offset
* TARGET_CHAR_BIT
);
145 offset
+= TYPE_LENGTH (FIELD_TYPE (*field
));
148 /* void *type_info; */
149 FIELD_NAME (*field
) = "type_info";
150 FIELD_TYPE (*field
) = void_ptr_type
;
151 SET_FIELD_BITPOS (*field
, offset
* TARGET_CHAR_BIT
);
152 offset
+= TYPE_LENGTH (FIELD_TYPE (*field
));
155 /* void (*virtual_functions[0]) (); */
156 FIELD_NAME (*field
) = "virtual_functions";
157 FIELD_TYPE (*field
) = lookup_array_range_type (ptr_to_void_fn_type
, 0, -1);
158 SET_FIELD_BITPOS (*field
, offset
* TARGET_CHAR_BIT
);
159 offset
+= TYPE_LENGTH (FIELD_TYPE (*field
));
162 /* We assumed in the allocation above that there were four fields. */
163 gdb_assert (field
== (field_list
+ 4));
165 t
= arch_type (arch
, TYPE_CODE_STRUCT
, offset
, NULL
);
166 TYPE_NFIELDS (t
) = field
- field_list
;
167 TYPE_FIELDS (t
) = field_list
;
168 TYPE_TAG_NAME (t
) = "gdb_gnu_v3_abi_vtable";
169 INIT_CPLUS_SPECIFIC (t
);
171 return make_type_with_address_space (t
, TYPE_INSTANCE_FLAG_CODE_SPACE
);
175 /* Return the ptrdiff_t type used in the vtable type. */
177 vtable_ptrdiff_type (struct gdbarch
*gdbarch
)
179 struct type
*vtable_type
= gdbarch_data (gdbarch
, vtable_type_gdbarch_data
);
181 /* The "offset_to_top" field has the appropriate (ptrdiff_t) type. */
182 return TYPE_FIELD_TYPE (vtable_type
, vtable_field_offset_to_top
);
185 /* Return the offset from the start of the imaginary `struct
186 gdb_gnu_v3_abi_vtable' object to the vtable's "address point"
187 (i.e., where objects' virtual table pointers point). */
189 vtable_address_point_offset (struct gdbarch
*gdbarch
)
191 struct type
*vtable_type
= gdbarch_data (gdbarch
, vtable_type_gdbarch_data
);
193 return (TYPE_FIELD_BITPOS (vtable_type
, vtable_field_virtual_functions
)
198 /* Determine whether structure TYPE is a dynamic class. Cache the
202 gnuv3_dynamic_class (struct type
*type
)
204 int fieldnum
, fieldelem
;
206 if (TYPE_CPLUS_DYNAMIC (type
))
207 return TYPE_CPLUS_DYNAMIC (type
) == 1;
209 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
211 for (fieldnum
= 0; fieldnum
< TYPE_N_BASECLASSES (type
); fieldnum
++)
212 if (BASETYPE_VIA_VIRTUAL (type
, fieldnum
)
213 || gnuv3_dynamic_class (TYPE_FIELD_TYPE (type
, fieldnum
)))
215 TYPE_CPLUS_DYNAMIC (type
) = 1;
219 for (fieldnum
= 0; fieldnum
< TYPE_NFN_FIELDS (type
); fieldnum
++)
220 for (fieldelem
= 0; fieldelem
< TYPE_FN_FIELDLIST_LENGTH (type
, fieldnum
);
223 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, fieldnum
);
225 if (TYPE_FN_FIELD_VIRTUAL_P (f
, fieldelem
))
227 TYPE_CPLUS_DYNAMIC (type
) = 1;
232 TYPE_CPLUS_DYNAMIC (type
) = -1;
236 /* Find the vtable for a value of CONTAINER_TYPE located at
237 CONTAINER_ADDR. Return a value of the correct vtable type for this
238 architecture, or NULL if CONTAINER does not have a vtable. */
240 static struct value
*
241 gnuv3_get_vtable (struct gdbarch
*gdbarch
,
242 struct type
*container_type
, CORE_ADDR container_addr
)
244 struct type
*vtable_type
= gdbarch_data (gdbarch
,
245 vtable_type_gdbarch_data
);
246 struct type
*vtable_pointer_type
;
247 struct value
*vtable_pointer
;
248 CORE_ADDR vtable_address
;
250 /* If this type does not have a virtual table, don't read the first
252 if (!gnuv3_dynamic_class (check_typedef (container_type
)))
255 /* We do not consult the debug information to find the virtual table.
256 The ABI specifies that it is always at offset zero in any class,
257 and debug information may not represent it.
259 We avoid using value_contents on principle, because the object might
262 /* Find the type "pointer to virtual table". */
263 vtable_pointer_type
= lookup_pointer_type (vtable_type
);
265 /* Load it from the start of the class. */
266 vtable_pointer
= value_at (vtable_pointer_type
, container_addr
);
267 vtable_address
= value_as_address (vtable_pointer
);
269 /* Correct it to point at the start of the virtual table, rather
270 than the address point. */
271 return value_at_lazy (vtable_type
,
273 - vtable_address_point_offset (gdbarch
));
278 gnuv3_rtti_type (struct value
*value
,
279 int *full_p
, int *top_p
, int *using_enc_p
)
281 struct gdbarch
*gdbarch
;
282 struct type
*values_type
= check_typedef (value_type (value
));
283 struct value
*vtable
;
284 struct minimal_symbol
*vtable_symbol
;
285 const char *vtable_symbol_name
;
286 const char *class_name
;
287 struct type
*run_time_type
;
288 LONGEST offset_to_top
;
291 /* We only have RTTI for class objects. */
292 if (TYPE_CODE (values_type
) != TYPE_CODE_CLASS
)
295 /* Java doesn't have RTTI following the C++ ABI. */
296 if (TYPE_CPLUS_REALLY_JAVA (values_type
))
299 /* Determine architecture. */
300 gdbarch
= get_type_arch (values_type
);
305 vtable
= gnuv3_get_vtable (gdbarch
, value_type (value
),
306 value_as_address (value_addr (value
)));
310 /* Find the linker symbol for this vtable. */
312 = lookup_minimal_symbol_by_pc (value_address (vtable
)
313 + value_embedded_offset (vtable
)).minsym
;
317 /* The symbol's demangled name should be something like "vtable for
318 CLASS", where CLASS is the name of the run-time type of VALUE.
319 If we didn't like this approach, we could instead look in the
320 type_info object itself to get the class name. But this way
321 should work just as well, and doesn't read target memory. */
322 vtable_symbol_name
= MSYMBOL_DEMANGLED_NAME (vtable_symbol
);
323 if (vtable_symbol_name
== NULL
324 || strncmp (vtable_symbol_name
, "vtable for ", 11))
326 warning (_("can't find linker symbol for virtual table for `%s' value"),
327 TYPE_SAFE_NAME (values_type
));
328 if (vtable_symbol_name
)
329 warning (_(" found `%s' instead"), vtable_symbol_name
);
332 class_name
= vtable_symbol_name
+ 11;
334 /* Strip off @plt and version suffixes. */
335 atsign
= strchr (class_name
, '@');
340 copy
= alloca (atsign
- class_name
+ 1);
341 memcpy (copy
, class_name
, atsign
- class_name
);
342 copy
[atsign
- class_name
] = '\0';
346 /* Try to look up the class name as a type name. */
347 /* FIXME: chastain/2003-11-26: block=NULL is bogus. See pr gdb/1465. */
348 run_time_type
= cp_lookup_rtti_type (class_name
, NULL
);
349 if (run_time_type
== NULL
)
352 /* Get the offset from VALUE to the top of the complete object.
353 NOTE: this is the reverse of the meaning of *TOP_P. */
355 = value_as_long (value_field (vtable
, vtable_field_offset_to_top
));
358 *full_p
= (- offset_to_top
== value_embedded_offset (value
)
359 && (TYPE_LENGTH (value_enclosing_type (value
))
360 >= TYPE_LENGTH (run_time_type
)));
362 *top_p
= - offset_to_top
;
363 return run_time_type
;
366 /* Return a function pointer for CONTAINER's VTABLE_INDEX'th virtual
367 function, of type FNTYPE. */
369 static struct value
*
370 gnuv3_get_virtual_fn (struct gdbarch
*gdbarch
, struct value
*container
,
371 struct type
*fntype
, int vtable_index
)
373 struct value
*vtable
, *vfn
;
375 /* Every class with virtual functions must have a vtable. */
376 vtable
= gnuv3_get_vtable (gdbarch
, value_type (container
),
377 value_as_address (value_addr (container
)));
378 gdb_assert (vtable
!= NULL
);
380 /* Fetch the appropriate function pointer from the vtable. */
381 vfn
= value_subscript (value_field (vtable
, vtable_field_virtual_functions
),
384 /* If this architecture uses function descriptors directly in the vtable,
385 then the address of the vtable entry is actually a "function pointer"
386 (i.e. points to the descriptor). We don't need to scale the index
387 by the size of a function descriptor; GCC does that before outputing
388 debug information. */
389 if (gdbarch_vtable_function_descriptors (gdbarch
))
390 vfn
= value_addr (vfn
);
392 /* Cast the function pointer to the appropriate type. */
393 vfn
= value_cast (lookup_pointer_type (fntype
), vfn
);
398 /* GNU v3 implementation of value_virtual_fn_field. See cp-abi.h
399 for a description of the arguments. */
401 static struct value
*
402 gnuv3_virtual_fn_field (struct value
**value_p
,
403 struct fn_field
*f
, int j
,
404 struct type
*vfn_base
, int offset
)
406 struct type
*values_type
= check_typedef (value_type (*value_p
));
407 struct gdbarch
*gdbarch
;
409 /* Some simple sanity checks. */
410 if (TYPE_CODE (values_type
) != TYPE_CODE_CLASS
)
411 error (_("Only classes can have virtual functions."));
413 /* Determine architecture. */
414 gdbarch
= get_type_arch (values_type
);
416 /* Cast our value to the base class which defines this virtual
417 function. This takes care of any necessary `this'
419 if (vfn_base
!= values_type
)
420 *value_p
= value_cast (vfn_base
, *value_p
);
422 return gnuv3_get_virtual_fn (gdbarch
, *value_p
, TYPE_FN_FIELD_TYPE (f
, j
),
423 TYPE_FN_FIELD_VOFFSET (f
, j
));
426 /* Compute the offset of the baseclass which is
427 the INDEXth baseclass of class TYPE,
428 for value at VALADDR (in host) at ADDRESS (in target).
429 The result is the offset of the baseclass value relative
430 to (the address of)(ARG) + OFFSET.
432 -1 is returned on error. */
435 gnuv3_baseclass_offset (struct type
*type
, int index
,
436 const bfd_byte
*valaddr
, int embedded_offset
,
437 CORE_ADDR address
, const struct value
*val
)
439 struct gdbarch
*gdbarch
;
440 struct type
*ptr_type
;
441 struct value
*vtable
;
442 struct value
*vbase_array
;
443 long int cur_base_offset
, base_offset
;
445 /* Determine architecture. */
446 gdbarch
= get_type_arch (type
);
447 ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
449 /* If it isn't a virtual base, this is easy. The offset is in the
450 type definition. Likewise for Java, which doesn't really have
451 virtual inheritance in the C++ sense. */
452 if (!BASETYPE_VIA_VIRTUAL (type
, index
) || TYPE_CPLUS_REALLY_JAVA (type
))
453 return TYPE_BASECLASS_BITPOS (type
, index
) / 8;
455 /* To access a virtual base, we need to use the vbase offset stored in
456 our vtable. Recent GCC versions provide this information. If it isn't
457 available, we could get what we needed from RTTI, or from drawing the
458 complete inheritance graph based on the debug info. Neither is
460 cur_base_offset
= TYPE_BASECLASS_BITPOS (type
, index
) / 8;
461 if (cur_base_offset
>= - vtable_address_point_offset (gdbarch
))
462 error (_("Expected a negative vbase offset (old compiler?)"));
464 cur_base_offset
= cur_base_offset
+ vtable_address_point_offset (gdbarch
);
465 if ((- cur_base_offset
) % TYPE_LENGTH (ptr_type
) != 0)
466 error (_("Misaligned vbase offset."));
467 cur_base_offset
= cur_base_offset
/ ((int) TYPE_LENGTH (ptr_type
));
469 vtable
= gnuv3_get_vtable (gdbarch
, type
, address
+ embedded_offset
);
470 gdb_assert (vtable
!= NULL
);
471 vbase_array
= value_field (vtable
, vtable_field_vcall_and_vbase_offsets
);
472 base_offset
= value_as_long (value_subscript (vbase_array
, cur_base_offset
));
476 /* Locate a virtual method in DOMAIN or its non-virtual base classes
477 which has virtual table index VOFFSET. The method has an associated
478 "this" adjustment of ADJUSTMENT bytes. */
481 gnuv3_find_method_in (struct type
*domain
, CORE_ADDR voffset
,
486 /* Search this class first. */
491 len
= TYPE_NFN_FIELDS (domain
);
492 for (i
= 0; i
< len
; i
++)
497 f
= TYPE_FN_FIELDLIST1 (domain
, i
);
498 len2
= TYPE_FN_FIELDLIST_LENGTH (domain
, i
);
500 check_stub_method_group (domain
, i
);
501 for (j
= 0; j
< len2
; j
++)
502 if (TYPE_FN_FIELD_VOFFSET (f
, j
) == voffset
)
503 return TYPE_FN_FIELD_PHYSNAME (f
, j
);
507 /* Next search non-virtual bases. If it's in a virtual base,
508 we're out of luck. */
509 for (i
= 0; i
< TYPE_N_BASECLASSES (domain
); i
++)
512 struct type
*basetype
;
514 if (BASETYPE_VIA_VIRTUAL (domain
, i
))
517 pos
= TYPE_BASECLASS_BITPOS (domain
, i
) / 8;
518 basetype
= TYPE_FIELD_TYPE (domain
, i
);
519 /* Recurse with a modified adjustment. We don't need to adjust
521 if (adjustment
>= pos
&& adjustment
< pos
+ TYPE_LENGTH (basetype
))
522 return gnuv3_find_method_in (basetype
, voffset
, adjustment
- pos
);
528 /* Decode GNU v3 method pointer. */
531 gnuv3_decode_method_ptr (struct gdbarch
*gdbarch
,
532 const gdb_byte
*contents
,
534 LONGEST
*adjustment_p
)
536 struct type
*funcptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
537 struct type
*offset_type
= vtable_ptrdiff_type (gdbarch
);
538 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
540 LONGEST voffset
, adjustment
;
543 /* Extract the pointer to member. The first element is either a pointer
544 or a vtable offset. For pointers, we need to use extract_typed_address
545 to allow the back-end to convert the pointer to a GDB address -- but
546 vtable offsets we must handle as integers. At this point, we do not
547 yet know which case we have, so we extract the value under both
548 interpretations and choose the right one later on. */
549 ptr_value
= extract_typed_address (contents
, funcptr_type
);
550 voffset
= extract_signed_integer (contents
,
551 TYPE_LENGTH (funcptr_type
), byte_order
);
552 contents
+= TYPE_LENGTH (funcptr_type
);
553 adjustment
= extract_signed_integer (contents
,
554 TYPE_LENGTH (offset_type
), byte_order
);
556 if (!gdbarch_vbit_in_delta (gdbarch
))
559 voffset
= voffset
^ vbit
;
563 vbit
= adjustment
& 1;
564 adjustment
= adjustment
>> 1;
567 *value_p
= vbit
? voffset
: ptr_value
;
568 *adjustment_p
= adjustment
;
572 /* GNU v3 implementation of cplus_print_method_ptr. */
575 gnuv3_print_method_ptr (const gdb_byte
*contents
,
577 struct ui_file
*stream
)
579 struct type
*domain
= TYPE_DOMAIN_TYPE (type
);
580 struct gdbarch
*gdbarch
= get_type_arch (domain
);
585 /* Extract the pointer to member. */
586 vbit
= gnuv3_decode_method_ptr (gdbarch
, contents
, &ptr_value
, &adjustment
);
588 /* Check for NULL. */
589 if (ptr_value
== 0 && vbit
== 0)
591 fprintf_filtered (stream
, "NULL");
595 /* Search for a virtual method. */
599 const char *physname
;
601 /* It's a virtual table offset, maybe in this class. Search
602 for a field with the correct vtable offset. First convert it
603 to an index, as used in TYPE_FN_FIELD_VOFFSET. */
604 voffset
= ptr_value
/ TYPE_LENGTH (vtable_ptrdiff_type (gdbarch
));
606 physname
= gnuv3_find_method_in (domain
, voffset
, adjustment
);
608 /* If we found a method, print that. We don't bother to disambiguate
609 possible paths to the method based on the adjustment. */
612 char *demangled_name
= gdb_demangle (physname
,
613 DMGL_ANSI
| DMGL_PARAMS
);
615 fprintf_filtered (stream
, "&virtual ");
616 if (demangled_name
== NULL
)
617 fputs_filtered (physname
, stream
);
620 fputs_filtered (demangled_name
, stream
);
621 xfree (demangled_name
);
626 else if (ptr_value
!= 0)
628 /* Found a non-virtual function: print out the type. */
629 fputs_filtered ("(", stream
);
630 c_print_type (type
, "", stream
, -1, 0, &type_print_raw_options
);
631 fputs_filtered (") ", stream
);
634 /* We didn't find it; print the raw data. */
637 fprintf_filtered (stream
, "&virtual table offset ");
638 print_longest (stream
, 'd', 1, ptr_value
);
642 struct value_print_options opts
;
644 get_user_print_options (&opts
);
645 print_address_demangle (&opts
, gdbarch
, ptr_value
, stream
, demangle
);
650 fprintf_filtered (stream
, ", this adjustment ");
651 print_longest (stream
, 'd', 1, adjustment
);
655 /* GNU v3 implementation of cplus_method_ptr_size. */
658 gnuv3_method_ptr_size (struct type
*type
)
660 struct gdbarch
*gdbarch
= get_type_arch (type
);
662 return 2 * TYPE_LENGTH (builtin_type (gdbarch
)->builtin_data_ptr
);
665 /* GNU v3 implementation of cplus_make_method_ptr. */
668 gnuv3_make_method_ptr (struct type
*type
, gdb_byte
*contents
,
669 CORE_ADDR value
, int is_virtual
)
671 struct gdbarch
*gdbarch
= get_type_arch (type
);
672 int size
= TYPE_LENGTH (builtin_type (gdbarch
)->builtin_data_ptr
);
673 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
675 /* FIXME drow/2006-12-24: The adjustment of "this" is currently
676 always zero, since the method pointer is of the correct type.
677 But if the method pointer came from a base class, this is
678 incorrect - it should be the offset to the base. The best
679 fix might be to create the pointer to member pointing at the
680 base class and cast it to the derived class, but that requires
681 support for adjusting pointers to members when casting them -
682 not currently supported by GDB. */
684 if (!gdbarch_vbit_in_delta (gdbarch
))
686 store_unsigned_integer (contents
, size
, byte_order
, value
| is_virtual
);
687 store_unsigned_integer (contents
+ size
, size
, byte_order
, 0);
691 store_unsigned_integer (contents
, size
, byte_order
, value
);
692 store_unsigned_integer (contents
+ size
, size
, byte_order
, is_virtual
);
696 /* GNU v3 implementation of cplus_method_ptr_to_value. */
698 static struct value
*
699 gnuv3_method_ptr_to_value (struct value
**this_p
, struct value
*method_ptr
)
701 struct gdbarch
*gdbarch
;
702 const gdb_byte
*contents
= value_contents (method_ptr
);
704 struct type
*domain_type
, *final_type
, *method_type
;
708 domain_type
= TYPE_DOMAIN_TYPE (check_typedef (value_type (method_ptr
)));
709 final_type
= lookup_pointer_type (domain_type
);
711 method_type
= TYPE_TARGET_TYPE (check_typedef (value_type (method_ptr
)));
713 /* Extract the pointer to member. */
714 gdbarch
= get_type_arch (domain_type
);
715 vbit
= gnuv3_decode_method_ptr (gdbarch
, contents
, &ptr_value
, &adjustment
);
717 /* First convert THIS to match the containing type of the pointer to
718 member. This cast may adjust the value of THIS. */
719 *this_p
= value_cast (final_type
, *this_p
);
721 /* Then apply whatever adjustment is necessary. This creates a somewhat
722 strange pointer: it claims to have type FINAL_TYPE, but in fact it
723 might not be a valid FINAL_TYPE. For instance, it might be a
724 base class of FINAL_TYPE. And if it's not the primary base class,
725 then printing it out as a FINAL_TYPE object would produce some pretty
728 But we don't really know the type of the first argument in
729 METHOD_TYPE either, which is why this happens. We can't
730 dereference this later as a FINAL_TYPE, but once we arrive in the
731 called method we'll have debugging information for the type of
732 "this" - and that'll match the value we produce here.
734 You can provoke this case by casting a Base::* to a Derived::*, for
736 *this_p
= value_cast (builtin_type (gdbarch
)->builtin_data_ptr
, *this_p
);
737 *this_p
= value_ptradd (*this_p
, adjustment
);
738 *this_p
= value_cast (final_type
, *this_p
);
744 voffset
= ptr_value
/ TYPE_LENGTH (vtable_ptrdiff_type (gdbarch
));
745 return gnuv3_get_virtual_fn (gdbarch
, value_ind (*this_p
),
746 method_type
, voffset
);
749 return value_from_pointer (lookup_pointer_type (method_type
), ptr_value
);
752 /* Objects of this type are stored in a hash table and a vector when
753 printing the vtables for a class. */
755 struct value_and_voffset
757 /* The value representing the object. */
760 /* The maximum vtable offset we've found for any object at this
761 offset in the outermost object. */
765 typedef struct value_and_voffset
*value_and_voffset_p
;
766 DEF_VEC_P (value_and_voffset_p
);
768 /* Hash function for value_and_voffset. */
771 hash_value_and_voffset (const void *p
)
773 const struct value_and_voffset
*o
= p
;
775 return value_address (o
->value
) + value_embedded_offset (o
->value
);
778 /* Equality function for value_and_voffset. */
781 eq_value_and_voffset (const void *a
, const void *b
)
783 const struct value_and_voffset
*ova
= a
;
784 const struct value_and_voffset
*ovb
= b
;
786 return (value_address (ova
->value
) + value_embedded_offset (ova
->value
)
787 == value_address (ovb
->value
) + value_embedded_offset (ovb
->value
));
790 /* qsort comparison function for value_and_voffset. */
793 compare_value_and_voffset (const void *a
, const void *b
)
795 const struct value_and_voffset
* const *ova
= a
;
796 CORE_ADDR addra
= (value_address ((*ova
)->value
)
797 + value_embedded_offset ((*ova
)->value
));
798 const struct value_and_voffset
* const *ovb
= b
;
799 CORE_ADDR addrb
= (value_address ((*ovb
)->value
)
800 + value_embedded_offset ((*ovb
)->value
));
809 /* A helper function used when printing vtables. This determines the
810 key (most derived) sub-object at each address and also computes the
811 maximum vtable offset seen for the corresponding vtable. Updates
812 OFFSET_HASH and OFFSET_VEC with a new value_and_voffset object, if
813 needed. VALUE is the object to examine. */
816 compute_vtable_size (htab_t offset_hash
,
817 VEC (value_and_voffset_p
) **offset_vec
,
821 struct type
*type
= check_typedef (value_type (value
));
823 struct value_and_voffset search_vo
, *current_vo
;
825 /* If the object is not dynamic, then we are done; as it cannot have
826 dynamic base types either. */
827 if (!gnuv3_dynamic_class (type
))
830 /* Update the hash and the vec, if needed. */
831 search_vo
.value
= value
;
832 slot
= htab_find_slot (offset_hash
, &search_vo
, INSERT
);
837 current_vo
= XNEW (struct value_and_voffset
);
838 current_vo
->value
= value
;
839 current_vo
->max_voffset
= -1;
841 VEC_safe_push (value_and_voffset_p
, *offset_vec
, current_vo
);
844 /* Update the value_and_voffset object with the highest vtable
845 offset from this class. */
846 for (i
= 0; i
< TYPE_NFN_FIELDS (type
); ++i
)
849 struct fn_field
*fn
= TYPE_FN_FIELDLIST1 (type
, i
);
851 for (j
= 0; j
< TYPE_FN_FIELDLIST_LENGTH (type
, i
); ++j
)
853 if (TYPE_FN_FIELD_VIRTUAL_P (fn
, j
))
855 int voffset
= TYPE_FN_FIELD_VOFFSET (fn
, j
);
857 if (voffset
> current_vo
->max_voffset
)
858 current_vo
->max_voffset
= voffset
;
863 /* Recurse into base classes. */
864 for (i
= 0; i
< TYPE_N_BASECLASSES (type
); ++i
)
865 compute_vtable_size (offset_hash
, offset_vec
, value_field (value
, i
));
868 /* Helper for gnuv3_print_vtable that prints a single vtable. */
871 print_one_vtable (struct gdbarch
*gdbarch
, struct value
*value
,
873 struct value_print_options
*opts
)
876 struct type
*type
= check_typedef (value_type (value
));
877 struct value
*vtable
;
880 vtable
= gnuv3_get_vtable (gdbarch
, type
,
881 value_address (value
)
882 + value_embedded_offset (value
));
883 vt_addr
= value_address (value_field (vtable
,
884 vtable_field_virtual_functions
));
886 printf_filtered (_("vtable for '%s' @ %s (subobject @ %s):\n"),
887 TYPE_SAFE_NAME (type
),
888 paddress (gdbarch
, vt_addr
),
889 paddress (gdbarch
, (value_address (value
)
890 + value_embedded_offset (value
))));
892 for (i
= 0; i
<= max_voffset
; ++i
)
894 /* Initialize it just to avoid a GCC false warning. */
897 volatile struct gdb_exception ex
;
899 printf_filtered ("[%d]: ", i
);
901 vfn
= value_subscript (value_field (vtable
,
902 vtable_field_virtual_functions
),
905 if (gdbarch_vtable_function_descriptors (gdbarch
))
906 vfn
= value_addr (vfn
);
908 TRY_CATCH (ex
, RETURN_MASK_ERROR
)
910 addr
= value_as_address (vfn
);
913 printf_filtered (_("<error: %s>"), ex
.message
);
915 print_function_pointer_address (opts
, gdbarch
, addr
, gdb_stdout
);
916 printf_filtered ("\n");
920 /* Implementation of the print_vtable method. */
923 gnuv3_print_vtable (struct value
*value
)
925 struct gdbarch
*gdbarch
;
927 struct value
*vtable
;
928 struct value_print_options opts
;
930 struct cleanup
*cleanup
;
931 VEC (value_and_voffset_p
) *result_vec
= NULL
;
932 struct value_and_voffset
*iter
;
935 value
= coerce_ref (value
);
936 type
= check_typedef (value_type (value
));
937 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
939 value
= value_ind (value
);
940 type
= check_typedef (value_type (value
));
943 get_user_print_options (&opts
);
945 /* Respect 'set print object'. */
946 if (opts
.objectprint
)
948 value
= value_full_object (value
, NULL
, 0, 0, 0);
949 type
= check_typedef (value_type (value
));
952 gdbarch
= get_type_arch (type
);
953 vtable
= gnuv3_get_vtable (gdbarch
, type
,
954 value_as_address (value_addr (value
)));
958 printf_filtered (_("This object does not have a virtual function table\n"));
962 offset_hash
= htab_create_alloc (1, hash_value_and_voffset
,
963 eq_value_and_voffset
,
964 xfree
, xcalloc
, xfree
);
965 cleanup
= make_cleanup_htab_delete (offset_hash
);
966 make_cleanup (VEC_cleanup (value_and_voffset_p
), &result_vec
);
968 compute_vtable_size (offset_hash
, &result_vec
, value
);
970 qsort (VEC_address (value_and_voffset_p
, result_vec
),
971 VEC_length (value_and_voffset_p
, result_vec
),
972 sizeof (value_and_voffset_p
),
973 compare_value_and_voffset
);
976 for (i
= 0; VEC_iterate (value_and_voffset_p
, result_vec
, i
, iter
); ++i
)
978 if (iter
->max_voffset
>= 0)
981 printf_filtered ("\n");
982 print_one_vtable (gdbarch
, iter
->value
, iter
->max_voffset
, &opts
);
987 do_cleanups (cleanup
);
990 /* Return a GDB type representing `struct std::type_info', laid out
991 appropriately for ARCH.
993 We use this function as the gdbarch per-architecture data
994 initialization function. */
997 build_std_type_info_type (struct gdbarch
*arch
)
1000 struct field
*field_list
, *field
;
1002 struct type
*void_ptr_type
1003 = builtin_type (arch
)->builtin_data_ptr
;
1004 struct type
*char_type
1005 = builtin_type (arch
)->builtin_char
;
1006 struct type
*char_ptr_type
1007 = make_pointer_type (make_cv_type (1, 0, char_type
, NULL
), NULL
);
1009 field_list
= xmalloc (sizeof (struct field
[2]));
1010 memset (field_list
, 0, sizeof (struct field
[2]));
1011 field
= &field_list
[0];
1015 FIELD_NAME (*field
) = "_vptr.type_info";
1016 FIELD_TYPE (*field
) = void_ptr_type
;
1017 SET_FIELD_BITPOS (*field
, offset
* TARGET_CHAR_BIT
);
1018 offset
+= TYPE_LENGTH (FIELD_TYPE (*field
));
1022 FIELD_NAME (*field
) = "__name";
1023 FIELD_TYPE (*field
) = char_ptr_type
;
1024 SET_FIELD_BITPOS (*field
, offset
* TARGET_CHAR_BIT
);
1025 offset
+= TYPE_LENGTH (FIELD_TYPE (*field
));
1028 gdb_assert (field
== (field_list
+ 2));
1030 t
= arch_type (arch
, TYPE_CODE_STRUCT
, offset
, NULL
);
1031 TYPE_NFIELDS (t
) = field
- field_list
;
1032 TYPE_FIELDS (t
) = field_list
;
1033 TYPE_TAG_NAME (t
) = "gdb_gnu_v3_type_info";
1034 INIT_CPLUS_SPECIFIC (t
);
1039 /* Implement the 'get_typeid_type' method. */
1041 static struct type
*
1042 gnuv3_get_typeid_type (struct gdbarch
*gdbarch
)
1044 struct symbol
*typeinfo
;
1045 struct type
*typeinfo_type
;
1047 typeinfo
= lookup_symbol ("std::type_info", NULL
, STRUCT_DOMAIN
, NULL
);
1048 if (typeinfo
== NULL
)
1049 typeinfo_type
= gdbarch_data (gdbarch
, std_type_info_gdbarch_data
);
1051 typeinfo_type
= SYMBOL_TYPE (typeinfo
);
1053 return typeinfo_type
;
1056 /* Implement the 'get_typeid' method. */
1058 static struct value
*
1059 gnuv3_get_typeid (struct value
*value
)
1061 struct type
*typeinfo_type
;
1063 struct gdbarch
*gdbarch
;
1064 struct cleanup
*cleanup
;
1065 struct value
*result
;
1066 char *typename
, *canonical
;
1068 /* We have to handle values a bit trickily here, to allow this code
1069 to work properly with non_lvalue values that are really just
1071 if (value_lval_const (value
) == lval_memory
)
1072 value
= coerce_ref (value
);
1074 type
= check_typedef (value_type (value
));
1076 /* In the non_lvalue case, a reference might have slipped through
1078 if (TYPE_CODE (type
) == TYPE_CODE_REF
)
1079 type
= check_typedef (TYPE_TARGET_TYPE (type
));
1081 /* Ignore top-level cv-qualifiers. */
1082 type
= make_cv_type (0, 0, type
, NULL
);
1083 gdbarch
= get_type_arch (type
);
1085 typename
= type_to_string (type
);
1086 if (typename
== NULL
)
1087 error (_("cannot find typeinfo for unnamed type"));
1088 cleanup
= make_cleanup (xfree
, typename
);
1090 /* We need to canonicalize the type name here, because we do lookups
1091 using the demangled name, and so we must match the format it
1092 uses. E.g., GDB tends to use "const char *" as a type name, but
1093 the demangler uses "char const *". */
1094 canonical
= cp_canonicalize_string (typename
);
1095 if (canonical
!= NULL
)
1097 make_cleanup (xfree
, canonical
);
1098 typename
= canonical
;
1101 typeinfo_type
= gnuv3_get_typeid_type (gdbarch
);
1103 /* We check for lval_memory because in the "typeid (type-id)" case,
1104 the type is passed via a not_lval value object. */
1105 if (TYPE_CODE (type
) == TYPE_CODE_CLASS
1106 && value_lval_const (value
) == lval_memory
1107 && gnuv3_dynamic_class (type
))
1109 struct value
*vtable
, *typeinfo_value
;
1110 CORE_ADDR address
= value_address (value
) + value_embedded_offset (value
);
1112 vtable
= gnuv3_get_vtable (gdbarch
, type
, address
);
1114 error (_("cannot find typeinfo for object of type '%s'"), typename
);
1115 typeinfo_value
= value_field (vtable
, vtable_field_type_info
);
1116 result
= value_ind (value_cast (make_pointer_type (typeinfo_type
, NULL
),
1122 struct bound_minimal_symbol minsym
;
1124 sym_name
= concat ("typeinfo for ", typename
, (char *) NULL
);
1125 make_cleanup (xfree
, sym_name
);
1126 minsym
= lookup_minimal_symbol (sym_name
, NULL
, NULL
);
1128 if (minsym
.minsym
== NULL
)
1129 error (_("could not find typeinfo symbol for '%s'"), typename
);
1131 result
= value_at_lazy (typeinfo_type
, BMSYMBOL_VALUE_ADDRESS (minsym
));
1134 do_cleanups (cleanup
);
1138 /* Implement the 'get_typename_from_type_info' method. */
1141 gnuv3_get_typename_from_type_info (struct value
*type_info_ptr
)
1143 struct gdbarch
*gdbarch
= get_type_arch (value_type (type_info_ptr
));
1144 struct bound_minimal_symbol typeinfo_sym
;
1146 const char *symname
;
1147 const char *class_name
;
1150 addr
= value_as_address (type_info_ptr
);
1151 typeinfo_sym
= lookup_minimal_symbol_by_pc (addr
);
1152 if (typeinfo_sym
.minsym
== NULL
)
1153 error (_("could not find minimal symbol for typeinfo address %s"),
1154 paddress (gdbarch
, addr
));
1156 #define TYPEINFO_PREFIX "typeinfo for "
1157 #define TYPEINFO_PREFIX_LEN (sizeof (TYPEINFO_PREFIX) - 1)
1158 symname
= MSYMBOL_DEMANGLED_NAME (typeinfo_sym
.minsym
);
1159 if (symname
== NULL
|| strncmp (symname
, TYPEINFO_PREFIX
,
1160 TYPEINFO_PREFIX_LEN
))
1161 error (_("typeinfo symbol '%s' has unexpected name"),
1162 MSYMBOL_LINKAGE_NAME (typeinfo_sym
.minsym
));
1163 class_name
= symname
+ TYPEINFO_PREFIX_LEN
;
1165 /* Strip off @plt and version suffixes. */
1166 atsign
= strchr (class_name
, '@');
1168 return savestring (class_name
, atsign
- class_name
);
1169 return xstrdup (class_name
);
1172 /* Implement the 'get_type_from_type_info' method. */
1174 static struct type
*
1175 gnuv3_get_type_from_type_info (struct value
*type_info_ptr
)
1178 struct cleanup
*cleanup
;
1179 struct value
*type_val
;
1180 struct expression
*expr
;
1181 struct type
*result
;
1183 typename
= gnuv3_get_typename_from_type_info (type_info_ptr
);
1184 cleanup
= make_cleanup (xfree
, typename
);
1186 /* We have to parse the type name, since in general there is not a
1187 symbol for a type. This is somewhat bogus since there may be a
1188 mis-parse. Another approach might be to re-use the demangler's
1189 internal form to reconstruct the type somehow. */
1191 expr
= parse_expression (typename
);
1192 make_cleanup (xfree
, expr
);
1194 type_val
= evaluate_type (expr
);
1195 result
= value_type (type_val
);
1197 do_cleanups (cleanup
);
1201 /* Determine if we are currently in a C++ thunk. If so, get the address
1202 of the routine we are thunking to and continue to there instead. */
1205 gnuv3_skip_trampoline (struct frame_info
*frame
, CORE_ADDR stop_pc
)
1207 CORE_ADDR real_stop_pc
, method_stop_pc
, func_addr
;
1208 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1209 struct bound_minimal_symbol thunk_sym
, fn_sym
;
1210 struct obj_section
*section
;
1211 const char *thunk_name
, *fn_name
;
1213 real_stop_pc
= gdbarch_skip_trampoline_code (gdbarch
, frame
, stop_pc
);
1214 if (real_stop_pc
== 0)
1215 real_stop_pc
= stop_pc
;
1217 /* Find the linker symbol for this potential thunk. */
1218 thunk_sym
= lookup_minimal_symbol_by_pc (real_stop_pc
);
1219 section
= find_pc_section (real_stop_pc
);
1220 if (thunk_sym
.minsym
== NULL
|| section
== NULL
)
1223 /* The symbol's demangled name should be something like "virtual
1224 thunk to FUNCTION", where FUNCTION is the name of the function
1225 being thunked to. */
1226 thunk_name
= MSYMBOL_DEMANGLED_NAME (thunk_sym
.minsym
);
1227 if (thunk_name
== NULL
|| strstr (thunk_name
, " thunk to ") == NULL
)
1230 fn_name
= strstr (thunk_name
, " thunk to ") + strlen (" thunk to ");
1231 fn_sym
= lookup_minimal_symbol (fn_name
, NULL
, section
->objfile
);
1232 if (fn_sym
.minsym
== NULL
)
1235 method_stop_pc
= BMSYMBOL_VALUE_ADDRESS (fn_sym
);
1237 /* Some targets have minimal symbols pointing to function descriptors
1238 (powerpc 64 for example). Make sure to retrieve the address
1239 of the real function from the function descriptor before passing on
1240 the address to other layers of GDB. */
1241 func_addr
= gdbarch_convert_from_func_ptr_addr (gdbarch
, method_stop_pc
,
1244 method_stop_pc
= func_addr
;
1246 real_stop_pc
= gdbarch_skip_trampoline_code
1247 (gdbarch
, frame
, method_stop_pc
);
1248 if (real_stop_pc
== 0)
1249 real_stop_pc
= method_stop_pc
;
1251 return real_stop_pc
;
1254 /* Return nonzero if a type should be passed by reference.
1256 The rule in the v3 ABI document comes from section 3.1.1. If the
1257 type has a non-trivial copy constructor or destructor, then the
1258 caller must make a copy (by calling the copy constructor if there
1259 is one or perform the copy itself otherwise), pass the address of
1260 the copy, and then destroy the temporary (if necessary).
1262 For return values with non-trivial copy constructors or
1263 destructors, space will be allocated in the caller, and a pointer
1264 will be passed as the first argument (preceding "this").
1266 We don't have a bulletproof mechanism for determining whether a
1267 constructor or destructor is trivial. For GCC and DWARF2 debug
1268 information, we can check the artificial flag.
1270 We don't do anything with the constructors or destructors,
1271 but we have to get the argument passing right anyway. */
1273 gnuv3_pass_by_reference (struct type
*type
)
1275 int fieldnum
, fieldelem
;
1277 CHECK_TYPEDEF (type
);
1279 /* We're only interested in things that can have methods. */
1280 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
1281 && TYPE_CODE (type
) != TYPE_CODE_CLASS
1282 && TYPE_CODE (type
) != TYPE_CODE_UNION
)
1285 for (fieldnum
= 0; fieldnum
< TYPE_NFN_FIELDS (type
); fieldnum
++)
1286 for (fieldelem
= 0; fieldelem
< TYPE_FN_FIELDLIST_LENGTH (type
, fieldnum
);
1289 struct fn_field
*fn
= TYPE_FN_FIELDLIST1 (type
, fieldnum
);
1290 const char *name
= TYPE_FN_FIELDLIST_NAME (type
, fieldnum
);
1291 struct type
*fieldtype
= TYPE_FN_FIELD_TYPE (fn
, fieldelem
);
1293 /* If this function is marked as artificial, it is compiler-generated,
1294 and we assume it is trivial. */
1295 if (TYPE_FN_FIELD_ARTIFICIAL (fn
, fieldelem
))
1298 /* If we've found a destructor, we must pass this by reference. */
1302 /* If the mangled name of this method doesn't indicate that it
1303 is a constructor, we're not interested.
1305 FIXME drow/2007-09-23: We could do this using the name of
1306 the method and the name of the class instead of dealing
1307 with the mangled name. We don't have a convenient function
1308 to strip off both leading scope qualifiers and trailing
1309 template arguments yet. */
1310 if (!is_constructor_name (TYPE_FN_FIELD_PHYSNAME (fn
, fieldelem
))
1311 && !TYPE_FN_FIELD_CONSTRUCTOR (fn
, fieldelem
))
1314 /* If this method takes two arguments, and the second argument is
1315 a reference to this class, then it is a copy constructor. */
1316 if (TYPE_NFIELDS (fieldtype
) == 2
1317 && TYPE_CODE (TYPE_FIELD_TYPE (fieldtype
, 1)) == TYPE_CODE_REF
1318 && check_typedef (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (fieldtype
,
1323 /* Even if all the constructors and destructors were artificial, one
1324 of them may have invoked a non-artificial constructor or
1325 destructor in a base class. If any base class needs to be passed
1326 by reference, so does this class. Similarly for members, which
1327 are constructed whenever this class is. We do not need to worry
1328 about recursive loops here, since we are only looking at members
1329 of complete class type. Also ignore any static members. */
1330 for (fieldnum
= 0; fieldnum
< TYPE_NFIELDS (type
); fieldnum
++)
1331 if (! field_is_static (&TYPE_FIELD (type
, fieldnum
))
1332 && gnuv3_pass_by_reference (TYPE_FIELD_TYPE (type
, fieldnum
)))
1339 init_gnuv3_ops (void)
1341 vtable_type_gdbarch_data
1342 = gdbarch_data_register_post_init (build_gdb_vtable_type
);
1343 std_type_info_gdbarch_data
1344 = gdbarch_data_register_post_init (build_std_type_info_type
);
1346 gnu_v3_abi_ops
.shortname
= "gnu-v3";
1347 gnu_v3_abi_ops
.longname
= "GNU G++ Version 3 ABI";
1348 gnu_v3_abi_ops
.doc
= "G++ Version 3 ABI";
1349 gnu_v3_abi_ops
.is_destructor_name
=
1350 (enum dtor_kinds (*) (const char *))is_gnu_v3_mangled_dtor
;
1351 gnu_v3_abi_ops
.is_constructor_name
=
1352 (enum ctor_kinds (*) (const char *))is_gnu_v3_mangled_ctor
;
1353 gnu_v3_abi_ops
.is_vtable_name
= gnuv3_is_vtable_name
;
1354 gnu_v3_abi_ops
.is_operator_name
= gnuv3_is_operator_name
;
1355 gnu_v3_abi_ops
.rtti_type
= gnuv3_rtti_type
;
1356 gnu_v3_abi_ops
.virtual_fn_field
= gnuv3_virtual_fn_field
;
1357 gnu_v3_abi_ops
.baseclass_offset
= gnuv3_baseclass_offset
;
1358 gnu_v3_abi_ops
.print_method_ptr
= gnuv3_print_method_ptr
;
1359 gnu_v3_abi_ops
.method_ptr_size
= gnuv3_method_ptr_size
;
1360 gnu_v3_abi_ops
.make_method_ptr
= gnuv3_make_method_ptr
;
1361 gnu_v3_abi_ops
.method_ptr_to_value
= gnuv3_method_ptr_to_value
;
1362 gnu_v3_abi_ops
.print_vtable
= gnuv3_print_vtable
;
1363 gnu_v3_abi_ops
.get_typeid
= gnuv3_get_typeid
;
1364 gnu_v3_abi_ops
.get_typeid_type
= gnuv3_get_typeid_type
;
1365 gnu_v3_abi_ops
.get_type_from_type_info
= gnuv3_get_type_from_type_info
;
1366 gnu_v3_abi_ops
.get_typename_from_type_info
1367 = gnuv3_get_typename_from_type_info
;
1368 gnu_v3_abi_ops
.skip_trampoline
= gnuv3_skip_trampoline
;
1369 gnu_v3_abi_ops
.pass_by_reference
= gnuv3_pass_by_reference
;
1372 extern initialize_file_ftype _initialize_gnu_v3_abi
; /* -Wmissing-prototypes */
1375 _initialize_gnu_v3_abi (void)
1379 register_cp_abi (&gnu_v3_abi_ops
);
1380 set_cp_abi_as_auto_default (gnu_v3_abi_ops
.shortname
);