1 /* Abstraction of GNU v3 abi.
2 Contributed by Jim Blandy <jimb@redhat.com>
4 Copyright (C) 2001-2017 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 startswith (name
, "_ZTV");
46 gnuv3_is_operator_name (const char *name
)
48 return startswith (name
, "operator");
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
= XCNEWVEC (struct field
, 4);
129 field
= &field_list
[0];
132 /* ptrdiff_t vcall_and_vbase_offsets[0]; */
133 FIELD_NAME (*field
) = "vcall_and_vbase_offsets";
134 FIELD_TYPE (*field
) = lookup_array_range_type (ptrdiff_type
, 0, -1);
135 SET_FIELD_BITPOS (*field
, offset
* TARGET_CHAR_BIT
);
136 offset
+= TYPE_LENGTH (FIELD_TYPE (*field
));
139 /* ptrdiff_t offset_to_top; */
140 FIELD_NAME (*field
) = "offset_to_top";
141 FIELD_TYPE (*field
) = ptrdiff_type
;
142 SET_FIELD_BITPOS (*field
, offset
* TARGET_CHAR_BIT
);
143 offset
+= TYPE_LENGTH (FIELD_TYPE (*field
));
146 /* void *type_info; */
147 FIELD_NAME (*field
) = "type_info";
148 FIELD_TYPE (*field
) = void_ptr_type
;
149 SET_FIELD_BITPOS (*field
, offset
* TARGET_CHAR_BIT
);
150 offset
+= TYPE_LENGTH (FIELD_TYPE (*field
));
153 /* void (*virtual_functions[0]) (); */
154 FIELD_NAME (*field
) = "virtual_functions";
155 FIELD_TYPE (*field
) = lookup_array_range_type (ptr_to_void_fn_type
, 0, -1);
156 SET_FIELD_BITPOS (*field
, offset
* TARGET_CHAR_BIT
);
157 offset
+= TYPE_LENGTH (FIELD_TYPE (*field
));
160 /* We assumed in the allocation above that there were four fields. */
161 gdb_assert (field
== (field_list
+ 4));
163 t
= arch_type (arch
, TYPE_CODE_STRUCT
, offset
, NULL
);
164 TYPE_NFIELDS (t
) = field
- field_list
;
165 TYPE_FIELDS (t
) = field_list
;
166 TYPE_TAG_NAME (t
) = "gdb_gnu_v3_abi_vtable";
167 INIT_CPLUS_SPECIFIC (t
);
169 return make_type_with_address_space (t
, TYPE_INSTANCE_FLAG_CODE_SPACE
);
173 /* Return the ptrdiff_t type used in the vtable type. */
175 vtable_ptrdiff_type (struct gdbarch
*gdbarch
)
177 struct type
*vtable_type
178 = (struct 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
191 = (struct 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 type
= check_typedef (type
);
207 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_STRUCT
208 || TYPE_CODE (type
) == TYPE_CODE_UNION
);
210 if (TYPE_CODE (type
) == TYPE_CODE_UNION
)
213 if (TYPE_CPLUS_DYNAMIC (type
))
214 return TYPE_CPLUS_DYNAMIC (type
) == 1;
216 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
218 for (fieldnum
= 0; fieldnum
< TYPE_N_BASECLASSES (type
); fieldnum
++)
219 if (BASETYPE_VIA_VIRTUAL (type
, fieldnum
)
220 || gnuv3_dynamic_class (TYPE_FIELD_TYPE (type
, fieldnum
)))
222 TYPE_CPLUS_DYNAMIC (type
) = 1;
226 for (fieldnum
= 0; fieldnum
< TYPE_NFN_FIELDS (type
); fieldnum
++)
227 for (fieldelem
= 0; fieldelem
< TYPE_FN_FIELDLIST_LENGTH (type
, fieldnum
);
230 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, fieldnum
);
232 if (TYPE_FN_FIELD_VIRTUAL_P (f
, fieldelem
))
234 TYPE_CPLUS_DYNAMIC (type
) = 1;
239 TYPE_CPLUS_DYNAMIC (type
) = -1;
243 /* Find the vtable for a value of CONTAINER_TYPE located at
244 CONTAINER_ADDR. Return a value of the correct vtable type for this
245 architecture, or NULL if CONTAINER does not have a vtable. */
247 static struct value
*
248 gnuv3_get_vtable (struct gdbarch
*gdbarch
,
249 struct type
*container_type
, CORE_ADDR container_addr
)
251 struct type
*vtable_type
252 = (struct type
*) gdbarch_data (gdbarch
, vtable_type_gdbarch_data
);
253 struct type
*vtable_pointer_type
;
254 struct value
*vtable_pointer
;
255 CORE_ADDR vtable_address
;
257 container_type
= check_typedef (container_type
);
258 gdb_assert (TYPE_CODE (container_type
) == TYPE_CODE_STRUCT
);
260 /* If this type does not have a virtual table, don't read the first
262 if (!gnuv3_dynamic_class (container_type
))
265 /* We do not consult the debug information to find the virtual table.
266 The ABI specifies that it is always at offset zero in any class,
267 and debug information may not represent it.
269 We avoid using value_contents on principle, because the object might
272 /* Find the type "pointer to virtual table". */
273 vtable_pointer_type
= lookup_pointer_type (vtable_type
);
275 /* Load it from the start of the class. */
276 vtable_pointer
= value_at (vtable_pointer_type
, container_addr
);
277 vtable_address
= value_as_address (vtable_pointer
);
279 /* Correct it to point at the start of the virtual table, rather
280 than the address point. */
281 return value_at_lazy (vtable_type
,
283 - vtable_address_point_offset (gdbarch
));
288 gnuv3_rtti_type (struct value
*value
,
289 int *full_p
, LONGEST
*top_p
, int *using_enc_p
)
291 struct gdbarch
*gdbarch
;
292 struct type
*values_type
= check_typedef (value_type (value
));
293 struct value
*vtable
;
294 struct minimal_symbol
*vtable_symbol
;
295 const char *vtable_symbol_name
;
296 const char *class_name
;
297 struct type
*run_time_type
;
298 LONGEST offset_to_top
;
301 /* We only have RTTI for class objects. */
302 if (TYPE_CODE (values_type
) != TYPE_CODE_STRUCT
)
305 /* Determine architecture. */
306 gdbarch
= get_type_arch (values_type
);
311 vtable
= gnuv3_get_vtable (gdbarch
, values_type
,
312 value_as_address (value_addr (value
)));
316 /* Find the linker symbol for this vtable. */
318 = lookup_minimal_symbol_by_pc (value_address (vtable
)
319 + value_embedded_offset (vtable
)).minsym
;
323 /* The symbol's demangled name should be something like "vtable for
324 CLASS", where CLASS is the name of the run-time type of VALUE.
325 If we didn't like this approach, we could instead look in the
326 type_info object itself to get the class name. But this way
327 should work just as well, and doesn't read target memory. */
328 vtable_symbol_name
= MSYMBOL_DEMANGLED_NAME (vtable_symbol
);
329 if (vtable_symbol_name
== NULL
330 || !startswith (vtable_symbol_name
, "vtable for "))
332 warning (_("can't find linker symbol for virtual table for `%s' value"),
333 TYPE_SAFE_NAME (values_type
));
334 if (vtable_symbol_name
)
335 warning (_(" found `%s' instead"), vtable_symbol_name
);
338 class_name
= vtable_symbol_name
+ 11;
340 /* Strip off @plt and version suffixes. */
341 atsign
= strchr (class_name
, '@');
346 copy
= (char *) alloca (atsign
- class_name
+ 1);
347 memcpy (copy
, class_name
, atsign
- class_name
);
348 copy
[atsign
- class_name
] = '\0';
352 /* Try to look up the class name as a type name. */
353 /* FIXME: chastain/2003-11-26: block=NULL is bogus. See pr gdb/1465. */
354 run_time_type
= cp_lookup_rtti_type (class_name
, NULL
);
355 if (run_time_type
== NULL
)
358 /* Get the offset from VALUE to the top of the complete object.
359 NOTE: this is the reverse of the meaning of *TOP_P. */
361 = value_as_long (value_field (vtable
, vtable_field_offset_to_top
));
364 *full_p
= (- offset_to_top
== value_embedded_offset (value
)
365 && (TYPE_LENGTH (value_enclosing_type (value
))
366 >= TYPE_LENGTH (run_time_type
)));
368 *top_p
= - offset_to_top
;
369 return run_time_type
;
372 /* Return a function pointer for CONTAINER's VTABLE_INDEX'th virtual
373 function, of type FNTYPE. */
375 static struct value
*
376 gnuv3_get_virtual_fn (struct gdbarch
*gdbarch
, struct value
*container
,
377 struct type
*fntype
, int vtable_index
)
379 struct value
*vtable
, *vfn
;
381 /* Every class with virtual functions must have a vtable. */
382 vtable
= gnuv3_get_vtable (gdbarch
, value_type (container
),
383 value_as_address (value_addr (container
)));
384 gdb_assert (vtable
!= NULL
);
386 /* Fetch the appropriate function pointer from the vtable. */
387 vfn
= value_subscript (value_field (vtable
, vtable_field_virtual_functions
),
390 /* If this architecture uses function descriptors directly in the vtable,
391 then the address of the vtable entry is actually a "function pointer"
392 (i.e. points to the descriptor). We don't need to scale the index
393 by the size of a function descriptor; GCC does that before outputing
394 debug information. */
395 if (gdbarch_vtable_function_descriptors (gdbarch
))
396 vfn
= value_addr (vfn
);
398 /* Cast the function pointer to the appropriate type. */
399 vfn
= value_cast (lookup_pointer_type (fntype
), vfn
);
404 /* GNU v3 implementation of value_virtual_fn_field. See cp-abi.h
405 for a description of the arguments. */
407 static struct value
*
408 gnuv3_virtual_fn_field (struct value
**value_p
,
409 struct fn_field
*f
, int j
,
410 struct type
*vfn_base
, int offset
)
412 struct type
*values_type
= check_typedef (value_type (*value_p
));
413 struct gdbarch
*gdbarch
;
415 /* Some simple sanity checks. */
416 if (TYPE_CODE (values_type
) != TYPE_CODE_STRUCT
)
417 error (_("Only classes can have virtual functions."));
419 /* Determine architecture. */
420 gdbarch
= get_type_arch (values_type
);
422 /* Cast our value to the base class which defines this virtual
423 function. This takes care of any necessary `this'
425 if (vfn_base
!= values_type
)
426 *value_p
= value_cast (vfn_base
, *value_p
);
428 return gnuv3_get_virtual_fn (gdbarch
, *value_p
, TYPE_FN_FIELD_TYPE (f
, j
),
429 TYPE_FN_FIELD_VOFFSET (f
, j
));
432 /* Compute the offset of the baseclass which is
433 the INDEXth baseclass of class TYPE,
434 for value at VALADDR (in host) at ADDRESS (in target).
435 The result is the offset of the baseclass value relative
436 to (the address of)(ARG) + OFFSET.
438 -1 is returned on error. */
441 gnuv3_baseclass_offset (struct type
*type
, int index
,
442 const bfd_byte
*valaddr
, LONGEST embedded_offset
,
443 CORE_ADDR address
, const struct value
*val
)
445 struct gdbarch
*gdbarch
;
446 struct type
*ptr_type
;
447 struct value
*vtable
;
448 struct value
*vbase_array
;
449 long int cur_base_offset
, base_offset
;
451 /* Determine architecture. */
452 gdbarch
= get_type_arch (type
);
453 ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
455 /* If it isn't a virtual base, this is easy. The offset is in the
457 if (!BASETYPE_VIA_VIRTUAL (type
, index
))
458 return TYPE_BASECLASS_BITPOS (type
, index
) / 8;
460 /* To access a virtual base, we need to use the vbase offset stored in
461 our vtable. Recent GCC versions provide this information. If it isn't
462 available, we could get what we needed from RTTI, or from drawing the
463 complete inheritance graph based on the debug info. Neither is
465 cur_base_offset
= TYPE_BASECLASS_BITPOS (type
, index
) / 8;
466 if (cur_base_offset
>= - vtable_address_point_offset (gdbarch
))
467 error (_("Expected a negative vbase offset (old compiler?)"));
469 cur_base_offset
= cur_base_offset
+ vtable_address_point_offset (gdbarch
);
470 if ((- cur_base_offset
) % TYPE_LENGTH (ptr_type
) != 0)
471 error (_("Misaligned vbase offset."));
472 cur_base_offset
= cur_base_offset
/ ((int) TYPE_LENGTH (ptr_type
));
474 vtable
= gnuv3_get_vtable (gdbarch
, type
, address
+ embedded_offset
);
475 gdb_assert (vtable
!= NULL
);
476 vbase_array
= value_field (vtable
, vtable_field_vcall_and_vbase_offsets
);
477 base_offset
= value_as_long (value_subscript (vbase_array
, cur_base_offset
));
481 /* Locate a virtual method in DOMAIN or its non-virtual base classes
482 which has virtual table index VOFFSET. The method has an associated
483 "this" adjustment of ADJUSTMENT bytes. */
486 gnuv3_find_method_in (struct type
*domain
, CORE_ADDR voffset
,
491 /* Search this class first. */
496 len
= TYPE_NFN_FIELDS (domain
);
497 for (i
= 0; i
< len
; i
++)
502 f
= TYPE_FN_FIELDLIST1 (domain
, i
);
503 len2
= TYPE_FN_FIELDLIST_LENGTH (domain
, i
);
505 check_stub_method_group (domain
, i
);
506 for (j
= 0; j
< len2
; j
++)
507 if (TYPE_FN_FIELD_VOFFSET (f
, j
) == voffset
)
508 return TYPE_FN_FIELD_PHYSNAME (f
, j
);
512 /* Next search non-virtual bases. If it's in a virtual base,
513 we're out of luck. */
514 for (i
= 0; i
< TYPE_N_BASECLASSES (domain
); i
++)
517 struct type
*basetype
;
519 if (BASETYPE_VIA_VIRTUAL (domain
, i
))
522 pos
= TYPE_BASECLASS_BITPOS (domain
, i
) / 8;
523 basetype
= TYPE_FIELD_TYPE (domain
, i
);
524 /* Recurse with a modified adjustment. We don't need to adjust
526 if (adjustment
>= pos
&& adjustment
< pos
+ TYPE_LENGTH (basetype
))
527 return gnuv3_find_method_in (basetype
, voffset
, adjustment
- pos
);
533 /* Decode GNU v3 method pointer. */
536 gnuv3_decode_method_ptr (struct gdbarch
*gdbarch
,
537 const gdb_byte
*contents
,
539 LONGEST
*adjustment_p
)
541 struct type
*funcptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
542 struct type
*offset_type
= vtable_ptrdiff_type (gdbarch
);
543 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
545 LONGEST voffset
, adjustment
;
548 /* Extract the pointer to member. The first element is either a pointer
549 or a vtable offset. For pointers, we need to use extract_typed_address
550 to allow the back-end to convert the pointer to a GDB address -- but
551 vtable offsets we must handle as integers. At this point, we do not
552 yet know which case we have, so we extract the value under both
553 interpretations and choose the right one later on. */
554 ptr_value
= extract_typed_address (contents
, funcptr_type
);
555 voffset
= extract_signed_integer (contents
,
556 TYPE_LENGTH (funcptr_type
), byte_order
);
557 contents
+= TYPE_LENGTH (funcptr_type
);
558 adjustment
= extract_signed_integer (contents
,
559 TYPE_LENGTH (offset_type
), byte_order
);
561 if (!gdbarch_vbit_in_delta (gdbarch
))
564 voffset
= voffset
^ vbit
;
568 vbit
= adjustment
& 1;
569 adjustment
= adjustment
>> 1;
572 *value_p
= vbit
? voffset
: ptr_value
;
573 *adjustment_p
= adjustment
;
577 /* GNU v3 implementation of cplus_print_method_ptr. */
580 gnuv3_print_method_ptr (const gdb_byte
*contents
,
582 struct ui_file
*stream
)
584 struct type
*self_type
= TYPE_SELF_TYPE (type
);
585 struct gdbarch
*gdbarch
= get_type_arch (self_type
);
590 /* Extract the pointer to member. */
591 vbit
= gnuv3_decode_method_ptr (gdbarch
, contents
, &ptr_value
, &adjustment
);
593 /* Check for NULL. */
594 if (ptr_value
== 0 && vbit
== 0)
596 fprintf_filtered (stream
, "NULL");
600 /* Search for a virtual method. */
604 const char *physname
;
606 /* It's a virtual table offset, maybe in this class. Search
607 for a field with the correct vtable offset. First convert it
608 to an index, as used in TYPE_FN_FIELD_VOFFSET. */
609 voffset
= ptr_value
/ TYPE_LENGTH (vtable_ptrdiff_type (gdbarch
));
611 physname
= gnuv3_find_method_in (self_type
, voffset
, adjustment
);
613 /* If we found a method, print that. We don't bother to disambiguate
614 possible paths to the method based on the adjustment. */
617 char *demangled_name
= gdb_demangle (physname
,
618 DMGL_ANSI
| DMGL_PARAMS
);
620 fprintf_filtered (stream
, "&virtual ");
621 if (demangled_name
== NULL
)
622 fputs_filtered (physname
, stream
);
625 fputs_filtered (demangled_name
, stream
);
626 xfree (demangled_name
);
631 else if (ptr_value
!= 0)
633 /* Found a non-virtual function: print out the type. */
634 fputs_filtered ("(", stream
);
635 c_print_type (type
, "", stream
, -1, 0, &type_print_raw_options
);
636 fputs_filtered (") ", stream
);
639 /* We didn't find it; print the raw data. */
642 fprintf_filtered (stream
, "&virtual table offset ");
643 print_longest (stream
, 'd', 1, ptr_value
);
647 struct value_print_options opts
;
649 get_user_print_options (&opts
);
650 print_address_demangle (&opts
, gdbarch
, ptr_value
, stream
, demangle
);
655 fprintf_filtered (stream
, ", this adjustment ");
656 print_longest (stream
, 'd', 1, adjustment
);
660 /* GNU v3 implementation of cplus_method_ptr_size. */
663 gnuv3_method_ptr_size (struct type
*type
)
665 struct gdbarch
*gdbarch
= get_type_arch (type
);
667 return 2 * TYPE_LENGTH (builtin_type (gdbarch
)->builtin_data_ptr
);
670 /* GNU v3 implementation of cplus_make_method_ptr. */
673 gnuv3_make_method_ptr (struct type
*type
, gdb_byte
*contents
,
674 CORE_ADDR value
, int is_virtual
)
676 struct gdbarch
*gdbarch
= get_type_arch (type
);
677 int size
= TYPE_LENGTH (builtin_type (gdbarch
)->builtin_data_ptr
);
678 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
680 /* FIXME drow/2006-12-24: The adjustment of "this" is currently
681 always zero, since the method pointer is of the correct type.
682 But if the method pointer came from a base class, this is
683 incorrect - it should be the offset to the base. The best
684 fix might be to create the pointer to member pointing at the
685 base class and cast it to the derived class, but that requires
686 support for adjusting pointers to members when casting them -
687 not currently supported by GDB. */
689 if (!gdbarch_vbit_in_delta (gdbarch
))
691 store_unsigned_integer (contents
, size
, byte_order
, value
| is_virtual
);
692 store_unsigned_integer (contents
+ size
, size
, byte_order
, 0);
696 store_unsigned_integer (contents
, size
, byte_order
, value
);
697 store_unsigned_integer (contents
+ size
, size
, byte_order
, is_virtual
);
701 /* GNU v3 implementation of cplus_method_ptr_to_value. */
703 static struct value
*
704 gnuv3_method_ptr_to_value (struct value
**this_p
, struct value
*method_ptr
)
706 struct gdbarch
*gdbarch
;
707 const gdb_byte
*contents
= value_contents (method_ptr
);
709 struct type
*self_type
, *final_type
, *method_type
;
713 self_type
= TYPE_SELF_TYPE (check_typedef (value_type (method_ptr
)));
714 final_type
= lookup_pointer_type (self_type
);
716 method_type
= TYPE_TARGET_TYPE (check_typedef (value_type (method_ptr
)));
718 /* Extract the pointer to member. */
719 gdbarch
= get_type_arch (self_type
);
720 vbit
= gnuv3_decode_method_ptr (gdbarch
, contents
, &ptr_value
, &adjustment
);
722 /* First convert THIS to match the containing type of the pointer to
723 member. This cast may adjust the value of THIS. */
724 *this_p
= value_cast (final_type
, *this_p
);
726 /* Then apply whatever adjustment is necessary. This creates a somewhat
727 strange pointer: it claims to have type FINAL_TYPE, but in fact it
728 might not be a valid FINAL_TYPE. For instance, it might be a
729 base class of FINAL_TYPE. And if it's not the primary base class,
730 then printing it out as a FINAL_TYPE object would produce some pretty
733 But we don't really know the type of the first argument in
734 METHOD_TYPE either, which is why this happens. We can't
735 dereference this later as a FINAL_TYPE, but once we arrive in the
736 called method we'll have debugging information for the type of
737 "this" - and that'll match the value we produce here.
739 You can provoke this case by casting a Base::* to a Derived::*, for
741 *this_p
= value_cast (builtin_type (gdbarch
)->builtin_data_ptr
, *this_p
);
742 *this_p
= value_ptradd (*this_p
, adjustment
);
743 *this_p
= value_cast (final_type
, *this_p
);
749 voffset
= ptr_value
/ TYPE_LENGTH (vtable_ptrdiff_type (gdbarch
));
750 return gnuv3_get_virtual_fn (gdbarch
, value_ind (*this_p
),
751 method_type
, voffset
);
754 return value_from_pointer (lookup_pointer_type (method_type
), ptr_value
);
757 /* Objects of this type are stored in a hash table and a vector when
758 printing the vtables for a class. */
760 struct value_and_voffset
762 /* The value representing the object. */
765 /* The maximum vtable offset we've found for any object at this
766 offset in the outermost object. */
770 typedef struct value_and_voffset
*value_and_voffset_p
;
771 DEF_VEC_P (value_and_voffset_p
);
773 /* Hash function for value_and_voffset. */
776 hash_value_and_voffset (const void *p
)
778 const struct value_and_voffset
*o
= (const struct value_and_voffset
*) p
;
780 return value_address (o
->value
) + value_embedded_offset (o
->value
);
783 /* Equality function for value_and_voffset. */
786 eq_value_and_voffset (const void *a
, const void *b
)
788 const struct value_and_voffset
*ova
= (const struct value_and_voffset
*) a
;
789 const struct value_and_voffset
*ovb
= (const struct value_and_voffset
*) b
;
791 return (value_address (ova
->value
) + value_embedded_offset (ova
->value
)
792 == value_address (ovb
->value
) + value_embedded_offset (ovb
->value
));
795 /* qsort comparison function for value_and_voffset. */
798 compare_value_and_voffset (const void *a
, const void *b
)
800 const struct value_and_voffset
* const *ova
801 = (const struct value_and_voffset
* const *) a
;
802 CORE_ADDR addra
= (value_address ((*ova
)->value
)
803 + value_embedded_offset ((*ova
)->value
));
804 const struct value_and_voffset
* const *ovb
805 = (const struct value_and_voffset
* const *) b
;
806 CORE_ADDR addrb
= (value_address ((*ovb
)->value
)
807 + value_embedded_offset ((*ovb
)->value
));
816 /* A helper function used when printing vtables. This determines the
817 key (most derived) sub-object at each address and also computes the
818 maximum vtable offset seen for the corresponding vtable. Updates
819 OFFSET_HASH and OFFSET_VEC with a new value_and_voffset object, if
820 needed. VALUE is the object to examine. */
823 compute_vtable_size (htab_t offset_hash
,
824 VEC (value_and_voffset_p
) **offset_vec
,
828 struct type
*type
= check_typedef (value_type (value
));
830 struct value_and_voffset search_vo
, *current_vo
;
832 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_STRUCT
);
834 /* If the object is not dynamic, then we are done; as it cannot have
835 dynamic base types either. */
836 if (!gnuv3_dynamic_class (type
))
839 /* Update the hash and the vec, if needed. */
840 search_vo
.value
= value
;
841 slot
= htab_find_slot (offset_hash
, &search_vo
, INSERT
);
843 current_vo
= (struct value_and_voffset
*) *slot
;
846 current_vo
= XNEW (struct value_and_voffset
);
847 current_vo
->value
= value
;
848 current_vo
->max_voffset
= -1;
850 VEC_safe_push (value_and_voffset_p
, *offset_vec
, current_vo
);
853 /* Update the value_and_voffset object with the highest vtable
854 offset from this class. */
855 for (i
= 0; i
< TYPE_NFN_FIELDS (type
); ++i
)
858 struct fn_field
*fn
= TYPE_FN_FIELDLIST1 (type
, i
);
860 for (j
= 0; j
< TYPE_FN_FIELDLIST_LENGTH (type
, i
); ++j
)
862 if (TYPE_FN_FIELD_VIRTUAL_P (fn
, j
))
864 int voffset
= TYPE_FN_FIELD_VOFFSET (fn
, j
);
866 if (voffset
> current_vo
->max_voffset
)
867 current_vo
->max_voffset
= voffset
;
872 /* Recurse into base classes. */
873 for (i
= 0; i
< TYPE_N_BASECLASSES (type
); ++i
)
874 compute_vtable_size (offset_hash
, offset_vec
, value_field (value
, i
));
877 /* Helper for gnuv3_print_vtable that prints a single vtable. */
880 print_one_vtable (struct gdbarch
*gdbarch
, struct value
*value
,
882 struct value_print_options
*opts
)
885 struct type
*type
= check_typedef (value_type (value
));
886 struct value
*vtable
;
889 vtable
= gnuv3_get_vtable (gdbarch
, type
,
890 value_address (value
)
891 + value_embedded_offset (value
));
892 vt_addr
= value_address (value_field (vtable
,
893 vtable_field_virtual_functions
));
895 printf_filtered (_("vtable for '%s' @ %s (subobject @ %s):\n"),
896 TYPE_SAFE_NAME (type
),
897 paddress (gdbarch
, vt_addr
),
898 paddress (gdbarch
, (value_address (value
)
899 + value_embedded_offset (value
))));
901 for (i
= 0; i
<= max_voffset
; ++i
)
903 /* Initialize it just to avoid a GCC false warning. */
908 printf_filtered ("[%d]: ", i
);
910 vfn
= value_subscript (value_field (vtable
,
911 vtable_field_virtual_functions
),
914 if (gdbarch_vtable_function_descriptors (gdbarch
))
915 vfn
= value_addr (vfn
);
919 addr
= value_as_address (vfn
);
921 CATCH (ex
, RETURN_MASK_ERROR
)
923 printf_filtered (_("<error: %s>"), ex
.message
);
929 print_function_pointer_address (opts
, gdbarch
, addr
, gdb_stdout
);
930 printf_filtered ("\n");
934 /* Implementation of the print_vtable method. */
937 gnuv3_print_vtable (struct value
*value
)
939 struct gdbarch
*gdbarch
;
941 struct value
*vtable
;
942 struct value_print_options opts
;
943 struct cleanup
*cleanup
;
944 VEC (value_and_voffset_p
) *result_vec
= NULL
;
945 struct value_and_voffset
*iter
;
948 value
= coerce_ref (value
);
949 type
= check_typedef (value_type (value
));
950 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
952 value
= value_ind (value
);
953 type
= check_typedef (value_type (value
));
956 get_user_print_options (&opts
);
958 /* Respect 'set print object'. */
959 if (opts
.objectprint
)
961 value
= value_full_object (value
, NULL
, 0, 0, 0);
962 type
= check_typedef (value_type (value
));
965 gdbarch
= get_type_arch (type
);
968 if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
969 vtable
= gnuv3_get_vtable (gdbarch
, type
,
970 value_as_address (value_addr (value
)));
974 printf_filtered (_("This object does not have a virtual function table\n"));
978 htab_up
offset_hash (htab_create_alloc (1, hash_value_and_voffset
,
979 eq_value_and_voffset
,
980 xfree
, xcalloc
, xfree
));
981 cleanup
= make_cleanup (VEC_cleanup (value_and_voffset_p
), &result_vec
);
983 compute_vtable_size (offset_hash
.get (), &result_vec
, value
);
985 qsort (VEC_address (value_and_voffset_p
, result_vec
),
986 VEC_length (value_and_voffset_p
, result_vec
),
987 sizeof (value_and_voffset_p
),
988 compare_value_and_voffset
);
991 for (i
= 0; VEC_iterate (value_and_voffset_p
, result_vec
, i
, iter
); ++i
)
993 if (iter
->max_voffset
>= 0)
996 printf_filtered ("\n");
997 print_one_vtable (gdbarch
, iter
->value
, iter
->max_voffset
, &opts
);
1002 do_cleanups (cleanup
);
1005 /* Return a GDB type representing `struct std::type_info', laid out
1006 appropriately for ARCH.
1008 We use this function as the gdbarch per-architecture data
1009 initialization function. */
1012 build_std_type_info_type (struct gdbarch
*arch
)
1015 struct field
*field_list
, *field
;
1017 struct type
*void_ptr_type
1018 = builtin_type (arch
)->builtin_data_ptr
;
1019 struct type
*char_type
1020 = builtin_type (arch
)->builtin_char
;
1021 struct type
*char_ptr_type
1022 = make_pointer_type (make_cv_type (1, 0, char_type
, NULL
), NULL
);
1024 field_list
= XCNEWVEC (struct field
, 2);
1025 field
= &field_list
[0];
1029 FIELD_NAME (*field
) = "_vptr.type_info";
1030 FIELD_TYPE (*field
) = void_ptr_type
;
1031 SET_FIELD_BITPOS (*field
, offset
* TARGET_CHAR_BIT
);
1032 offset
+= TYPE_LENGTH (FIELD_TYPE (*field
));
1036 FIELD_NAME (*field
) = "__name";
1037 FIELD_TYPE (*field
) = char_ptr_type
;
1038 SET_FIELD_BITPOS (*field
, offset
* TARGET_CHAR_BIT
);
1039 offset
+= TYPE_LENGTH (FIELD_TYPE (*field
));
1042 gdb_assert (field
== (field_list
+ 2));
1044 t
= arch_type (arch
, TYPE_CODE_STRUCT
, offset
, NULL
);
1045 TYPE_NFIELDS (t
) = field
- field_list
;
1046 TYPE_FIELDS (t
) = field_list
;
1047 TYPE_TAG_NAME (t
) = "gdb_gnu_v3_type_info";
1048 INIT_CPLUS_SPECIFIC (t
);
1053 /* Implement the 'get_typeid_type' method. */
1055 static struct type
*
1056 gnuv3_get_typeid_type (struct gdbarch
*gdbarch
)
1058 struct symbol
*typeinfo
;
1059 struct type
*typeinfo_type
;
1061 typeinfo
= lookup_symbol ("std::type_info", NULL
, STRUCT_DOMAIN
,
1063 if (typeinfo
== NULL
)
1065 = (struct type
*) gdbarch_data (gdbarch
, std_type_info_gdbarch_data
);
1067 typeinfo_type
= SYMBOL_TYPE (typeinfo
);
1069 return typeinfo_type
;
1072 /* Implement the 'get_typeid' method. */
1074 static struct value
*
1075 gnuv3_get_typeid (struct value
*value
)
1077 struct type
*typeinfo_type
;
1079 struct gdbarch
*gdbarch
;
1080 struct cleanup
*cleanup
;
1081 struct value
*result
;
1082 std::string type_name
, canonical
;
1084 /* We have to handle values a bit trickily here, to allow this code
1085 to work properly with non_lvalue values that are really just
1087 if (value_lval_const (value
) == lval_memory
)
1088 value
= coerce_ref (value
);
1090 type
= check_typedef (value_type (value
));
1092 /* In the non_lvalue case, a reference might have slipped through
1094 if (TYPE_CODE (type
) == TYPE_CODE_REF
)
1095 type
= check_typedef (TYPE_TARGET_TYPE (type
));
1097 /* Ignore top-level cv-qualifiers. */
1098 type
= make_cv_type (0, 0, type
, NULL
);
1099 gdbarch
= get_type_arch (type
);
1101 type_name
= type_to_string (type
);
1102 if (type_name
.empty ())
1103 error (_("cannot find typeinfo for unnamed type"));
1105 /* We need to canonicalize the type name here, because we do lookups
1106 using the demangled name, and so we must match the format it
1107 uses. E.g., GDB tends to use "const char *" as a type name, but
1108 the demangler uses "char const *". */
1109 canonical
= cp_canonicalize_string (type_name
.c_str ());
1110 if (!canonical
.empty ())
1111 type_name
= canonical
;
1113 typeinfo_type
= gnuv3_get_typeid_type (gdbarch
);
1115 /* We check for lval_memory because in the "typeid (type-id)" case,
1116 the type is passed via a not_lval value object. */
1117 if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
1118 && value_lval_const (value
) == lval_memory
1119 && gnuv3_dynamic_class (type
))
1121 struct value
*vtable
, *typeinfo_value
;
1122 CORE_ADDR address
= value_address (value
) + value_embedded_offset (value
);
1124 vtable
= gnuv3_get_vtable (gdbarch
, type
, address
);
1126 error (_("cannot find typeinfo for object of type '%s'"),
1127 type_name
.c_str ());
1128 typeinfo_value
= value_field (vtable
, vtable_field_type_info
);
1129 result
= value_ind (value_cast (make_pointer_type (typeinfo_type
, NULL
),
1134 std::string sym_name
= std::string ("typeinfo for ") + type_name
;
1135 bound_minimal_symbol minsym
1136 = lookup_minimal_symbol (sym_name
.c_str (), NULL
, NULL
);
1138 if (minsym
.minsym
== NULL
)
1139 error (_("could not find typeinfo symbol for '%s'"), type_name
.c_str ());
1141 result
= value_at_lazy (typeinfo_type
, BMSYMBOL_VALUE_ADDRESS (minsym
));
1147 /* Implement the 'get_typename_from_type_info' method. */
1150 gnuv3_get_typename_from_type_info (struct value
*type_info_ptr
)
1152 struct gdbarch
*gdbarch
= get_type_arch (value_type (type_info_ptr
));
1153 struct bound_minimal_symbol typeinfo_sym
;
1155 const char *symname
;
1156 const char *class_name
;
1159 addr
= value_as_address (type_info_ptr
);
1160 typeinfo_sym
= lookup_minimal_symbol_by_pc (addr
);
1161 if (typeinfo_sym
.minsym
== NULL
)
1162 error (_("could not find minimal symbol for typeinfo address %s"),
1163 paddress (gdbarch
, addr
));
1165 #define TYPEINFO_PREFIX "typeinfo for "
1166 #define TYPEINFO_PREFIX_LEN (sizeof (TYPEINFO_PREFIX) - 1)
1167 symname
= MSYMBOL_DEMANGLED_NAME (typeinfo_sym
.minsym
);
1168 if (symname
== NULL
|| strncmp (symname
, TYPEINFO_PREFIX
,
1169 TYPEINFO_PREFIX_LEN
))
1170 error (_("typeinfo symbol '%s' has unexpected name"),
1171 MSYMBOL_LINKAGE_NAME (typeinfo_sym
.minsym
));
1172 class_name
= symname
+ TYPEINFO_PREFIX_LEN
;
1174 /* Strip off @plt and version suffixes. */
1175 atsign
= strchr (class_name
, '@');
1177 return std::string (class_name
, atsign
- class_name
);
1181 /* Implement the 'get_type_from_type_info' method. */
1183 static struct type
*
1184 gnuv3_get_type_from_type_info (struct value
*type_info_ptr
)
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. */
1190 std::string type_name
= gnuv3_get_typename_from_type_info (type_info_ptr
);
1191 expression_up
expr (parse_expression (type_name
.c_str ()));
1192 struct value
*type_val
= evaluate_type (expr
.get ());
1193 return value_type (type_val
);
1196 /* Determine if we are currently in a C++ thunk. If so, get the address
1197 of the routine we are thunking to and continue to there instead. */
1200 gnuv3_skip_trampoline (struct frame_info
*frame
, CORE_ADDR stop_pc
)
1202 CORE_ADDR real_stop_pc
, method_stop_pc
, func_addr
;
1203 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1204 struct bound_minimal_symbol thunk_sym
, fn_sym
;
1205 struct obj_section
*section
;
1206 const char *thunk_name
, *fn_name
;
1208 real_stop_pc
= gdbarch_skip_trampoline_code (gdbarch
, frame
, stop_pc
);
1209 if (real_stop_pc
== 0)
1210 real_stop_pc
= stop_pc
;
1212 /* Find the linker symbol for this potential thunk. */
1213 thunk_sym
= lookup_minimal_symbol_by_pc (real_stop_pc
);
1214 section
= find_pc_section (real_stop_pc
);
1215 if (thunk_sym
.minsym
== NULL
|| section
== NULL
)
1218 /* The symbol's demangled name should be something like "virtual
1219 thunk to FUNCTION", where FUNCTION is the name of the function
1220 being thunked to. */
1221 thunk_name
= MSYMBOL_DEMANGLED_NAME (thunk_sym
.minsym
);
1222 if (thunk_name
== NULL
|| strstr (thunk_name
, " thunk to ") == NULL
)
1225 fn_name
= strstr (thunk_name
, " thunk to ") + strlen (" thunk to ");
1226 fn_sym
= lookup_minimal_symbol (fn_name
, NULL
, section
->objfile
);
1227 if (fn_sym
.minsym
== NULL
)
1230 method_stop_pc
= BMSYMBOL_VALUE_ADDRESS (fn_sym
);
1232 /* Some targets have minimal symbols pointing to function descriptors
1233 (powerpc 64 for example). Make sure to retrieve the address
1234 of the real function from the function descriptor before passing on
1235 the address to other layers of GDB. */
1236 func_addr
= gdbarch_convert_from_func_ptr_addr (gdbarch
, method_stop_pc
,
1239 method_stop_pc
= func_addr
;
1241 real_stop_pc
= gdbarch_skip_trampoline_code
1242 (gdbarch
, frame
, method_stop_pc
);
1243 if (real_stop_pc
== 0)
1244 real_stop_pc
= method_stop_pc
;
1246 return real_stop_pc
;
1249 /* Return nonzero if a type should be passed by reference.
1251 The rule in the v3 ABI document comes from section 3.1.1. If the
1252 type has a non-trivial copy constructor or destructor, then the
1253 caller must make a copy (by calling the copy constructor if there
1254 is one or perform the copy itself otherwise), pass the address of
1255 the copy, and then destroy the temporary (if necessary).
1257 For return values with non-trivial copy constructors or
1258 destructors, space will be allocated in the caller, and a pointer
1259 will be passed as the first argument (preceding "this").
1261 We don't have a bulletproof mechanism for determining whether a
1262 constructor or destructor is trivial. For GCC and DWARF2 debug
1263 information, we can check the artificial flag.
1265 We don't do anything with the constructors or destructors,
1266 but we have to get the argument passing right anyway. */
1268 gnuv3_pass_by_reference (struct type
*type
)
1270 int fieldnum
, fieldelem
;
1272 type
= check_typedef (type
);
1274 /* We're only interested in things that can have methods. */
1275 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
1276 && TYPE_CODE (type
) != TYPE_CODE_UNION
)
1279 /* A dynamic class has a non-trivial copy constructor.
1280 See c++98 section 12.8 Copying class objects [class.copy]. */
1281 if (gnuv3_dynamic_class (type
))
1284 for (fieldnum
= 0; fieldnum
< TYPE_NFN_FIELDS (type
); fieldnum
++)
1285 for (fieldelem
= 0; fieldelem
< TYPE_FN_FIELDLIST_LENGTH (type
, fieldnum
);
1288 struct fn_field
*fn
= TYPE_FN_FIELDLIST1 (type
, fieldnum
);
1289 const char *name
= TYPE_FN_FIELDLIST_NAME (type
, fieldnum
);
1290 struct type
*fieldtype
= TYPE_FN_FIELD_TYPE (fn
, fieldelem
);
1292 /* If this function is marked as artificial, it is compiler-generated,
1293 and we assume it is trivial. */
1294 if (TYPE_FN_FIELD_ARTIFICIAL (fn
, fieldelem
))
1297 /* If we've found a destructor, we must pass this by reference. */
1301 /* If the mangled name of this method doesn't indicate that it
1302 is a constructor, we're not interested.
1304 FIXME drow/2007-09-23: We could do this using the name of
1305 the method and the name of the class instead of dealing
1306 with the mangled name. We don't have a convenient function
1307 to strip off both leading scope qualifiers and trailing
1308 template arguments yet. */
1309 if (!is_constructor_name (TYPE_FN_FIELD_PHYSNAME (fn
, fieldelem
))
1310 && !TYPE_FN_FIELD_CONSTRUCTOR (fn
, fieldelem
))
1313 /* If this method takes two arguments, and the second argument is
1314 a reference to this class, then it is a copy constructor. */
1315 if (TYPE_NFIELDS (fieldtype
) == 2)
1317 struct type
*arg_type
= TYPE_FIELD_TYPE (fieldtype
, 1);
1319 if (TYPE_CODE (arg_type
) == TYPE_CODE_REF
)
1321 struct type
*arg_target_type
;
1323 arg_target_type
= check_typedef (TYPE_TARGET_TYPE (arg_type
));
1324 if (class_types_same_p (arg_target_type
, type
))
1330 /* Even if all the constructors and destructors were artificial, one
1331 of them may have invoked a non-artificial constructor or
1332 destructor in a base class. If any base class needs to be passed
1333 by reference, so does this class. Similarly for members, which
1334 are constructed whenever this class is. We do not need to worry
1335 about recursive loops here, since we are only looking at members
1336 of complete class type. Also ignore any static members. */
1337 for (fieldnum
= 0; fieldnum
< TYPE_NFIELDS (type
); fieldnum
++)
1338 if (! field_is_static (&TYPE_FIELD (type
, fieldnum
))
1339 && gnuv3_pass_by_reference (TYPE_FIELD_TYPE (type
, fieldnum
)))
1346 init_gnuv3_ops (void)
1348 vtable_type_gdbarch_data
1349 = gdbarch_data_register_post_init (build_gdb_vtable_type
);
1350 std_type_info_gdbarch_data
1351 = gdbarch_data_register_post_init (build_std_type_info_type
);
1353 gnu_v3_abi_ops
.shortname
= "gnu-v3";
1354 gnu_v3_abi_ops
.longname
= "GNU G++ Version 3 ABI";
1355 gnu_v3_abi_ops
.doc
= "G++ Version 3 ABI";
1356 gnu_v3_abi_ops
.is_destructor_name
=
1357 (enum dtor_kinds (*) (const char *))is_gnu_v3_mangled_dtor
;
1358 gnu_v3_abi_ops
.is_constructor_name
=
1359 (enum ctor_kinds (*) (const char *))is_gnu_v3_mangled_ctor
;
1360 gnu_v3_abi_ops
.is_vtable_name
= gnuv3_is_vtable_name
;
1361 gnu_v3_abi_ops
.is_operator_name
= gnuv3_is_operator_name
;
1362 gnu_v3_abi_ops
.rtti_type
= gnuv3_rtti_type
;
1363 gnu_v3_abi_ops
.virtual_fn_field
= gnuv3_virtual_fn_field
;
1364 gnu_v3_abi_ops
.baseclass_offset
= gnuv3_baseclass_offset
;
1365 gnu_v3_abi_ops
.print_method_ptr
= gnuv3_print_method_ptr
;
1366 gnu_v3_abi_ops
.method_ptr_size
= gnuv3_method_ptr_size
;
1367 gnu_v3_abi_ops
.make_method_ptr
= gnuv3_make_method_ptr
;
1368 gnu_v3_abi_ops
.method_ptr_to_value
= gnuv3_method_ptr_to_value
;
1369 gnu_v3_abi_ops
.print_vtable
= gnuv3_print_vtable
;
1370 gnu_v3_abi_ops
.get_typeid
= gnuv3_get_typeid
;
1371 gnu_v3_abi_ops
.get_typeid_type
= gnuv3_get_typeid_type
;
1372 gnu_v3_abi_ops
.get_type_from_type_info
= gnuv3_get_type_from_type_info
;
1373 gnu_v3_abi_ops
.get_typename_from_type_info
1374 = gnuv3_get_typename_from_type_info
;
1375 gnu_v3_abi_ops
.skip_trampoline
= gnuv3_skip_trampoline
;
1376 gnu_v3_abi_ops
.pass_by_reference
= gnuv3_pass_by_reference
;
1379 extern initialize_file_ftype _initialize_gnu_v3_abi
; /* -Wmissing-prototypes */
1382 _initialize_gnu_v3_abi (void)
1386 register_cp_abi (&gnu_v3_abi_ops
);
1387 set_cp_abi_as_auto_default (gnu_v3_abi_ops
.shortname
);