1 /* Abstraction of GNU v3 abi.
2 Contributed by Jim Blandy <jimb@redhat.com>
4 Copyright (C) 2001-2021 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"
30 #include "typeprint.h"
32 #include "cli/cli-style.h"
33 #include "dwarf2/loc.h"
35 static struct cp_abi_ops gnu_v3_abi_ops
;
37 /* A gdbarch key for std::type_info, in the event that it can't be
38 found in the debug info. */
40 static struct gdbarch_data
*std_type_info_gdbarch_data
;
44 gnuv3_is_vtable_name (const char *name
)
46 return startswith (name
, "_ZTV");
50 gnuv3_is_operator_name (const char *name
)
52 return startswith (name
, CP_OPERATOR_STR
);
56 /* To help us find the components of a vtable, we build ourselves a
57 GDB type object representing the vtable structure. Following the
58 V3 ABI, it goes something like this:
60 struct gdb_gnu_v3_abi_vtable {
62 / * An array of virtual call and virtual base offsets. The real
63 length of this array depends on the class hierarchy; we use
64 negative subscripts to access the elements. Yucky, but
65 better than the alternatives. * /
66 ptrdiff_t vcall_and_vbase_offsets[0];
68 / * The offset from a virtual pointer referring to this table
69 to the top of the complete object. * /
70 ptrdiff_t offset_to_top;
72 / * The type_info pointer for this class. This is really a
73 std::type_info *, but GDB doesn't really look at the
74 type_info object itself, so we don't bother to get the type
78 / * Virtual table pointers in objects point here. * /
80 / * Virtual function pointers. Like the vcall/vbase array, the
81 real length of this table depends on the class hierarchy. * /
82 void (*virtual_functions[0]) ();
86 The catch, of course, is that the exact layout of this table
87 depends on the ABI --- word size, endianness, alignment, etc. So
88 the GDB type object is actually a per-architecture kind of thing.
90 vtable_type_gdbarch_data is a gdbarch per-architecture data pointer
91 which refers to the struct type * for this structure, laid out
92 appropriately for the architecture. */
93 static struct gdbarch_data
*vtable_type_gdbarch_data
;
96 /* Human-readable names for the numbers of the fields above. */
98 vtable_field_vcall_and_vbase_offsets
,
99 vtable_field_offset_to_top
,
100 vtable_field_type_info
,
101 vtable_field_virtual_functions
105 /* Return a GDB type representing `struct gdb_gnu_v3_abi_vtable',
106 described above, laid out appropriately for ARCH.
108 We use this function as the gdbarch per-architecture data
109 initialization function. */
111 build_gdb_vtable_type (struct gdbarch
*arch
)
114 struct field
*field_list
, *field
;
117 struct type
*void_ptr_type
118 = builtin_type (arch
)->builtin_data_ptr
;
119 struct type
*ptr_to_void_fn_type
120 = builtin_type (arch
)->builtin_func_ptr
;
122 /* ARCH can't give us the true ptrdiff_t type, so we guess. */
123 struct type
*ptrdiff_type
124 = arch_integer_type (arch
, gdbarch_ptr_bit (arch
), 0, "ptrdiff_t");
126 /* We assume no padding is necessary, since GDB doesn't know
127 anything about alignment at the moment. If this assumption bites
128 us, we should add a gdbarch method which, given a type, returns
129 the alignment that type requires, and then use that here. */
131 /* Build the field list. */
132 field_list
= XCNEWVEC (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
->set_type (lookup_array_range_type (ptrdiff_type
, 0, -1));
139 SET_FIELD_BITPOS (*field
, offset
* TARGET_CHAR_BIT
);
140 offset
+= TYPE_LENGTH (field
->type ());
143 /* ptrdiff_t offset_to_top; */
144 FIELD_NAME (*field
) = "offset_to_top";
145 field
->set_type (ptrdiff_type
);
146 SET_FIELD_BITPOS (*field
, offset
* TARGET_CHAR_BIT
);
147 offset
+= TYPE_LENGTH (field
->type ());
150 /* void *type_info; */
151 FIELD_NAME (*field
) = "type_info";
152 field
->set_type (void_ptr_type
);
153 SET_FIELD_BITPOS (*field
, offset
* TARGET_CHAR_BIT
);
154 offset
+= TYPE_LENGTH (field
->type ());
157 /* void (*virtual_functions[0]) (); */
158 FIELD_NAME (*field
) = "virtual_functions";
159 field
->set_type (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 ());
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
* TARGET_CHAR_BIT
, NULL
);
168 t
->set_num_fields (field
- field_list
);
169 t
->set_fields (field_list
);
170 t
->set_name ("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
182 = (struct type
*) gdbarch_data (gdbarch
, vtable_type_gdbarch_data
);
184 /* The "offset_to_top" field has the appropriate (ptrdiff_t) type. */
185 return vtable_type
->field (vtable_field_offset_to_top
).type ();
188 /* Return the offset from the start of the imaginary `struct
189 gdb_gnu_v3_abi_vtable' object to the vtable's "address point"
190 (i.e., where objects' virtual table pointers point). */
192 vtable_address_point_offset (struct gdbarch
*gdbarch
)
194 struct type
*vtable_type
195 = (struct type
*) gdbarch_data (gdbarch
, vtable_type_gdbarch_data
);
197 return (TYPE_FIELD_BITPOS (vtable_type
, vtable_field_virtual_functions
)
202 /* Determine whether structure TYPE is a dynamic class. Cache the
206 gnuv3_dynamic_class (struct type
*type
)
208 int fieldnum
, fieldelem
;
210 type
= check_typedef (type
);
211 gdb_assert (type
->code () == TYPE_CODE_STRUCT
212 || type
->code () == TYPE_CODE_UNION
);
214 if (type
->code () == TYPE_CODE_UNION
)
217 if (TYPE_CPLUS_DYNAMIC (type
))
218 return TYPE_CPLUS_DYNAMIC (type
) == 1;
220 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
222 for (fieldnum
= 0; fieldnum
< TYPE_N_BASECLASSES (type
); fieldnum
++)
223 if (BASETYPE_VIA_VIRTUAL (type
, fieldnum
)
224 || gnuv3_dynamic_class (type
->field (fieldnum
).type ()))
226 TYPE_CPLUS_DYNAMIC (type
) = 1;
230 for (fieldnum
= 0; fieldnum
< TYPE_NFN_FIELDS (type
); fieldnum
++)
231 for (fieldelem
= 0; fieldelem
< TYPE_FN_FIELDLIST_LENGTH (type
, fieldnum
);
234 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, fieldnum
);
236 if (TYPE_FN_FIELD_VIRTUAL_P (f
, fieldelem
))
238 TYPE_CPLUS_DYNAMIC (type
) = 1;
243 TYPE_CPLUS_DYNAMIC (type
) = -1;
247 /* Find the vtable for a value of CONTAINER_TYPE located at
248 CONTAINER_ADDR. Return a value of the correct vtable type for this
249 architecture, or NULL if CONTAINER does not have a vtable. */
251 static struct value
*
252 gnuv3_get_vtable (struct gdbarch
*gdbarch
,
253 struct type
*container_type
, CORE_ADDR container_addr
)
255 struct type
*vtable_type
256 = (struct type
*) gdbarch_data (gdbarch
, vtable_type_gdbarch_data
);
257 struct type
*vtable_pointer_type
;
258 struct value
*vtable_pointer
;
259 CORE_ADDR vtable_address
;
261 container_type
= check_typedef (container_type
);
262 gdb_assert (container_type
->code () == TYPE_CODE_STRUCT
);
264 /* If this type does not have a virtual table, don't read the first
266 if (!gnuv3_dynamic_class (container_type
))
269 /* We do not consult the debug information to find the virtual table.
270 The ABI specifies that it is always at offset zero in any class,
271 and debug information may not represent it.
273 We avoid using value_contents on principle, because the object might
276 /* Find the type "pointer to virtual table". */
277 vtable_pointer_type
= lookup_pointer_type (vtable_type
);
279 /* Load it from the start of the class. */
280 vtable_pointer
= value_at (vtable_pointer_type
, container_addr
);
281 vtable_address
= value_as_address (vtable_pointer
);
283 /* Correct it to point at the start of the virtual table, rather
284 than the address point. */
285 return value_at_lazy (vtable_type
,
287 - vtable_address_point_offset (gdbarch
));
292 gnuv3_rtti_type (struct value
*value
,
293 int *full_p
, LONGEST
*top_p
, int *using_enc_p
)
295 struct gdbarch
*gdbarch
;
296 struct type
*values_type
= check_typedef (value_type (value
));
297 struct value
*vtable
;
298 struct minimal_symbol
*vtable_symbol
;
299 const char *vtable_symbol_name
;
300 const char *class_name
;
301 struct type
*run_time_type
;
302 LONGEST offset_to_top
;
305 /* We only have RTTI for dynamic class objects. */
306 if (values_type
->code () != TYPE_CODE_STRUCT
307 || !gnuv3_dynamic_class (values_type
))
310 /* Determine architecture. */
311 gdbarch
= values_type
->arch ();
316 vtable
= gnuv3_get_vtable (gdbarch
, values_type
,
317 value_as_address (value_addr (value
)));
321 /* Find the linker symbol for this vtable. */
323 = lookup_minimal_symbol_by_pc (value_address (vtable
)
324 + value_embedded_offset (vtable
)).minsym
;
328 /* The symbol's demangled name should be something like "vtable for
329 CLASS", where CLASS is the name of the run-time type of VALUE.
330 If we didn't like this approach, we could instead look in the
331 type_info object itself to get the class name. But this way
332 should work just as well, and doesn't read target memory. */
333 vtable_symbol_name
= vtable_symbol
->demangled_name ();
334 if (vtable_symbol_name
== NULL
335 || !startswith (vtable_symbol_name
, "vtable for "))
337 warning (_("can't find linker symbol for virtual table for `%s' value"),
338 TYPE_SAFE_NAME (values_type
));
339 if (vtable_symbol_name
)
340 warning (_(" found `%s' instead"), vtable_symbol_name
);
343 class_name
= vtable_symbol_name
+ 11;
345 /* Strip off @plt and version suffixes. */
346 atsign
= strchr (class_name
, '@');
351 copy
= (char *) alloca (atsign
- class_name
+ 1);
352 memcpy (copy
, class_name
, atsign
- class_name
);
353 copy
[atsign
- class_name
] = '\0';
357 /* Try to look up the class name as a type name. */
358 /* FIXME: chastain/2003-11-26: block=NULL is bogus. See pr gdb/1465. */
359 run_time_type
= cp_lookup_rtti_type (class_name
, NULL
);
360 if (run_time_type
== NULL
)
363 /* Get the offset from VALUE to the top of the complete object.
364 NOTE: this is the reverse of the meaning of *TOP_P. */
366 = value_as_long (value_field (vtable
, vtable_field_offset_to_top
));
369 *full_p
= (- offset_to_top
== value_embedded_offset (value
)
370 && (TYPE_LENGTH (value_enclosing_type (value
))
371 >= TYPE_LENGTH (run_time_type
)));
373 *top_p
= - offset_to_top
;
374 return run_time_type
;
377 /* Return a function pointer for CONTAINER's VTABLE_INDEX'th virtual
378 function, of type FNTYPE. */
380 static struct value
*
381 gnuv3_get_virtual_fn (struct gdbarch
*gdbarch
, struct value
*container
,
382 struct type
*fntype
, int vtable_index
)
384 struct value
*vtable
, *vfn
;
386 /* Every class with virtual functions must have a vtable. */
387 vtable
= gnuv3_get_vtable (gdbarch
, value_type (container
),
388 value_as_address (value_addr (container
)));
389 gdb_assert (vtable
!= NULL
);
391 /* Fetch the appropriate function pointer from the vtable. */
392 vfn
= value_subscript (value_field (vtable
, vtable_field_virtual_functions
),
395 /* If this architecture uses function descriptors directly in the vtable,
396 then the address of the vtable entry is actually a "function pointer"
397 (i.e. points to the descriptor). We don't need to scale the index
398 by the size of a function descriptor; GCC does that before outputting
399 debug information. */
400 if (gdbarch_vtable_function_descriptors (gdbarch
))
401 vfn
= value_addr (vfn
);
403 /* Cast the function pointer to the appropriate type. */
404 vfn
= value_cast (lookup_pointer_type (fntype
), vfn
);
409 /* GNU v3 implementation of value_virtual_fn_field. See cp-abi.h
410 for a description of the arguments. */
412 static struct value
*
413 gnuv3_virtual_fn_field (struct value
**value_p
,
414 struct fn_field
*f
, int j
,
415 struct type
*vfn_base
, int offset
)
417 struct type
*values_type
= check_typedef (value_type (*value_p
));
418 struct gdbarch
*gdbarch
;
420 /* Some simple sanity checks. */
421 if (values_type
->code () != TYPE_CODE_STRUCT
)
422 error (_("Only classes can have virtual functions."));
424 /* Determine architecture. */
425 gdbarch
= values_type
->arch ();
427 /* Cast our value to the base class which defines this virtual
428 function. This takes care of any necessary `this'
430 if (vfn_base
!= values_type
)
431 *value_p
= value_cast (vfn_base
, *value_p
);
433 return gnuv3_get_virtual_fn (gdbarch
, *value_p
, TYPE_FN_FIELD_TYPE (f
, j
),
434 TYPE_FN_FIELD_VOFFSET (f
, j
));
437 /* Compute the offset of the baseclass which is
438 the INDEXth baseclass of class TYPE,
439 for value at VALADDR (in host) at ADDRESS (in target).
440 The result is the offset of the baseclass value relative
441 to (the address of)(ARG) + OFFSET.
443 -1 is returned on error. */
446 gnuv3_baseclass_offset (struct type
*type
, int index
,
447 const bfd_byte
*valaddr
, LONGEST embedded_offset
,
448 CORE_ADDR address
, const struct value
*val
)
450 struct gdbarch
*gdbarch
;
451 struct type
*ptr_type
;
452 struct value
*vtable
;
453 struct value
*vbase_array
;
454 long int cur_base_offset
, base_offset
;
456 /* Determine architecture. */
457 gdbarch
= type
->arch ();
458 ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
460 /* If it isn't a virtual base, this is easy. The offset is in the
462 if (!BASETYPE_VIA_VIRTUAL (type
, index
))
463 return TYPE_BASECLASS_BITPOS (type
, index
) / 8;
465 /* If we have a DWARF expression for the offset, evaluate it. */
466 if (TYPE_FIELD_LOC_KIND (type
, index
) == FIELD_LOC_KIND_DWARF_BLOCK
)
468 struct dwarf2_property_baton baton
;
470 = lookup_pointer_type (type
->field (index
).type ());
471 baton
.locexpr
= *TYPE_FIELD_DWARF_BLOCK (type
, index
);
473 struct dynamic_prop prop
;
474 prop
.set_locexpr (&baton
);
476 struct property_addr_info addr_stack
;
477 addr_stack
.type
= type
;
478 /* Note that we don't set "valaddr" here. Doing so causes
479 regressions. FIXME. */
480 addr_stack
.addr
= address
+ embedded_offset
;
481 addr_stack
.next
= nullptr;
484 if (dwarf2_evaluate_property (&prop
, nullptr, &addr_stack
, &result
,
486 return (int) (result
- addr_stack
.addr
);
489 /* To access a virtual base, we need to use the vbase offset stored in
490 our vtable. Recent GCC versions provide this information. If it isn't
491 available, we could get what we needed from RTTI, or from drawing the
492 complete inheritance graph based on the debug info. Neither is
494 cur_base_offset
= TYPE_BASECLASS_BITPOS (type
, index
) / 8;
495 if (cur_base_offset
>= - vtable_address_point_offset (gdbarch
))
496 error (_("Expected a negative vbase offset (old compiler?)"));
498 cur_base_offset
= cur_base_offset
+ vtable_address_point_offset (gdbarch
);
499 if ((- cur_base_offset
) % TYPE_LENGTH (ptr_type
) != 0)
500 error (_("Misaligned vbase offset."));
501 cur_base_offset
= cur_base_offset
/ ((int) TYPE_LENGTH (ptr_type
));
503 vtable
= gnuv3_get_vtable (gdbarch
, type
, address
+ embedded_offset
);
504 gdb_assert (vtable
!= NULL
);
505 vbase_array
= value_field (vtable
, vtable_field_vcall_and_vbase_offsets
);
506 base_offset
= value_as_long (value_subscript (vbase_array
, cur_base_offset
));
510 /* Locate a virtual method in DOMAIN or its non-virtual base classes
511 which has virtual table index VOFFSET. The method has an associated
512 "this" adjustment of ADJUSTMENT bytes. */
515 gnuv3_find_method_in (struct type
*domain
, CORE_ADDR voffset
,
520 /* Search this class first. */
525 len
= TYPE_NFN_FIELDS (domain
);
526 for (i
= 0; i
< len
; i
++)
531 f
= TYPE_FN_FIELDLIST1 (domain
, i
);
532 len2
= TYPE_FN_FIELDLIST_LENGTH (domain
, i
);
534 check_stub_method_group (domain
, i
);
535 for (j
= 0; j
< len2
; j
++)
536 if (TYPE_FN_FIELD_VOFFSET (f
, j
) == voffset
)
537 return TYPE_FN_FIELD_PHYSNAME (f
, j
);
541 /* Next search non-virtual bases. If it's in a virtual base,
542 we're out of luck. */
543 for (i
= 0; i
< TYPE_N_BASECLASSES (domain
); i
++)
546 struct type
*basetype
;
548 if (BASETYPE_VIA_VIRTUAL (domain
, i
))
551 pos
= TYPE_BASECLASS_BITPOS (domain
, i
) / 8;
552 basetype
= domain
->field (i
).type ();
553 /* Recurse with a modified adjustment. We don't need to adjust
555 if (adjustment
>= pos
&& adjustment
< pos
+ TYPE_LENGTH (basetype
))
556 return gnuv3_find_method_in (basetype
, voffset
, adjustment
- pos
);
562 /* Decode GNU v3 method pointer. */
565 gnuv3_decode_method_ptr (struct gdbarch
*gdbarch
,
566 const gdb_byte
*contents
,
568 LONGEST
*adjustment_p
)
570 struct type
*funcptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
571 struct type
*offset_type
= vtable_ptrdiff_type (gdbarch
);
572 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
574 LONGEST voffset
, adjustment
;
577 /* Extract the pointer to member. The first element is either a pointer
578 or a vtable offset. For pointers, we need to use extract_typed_address
579 to allow the back-end to convert the pointer to a GDB address -- but
580 vtable offsets we must handle as integers. At this point, we do not
581 yet know which case we have, so we extract the value under both
582 interpretations and choose the right one later on. */
583 ptr_value
= extract_typed_address (contents
, funcptr_type
);
584 voffset
= extract_signed_integer (contents
,
585 TYPE_LENGTH (funcptr_type
), byte_order
);
586 contents
+= TYPE_LENGTH (funcptr_type
);
587 adjustment
= extract_signed_integer (contents
,
588 TYPE_LENGTH (offset_type
), byte_order
);
590 if (!gdbarch_vbit_in_delta (gdbarch
))
593 voffset
= voffset
^ vbit
;
597 vbit
= adjustment
& 1;
598 adjustment
= adjustment
>> 1;
601 *value_p
= vbit
? voffset
: ptr_value
;
602 *adjustment_p
= adjustment
;
606 /* GNU v3 implementation of cplus_print_method_ptr. */
609 gnuv3_print_method_ptr (const gdb_byte
*contents
,
611 struct ui_file
*stream
)
613 struct type
*self_type
= TYPE_SELF_TYPE (type
);
614 struct gdbarch
*gdbarch
= self_type
->arch ();
619 /* Extract the pointer to member. */
620 vbit
= gnuv3_decode_method_ptr (gdbarch
, contents
, &ptr_value
, &adjustment
);
622 /* Check for NULL. */
623 if (ptr_value
== 0 && vbit
== 0)
625 fprintf_filtered (stream
, "NULL");
629 /* Search for a virtual method. */
633 const char *physname
;
635 /* It's a virtual table offset, maybe in this class. Search
636 for a field with the correct vtable offset. First convert it
637 to an index, as used in TYPE_FN_FIELD_VOFFSET. */
638 voffset
= ptr_value
/ TYPE_LENGTH (vtable_ptrdiff_type (gdbarch
));
640 physname
= gnuv3_find_method_in (self_type
, voffset
, adjustment
);
642 /* If we found a method, print that. We don't bother to disambiguate
643 possible paths to the method based on the adjustment. */
646 char *demangled_name
= gdb_demangle (physname
,
647 DMGL_ANSI
| DMGL_PARAMS
);
649 fprintf_filtered (stream
, "&virtual ");
650 if (demangled_name
== NULL
)
651 fputs_filtered (physname
, stream
);
654 fputs_filtered (demangled_name
, stream
);
655 xfree (demangled_name
);
660 else if (ptr_value
!= 0)
662 /* Found a non-virtual function: print out the type. */
663 fputs_filtered ("(", stream
);
664 c_print_type (type
, "", stream
, -1, 0, &type_print_raw_options
);
665 fputs_filtered (") ", stream
);
668 /* We didn't find it; print the raw data. */
671 fprintf_filtered (stream
, "&virtual table offset ");
672 print_longest (stream
, 'd', 1, ptr_value
);
676 struct value_print_options opts
;
678 get_user_print_options (&opts
);
679 print_address_demangle (&opts
, gdbarch
, ptr_value
, stream
, demangle
);
684 fprintf_filtered (stream
, ", this adjustment ");
685 print_longest (stream
, 'd', 1, adjustment
);
689 /* GNU v3 implementation of cplus_method_ptr_size. */
692 gnuv3_method_ptr_size (struct type
*type
)
694 return 2 * TYPE_LENGTH (builtin_type (type
->arch ())->builtin_data_ptr
);
697 /* GNU v3 implementation of cplus_make_method_ptr. */
700 gnuv3_make_method_ptr (struct type
*type
, gdb_byte
*contents
,
701 CORE_ADDR value
, int is_virtual
)
703 struct gdbarch
*gdbarch
= type
->arch ();
704 int size
= TYPE_LENGTH (builtin_type (gdbarch
)->builtin_data_ptr
);
705 enum bfd_endian byte_order
= type_byte_order (type
);
707 /* FIXME drow/2006-12-24: The adjustment of "this" is currently
708 always zero, since the method pointer is of the correct type.
709 But if the method pointer came from a base class, this is
710 incorrect - it should be the offset to the base. The best
711 fix might be to create the pointer to member pointing at the
712 base class and cast it to the derived class, but that requires
713 support for adjusting pointers to members when casting them -
714 not currently supported by GDB. */
716 if (!gdbarch_vbit_in_delta (gdbarch
))
718 store_unsigned_integer (contents
, size
, byte_order
, value
| is_virtual
);
719 store_unsigned_integer (contents
+ size
, size
, byte_order
, 0);
723 store_unsigned_integer (contents
, size
, byte_order
, value
);
724 store_unsigned_integer (contents
+ size
, size
, byte_order
, is_virtual
);
728 /* GNU v3 implementation of cplus_method_ptr_to_value. */
730 static struct value
*
731 gnuv3_method_ptr_to_value (struct value
**this_p
, struct value
*method_ptr
)
733 struct gdbarch
*gdbarch
;
734 const gdb_byte
*contents
= value_contents (method_ptr
);
736 struct type
*self_type
, *final_type
, *method_type
;
740 self_type
= TYPE_SELF_TYPE (check_typedef (value_type (method_ptr
)));
741 final_type
= lookup_pointer_type (self_type
);
743 method_type
= TYPE_TARGET_TYPE (check_typedef (value_type (method_ptr
)));
745 /* Extract the pointer to member. */
746 gdbarch
= self_type
->arch ();
747 vbit
= gnuv3_decode_method_ptr (gdbarch
, contents
, &ptr_value
, &adjustment
);
749 /* First convert THIS to match the containing type of the pointer to
750 member. This cast may adjust the value of THIS. */
751 *this_p
= value_cast (final_type
, *this_p
);
753 /* Then apply whatever adjustment is necessary. This creates a somewhat
754 strange pointer: it claims to have type FINAL_TYPE, but in fact it
755 might not be a valid FINAL_TYPE. For instance, it might be a
756 base class of FINAL_TYPE. And if it's not the primary base class,
757 then printing it out as a FINAL_TYPE object would produce some pretty
760 But we don't really know the type of the first argument in
761 METHOD_TYPE either, which is why this happens. We can't
762 dereference this later as a FINAL_TYPE, but once we arrive in the
763 called method we'll have debugging information for the type of
764 "this" - and that'll match the value we produce here.
766 You can provoke this case by casting a Base::* to a Derived::*, for
768 *this_p
= value_cast (builtin_type (gdbarch
)->builtin_data_ptr
, *this_p
);
769 *this_p
= value_ptradd (*this_p
, adjustment
);
770 *this_p
= value_cast (final_type
, *this_p
);
776 voffset
= ptr_value
/ TYPE_LENGTH (vtable_ptrdiff_type (gdbarch
));
777 return gnuv3_get_virtual_fn (gdbarch
, value_ind (*this_p
),
778 method_type
, voffset
);
781 return value_from_pointer (lookup_pointer_type (method_type
), ptr_value
);
784 /* Objects of this type are stored in a hash table and a vector when
785 printing the vtables for a class. */
787 struct value_and_voffset
789 /* The value representing the object. */
792 /* The maximum vtable offset we've found for any object at this
793 offset in the outermost object. */
797 /* Hash function for value_and_voffset. */
800 hash_value_and_voffset (const void *p
)
802 const struct value_and_voffset
*o
= (const struct value_and_voffset
*) p
;
804 return value_address (o
->value
) + value_embedded_offset (o
->value
);
807 /* Equality function for value_and_voffset. */
810 eq_value_and_voffset (const void *a
, const void *b
)
812 const struct value_and_voffset
*ova
= (const struct value_and_voffset
*) a
;
813 const struct value_and_voffset
*ovb
= (const struct value_and_voffset
*) b
;
815 return (value_address (ova
->value
) + value_embedded_offset (ova
->value
)
816 == value_address (ovb
->value
) + value_embedded_offset (ovb
->value
));
819 /* Comparison function for value_and_voffset. */
822 compare_value_and_voffset (const struct value_and_voffset
*va
,
823 const struct value_and_voffset
*vb
)
825 CORE_ADDR addra
= (value_address (va
->value
)
826 + value_embedded_offset (va
->value
));
827 CORE_ADDR addrb
= (value_address (vb
->value
)
828 + value_embedded_offset (vb
->value
));
830 return addra
< addrb
;
833 /* A helper function used when printing vtables. This determines the
834 key (most derived) sub-object at each address and also computes the
835 maximum vtable offset seen for the corresponding vtable. Updates
836 OFFSET_HASH and OFFSET_VEC with a new value_and_voffset object, if
837 needed. VALUE is the object to examine. */
840 compute_vtable_size (htab_t offset_hash
,
841 std::vector
<value_and_voffset
*> *offset_vec
,
845 struct type
*type
= check_typedef (value_type (value
));
847 struct value_and_voffset search_vo
, *current_vo
;
849 gdb_assert (type
->code () == TYPE_CODE_STRUCT
);
851 /* If the object is not dynamic, then we are done; as it cannot have
852 dynamic base types either. */
853 if (!gnuv3_dynamic_class (type
))
856 /* Update the hash and the vec, if needed. */
857 search_vo
.value
= value
;
858 slot
= htab_find_slot (offset_hash
, &search_vo
, INSERT
);
860 current_vo
= (struct value_and_voffset
*) *slot
;
863 current_vo
= XNEW (struct value_and_voffset
);
864 current_vo
->value
= value
;
865 current_vo
->max_voffset
= -1;
867 offset_vec
->push_back (current_vo
);
870 /* Update the value_and_voffset object with the highest vtable
871 offset from this class. */
872 for (i
= 0; i
< TYPE_NFN_FIELDS (type
); ++i
)
875 struct fn_field
*fn
= TYPE_FN_FIELDLIST1 (type
, i
);
877 for (j
= 0; j
< TYPE_FN_FIELDLIST_LENGTH (type
, i
); ++j
)
879 if (TYPE_FN_FIELD_VIRTUAL_P (fn
, j
))
881 int voffset
= TYPE_FN_FIELD_VOFFSET (fn
, j
);
883 if (voffset
> current_vo
->max_voffset
)
884 current_vo
->max_voffset
= voffset
;
889 /* Recurse into base classes. */
890 for (i
= 0; i
< TYPE_N_BASECLASSES (type
); ++i
)
891 compute_vtable_size (offset_hash
, offset_vec
, value_field (value
, i
));
894 /* Helper for gnuv3_print_vtable that prints a single vtable. */
897 print_one_vtable (struct gdbarch
*gdbarch
, struct value
*value
,
899 struct value_print_options
*opts
)
902 struct type
*type
= check_typedef (value_type (value
));
903 struct value
*vtable
;
906 vtable
= gnuv3_get_vtable (gdbarch
, type
,
907 value_address (value
)
908 + value_embedded_offset (value
));
909 vt_addr
= value_address (value_field (vtable
,
910 vtable_field_virtual_functions
));
912 printf_filtered (_("vtable for '%s' @ %s (subobject @ %s):\n"),
913 TYPE_SAFE_NAME (type
),
914 paddress (gdbarch
, vt_addr
),
915 paddress (gdbarch
, (value_address (value
)
916 + value_embedded_offset (value
))));
918 for (i
= 0; i
<= max_voffset
; ++i
)
920 /* Initialize it just to avoid a GCC false warning. */
925 printf_filtered ("[%d]: ", i
);
927 vfn
= value_subscript (value_field (vtable
,
928 vtable_field_virtual_functions
),
931 if (gdbarch_vtable_function_descriptors (gdbarch
))
932 vfn
= value_addr (vfn
);
936 addr
= value_as_address (vfn
);
938 catch (const gdb_exception_error
&ex
)
940 fprintf_styled (gdb_stdout
, metadata_style
.style (),
941 _("<error: %s>"), ex
.what ());
946 print_function_pointer_address (opts
, gdbarch
, addr
, gdb_stdout
);
947 printf_filtered ("\n");
951 /* Implementation of the print_vtable method. */
954 gnuv3_print_vtable (struct value
*value
)
956 struct gdbarch
*gdbarch
;
958 struct value
*vtable
;
959 struct value_print_options opts
;
962 value
= coerce_ref (value
);
963 type
= check_typedef (value_type (value
));
964 if (type
->code () == TYPE_CODE_PTR
)
966 value
= value_ind (value
);
967 type
= check_typedef (value_type (value
));
970 get_user_print_options (&opts
);
972 /* Respect 'set print object'. */
973 if (opts
.objectprint
)
975 value
= value_full_object (value
, NULL
, 0, 0, 0);
976 type
= check_typedef (value_type (value
));
979 gdbarch
= type
->arch ();
982 if (type
->code () == TYPE_CODE_STRUCT
)
983 vtable
= gnuv3_get_vtable (gdbarch
, type
,
984 value_as_address (value_addr (value
)));
988 printf_filtered (_("This object does not have a virtual function table\n"));
992 htab_up
offset_hash (htab_create_alloc (1, hash_value_and_voffset
,
993 eq_value_and_voffset
,
994 xfree
, xcalloc
, xfree
));
995 std::vector
<value_and_voffset
*> result_vec
;
997 compute_vtable_size (offset_hash
.get (), &result_vec
, value
);
998 std::sort (result_vec
.begin (), result_vec
.end (),
999 compare_value_and_voffset
);
1002 for (value_and_voffset
*iter
: result_vec
)
1004 if (iter
->max_voffset
>= 0)
1007 printf_filtered ("\n");
1008 print_one_vtable (gdbarch
, iter
->value
, iter
->max_voffset
, &opts
);
1014 /* Return a GDB type representing `struct std::type_info', laid out
1015 appropriately for ARCH.
1017 We use this function as the gdbarch per-architecture data
1018 initialization function. */
1021 build_std_type_info_type (struct gdbarch
*arch
)
1024 struct field
*field_list
, *field
;
1026 struct type
*void_ptr_type
1027 = builtin_type (arch
)->builtin_data_ptr
;
1028 struct type
*char_type
1029 = builtin_type (arch
)->builtin_char
;
1030 struct type
*char_ptr_type
1031 = make_pointer_type (make_cv_type (1, 0, char_type
, NULL
), NULL
);
1033 field_list
= XCNEWVEC (struct field
, 2);
1034 field
= &field_list
[0];
1038 FIELD_NAME (*field
) = "_vptr.type_info";
1039 field
->set_type (void_ptr_type
);
1040 SET_FIELD_BITPOS (*field
, offset
* TARGET_CHAR_BIT
);
1041 offset
+= TYPE_LENGTH (field
->type ());
1045 FIELD_NAME (*field
) = "__name";
1046 field
->set_type (char_ptr_type
);
1047 SET_FIELD_BITPOS (*field
, offset
* TARGET_CHAR_BIT
);
1048 offset
+= TYPE_LENGTH (field
->type ());
1051 gdb_assert (field
== (field_list
+ 2));
1053 t
= arch_type (arch
, TYPE_CODE_STRUCT
, offset
* TARGET_CHAR_BIT
, NULL
);
1054 t
->set_num_fields (field
- field_list
);
1055 t
->set_fields (field_list
);
1056 t
->set_name ("gdb_gnu_v3_type_info");
1057 INIT_CPLUS_SPECIFIC (t
);
1062 /* Implement the 'get_typeid_type' method. */
1064 static struct type
*
1065 gnuv3_get_typeid_type (struct gdbarch
*gdbarch
)
1067 struct symbol
*typeinfo
;
1068 struct type
*typeinfo_type
;
1070 typeinfo
= lookup_symbol ("std::type_info", NULL
, STRUCT_DOMAIN
,
1072 if (typeinfo
== NULL
)
1074 = (struct type
*) gdbarch_data (gdbarch
, std_type_info_gdbarch_data
);
1076 typeinfo_type
= SYMBOL_TYPE (typeinfo
);
1078 return typeinfo_type
;
1081 /* Implement the 'get_typeid' method. */
1083 static struct value
*
1084 gnuv3_get_typeid (struct value
*value
)
1086 struct type
*typeinfo_type
;
1088 struct gdbarch
*gdbarch
;
1089 struct value
*result
;
1090 std::string type_name
;
1091 gdb::unique_xmalloc_ptr
<char> canonical
;
1093 /* We have to handle values a bit trickily here, to allow this code
1094 to work properly with non_lvalue values that are really just
1096 if (value_lval_const (value
) == lval_memory
)
1097 value
= coerce_ref (value
);
1099 type
= check_typedef (value_type (value
));
1101 /* In the non_lvalue case, a reference might have slipped through
1103 if (type
->code () == TYPE_CODE_REF
)
1104 type
= check_typedef (TYPE_TARGET_TYPE (type
));
1106 /* Ignore top-level cv-qualifiers. */
1107 type
= make_cv_type (0, 0, type
, NULL
);
1108 gdbarch
= type
->arch ();
1110 type_name
= type_to_string (type
);
1111 if (type_name
.empty ())
1112 error (_("cannot find typeinfo for unnamed type"));
1114 /* We need to canonicalize the type name here, because we do lookups
1115 using the demangled name, and so we must match the format it
1116 uses. E.g., GDB tends to use "const char *" as a type name, but
1117 the demangler uses "char const *". */
1118 canonical
= cp_canonicalize_string (type_name
.c_str ());
1119 const char *name
= (canonical
== nullptr
1120 ? type_name
.c_str ()
1121 : canonical
.get ());
1123 typeinfo_type
= gnuv3_get_typeid_type (gdbarch
);
1125 /* We check for lval_memory because in the "typeid (type-id)" case,
1126 the type is passed via a not_lval value object. */
1127 if (type
->code () == TYPE_CODE_STRUCT
1128 && value_lval_const (value
) == lval_memory
1129 && gnuv3_dynamic_class (type
))
1131 struct value
*vtable
, *typeinfo_value
;
1132 CORE_ADDR address
= value_address (value
) + value_embedded_offset (value
);
1134 vtable
= gnuv3_get_vtable (gdbarch
, type
, address
);
1136 error (_("cannot find typeinfo for object of type '%s'"),
1138 typeinfo_value
= value_field (vtable
, vtable_field_type_info
);
1139 result
= value_ind (value_cast (make_pointer_type (typeinfo_type
, NULL
),
1144 std::string sym_name
= std::string ("typeinfo for ") + name
;
1145 bound_minimal_symbol minsym
1146 = lookup_minimal_symbol (sym_name
.c_str (), NULL
, NULL
);
1148 if (minsym
.minsym
== NULL
)
1149 error (_("could not find typeinfo symbol for '%s'"), name
);
1151 result
= value_at_lazy (typeinfo_type
, BMSYMBOL_VALUE_ADDRESS (minsym
));
1157 /* Implement the 'get_typename_from_type_info' method. */
1160 gnuv3_get_typename_from_type_info (struct value
*type_info_ptr
)
1162 struct gdbarch
*gdbarch
= value_type (type_info_ptr
)->arch ();
1163 struct bound_minimal_symbol typeinfo_sym
;
1165 const char *symname
;
1166 const char *class_name
;
1169 addr
= value_as_address (type_info_ptr
);
1170 typeinfo_sym
= lookup_minimal_symbol_by_pc (addr
);
1171 if (typeinfo_sym
.minsym
== NULL
)
1172 error (_("could not find minimal symbol for typeinfo address %s"),
1173 paddress (gdbarch
, addr
));
1175 #define TYPEINFO_PREFIX "typeinfo for "
1176 #define TYPEINFO_PREFIX_LEN (sizeof (TYPEINFO_PREFIX) - 1)
1177 symname
= typeinfo_sym
.minsym
->demangled_name ();
1178 if (symname
== NULL
|| strncmp (symname
, TYPEINFO_PREFIX
,
1179 TYPEINFO_PREFIX_LEN
))
1180 error (_("typeinfo symbol '%s' has unexpected name"),
1181 typeinfo_sym
.minsym
->linkage_name ());
1182 class_name
= symname
+ TYPEINFO_PREFIX_LEN
;
1184 /* Strip off @plt and version suffixes. */
1185 atsign
= strchr (class_name
, '@');
1187 return std::string (class_name
, atsign
- class_name
);
1191 /* Implement the 'get_type_from_type_info' method. */
1193 static struct type
*
1194 gnuv3_get_type_from_type_info (struct value
*type_info_ptr
)
1196 /* We have to parse the type name, since in general there is not a
1197 symbol for a type. This is somewhat bogus since there may be a
1198 mis-parse. Another approach might be to re-use the demangler's
1199 internal form to reconstruct the type somehow. */
1200 std::string type_name
= gnuv3_get_typename_from_type_info (type_info_ptr
);
1201 expression_up
expr (parse_expression (type_name
.c_str ()));
1202 struct value
*type_val
= evaluate_type (expr
.get ());
1203 return value_type (type_val
);
1206 /* Determine if we are currently in a C++ thunk. If so, get the address
1207 of the routine we are thunking to and continue to there instead. */
1210 gnuv3_skip_trampoline (struct frame_info
*frame
, CORE_ADDR stop_pc
)
1212 CORE_ADDR real_stop_pc
, method_stop_pc
, func_addr
;
1213 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1214 struct bound_minimal_symbol thunk_sym
, fn_sym
;
1215 struct obj_section
*section
;
1216 const char *thunk_name
, *fn_name
;
1218 real_stop_pc
= gdbarch_skip_trampoline_code (gdbarch
, frame
, stop_pc
);
1219 if (real_stop_pc
== 0)
1220 real_stop_pc
= stop_pc
;
1222 /* Find the linker symbol for this potential thunk. */
1223 thunk_sym
= lookup_minimal_symbol_by_pc (real_stop_pc
);
1224 section
= find_pc_section (real_stop_pc
);
1225 if (thunk_sym
.minsym
== NULL
|| section
== NULL
)
1228 /* The symbol's demangled name should be something like "virtual
1229 thunk to FUNCTION", where FUNCTION is the name of the function
1230 being thunked to. */
1231 thunk_name
= thunk_sym
.minsym
->demangled_name ();
1232 if (thunk_name
== NULL
|| strstr (thunk_name
, " thunk to ") == NULL
)
1235 fn_name
= strstr (thunk_name
, " thunk to ") + strlen (" thunk to ");
1236 fn_sym
= lookup_minimal_symbol (fn_name
, NULL
, section
->objfile
);
1237 if (fn_sym
.minsym
== NULL
)
1240 method_stop_pc
= BMSYMBOL_VALUE_ADDRESS (fn_sym
);
1242 /* Some targets have minimal symbols pointing to function descriptors
1243 (powerpc 64 for example). Make sure to retrieve the address
1244 of the real function from the function descriptor before passing on
1245 the address to other layers of GDB. */
1246 func_addr
= gdbarch_convert_from_func_ptr_addr (gdbarch
, method_stop_pc
,
1247 current_top_target ());
1249 method_stop_pc
= func_addr
;
1251 real_stop_pc
= gdbarch_skip_trampoline_code
1252 (gdbarch
, frame
, method_stop_pc
);
1253 if (real_stop_pc
== 0)
1254 real_stop_pc
= method_stop_pc
;
1256 return real_stop_pc
;
1259 /* A member function is in one these states. */
1261 enum definition_style
1263 DOES_NOT_EXIST_IN_SOURCE
,
1270 /* Return how the given field is defined. */
1272 static definition_style
1273 get_def_style (struct fn_field
*fn
, int fieldelem
)
1275 if (TYPE_FN_FIELD_DELETED (fn
, fieldelem
))
1278 if (TYPE_FN_FIELD_ARTIFICIAL (fn
, fieldelem
))
1279 return DOES_NOT_EXIST_IN_SOURCE
;
1281 switch (TYPE_FN_FIELD_DEFAULTED (fn
, fieldelem
))
1283 case DW_DEFAULTED_no
:
1285 case DW_DEFAULTED_in_class
:
1286 return DEFAULTED_INSIDE
;
1287 case DW_DEFAULTED_out_of_class
:
1288 return DEFAULTED_OUTSIDE
;
1296 /* Helper functions to determine whether the given definition style
1297 denotes that the definition is user-provided or implicit.
1298 Being defaulted outside the class decl counts as an explicit
1299 user-definition, while being defaulted inside is implicit. */
1302 is_user_provided_def (definition_style def
)
1304 return def
== EXPLICIT
|| def
== DEFAULTED_OUTSIDE
;
1308 is_implicit_def (definition_style def
)
1310 return def
== DOES_NOT_EXIST_IN_SOURCE
|| def
== DEFAULTED_INSIDE
;
1313 /* Helper function to decide if METHOD_TYPE is a copy/move
1314 constructor type for CLASS_TYPE. EXPECTED is the expected
1315 type code for the "right-hand-side" argument.
1316 This function is supposed to be used by the IS_COPY_CONSTRUCTOR_TYPE
1317 and IS_MOVE_CONSTRUCTOR_TYPE functions below. Normally, you should
1318 not need to call this directly. */
1321 is_copy_or_move_constructor_type (struct type
*class_type
,
1322 struct type
*method_type
,
1325 /* The method should take at least two arguments... */
1326 if (method_type
->num_fields () < 2)
1329 /* ...and the second argument should be the same as the class
1330 type, with the expected type code... */
1331 struct type
*arg_type
= method_type
->field (1).type ();
1333 if (arg_type
->code () != expected
)
1336 struct type
*target
= check_typedef (TYPE_TARGET_TYPE (arg_type
));
1337 if (!(class_types_same_p (target
, class_type
)))
1340 /* ...and if any of the remaining arguments don't have a default value
1341 then this is not a copy or move constructor, but just a
1343 for (int i
= 2; i
< method_type
->num_fields (); i
++)
1345 arg_type
= method_type
->field (i
).type ();
1346 /* FIXME aktemur/2019-10-31: As of this date, neither
1347 clang++-7.0.0 nor g++-8.2.0 produce a DW_AT_default_value
1348 attribute. GDB is also not set to read this attribute, yet.
1349 Hence, we immediately return false if there are more than
1352 https://gcc.gnu.org/bugzilla/show_bug.cgi?id=42959
1360 /* Return true if METHOD_TYPE is a copy ctor type for CLASS_TYPE. */
1363 is_copy_constructor_type (struct type
*class_type
,
1364 struct type
*method_type
)
1366 return is_copy_or_move_constructor_type (class_type
, method_type
,
1370 /* Return true if METHOD_TYPE is a move ctor type for CLASS_TYPE. */
1373 is_move_constructor_type (struct type
*class_type
,
1374 struct type
*method_type
)
1376 return is_copy_or_move_constructor_type (class_type
, method_type
,
1377 TYPE_CODE_RVALUE_REF
);
1380 /* Return pass-by-reference information for the given TYPE.
1382 The rule in the v3 ABI document comes from section 3.1.1. If the
1383 type has a non-trivial copy constructor or destructor, then the
1384 caller must make a copy (by calling the copy constructor if there
1385 is one or perform the copy itself otherwise), pass the address of
1386 the copy, and then destroy the temporary (if necessary).
1388 For return values with non-trivial copy/move constructors or
1389 destructors, space will be allocated in the caller, and a pointer
1390 will be passed as the first argument (preceding "this").
1392 We don't have a bulletproof mechanism for determining whether a
1393 constructor or destructor is trivial. For GCC and DWARF5 debug
1394 information, we can check the calling_convention attribute,
1395 the 'artificial' flag, the 'defaulted' attribute, and the
1396 'deleted' attribute. */
1398 static struct language_pass_by_ref_info
1399 gnuv3_pass_by_reference (struct type
*type
)
1401 int fieldnum
, fieldelem
;
1403 type
= check_typedef (type
);
1405 /* Start with the default values. */
1406 struct language_pass_by_ref_info info
;
1408 bool has_cc_attr
= false;
1409 bool is_pass_by_value
= false;
1410 bool is_dynamic
= false;
1411 definition_style cctor_def
= DOES_NOT_EXIST_IN_SOURCE
;
1412 definition_style dtor_def
= DOES_NOT_EXIST_IN_SOURCE
;
1413 definition_style mctor_def
= DOES_NOT_EXIST_IN_SOURCE
;
1415 /* We're only interested in things that can have methods. */
1416 if (type
->code () != TYPE_CODE_STRUCT
1417 && type
->code () != TYPE_CODE_UNION
)
1420 /* The compiler may have emitted the calling convention attribute.
1421 Note: GCC does not produce this attribute as of version 9.2.1.
1422 Bug link: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=92418 */
1423 if (TYPE_CPLUS_CALLING_CONVENTION (type
) == DW_CC_pass_by_value
)
1426 is_pass_by_value
= true;
1427 /* Do not return immediately. We have to find out if this type
1428 is copy_constructible and destructible. */
1431 if (TYPE_CPLUS_CALLING_CONVENTION (type
) == DW_CC_pass_by_reference
)
1434 is_pass_by_value
= false;
1437 /* A dynamic class has a non-trivial copy constructor.
1438 See c++98 section 12.8 Copying class objects [class.copy]. */
1439 if (gnuv3_dynamic_class (type
))
1442 for (fieldnum
= 0; fieldnum
< TYPE_NFN_FIELDS (type
); fieldnum
++)
1443 for (fieldelem
= 0; fieldelem
< TYPE_FN_FIELDLIST_LENGTH (type
, fieldnum
);
1446 struct fn_field
*fn
= TYPE_FN_FIELDLIST1 (type
, fieldnum
);
1447 const char *name
= TYPE_FN_FIELDLIST_NAME (type
, fieldnum
);
1448 struct type
*fieldtype
= TYPE_FN_FIELD_TYPE (fn
, fieldelem
);
1452 /* We've found a destructor.
1453 There should be at most one dtor definition. */
1454 gdb_assert (dtor_def
== DOES_NOT_EXIST_IN_SOURCE
);
1455 dtor_def
= get_def_style (fn
, fieldelem
);
1457 else if (is_constructor_name (TYPE_FN_FIELD_PHYSNAME (fn
, fieldelem
))
1458 || TYPE_FN_FIELD_CONSTRUCTOR (fn
, fieldelem
))
1460 /* FIXME drow/2007-09-23: We could do this using the name of
1461 the method and the name of the class instead of dealing
1462 with the mangled name. We don't have a convenient function
1463 to strip off both leading scope qualifiers and trailing
1464 template arguments yet. */
1465 if (is_copy_constructor_type (type
, fieldtype
))
1467 /* There may be more than one cctors. E.g.: one that
1468 take a const parameter and another that takes a
1469 non-const parameter. Such as:
1476 It is sufficient for the type to be non-trivial
1477 even only one of the cctors is explicit.
1478 Therefore, update the cctor_def value in the
1479 implicit -> explicit direction, not backwards. */
1481 if (is_implicit_def (cctor_def
))
1482 cctor_def
= get_def_style (fn
, fieldelem
);
1484 else if (is_move_constructor_type (type
, fieldtype
))
1486 /* Again, there may be multiple move ctors. Update the
1487 mctor_def value if we found an explicit def and the
1488 existing one is not explicit. Otherwise retain the
1490 if (is_implicit_def (mctor_def
))
1491 mctor_def
= get_def_style (fn
, fieldelem
);
1496 bool cctor_implicitly_deleted
1497 = (mctor_def
!= DOES_NOT_EXIST_IN_SOURCE
1498 && cctor_def
== DOES_NOT_EXIST_IN_SOURCE
);
1500 bool cctor_explicitly_deleted
= (cctor_def
== DELETED
);
1502 if (cctor_implicitly_deleted
|| cctor_explicitly_deleted
)
1503 info
.copy_constructible
= false;
1505 if (dtor_def
== DELETED
)
1506 info
.destructible
= false;
1508 info
.trivially_destructible
= is_implicit_def (dtor_def
);
1510 info
.trivially_copy_constructible
1511 = (is_implicit_def (cctor_def
)
1514 info
.trivially_copyable
1515 = (info
.trivially_copy_constructible
1516 && info
.trivially_destructible
1517 && !is_user_provided_def (mctor_def
));
1519 /* Even if all the constructors and destructors were artificial, one
1520 of them may have invoked a non-artificial constructor or
1521 destructor in a base class. If any base class needs to be passed
1522 by reference, so does this class. Similarly for members, which
1523 are constructed whenever this class is. We do not need to worry
1524 about recursive loops here, since we are only looking at members
1525 of complete class type. Also ignore any static members. */
1526 for (fieldnum
= 0; fieldnum
< type
->num_fields (); fieldnum
++)
1527 if (!field_is_static (&type
->field (fieldnum
)))
1529 struct type
*field_type
= type
->field (fieldnum
).type ();
1531 /* For arrays, make the decision based on the element type. */
1532 if (field_type
->code () == TYPE_CODE_ARRAY
)
1533 field_type
= check_typedef (TYPE_TARGET_TYPE (field_type
));
1535 struct language_pass_by_ref_info field_info
1536 = gnuv3_pass_by_reference (field_type
);
1538 if (!field_info
.copy_constructible
)
1539 info
.copy_constructible
= false;
1540 if (!field_info
.destructible
)
1541 info
.destructible
= false;
1542 if (!field_info
.trivially_copyable
)
1543 info
.trivially_copyable
= false;
1544 if (!field_info
.trivially_copy_constructible
)
1545 info
.trivially_copy_constructible
= false;
1546 if (!field_info
.trivially_destructible
)
1547 info
.trivially_destructible
= false;
1550 /* Consistency check. */
1551 if (has_cc_attr
&& info
.trivially_copyable
!= is_pass_by_value
)
1553 /* DWARF CC attribute is not the same as the inferred value;
1554 use the DWARF attribute. */
1555 info
.trivially_copyable
= is_pass_by_value
;
1562 init_gnuv3_ops (void)
1564 vtable_type_gdbarch_data
1565 = gdbarch_data_register_post_init (build_gdb_vtable_type
);
1566 std_type_info_gdbarch_data
1567 = gdbarch_data_register_post_init (build_std_type_info_type
);
1569 gnu_v3_abi_ops
.shortname
= "gnu-v3";
1570 gnu_v3_abi_ops
.longname
= "GNU G++ Version 3 ABI";
1571 gnu_v3_abi_ops
.doc
= "G++ Version 3 ABI";
1572 gnu_v3_abi_ops
.is_destructor_name
=
1573 (enum dtor_kinds (*) (const char *))is_gnu_v3_mangled_dtor
;
1574 gnu_v3_abi_ops
.is_constructor_name
=
1575 (enum ctor_kinds (*) (const char *))is_gnu_v3_mangled_ctor
;
1576 gnu_v3_abi_ops
.is_vtable_name
= gnuv3_is_vtable_name
;
1577 gnu_v3_abi_ops
.is_operator_name
= gnuv3_is_operator_name
;
1578 gnu_v3_abi_ops
.rtti_type
= gnuv3_rtti_type
;
1579 gnu_v3_abi_ops
.virtual_fn_field
= gnuv3_virtual_fn_field
;
1580 gnu_v3_abi_ops
.baseclass_offset
= gnuv3_baseclass_offset
;
1581 gnu_v3_abi_ops
.print_method_ptr
= gnuv3_print_method_ptr
;
1582 gnu_v3_abi_ops
.method_ptr_size
= gnuv3_method_ptr_size
;
1583 gnu_v3_abi_ops
.make_method_ptr
= gnuv3_make_method_ptr
;
1584 gnu_v3_abi_ops
.method_ptr_to_value
= gnuv3_method_ptr_to_value
;
1585 gnu_v3_abi_ops
.print_vtable
= gnuv3_print_vtable
;
1586 gnu_v3_abi_ops
.get_typeid
= gnuv3_get_typeid
;
1587 gnu_v3_abi_ops
.get_typeid_type
= gnuv3_get_typeid_type
;
1588 gnu_v3_abi_ops
.get_type_from_type_info
= gnuv3_get_type_from_type_info
;
1589 gnu_v3_abi_ops
.get_typename_from_type_info
1590 = gnuv3_get_typename_from_type_info
;
1591 gnu_v3_abi_ops
.skip_trampoline
= gnuv3_skip_trampoline
;
1592 gnu_v3_abi_ops
.pass_by_reference
= gnuv3_pass_by_reference
;
1595 void _initialize_gnu_v3_abi ();
1597 _initialize_gnu_v3_abi ()
1601 register_cp_abi (&gnu_v3_abi_ops
);
1602 set_cp_abi_as_auto_default (gnu_v3_abi_ops
.shortname
);