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"
34 static struct cp_abi_ops gnu_v3_abi_ops
;
36 /* A gdbarch key for std::type_info, in the event that it can't be
37 found in the debug info. */
39 static struct gdbarch_data
*std_type_info_gdbarch_data
;
43 gnuv3_is_vtable_name (const char *name
)
45 return strncmp (name
, "_ZTV", 4) == 0;
49 gnuv3_is_operator_name (const char *name
)
51 return strncmp (name
, "operator", 8) == 0;
55 /* To help us find the components of a vtable, we build ourselves a
56 GDB type object representing the vtable structure. Following the
57 V3 ABI, it goes something like this:
59 struct gdb_gnu_v3_abi_vtable {
61 / * An array of virtual call and virtual base offsets. The real
62 length of this array depends on the class hierarchy; we use
63 negative subscripts to access the elements. Yucky, but
64 better than the alternatives. * /
65 ptrdiff_t vcall_and_vbase_offsets[0];
67 / * The offset from a virtual pointer referring to this table
68 to the top of the complete object. * /
69 ptrdiff_t offset_to_top;
71 / * The type_info pointer for this class. This is really a
72 std::type_info *, but GDB doesn't really look at the
73 type_info object itself, so we don't bother to get the type
77 / * Virtual table pointers in objects point here. * /
79 / * Virtual function pointers. Like the vcall/vbase array, the
80 real length of this table depends on the class hierarchy. * /
81 void (*virtual_functions[0]) ();
85 The catch, of course, is that the exact layout of this table
86 depends on the ABI --- word size, endianness, alignment, etc. So
87 the GDB type object is actually a per-architecture kind of thing.
89 vtable_type_gdbarch_data is a gdbarch per-architecture data pointer
90 which refers to the struct type * for this structure, laid out
91 appropriately for the architecture. */
92 static struct gdbarch_data
*vtable_type_gdbarch_data
;
95 /* Human-readable names for the numbers of the fields above. */
97 vtable_field_vcall_and_vbase_offsets
,
98 vtable_field_offset_to_top
,
99 vtable_field_type_info
,
100 vtable_field_virtual_functions
104 /* Return a GDB type representing `struct gdb_gnu_v3_abi_vtable',
105 described above, laid out appropriately for ARCH.
107 We use this function as the gdbarch per-architecture data
108 initialization function. */
110 build_gdb_vtable_type (struct gdbarch
*arch
)
113 struct field
*field_list
, *field
;
116 struct type
*void_ptr_type
117 = builtin_type (arch
)->builtin_data_ptr
;
118 struct type
*ptr_to_void_fn_type
119 = builtin_type (arch
)->builtin_func_ptr
;
121 /* ARCH can't give us the true ptrdiff_t type, so we guess. */
122 struct type
*ptrdiff_type
123 = arch_integer_type (arch
, gdbarch_ptr_bit (arch
), 0, "ptrdiff_t");
125 /* We assume no padding is necessary, since GDB doesn't know
126 anything about alignment at the moment. If this assumption bites
127 us, we should add a gdbarch method which, given a type, returns
128 the alignment that type requires, and then use that here. */
130 /* Build the field list. */
131 field_list
= xmalloc (sizeof (struct field
[4]));
132 memset (field_list
, 0, sizeof (struct field
[4]));
133 field
= &field_list
[0];
136 /* ptrdiff_t vcall_and_vbase_offsets[0]; */
137 FIELD_NAME (*field
) = "vcall_and_vbase_offsets";
138 FIELD_TYPE (*field
) = lookup_array_range_type (ptrdiff_type
, 0, -1);
139 SET_FIELD_BITPOS (*field
, offset
* TARGET_CHAR_BIT
);
140 offset
+= TYPE_LENGTH (FIELD_TYPE (*field
));
143 /* ptrdiff_t offset_to_top; */
144 FIELD_NAME (*field
) = "offset_to_top";
145 FIELD_TYPE (*field
) = ptrdiff_type
;
146 SET_FIELD_BITPOS (*field
, offset
* TARGET_CHAR_BIT
);
147 offset
+= TYPE_LENGTH (FIELD_TYPE (*field
));
150 /* void *type_info; */
151 FIELD_NAME (*field
) = "type_info";
152 FIELD_TYPE (*field
) = void_ptr_type
;
153 SET_FIELD_BITPOS (*field
, offset
* TARGET_CHAR_BIT
);
154 offset
+= TYPE_LENGTH (FIELD_TYPE (*field
));
157 /* void (*virtual_functions[0]) (); */
158 FIELD_NAME (*field
) = "virtual_functions";
159 FIELD_TYPE (*field
) = lookup_array_range_type (ptr_to_void_fn_type
, 0, -1);
160 SET_FIELD_BITPOS (*field
, offset
* TARGET_CHAR_BIT
);
161 offset
+= TYPE_LENGTH (FIELD_TYPE (*field
));
164 /* We assumed in the allocation above that there were four fields. */
165 gdb_assert (field
== (field_list
+ 4));
167 t
= arch_type (arch
, TYPE_CODE_STRUCT
, offset
, NULL
);
168 TYPE_NFIELDS (t
) = field
- field_list
;
169 TYPE_FIELDS (t
) = field_list
;
170 TYPE_TAG_NAME (t
) = "gdb_gnu_v3_abi_vtable";
171 INIT_CPLUS_SPECIFIC (t
);
173 return make_type_with_address_space (t
, TYPE_INSTANCE_FLAG_CODE_SPACE
);
177 /* Return the ptrdiff_t type used in the vtable type. */
179 vtable_ptrdiff_type (struct gdbarch
*gdbarch
)
181 struct type
*vtable_type
= gdbarch_data (gdbarch
, vtable_type_gdbarch_data
);
183 /* The "offset_to_top" field has the appropriate (ptrdiff_t) type. */
184 return TYPE_FIELD_TYPE (vtable_type
, vtable_field_offset_to_top
);
187 /* Return the offset from the start of the imaginary `struct
188 gdb_gnu_v3_abi_vtable' object to the vtable's "address point"
189 (i.e., where objects' virtual table pointers point). */
191 vtable_address_point_offset (struct gdbarch
*gdbarch
)
193 struct type
*vtable_type
= gdbarch_data (gdbarch
, vtable_type_gdbarch_data
);
195 return (TYPE_FIELD_BITPOS (vtable_type
, vtable_field_virtual_functions
)
200 /* Determine whether structure TYPE is a dynamic class. Cache the
204 gnuv3_dynamic_class (struct type
*type
)
206 int fieldnum
, fieldelem
;
208 if (TYPE_CPLUS_DYNAMIC (type
))
209 return TYPE_CPLUS_DYNAMIC (type
) == 1;
211 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
213 for (fieldnum
= 0; fieldnum
< TYPE_N_BASECLASSES (type
); fieldnum
++)
214 if (BASETYPE_VIA_VIRTUAL (type
, fieldnum
)
215 || gnuv3_dynamic_class (TYPE_FIELD_TYPE (type
, fieldnum
)))
217 TYPE_CPLUS_DYNAMIC (type
) = 1;
221 for (fieldnum
= 0; fieldnum
< TYPE_NFN_FIELDS (type
); fieldnum
++)
222 for (fieldelem
= 0; fieldelem
< TYPE_FN_FIELDLIST_LENGTH (type
, fieldnum
);
225 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, fieldnum
);
227 if (TYPE_FN_FIELD_VIRTUAL_P (f
, fieldelem
))
229 TYPE_CPLUS_DYNAMIC (type
) = 1;
234 TYPE_CPLUS_DYNAMIC (type
) = -1;
238 /* Find the vtable for a value of CONTAINER_TYPE located at
239 CONTAINER_ADDR. Return a value of the correct vtable type for this
240 architecture, or NULL if CONTAINER does not have a vtable. */
242 static struct value
*
243 gnuv3_get_vtable (struct gdbarch
*gdbarch
,
244 struct type
*container_type
, CORE_ADDR container_addr
)
246 struct type
*vtable_type
= gdbarch_data (gdbarch
,
247 vtable_type_gdbarch_data
);
248 struct type
*vtable_pointer_type
;
249 struct value
*vtable_pointer
;
250 CORE_ADDR vtable_address
;
252 /* If this type does not have a virtual table, don't read the first
254 if (!gnuv3_dynamic_class (check_typedef (container_type
)))
257 /* We do not consult the debug information to find the virtual table.
258 The ABI specifies that it is always at offset zero in any class,
259 and debug information may not represent it.
261 We avoid using value_contents on principle, because the object might
264 /* Find the type "pointer to virtual table". */
265 vtable_pointer_type
= lookup_pointer_type (vtable_type
);
267 /* Load it from the start of the class. */
268 vtable_pointer
= value_at (vtable_pointer_type
, container_addr
);
269 vtable_address
= value_as_address (vtable_pointer
);
271 /* Correct it to point at the start of the virtual table, rather
272 than the address point. */
273 return value_at_lazy (vtable_type
,
275 - vtable_address_point_offset (gdbarch
));
280 gnuv3_rtti_type (struct value
*value
,
281 int *full_p
, int *top_p
, int *using_enc_p
)
283 struct gdbarch
*gdbarch
;
284 struct type
*values_type
= check_typedef (value_type (value
));
285 struct value
*vtable
;
286 struct minimal_symbol
*vtable_symbol
;
287 const char *vtable_symbol_name
;
288 const char *class_name
;
289 struct type
*run_time_type
;
290 LONGEST offset_to_top
;
293 /* We only have RTTI for class objects. */
294 if (TYPE_CODE (values_type
) != TYPE_CODE_CLASS
)
297 /* Java doesn't have RTTI following the C++ ABI. */
298 if (TYPE_CPLUS_REALLY_JAVA (values_type
))
301 /* Determine architecture. */
302 gdbarch
= get_type_arch (values_type
);
307 vtable
= gnuv3_get_vtable (gdbarch
, value_type (value
),
308 value_as_address (value_addr (value
)));
312 /* Find the linker symbol for this vtable. */
314 = lookup_minimal_symbol_by_pc (value_address (vtable
)
315 + value_embedded_offset (vtable
)).minsym
;
319 /* The symbol's demangled name should be something like "vtable for
320 CLASS", where CLASS is the name of the run-time type of VALUE.
321 If we didn't like this approach, we could instead look in the
322 type_info object itself to get the class name. But this way
323 should work just as well, and doesn't read target memory. */
324 vtable_symbol_name
= MSYMBOL_DEMANGLED_NAME (vtable_symbol
);
325 if (vtable_symbol_name
== NULL
326 || strncmp (vtable_symbol_name
, "vtable for ", 11))
328 warning (_("can't find linker symbol for virtual table for `%s' value"),
329 TYPE_SAFE_NAME (values_type
));
330 if (vtable_symbol_name
)
331 warning (_(" found `%s' instead"), vtable_symbol_name
);
334 class_name
= vtable_symbol_name
+ 11;
336 /* Strip off @plt and version suffixes. */
337 atsign
= strchr (class_name
, '@');
342 copy
= alloca (atsign
- class_name
+ 1);
343 memcpy (copy
, class_name
, atsign
- class_name
);
344 copy
[atsign
- class_name
] = '\0';
348 /* Try to look up the class name as a type name. */
349 /* FIXME: chastain/2003-11-26: block=NULL is bogus. See pr gdb/1465. */
350 run_time_type
= cp_lookup_rtti_type (class_name
, NULL
);
351 if (run_time_type
== NULL
)
354 /* Get the offset from VALUE to the top of the complete object.
355 NOTE: this is the reverse of the meaning of *TOP_P. */
357 = value_as_long (value_field (vtable
, vtable_field_offset_to_top
));
360 *full_p
= (- offset_to_top
== value_embedded_offset (value
)
361 && (TYPE_LENGTH (value_enclosing_type (value
))
362 >= TYPE_LENGTH (run_time_type
)));
364 *top_p
= - offset_to_top
;
365 return run_time_type
;
368 /* Return a function pointer for CONTAINER's VTABLE_INDEX'th virtual
369 function, of type FNTYPE. */
371 static struct value
*
372 gnuv3_get_virtual_fn (struct gdbarch
*gdbarch
, struct value
*container
,
373 struct type
*fntype
, int vtable_index
)
375 struct value
*vtable
, *vfn
;
377 /* Every class with virtual functions must have a vtable. */
378 vtable
= gnuv3_get_vtable (gdbarch
, value_type (container
),
379 value_as_address (value_addr (container
)));
380 gdb_assert (vtable
!= NULL
);
382 /* Fetch the appropriate function pointer from the vtable. */
383 vfn
= value_subscript (value_field (vtable
, vtable_field_virtual_functions
),
386 /* If this architecture uses function descriptors directly in the vtable,
387 then the address of the vtable entry is actually a "function pointer"
388 (i.e. points to the descriptor). We don't need to scale the index
389 by the size of a function descriptor; GCC does that before outputing
390 debug information. */
391 if (gdbarch_vtable_function_descriptors (gdbarch
))
392 vfn
= value_addr (vfn
);
394 /* Cast the function pointer to the appropriate type. */
395 vfn
= value_cast (lookup_pointer_type (fntype
), vfn
);
400 /* GNU v3 implementation of value_virtual_fn_field. See cp-abi.h
401 for a description of the arguments. */
403 static struct value
*
404 gnuv3_virtual_fn_field (struct value
**value_p
,
405 struct fn_field
*f
, int j
,
406 struct type
*vfn_base
, int offset
)
408 struct type
*values_type
= check_typedef (value_type (*value_p
));
409 struct gdbarch
*gdbarch
;
411 /* Some simple sanity checks. */
412 if (TYPE_CODE (values_type
) != TYPE_CODE_CLASS
)
413 error (_("Only classes can have virtual functions."));
415 /* Determine architecture. */
416 gdbarch
= get_type_arch (values_type
);
418 /* Cast our value to the base class which defines this virtual
419 function. This takes care of any necessary `this'
421 if (vfn_base
!= values_type
)
422 *value_p
= value_cast (vfn_base
, *value_p
);
424 return gnuv3_get_virtual_fn (gdbarch
, *value_p
, TYPE_FN_FIELD_TYPE (f
, j
),
425 TYPE_FN_FIELD_VOFFSET (f
, j
));
428 /* Compute the offset of the baseclass which is
429 the INDEXth baseclass of class TYPE,
430 for value at VALADDR (in host) at ADDRESS (in target).
431 The result is the offset of the baseclass value relative
432 to (the address of)(ARG) + OFFSET.
434 -1 is returned on error. */
437 gnuv3_baseclass_offset (struct type
*type
, int index
,
438 const bfd_byte
*valaddr
, int embedded_offset
,
439 CORE_ADDR address
, const struct value
*val
)
441 struct gdbarch
*gdbarch
;
442 struct type
*ptr_type
;
443 struct value
*vtable
;
444 struct value
*vbase_array
;
445 long int cur_base_offset
, base_offset
;
447 /* Determine architecture. */
448 gdbarch
= get_type_arch (type
);
449 ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
451 /* If it isn't a virtual base, this is easy. The offset is in the
452 type definition. Likewise for Java, which doesn't really have
453 virtual inheritance in the C++ sense. */
454 if (!BASETYPE_VIA_VIRTUAL (type
, index
) || TYPE_CPLUS_REALLY_JAVA (type
))
455 return TYPE_BASECLASS_BITPOS (type
, index
) / 8;
457 /* To access a virtual base, we need to use the vbase offset stored in
458 our vtable. Recent GCC versions provide this information. If it isn't
459 available, we could get what we needed from RTTI, or from drawing the
460 complete inheritance graph based on the debug info. Neither is
462 cur_base_offset
= TYPE_BASECLASS_BITPOS (type
, index
) / 8;
463 if (cur_base_offset
>= - vtable_address_point_offset (gdbarch
))
464 error (_("Expected a negative vbase offset (old compiler?)"));
466 cur_base_offset
= cur_base_offset
+ vtable_address_point_offset (gdbarch
);
467 if ((- cur_base_offset
) % TYPE_LENGTH (ptr_type
) != 0)
468 error (_("Misaligned vbase offset."));
469 cur_base_offset
= cur_base_offset
/ ((int) TYPE_LENGTH (ptr_type
));
471 vtable
= gnuv3_get_vtable (gdbarch
, type
, address
+ embedded_offset
);
472 gdb_assert (vtable
!= NULL
);
473 vbase_array
= value_field (vtable
, vtable_field_vcall_and_vbase_offsets
);
474 base_offset
= value_as_long (value_subscript (vbase_array
, cur_base_offset
));
478 /* Locate a virtual method in DOMAIN or its non-virtual base classes
479 which has virtual table index VOFFSET. The method has an associated
480 "this" adjustment of ADJUSTMENT bytes. */
483 gnuv3_find_method_in (struct type
*domain
, CORE_ADDR voffset
,
488 /* Search this class first. */
493 len
= TYPE_NFN_FIELDS (domain
);
494 for (i
= 0; i
< len
; i
++)
499 f
= TYPE_FN_FIELDLIST1 (domain
, i
);
500 len2
= TYPE_FN_FIELDLIST_LENGTH (domain
, i
);
502 check_stub_method_group (domain
, i
);
503 for (j
= 0; j
< len2
; j
++)
504 if (TYPE_FN_FIELD_VOFFSET (f
, j
) == voffset
)
505 return TYPE_FN_FIELD_PHYSNAME (f
, j
);
509 /* Next search non-virtual bases. If it's in a virtual base,
510 we're out of luck. */
511 for (i
= 0; i
< TYPE_N_BASECLASSES (domain
); i
++)
514 struct type
*basetype
;
516 if (BASETYPE_VIA_VIRTUAL (domain
, i
))
519 pos
= TYPE_BASECLASS_BITPOS (domain
, i
) / 8;
520 basetype
= TYPE_FIELD_TYPE (domain
, i
);
521 /* Recurse with a modified adjustment. We don't need to adjust
523 if (adjustment
>= pos
&& adjustment
< pos
+ TYPE_LENGTH (basetype
))
524 return gnuv3_find_method_in (basetype
, voffset
, adjustment
- pos
);
530 /* Decode GNU v3 method pointer. */
533 gnuv3_decode_method_ptr (struct gdbarch
*gdbarch
,
534 const gdb_byte
*contents
,
536 LONGEST
*adjustment_p
)
538 struct type
*funcptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
539 struct type
*offset_type
= vtable_ptrdiff_type (gdbarch
);
540 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
542 LONGEST voffset
, adjustment
;
545 /* Extract the pointer to member. The first element is either a pointer
546 or a vtable offset. For pointers, we need to use extract_typed_address
547 to allow the back-end to convert the pointer to a GDB address -- but
548 vtable offsets we must handle as integers. At this point, we do not
549 yet know which case we have, so we extract the value under both
550 interpretations and choose the right one later on. */
551 ptr_value
= extract_typed_address (contents
, funcptr_type
);
552 voffset
= extract_signed_integer (contents
,
553 TYPE_LENGTH (funcptr_type
), byte_order
);
554 contents
+= TYPE_LENGTH (funcptr_type
);
555 adjustment
= extract_signed_integer (contents
,
556 TYPE_LENGTH (offset_type
), byte_order
);
558 if (!gdbarch_vbit_in_delta (gdbarch
))
561 voffset
= voffset
^ vbit
;
565 vbit
= adjustment
& 1;
566 adjustment
= adjustment
>> 1;
569 *value_p
= vbit
? voffset
: ptr_value
;
570 *adjustment_p
= adjustment
;
574 /* GNU v3 implementation of cplus_print_method_ptr. */
577 gnuv3_print_method_ptr (const gdb_byte
*contents
,
579 struct ui_file
*stream
)
581 struct type
*domain
= TYPE_DOMAIN_TYPE (type
);
582 struct gdbarch
*gdbarch
= get_type_arch (domain
);
587 /* Extract the pointer to member. */
588 vbit
= gnuv3_decode_method_ptr (gdbarch
, contents
, &ptr_value
, &adjustment
);
590 /* Check for NULL. */
591 if (ptr_value
== 0 && vbit
== 0)
593 fprintf_filtered (stream
, "NULL");
597 /* Search for a virtual method. */
601 const char *physname
;
603 /* It's a virtual table offset, maybe in this class. Search
604 for a field with the correct vtable offset. First convert it
605 to an index, as used in TYPE_FN_FIELD_VOFFSET. */
606 voffset
= ptr_value
/ TYPE_LENGTH (vtable_ptrdiff_type (gdbarch
));
608 physname
= gnuv3_find_method_in (domain
, voffset
, adjustment
);
610 /* If we found a method, print that. We don't bother to disambiguate
611 possible paths to the method based on the adjustment. */
614 char *demangled_name
= gdb_demangle (physname
,
615 DMGL_ANSI
| DMGL_PARAMS
);
617 fprintf_filtered (stream
, "&virtual ");
618 if (demangled_name
== NULL
)
619 fputs_filtered (physname
, stream
);
622 fputs_filtered (demangled_name
, stream
);
623 xfree (demangled_name
);
628 else if (ptr_value
!= 0)
630 /* Found a non-virtual function: print out the type. */
631 fputs_filtered ("(", stream
);
632 c_print_type (type
, "", stream
, -1, 0, &type_print_raw_options
);
633 fputs_filtered (") ", stream
);
636 /* We didn't find it; print the raw data. */
639 fprintf_filtered (stream
, "&virtual table offset ");
640 print_longest (stream
, 'd', 1, ptr_value
);
644 struct value_print_options opts
;
646 get_user_print_options (&opts
);
647 print_address_demangle (&opts
, gdbarch
, ptr_value
, stream
, demangle
);
652 fprintf_filtered (stream
, ", this adjustment ");
653 print_longest (stream
, 'd', 1, adjustment
);
657 /* GNU v3 implementation of cplus_method_ptr_size. */
660 gnuv3_method_ptr_size (struct type
*type
)
662 struct gdbarch
*gdbarch
= get_type_arch (type
);
664 return 2 * TYPE_LENGTH (builtin_type (gdbarch
)->builtin_data_ptr
);
667 /* GNU v3 implementation of cplus_make_method_ptr. */
670 gnuv3_make_method_ptr (struct type
*type
, gdb_byte
*contents
,
671 CORE_ADDR value
, int is_virtual
)
673 struct gdbarch
*gdbarch
= get_type_arch (type
);
674 int size
= TYPE_LENGTH (builtin_type (gdbarch
)->builtin_data_ptr
);
675 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
677 /* FIXME drow/2006-12-24: The adjustment of "this" is currently
678 always zero, since the method pointer is of the correct type.
679 But if the method pointer came from a base class, this is
680 incorrect - it should be the offset to the base. The best
681 fix might be to create the pointer to member pointing at the
682 base class and cast it to the derived class, but that requires
683 support for adjusting pointers to members when casting them -
684 not currently supported by GDB. */
686 if (!gdbarch_vbit_in_delta (gdbarch
))
688 store_unsigned_integer (contents
, size
, byte_order
, value
| is_virtual
);
689 store_unsigned_integer (contents
+ size
, size
, byte_order
, 0);
693 store_unsigned_integer (contents
, size
, byte_order
, value
);
694 store_unsigned_integer (contents
+ size
, size
, byte_order
, is_virtual
);
698 /* GNU v3 implementation of cplus_method_ptr_to_value. */
700 static struct value
*
701 gnuv3_method_ptr_to_value (struct value
**this_p
, struct value
*method_ptr
)
703 struct gdbarch
*gdbarch
;
704 const gdb_byte
*contents
= value_contents (method_ptr
);
706 struct type
*domain_type
, *final_type
, *method_type
;
710 domain_type
= TYPE_DOMAIN_TYPE (check_typedef (value_type (method_ptr
)));
711 final_type
= lookup_pointer_type (domain_type
);
713 method_type
= TYPE_TARGET_TYPE (check_typedef (value_type (method_ptr
)));
715 /* Extract the pointer to member. */
716 gdbarch
= get_type_arch (domain_type
);
717 vbit
= gnuv3_decode_method_ptr (gdbarch
, contents
, &ptr_value
, &adjustment
);
719 /* First convert THIS to match the containing type of the pointer to
720 member. This cast may adjust the value of THIS. */
721 *this_p
= value_cast (final_type
, *this_p
);
723 /* Then apply whatever adjustment is necessary. This creates a somewhat
724 strange pointer: it claims to have type FINAL_TYPE, but in fact it
725 might not be a valid FINAL_TYPE. For instance, it might be a
726 base class of FINAL_TYPE. And if it's not the primary base class,
727 then printing it out as a FINAL_TYPE object would produce some pretty
730 But we don't really know the type of the first argument in
731 METHOD_TYPE either, which is why this happens. We can't
732 dereference this later as a FINAL_TYPE, but once we arrive in the
733 called method we'll have debugging information for the type of
734 "this" - and that'll match the value we produce here.
736 You can provoke this case by casting a Base::* to a Derived::*, for
738 *this_p
= value_cast (builtin_type (gdbarch
)->builtin_data_ptr
, *this_p
);
739 *this_p
= value_ptradd (*this_p
, adjustment
);
740 *this_p
= value_cast (final_type
, *this_p
);
746 voffset
= ptr_value
/ TYPE_LENGTH (vtable_ptrdiff_type (gdbarch
));
747 return gnuv3_get_virtual_fn (gdbarch
, value_ind (*this_p
),
748 method_type
, voffset
);
751 return value_from_pointer (lookup_pointer_type (method_type
), ptr_value
);
754 /* Objects of this type are stored in a hash table and a vector when
755 printing the vtables for a class. */
757 struct value_and_voffset
759 /* The value representing the object. */
762 /* The maximum vtable offset we've found for any object at this
763 offset in the outermost object. */
767 typedef struct value_and_voffset
*value_and_voffset_p
;
768 DEF_VEC_P (value_and_voffset_p
);
770 /* Hash function for value_and_voffset. */
773 hash_value_and_voffset (const void *p
)
775 const struct value_and_voffset
*o
= p
;
777 return value_address (o
->value
) + value_embedded_offset (o
->value
);
780 /* Equality function for value_and_voffset. */
783 eq_value_and_voffset (const void *a
, const void *b
)
785 const struct value_and_voffset
*ova
= a
;
786 const struct value_and_voffset
*ovb
= b
;
788 return (value_address (ova
->value
) + value_embedded_offset (ova
->value
)
789 == value_address (ovb
->value
) + value_embedded_offset (ovb
->value
));
792 /* qsort comparison function for value_and_voffset. */
795 compare_value_and_voffset (const void *a
, const void *b
)
797 const struct value_and_voffset
* const *ova
= a
;
798 CORE_ADDR addra
= (value_address ((*ova
)->value
)
799 + value_embedded_offset ((*ova
)->value
));
800 const struct value_and_voffset
* const *ovb
= b
;
801 CORE_ADDR addrb
= (value_address ((*ovb
)->value
)
802 + value_embedded_offset ((*ovb
)->value
));
811 /* A helper function used when printing vtables. This determines the
812 key (most derived) sub-object at each address and also computes the
813 maximum vtable offset seen for the corresponding vtable. Updates
814 OFFSET_HASH and OFFSET_VEC with a new value_and_voffset object, if
815 needed. VALUE is the object to examine. */
818 compute_vtable_size (htab_t offset_hash
,
819 VEC (value_and_voffset_p
) **offset_vec
,
823 struct type
*type
= check_typedef (value_type (value
));
825 struct value_and_voffset search_vo
, *current_vo
;
827 /* If the object is not dynamic, then we are done; as it cannot have
828 dynamic base types either. */
829 if (!gnuv3_dynamic_class (type
))
832 /* Update the hash and the vec, if needed. */
833 search_vo
.value
= value
;
834 slot
= htab_find_slot (offset_hash
, &search_vo
, INSERT
);
839 current_vo
= XNEW (struct value_and_voffset
);
840 current_vo
->value
= value
;
841 current_vo
->max_voffset
= -1;
843 VEC_safe_push (value_and_voffset_p
, *offset_vec
, current_vo
);
846 /* Update the value_and_voffset object with the highest vtable
847 offset from this class. */
848 for (i
= 0; i
< TYPE_NFN_FIELDS (type
); ++i
)
851 struct fn_field
*fn
= TYPE_FN_FIELDLIST1 (type
, i
);
853 for (j
= 0; j
< TYPE_FN_FIELDLIST_LENGTH (type
, i
); ++j
)
855 if (TYPE_FN_FIELD_VIRTUAL_P (fn
, j
))
857 int voffset
= TYPE_FN_FIELD_VOFFSET (fn
, j
);
859 if (voffset
> current_vo
->max_voffset
)
860 current_vo
->max_voffset
= voffset
;
865 /* Recurse into base classes. */
866 for (i
= 0; i
< TYPE_N_BASECLASSES (type
); ++i
)
867 compute_vtable_size (offset_hash
, offset_vec
, value_field (value
, i
));
870 /* Helper for gnuv3_print_vtable that prints a single vtable. */
873 print_one_vtable (struct gdbarch
*gdbarch
, struct value
*value
,
875 struct value_print_options
*opts
)
878 struct type
*type
= check_typedef (value_type (value
));
879 struct value
*vtable
;
882 vtable
= gnuv3_get_vtable (gdbarch
, type
,
883 value_address (value
)
884 + value_embedded_offset (value
));
885 vt_addr
= value_address (value_field (vtable
,
886 vtable_field_virtual_functions
));
888 printf_filtered (_("vtable for '%s' @ %s (subobject @ %s):\n"),
889 TYPE_SAFE_NAME (type
),
890 paddress (gdbarch
, vt_addr
),
891 paddress (gdbarch
, (value_address (value
)
892 + value_embedded_offset (value
))));
894 for (i
= 0; i
<= max_voffset
; ++i
)
896 /* Initialize it just to avoid a GCC false warning. */
899 volatile struct gdb_exception ex
;
901 printf_filtered ("[%d]: ", i
);
903 vfn
= value_subscript (value_field (vtable
,
904 vtable_field_virtual_functions
),
907 if (gdbarch_vtable_function_descriptors (gdbarch
))
908 vfn
= value_addr (vfn
);
910 TRY_CATCH (ex
, RETURN_MASK_ERROR
)
912 addr
= value_as_address (vfn
);
915 printf_filtered (_("<error: %s>"), ex
.message
);
917 print_function_pointer_address (opts
, gdbarch
, addr
, gdb_stdout
);
918 printf_filtered ("\n");
922 /* Implementation of the print_vtable method. */
925 gnuv3_print_vtable (struct value
*value
)
927 struct gdbarch
*gdbarch
;
929 struct value
*vtable
;
930 struct value_print_options opts
;
932 struct cleanup
*cleanup
;
933 VEC (value_and_voffset_p
) *result_vec
= NULL
;
934 struct value_and_voffset
*iter
;
937 value
= coerce_ref (value
);
938 type
= check_typedef (value_type (value
));
939 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
941 value
= value_ind (value
);
942 type
= check_typedef (value_type (value
));
945 get_user_print_options (&opts
);
947 /* Respect 'set print object'. */
948 if (opts
.objectprint
)
950 value
= value_full_object (value
, NULL
, 0, 0, 0);
951 type
= check_typedef (value_type (value
));
954 gdbarch
= get_type_arch (type
);
955 vtable
= gnuv3_get_vtable (gdbarch
, type
,
956 value_as_address (value_addr (value
)));
960 printf_filtered (_("This object does not have a virtual function table\n"));
964 offset_hash
= htab_create_alloc (1, hash_value_and_voffset
,
965 eq_value_and_voffset
,
966 xfree
, xcalloc
, xfree
);
967 cleanup
= make_cleanup_htab_delete (offset_hash
);
968 make_cleanup (VEC_cleanup (value_and_voffset_p
), &result_vec
);
970 compute_vtable_size (offset_hash
, &result_vec
, value
);
972 qsort (VEC_address (value_and_voffset_p
, result_vec
),
973 VEC_length (value_and_voffset_p
, result_vec
),
974 sizeof (value_and_voffset_p
),
975 compare_value_and_voffset
);
978 for (i
= 0; VEC_iterate (value_and_voffset_p
, result_vec
, i
, iter
); ++i
)
980 if (iter
->max_voffset
>= 0)
983 printf_filtered ("\n");
984 print_one_vtable (gdbarch
, iter
->value
, iter
->max_voffset
, &opts
);
989 do_cleanups (cleanup
);
992 /* Return a GDB type representing `struct std::type_info', laid out
993 appropriately for ARCH.
995 We use this function as the gdbarch per-architecture data
996 initialization function. */
999 build_std_type_info_type (struct gdbarch
*arch
)
1002 struct field
*field_list
, *field
;
1004 struct type
*void_ptr_type
1005 = builtin_type (arch
)->builtin_data_ptr
;
1006 struct type
*char_type
1007 = builtin_type (arch
)->builtin_char
;
1008 struct type
*char_ptr_type
1009 = make_pointer_type (make_cv_type (1, 0, char_type
, NULL
), NULL
);
1011 field_list
= xmalloc (sizeof (struct field
[2]));
1012 memset (field_list
, 0, sizeof (struct field
[2]));
1013 field
= &field_list
[0];
1017 FIELD_NAME (*field
) = "_vptr.type_info";
1018 FIELD_TYPE (*field
) = void_ptr_type
;
1019 SET_FIELD_BITPOS (*field
, offset
* TARGET_CHAR_BIT
);
1020 offset
+= TYPE_LENGTH (FIELD_TYPE (*field
));
1024 FIELD_NAME (*field
) = "__name";
1025 FIELD_TYPE (*field
) = char_ptr_type
;
1026 SET_FIELD_BITPOS (*field
, offset
* TARGET_CHAR_BIT
);
1027 offset
+= TYPE_LENGTH (FIELD_TYPE (*field
));
1030 gdb_assert (field
== (field_list
+ 2));
1032 t
= arch_type (arch
, TYPE_CODE_STRUCT
, offset
, NULL
);
1033 TYPE_NFIELDS (t
) = field
- field_list
;
1034 TYPE_FIELDS (t
) = field_list
;
1035 TYPE_TAG_NAME (t
) = "gdb_gnu_v3_type_info";
1036 INIT_CPLUS_SPECIFIC (t
);
1041 /* Implement the 'get_typeid_type' method. */
1043 static struct type
*
1044 gnuv3_get_typeid_type (struct gdbarch
*gdbarch
)
1046 struct symbol
*typeinfo
;
1047 struct type
*typeinfo_type
;
1049 typeinfo
= lookup_symbol ("std::type_info", NULL
, STRUCT_DOMAIN
, NULL
);
1050 if (typeinfo
== NULL
)
1051 typeinfo_type
= gdbarch_data (gdbarch
, std_type_info_gdbarch_data
);
1053 typeinfo_type
= SYMBOL_TYPE (typeinfo
);
1055 return typeinfo_type
;
1058 /* Implement the 'get_typeid' method. */
1060 static struct value
*
1061 gnuv3_get_typeid (struct value
*value
)
1063 struct type
*typeinfo_type
;
1065 struct gdbarch
*gdbarch
;
1066 struct cleanup
*cleanup
;
1067 struct value
*result
;
1068 char *typename
, *canonical
;
1070 /* We have to handle values a bit trickily here, to allow this code
1071 to work properly with non_lvalue values that are really just
1073 if (value_lval_const (value
) == lval_memory
)
1074 value
= coerce_ref (value
);
1076 type
= check_typedef (value_type (value
));
1078 /* In the non_lvalue case, a reference might have slipped through
1080 if (TYPE_CODE (type
) == TYPE_CODE_REF
)
1081 type
= check_typedef (TYPE_TARGET_TYPE (type
));
1083 /* Ignore top-level cv-qualifiers. */
1084 type
= make_cv_type (0, 0, type
, NULL
);
1085 gdbarch
= get_type_arch (type
);
1087 typename
= type_to_string (type
);
1088 if (typename
== NULL
)
1089 error (_("cannot find typeinfo for unnamed type"));
1090 cleanup
= make_cleanup (xfree
, typename
);
1092 /* We need to canonicalize the type name here, because we do lookups
1093 using the demangled name, and so we must match the format it
1094 uses. E.g., GDB tends to use "const char *" as a type name, but
1095 the demangler uses "char const *". */
1096 canonical
= cp_canonicalize_string (typename
);
1097 if (canonical
!= NULL
)
1099 make_cleanup (xfree
, canonical
);
1100 typename
= canonical
;
1103 typeinfo_type
= gnuv3_get_typeid_type (gdbarch
);
1105 /* We check for lval_memory because in the "typeid (type-id)" case,
1106 the type is passed via a not_lval value object. */
1107 if (TYPE_CODE (type
) == TYPE_CODE_CLASS
1108 && value_lval_const (value
) == lval_memory
1109 && gnuv3_dynamic_class (type
))
1111 struct value
*vtable
, *typeinfo_value
;
1112 CORE_ADDR address
= value_address (value
) + value_embedded_offset (value
);
1114 vtable
= gnuv3_get_vtable (gdbarch
, type
, address
);
1116 error (_("cannot find typeinfo for object of type '%s'"), typename
);
1117 typeinfo_value
= value_field (vtable
, vtable_field_type_info
);
1118 result
= value_ind (value_cast (make_pointer_type (typeinfo_type
, NULL
),
1124 struct bound_minimal_symbol minsym
;
1126 sym_name
= concat ("typeinfo for ", typename
, (char *) NULL
);
1127 make_cleanup (xfree
, sym_name
);
1128 minsym
= lookup_minimal_symbol (sym_name
, NULL
, NULL
);
1130 if (minsym
.minsym
== NULL
)
1131 error (_("could not find typeinfo symbol for '%s'"), typename
);
1133 result
= value_at_lazy (typeinfo_type
, BMSYMBOL_VALUE_ADDRESS (minsym
));
1136 do_cleanups (cleanup
);
1140 /* Implement the 'get_typename_from_type_info' method. */
1143 gnuv3_get_typename_from_type_info (struct value
*type_info_ptr
)
1145 struct gdbarch
*gdbarch
= get_type_arch (value_type (type_info_ptr
));
1146 struct bound_minimal_symbol typeinfo_sym
;
1148 const char *symname
;
1149 const char *class_name
;
1152 addr
= value_as_address (type_info_ptr
);
1153 typeinfo_sym
= lookup_minimal_symbol_by_pc (addr
);
1154 if (typeinfo_sym
.minsym
== NULL
)
1155 error (_("could not find minimal symbol for typeinfo address %s"),
1156 paddress (gdbarch
, addr
));
1158 #define TYPEINFO_PREFIX "typeinfo for "
1159 #define TYPEINFO_PREFIX_LEN (sizeof (TYPEINFO_PREFIX) - 1)
1160 symname
= MSYMBOL_DEMANGLED_NAME (typeinfo_sym
.minsym
);
1161 if (symname
== NULL
|| strncmp (symname
, TYPEINFO_PREFIX
,
1162 TYPEINFO_PREFIX_LEN
))
1163 error (_("typeinfo symbol '%s' has unexpected name"),
1164 MSYMBOL_LINKAGE_NAME (typeinfo_sym
.minsym
));
1165 class_name
= symname
+ TYPEINFO_PREFIX_LEN
;
1167 /* Strip off @plt and version suffixes. */
1168 atsign
= strchr (class_name
, '@');
1170 return savestring (class_name
, atsign
- class_name
);
1171 return xstrdup (class_name
);
1174 /* Implement the 'get_type_from_type_info' method. */
1176 static struct type
*
1177 gnuv3_get_type_from_type_info (struct value
*type_info_ptr
)
1180 struct cleanup
*cleanup
;
1181 struct value
*type_val
;
1182 struct expression
*expr
;
1183 struct type
*result
;
1185 typename
= gnuv3_get_typename_from_type_info (type_info_ptr
);
1186 cleanup
= make_cleanup (xfree
, typename
);
1188 /* We have to parse the type name, since in general there is not a
1189 symbol for a type. This is somewhat bogus since there may be a
1190 mis-parse. Another approach might be to re-use the demangler's
1191 internal form to reconstruct the type somehow. */
1193 expr
= parse_expression (typename
);
1194 make_cleanup (xfree
, expr
);
1196 type_val
= evaluate_type (expr
);
1197 result
= value_type (type_val
);
1199 do_cleanups (cleanup
);
1203 /* Determine if we are currently in a C++ thunk. If so, get the address
1204 of the routine we are thunking to and continue to there instead. */
1207 gnuv3_skip_trampoline (struct frame_info
*frame
, CORE_ADDR stop_pc
)
1209 CORE_ADDR real_stop_pc
, method_stop_pc
, func_addr
;
1210 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1211 struct bound_minimal_symbol thunk_sym
, fn_sym
;
1212 struct obj_section
*section
;
1213 const char *thunk_name
, *fn_name
;
1215 real_stop_pc
= gdbarch_skip_trampoline_code (gdbarch
, frame
, stop_pc
);
1216 if (real_stop_pc
== 0)
1217 real_stop_pc
= stop_pc
;
1219 /* Find the linker symbol for this potential thunk. */
1220 thunk_sym
= lookup_minimal_symbol_by_pc (real_stop_pc
);
1221 section
= find_pc_section (real_stop_pc
);
1222 if (thunk_sym
.minsym
== NULL
|| section
== NULL
)
1225 /* The symbol's demangled name should be something like "virtual
1226 thunk to FUNCTION", where FUNCTION is the name of the function
1227 being thunked to. */
1228 thunk_name
= MSYMBOL_DEMANGLED_NAME (thunk_sym
.minsym
);
1229 if (thunk_name
== NULL
|| strstr (thunk_name
, " thunk to ") == NULL
)
1232 fn_name
= strstr (thunk_name
, " thunk to ") + strlen (" thunk to ");
1233 fn_sym
= lookup_minimal_symbol (fn_name
, NULL
, section
->objfile
);
1234 if (fn_sym
.minsym
== NULL
)
1237 method_stop_pc
= BMSYMBOL_VALUE_ADDRESS (fn_sym
);
1239 /* Some targets have minimal symbols pointing to function descriptors
1240 (powerpc 64 for example). Make sure to retrieve the address
1241 of the real function from the function descriptor before passing on
1242 the address to other layers of GDB. */
1243 func_addr
= gdbarch_convert_from_func_ptr_addr (gdbarch
, method_stop_pc
,
1246 method_stop_pc
= func_addr
;
1248 real_stop_pc
= gdbarch_skip_trampoline_code
1249 (gdbarch
, frame
, method_stop_pc
);
1250 if (real_stop_pc
== 0)
1251 real_stop_pc
= method_stop_pc
;
1253 return real_stop_pc
;
1256 /* Return nonzero if a type should be passed by reference.
1258 The rule in the v3 ABI document comes from section 3.1.1. If the
1259 type has a non-trivial copy constructor or destructor, then the
1260 caller must make a copy (by calling the copy constructor if there
1261 is one or perform the copy itself otherwise), pass the address of
1262 the copy, and then destroy the temporary (if necessary).
1264 For return values with non-trivial copy constructors or
1265 destructors, space will be allocated in the caller, and a pointer
1266 will be passed as the first argument (preceding "this").
1268 We don't have a bulletproof mechanism for determining whether a
1269 constructor or destructor is trivial. For GCC and DWARF2 debug
1270 information, we can check the artificial flag.
1272 We don't do anything with the constructors or destructors,
1273 but we have to get the argument passing right anyway. */
1275 gnuv3_pass_by_reference (struct type
*type
)
1277 int fieldnum
, fieldelem
;
1279 CHECK_TYPEDEF (type
);
1281 /* We're only interested in things that can have methods. */
1282 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
1283 && TYPE_CODE (type
) != TYPE_CODE_CLASS
1284 && TYPE_CODE (type
) != TYPE_CODE_UNION
)
1287 for (fieldnum
= 0; fieldnum
< TYPE_NFN_FIELDS (type
); fieldnum
++)
1288 for (fieldelem
= 0; fieldelem
< TYPE_FN_FIELDLIST_LENGTH (type
, fieldnum
);
1291 struct fn_field
*fn
= TYPE_FN_FIELDLIST1 (type
, fieldnum
);
1292 const char *name
= TYPE_FN_FIELDLIST_NAME (type
, fieldnum
);
1293 struct type
*fieldtype
= TYPE_FN_FIELD_TYPE (fn
, fieldelem
);
1295 /* If this function is marked as artificial, it is compiler-generated,
1296 and we assume it is trivial. */
1297 if (TYPE_FN_FIELD_ARTIFICIAL (fn
, fieldelem
))
1300 /* If we've found a destructor, we must pass this by reference. */
1304 /* If the mangled name of this method doesn't indicate that it
1305 is a constructor, we're not interested.
1307 FIXME drow/2007-09-23: We could do this using the name of
1308 the method and the name of the class instead of dealing
1309 with the mangled name. We don't have a convenient function
1310 to strip off both leading scope qualifiers and trailing
1311 template arguments yet. */
1312 if (!is_constructor_name (TYPE_FN_FIELD_PHYSNAME (fn
, fieldelem
))
1313 && !TYPE_FN_FIELD_CONSTRUCTOR (fn
, fieldelem
))
1316 /* If this method takes two arguments, and the second argument is
1317 a reference to this class, then it is a copy constructor. */
1318 if (TYPE_NFIELDS (fieldtype
) == 2
1319 && TYPE_CODE (TYPE_FIELD_TYPE (fieldtype
, 1)) == TYPE_CODE_REF
1320 && check_typedef (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (fieldtype
,
1325 /* Even if all the constructors and destructors were artificial, one
1326 of them may have invoked a non-artificial constructor or
1327 destructor in a base class. If any base class needs to be passed
1328 by reference, so does this class. Similarly for members, which
1329 are constructed whenever this class is. We do not need to worry
1330 about recursive loops here, since we are only looking at members
1331 of complete class type. Also ignore any static members. */
1332 for (fieldnum
= 0; fieldnum
< TYPE_NFIELDS (type
); fieldnum
++)
1333 if (! field_is_static (&TYPE_FIELD (type
, fieldnum
))
1334 && gnuv3_pass_by_reference (TYPE_FIELD_TYPE (type
, fieldnum
)))
1341 init_gnuv3_ops (void)
1343 vtable_type_gdbarch_data
1344 = gdbarch_data_register_post_init (build_gdb_vtable_type
);
1345 std_type_info_gdbarch_data
1346 = gdbarch_data_register_post_init (build_std_type_info_type
);
1348 gnu_v3_abi_ops
.shortname
= "gnu-v3";
1349 gnu_v3_abi_ops
.longname
= "GNU G++ Version 3 ABI";
1350 gnu_v3_abi_ops
.doc
= "G++ Version 3 ABI";
1351 gnu_v3_abi_ops
.is_destructor_name
=
1352 (enum dtor_kinds (*) (const char *))is_gnu_v3_mangled_dtor
;
1353 gnu_v3_abi_ops
.is_constructor_name
=
1354 (enum ctor_kinds (*) (const char *))is_gnu_v3_mangled_ctor
;
1355 gnu_v3_abi_ops
.is_vtable_name
= gnuv3_is_vtable_name
;
1356 gnu_v3_abi_ops
.is_operator_name
= gnuv3_is_operator_name
;
1357 gnu_v3_abi_ops
.rtti_type
= gnuv3_rtti_type
;
1358 gnu_v3_abi_ops
.virtual_fn_field
= gnuv3_virtual_fn_field
;
1359 gnu_v3_abi_ops
.baseclass_offset
= gnuv3_baseclass_offset
;
1360 gnu_v3_abi_ops
.print_method_ptr
= gnuv3_print_method_ptr
;
1361 gnu_v3_abi_ops
.method_ptr_size
= gnuv3_method_ptr_size
;
1362 gnu_v3_abi_ops
.make_method_ptr
= gnuv3_make_method_ptr
;
1363 gnu_v3_abi_ops
.method_ptr_to_value
= gnuv3_method_ptr_to_value
;
1364 gnu_v3_abi_ops
.print_vtable
= gnuv3_print_vtable
;
1365 gnu_v3_abi_ops
.get_typeid
= gnuv3_get_typeid
;
1366 gnu_v3_abi_ops
.get_typeid_type
= gnuv3_get_typeid_type
;
1367 gnu_v3_abi_ops
.get_type_from_type_info
= gnuv3_get_type_from_type_info
;
1368 gnu_v3_abi_ops
.get_typename_from_type_info
1369 = gnuv3_get_typename_from_type_info
;
1370 gnu_v3_abi_ops
.skip_trampoline
= gnuv3_skip_trampoline
;
1371 gnu_v3_abi_ops
.pass_by_reference
= gnuv3_pass_by_reference
;
1374 extern initialize_file_ftype _initialize_gnu_v3_abi
; /* -Wmissing-prototypes */
1377 _initialize_gnu_v3_abi (void)
1381 register_cp_abi (&gnu_v3_abi_ops
);
1382 set_cp_abi_as_auto_default (gnu_v3_abi_ops
.shortname
);