1 /* Abstraction of GNU v3 abi.
2 Contributed by Jim Blandy <jimb@redhat.com>
4 Copyright (C) 2001, 2002, 2003, 2005, 2006, 2007, 2008
5 Free Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
25 #include "cp-support.h"
30 #include "gdb_assert.h"
31 #include "gdb_string.h"
33 static struct cp_abi_ops gnu_v3_abi_ops;
36 gnuv3_is_vtable_name (const char *name)
38 return strncmp (name, "_ZTV", 4) == 0;
42 gnuv3_is_operator_name (const char *name)
44 return strncmp (name, "operator", 8) == 0;
48 /* To help us find the components of a vtable, we build ourselves a
49 GDB type object representing the vtable structure. Following the
50 V3 ABI, it goes something like this:
52 struct gdb_gnu_v3_abi_vtable {
54 / * An array of virtual call and virtual base offsets. The real
55 length of this array depends on the class hierarchy; we use
56 negative subscripts to access the elements. Yucky, but
57 better than the alternatives. * /
58 ptrdiff_t vcall_and_vbase_offsets[0];
60 / * The offset from a virtual pointer referring to this table
61 to the top of the complete object. * /
62 ptrdiff_t offset_to_top;
64 / * The type_info pointer for this class. This is really a
65 std::type_info *, but GDB doesn't really look at the
66 type_info object itself, so we don't bother to get the type
70 / * Virtual table pointers in objects point here. * /
72 / * Virtual function pointers. Like the vcall/vbase array, the
73 real length of this table depends on the class hierarchy. * /
74 void (*virtual_functions[0]) ();
78 The catch, of course, is that the exact layout of this table
79 depends on the ABI --- word size, endianness, alignment, etc. So
80 the GDB type object is actually a per-architecture kind of thing.
82 vtable_type_gdbarch_data is a gdbarch per-architecture data pointer
83 which refers to the struct type * for this structure, laid out
84 appropriately for the architecture. */
85 static struct gdbarch_data *vtable_type_gdbarch_data;
88 /* Human-readable names for the numbers of the fields above. */
90 vtable_field_vcall_and_vbase_offsets,
91 vtable_field_offset_to_top,
92 vtable_field_type_info,
93 vtable_field_virtual_functions
97 /* Return a GDB type representing `struct gdb_gnu_v3_abi_vtable',
98 described above, laid out appropriately for ARCH.
100 We use this function as the gdbarch per-architecture data
101 initialization function. */
103 build_gdb_vtable_type (struct gdbarch *arch)
106 struct field *field_list, *field;
109 struct type *void_ptr_type
110 = lookup_pointer_type (builtin_type_void);
111 struct type *ptr_to_void_fn_type
112 = lookup_pointer_type (lookup_function_type (builtin_type_void));
114 /* ARCH can't give us the true ptrdiff_t type, so we guess. */
115 struct type *ptrdiff_type
116 = init_type (TYPE_CODE_INT,
117 gdbarch_ptr_bit (arch) / TARGET_CHAR_BIT, 0,
120 /* We assume no padding is necessary, since GDB doesn't know
121 anything about alignment at the moment. If this assumption bites
122 us, we should add a gdbarch method which, given a type, returns
123 the alignment that type requires, and then use that here. */
125 /* Build the field list. */
126 field_list = xmalloc (sizeof (struct field [4]));
127 memset (field_list, 0, sizeof (struct field [4]));
128 field = &field_list[0];
131 /* ptrdiff_t vcall_and_vbase_offsets[0]; */
132 FIELD_NAME (*field) = "vcall_and_vbase_offsets";
134 = create_array_type (0, ptrdiff_type,
135 create_range_type (0, builtin_type_int, 0, -1));
136 FIELD_BITPOS (*field) = offset * TARGET_CHAR_BIT;
137 offset += TYPE_LENGTH (FIELD_TYPE (*field));
140 /* ptrdiff_t offset_to_top; */
141 FIELD_NAME (*field) = "offset_to_top";
142 FIELD_TYPE (*field) = ptrdiff_type;
143 FIELD_BITPOS (*field) = offset * TARGET_CHAR_BIT;
144 offset += TYPE_LENGTH (FIELD_TYPE (*field));
147 /* void *type_info; */
148 FIELD_NAME (*field) = "type_info";
149 FIELD_TYPE (*field) = void_ptr_type;
150 FIELD_BITPOS (*field) = offset * TARGET_CHAR_BIT;
151 offset += TYPE_LENGTH (FIELD_TYPE (*field));
154 /* void (*virtual_functions[0]) (); */
155 FIELD_NAME (*field) = "virtual_functions";
157 = create_array_type (0, ptr_to_void_fn_type,
158 create_range_type (0, builtin_type_int, 0, -1));
159 FIELD_BITPOS (*field) = offset * TARGET_CHAR_BIT;
160 offset += TYPE_LENGTH (FIELD_TYPE (*field));
163 /* We assumed in the allocation above that there were four fields. */
164 gdb_assert (field == (field_list + 4));
166 t = init_type (TYPE_CODE_STRUCT, offset, 0, 0, 0);
167 TYPE_NFIELDS (t) = field - field_list;
168 TYPE_FIELDS (t) = field_list;
169 TYPE_TAG_NAME (t) = "gdb_gnu_v3_abi_vtable";
175 /* Return the offset from the start of the imaginary `struct
176 gdb_gnu_v3_abi_vtable' object to the vtable's "address point"
177 (i.e., where objects' virtual table pointers point). */
179 vtable_address_point_offset (void)
181 struct type *vtable_type = gdbarch_data (current_gdbarch,
182 vtable_type_gdbarch_data);
184 return (TYPE_FIELD_BITPOS (vtable_type, vtable_field_virtual_functions)
190 gnuv3_rtti_type (struct value *value,
191 int *full_p, int *top_p, int *using_enc_p)
193 struct type *vtable_type = gdbarch_data (current_gdbarch,
194 vtable_type_gdbarch_data);
195 struct type *values_type = check_typedef (value_type (value));
196 CORE_ADDR vtable_address;
197 struct value *vtable;
198 struct minimal_symbol *vtable_symbol;
199 const char *vtable_symbol_name;
200 const char *class_name;
201 struct type *run_time_type;
202 struct type *base_type;
203 LONGEST offset_to_top;
204 struct type *values_type_vptr_basetype;
205 int values_type_vptr_fieldno;
207 /* We only have RTTI for class objects. */
208 if (TYPE_CODE (values_type) != TYPE_CODE_CLASS)
211 /* If we can't find the virtual table pointer for values_type, we
212 can't find the RTTI. */
213 values_type_vptr_fieldno = get_vptr_fieldno (values_type,
214 &values_type_vptr_basetype);
215 if (values_type_vptr_fieldno == -1)
221 /* Fetch VALUE's virtual table pointer, and tweak it to point at
222 an instance of our imaginary gdb_gnu_v3_abi_vtable structure. */
223 base_type = check_typedef (values_type_vptr_basetype);
224 if (values_type != base_type)
226 value = value_cast (base_type, value);
231 = value_as_address (value_field (value, values_type_vptr_fieldno));
232 vtable = value_at_lazy (vtable_type,
233 vtable_address - vtable_address_point_offset ());
235 /* Find the linker symbol for this vtable. */
237 = lookup_minimal_symbol_by_pc (VALUE_ADDRESS (vtable)
238 + value_offset (vtable)
239 + value_embedded_offset (vtable));
243 /* The symbol's demangled name should be something like "vtable for
244 CLASS", where CLASS is the name of the run-time type of VALUE.
245 If we didn't like this approach, we could instead look in the
246 type_info object itself to get the class name. But this way
247 should work just as well, and doesn't read target memory. */
248 vtable_symbol_name = SYMBOL_DEMANGLED_NAME (vtable_symbol);
249 if (vtable_symbol_name == NULL
250 || strncmp (vtable_symbol_name, "vtable for ", 11))
252 warning (_("can't find linker symbol for virtual table for `%s' value"),
253 TYPE_NAME (values_type));
254 if (vtable_symbol_name)
255 warning (_(" found `%s' instead"), vtable_symbol_name);
258 class_name = vtable_symbol_name + 11;
260 /* Try to look up the class name as a type name. */
261 /* FIXME: chastain/2003-11-26: block=NULL is bogus. See pr gdb/1465. */
262 run_time_type = cp_lookup_rtti_type (class_name, NULL);
263 if (run_time_type == NULL)
266 /* Get the offset from VALUE to the top of the complete object.
267 NOTE: this is the reverse of the meaning of *TOP_P. */
269 = value_as_long (value_field (vtable, vtable_field_offset_to_top));
272 *full_p = (- offset_to_top == value_embedded_offset (value)
273 && (TYPE_LENGTH (value_enclosing_type (value))
274 >= TYPE_LENGTH (run_time_type)));
276 *top_p = - offset_to_top;
278 return run_time_type;
281 /* Find the vtable for CONTAINER and return a value of the correct
282 vtable type for this architecture. */
284 static struct value *
285 gnuv3_get_vtable (struct value *container)
287 struct type *vtable_type = gdbarch_data (current_gdbarch,
288 vtable_type_gdbarch_data);
289 struct type *vtable_pointer_type;
290 struct value *vtable_pointer;
291 CORE_ADDR vtable_pointer_address, vtable_address;
293 /* We do not consult the debug information to find the virtual table.
294 The ABI specifies that it is always at offset zero in any class,
295 and debug information may not represent it. We won't issue an
296 error if there's a class with virtual functions but no virtual table
297 pointer, but something's already gone seriously wrong if that
300 We avoid using value_contents on principle, because the object might
303 /* Find the type "pointer to virtual table". */
304 vtable_pointer_type = lookup_pointer_type (vtable_type);
306 /* Load it from the start of the class. */
307 vtable_pointer_address = value_as_address (value_addr (container));
308 vtable_pointer = value_at (vtable_pointer_type, vtable_pointer_address);
309 vtable_address = value_as_address (vtable_pointer);
311 /* Correct it to point at the start of the virtual table, rather
312 than the address point. */
313 return value_at_lazy (vtable_type,
314 vtable_address - vtable_address_point_offset ());
317 /* Return a function pointer for CONTAINER's VTABLE_INDEX'th virtual
318 function, of type FNTYPE. */
320 static struct value *
321 gnuv3_get_virtual_fn (struct value *container, struct type *fntype,
324 struct value *vtable = gnuv3_get_vtable (container);
327 /* Fetch the appropriate function pointer from the vtable. */
328 vfn = value_subscript (value_field (vtable, vtable_field_virtual_functions),
329 value_from_longest (builtin_type_int, vtable_index));
331 /* If this architecture uses function descriptors directly in the vtable,
332 then the address of the vtable entry is actually a "function pointer"
333 (i.e. points to the descriptor). We don't need to scale the index
334 by the size of a function descriptor; GCC does that before outputing
335 debug information. */
336 if (gdbarch_vtable_function_descriptors (current_gdbarch))
337 vfn = value_addr (vfn);
339 /* Cast the function pointer to the appropriate type. */
340 vfn = value_cast (lookup_pointer_type (fntype), vfn);
345 /* GNU v3 implementation of value_virtual_fn_field. See cp-abi.h
346 for a description of the arguments. */
348 static struct value *
349 gnuv3_virtual_fn_field (struct value **value_p,
350 struct fn_field *f, int j,
351 struct type *vfn_base, int offset)
353 struct type *values_type = check_typedef (value_type (*value_p));
355 /* Some simple sanity checks. */
356 if (TYPE_CODE (values_type) != TYPE_CODE_CLASS)
357 error (_("Only classes can have virtual functions."));
359 /* Cast our value to the base class which defines this virtual
360 function. This takes care of any necessary `this'
362 if (vfn_base != values_type)
363 *value_p = value_cast (vfn_base, *value_p);
365 return gnuv3_get_virtual_fn (*value_p, TYPE_FN_FIELD_TYPE (f, j),
366 TYPE_FN_FIELD_VOFFSET (f, j));
369 /* Compute the offset of the baseclass which is
370 the INDEXth baseclass of class TYPE,
371 for value at VALADDR (in host) at ADDRESS (in target).
372 The result is the offset of the baseclass value relative
373 to (the address of)(ARG) + OFFSET.
375 -1 is returned on error. */
377 gnuv3_baseclass_offset (struct type *type, int index, const bfd_byte *valaddr,
380 struct type *vtable_type = gdbarch_data (current_gdbarch,
381 vtable_type_gdbarch_data);
382 struct value *vtable;
383 struct type *vbasetype;
384 struct value *offset_val, *vbase_array;
385 CORE_ADDR vtable_address;
386 long int cur_base_offset, base_offset;
387 int vbasetype_vptr_fieldno;
389 /* If it isn't a virtual base, this is easy. The offset is in the
391 if (!BASETYPE_VIA_VIRTUAL (type, index))
392 return TYPE_BASECLASS_BITPOS (type, index) / 8;
394 /* To access a virtual base, we need to use the vbase offset stored in
395 our vtable. Recent GCC versions provide this information. If it isn't
396 available, we could get what we needed from RTTI, or from drawing the
397 complete inheritance graph based on the debug info. Neither is
399 cur_base_offset = TYPE_BASECLASS_BITPOS (type, index) / 8;
400 if (cur_base_offset >= - vtable_address_point_offset ())
401 error (_("Expected a negative vbase offset (old compiler?)"));
403 cur_base_offset = cur_base_offset + vtable_address_point_offset ();
404 if ((- cur_base_offset) % TYPE_LENGTH (builtin_type_void_data_ptr) != 0)
405 error (_("Misaligned vbase offset."));
406 cur_base_offset = cur_base_offset
407 / ((int) TYPE_LENGTH (builtin_type_void_data_ptr));
409 /* We're now looking for the cur_base_offset'th entry (negative index)
410 in the vcall_and_vbase_offsets array. We used to cast the object to
411 its TYPE_VPTR_BASETYPE, and reference the vtable as TYPE_VPTR_FIELDNO;
412 however, that cast can not be done without calling baseclass_offset again
413 if the TYPE_VPTR_BASETYPE is a virtual base class, as described in the
414 v3 C++ ABI Section 2.4.I.2.b. Fortunately the ABI guarantees that the
415 vtable pointer will be located at the beginning of the object, so we can
416 bypass the casting. Verify that the TYPE_VPTR_FIELDNO is in fact at the
417 start of whichever baseclass it resides in, as a sanity measure - iff
418 we have debugging information for that baseclass. */
420 vbasetype = TYPE_VPTR_BASETYPE (type);
421 vbasetype_vptr_fieldno = get_vptr_fieldno (vbasetype, NULL);
423 if (vbasetype_vptr_fieldno >= 0
424 && TYPE_FIELD_BITPOS (vbasetype, vbasetype_vptr_fieldno) != 0)
425 error (_("Illegal vptr offset in class %s"),
426 TYPE_NAME (vbasetype) ? TYPE_NAME (vbasetype) : "<unknown>");
428 vtable_address = value_as_address (value_at_lazy (builtin_type_void_data_ptr,
430 vtable = value_at_lazy (vtable_type,
431 vtable_address - vtable_address_point_offset ());
432 offset_val = value_from_longest(builtin_type_int, cur_base_offset);
433 vbase_array = value_field (vtable, vtable_field_vcall_and_vbase_offsets);
434 base_offset = value_as_long (value_subscript (vbase_array, offset_val));
438 /* Locate a virtual method in DOMAIN or its non-virtual base classes
439 which has virtual table index VOFFSET. The method has an associated
440 "this" adjustment of ADJUSTMENT bytes. */
443 gnuv3_find_method_in (struct type *domain, CORE_ADDR voffset,
447 const char *physname;
449 /* Search this class first. */
455 len = TYPE_NFN_FIELDS (domain);
456 for (i = 0; i < len; i++)
461 f = TYPE_FN_FIELDLIST1 (domain, i);
462 len2 = TYPE_FN_FIELDLIST_LENGTH (domain, i);
464 check_stub_method_group (domain, i);
465 for (j = 0; j < len2; j++)
466 if (TYPE_FN_FIELD_VOFFSET (f, j) == voffset)
467 return TYPE_FN_FIELD_PHYSNAME (f, j);
471 /* Next search non-virtual bases. If it's in a virtual base,
472 we're out of luck. */
473 for (i = 0; i < TYPE_N_BASECLASSES (domain); i++)
476 struct type *basetype;
478 if (BASETYPE_VIA_VIRTUAL (domain, i))
481 pos = TYPE_BASECLASS_BITPOS (domain, i) / 8;
482 basetype = TYPE_FIELD_TYPE (domain, i);
483 /* Recurse with a modified adjustment. We don't need to adjust
485 if (adjustment >= pos && adjustment < pos + TYPE_LENGTH (basetype))
486 return gnuv3_find_method_in (basetype, voffset, adjustment - pos);
492 /* Decode GNU v3 method pointer. */
495 gnuv3_decode_method_ptr (const gdb_byte *contents,
497 LONGEST *adjustment_p)
499 struct type *funcptr_type = builtin_type_void_func_ptr;
500 struct type *offset_type = builtin_type_long;
502 LONGEST voffset, adjustment;
505 /* Extract the pointer to member. The first element is either a pointer
506 or a vtable offset. For pointers, we need to use extract_typed_address
507 to allow the back-end to convert the pointer to a GDB address -- but
508 vtable offsets we must handle as integers. At this point, we do not
509 yet know which case we have, so we extract the value under both
510 interpretations and choose the right one later on. */
511 ptr_value = extract_typed_address (contents, funcptr_type);
512 voffset = extract_signed_integer (contents, TYPE_LENGTH (funcptr_type));
513 contents += TYPE_LENGTH (funcptr_type);
514 adjustment = extract_signed_integer (contents, TYPE_LENGTH (offset_type));
516 if (!gdbarch_vbit_in_delta (current_gdbarch))
519 voffset = voffset ^ vbit;
523 vbit = adjustment & 1;
524 adjustment = adjustment >> 1;
527 *value_p = vbit? voffset : ptr_value;
528 *adjustment_p = adjustment;
532 /* GNU v3 implementation of cplus_print_method_ptr. */
535 gnuv3_print_method_ptr (const gdb_byte *contents,
537 struct ui_file *stream)
544 domain = TYPE_DOMAIN_TYPE (type);
546 /* Extract the pointer to member. */
547 vbit = gnuv3_decode_method_ptr (contents, &ptr_value, &adjustment);
549 /* Check for NULL. */
550 if (ptr_value == 0 && vbit == 0)
552 fprintf_filtered (stream, "NULL");
556 /* Search for a virtual method. */
560 const char *physname;
562 /* It's a virtual table offset, maybe in this class. Search
563 for a field with the correct vtable offset. First convert it
564 to an index, as used in TYPE_FN_FIELD_VOFFSET. */
565 voffset = ptr_value / TYPE_LENGTH (builtin_type_long);
567 physname = gnuv3_find_method_in (domain, voffset, adjustment);
569 /* If we found a method, print that. We don't bother to disambiguate
570 possible paths to the method based on the adjustment. */
573 char *demangled_name = cplus_demangle (physname,
574 DMGL_ANSI | DMGL_PARAMS);
575 if (demangled_name != NULL)
577 fprintf_filtered (stream, "&virtual ");
578 fputs_filtered (demangled_name, stream);
579 xfree (demangled_name);
585 /* We didn't find it; print the raw data. */
588 fprintf_filtered (stream, "&virtual table offset ");
589 print_longest (stream, 'd', 1, ptr_value);
592 print_address_demangle (ptr_value, stream, demangle);
596 fprintf_filtered (stream, ", this adjustment ");
597 print_longest (stream, 'd', 1, adjustment);
601 /* GNU v3 implementation of cplus_method_ptr_size. */
604 gnuv3_method_ptr_size (void)
606 return 2 * TYPE_LENGTH (builtin_type_void_data_ptr);
609 /* GNU v3 implementation of cplus_make_method_ptr. */
612 gnuv3_make_method_ptr (gdb_byte *contents, CORE_ADDR value, int is_virtual)
614 int size = TYPE_LENGTH (builtin_type_void_data_ptr);
616 /* FIXME drow/2006-12-24: The adjustment of "this" is currently
617 always zero, since the method pointer is of the correct type.
618 But if the method pointer came from a base class, this is
619 incorrect - it should be the offset to the base. The best
620 fix might be to create the pointer to member pointing at the
621 base class and cast it to the derived class, but that requires
622 support for adjusting pointers to members when casting them -
623 not currently supported by GDB. */
625 if (!gdbarch_vbit_in_delta (current_gdbarch))
627 store_unsigned_integer (contents, size, value | is_virtual);
628 store_unsigned_integer (contents + size, size, 0);
632 store_unsigned_integer (contents, size, value);
633 store_unsigned_integer (contents + size, size, is_virtual);
637 /* GNU v3 implementation of cplus_method_ptr_to_value. */
639 static struct value *
640 gnuv3_method_ptr_to_value (struct value **this_p, struct value *method_ptr)
642 const gdb_byte *contents = value_contents (method_ptr);
644 struct type *final_type, *method_type;
646 struct value *adjval;
649 final_type = TYPE_DOMAIN_TYPE (check_typedef (value_type (method_ptr)));
650 final_type = lookup_pointer_type (final_type);
652 method_type = TYPE_TARGET_TYPE (check_typedef (value_type (method_ptr)));
654 /* Extract the pointer to member. */
655 vbit = gnuv3_decode_method_ptr (contents, &ptr_value, &adjustment);
657 /* First convert THIS to match the containing type of the pointer to
658 member. This cast may adjust the value of THIS. */
659 *this_p = value_cast (final_type, *this_p);
661 /* Then apply whatever adjustment is necessary. This creates a somewhat
662 strange pointer: it claims to have type FINAL_TYPE, but in fact it
663 might not be a valid FINAL_TYPE. For instance, it might be a
664 base class of FINAL_TYPE. And if it's not the primary base class,
665 then printing it out as a FINAL_TYPE object would produce some pretty
668 But we don't really know the type of the first argument in
669 METHOD_TYPE either, which is why this happens. We can't
670 dereference this later as a FINAL_TYPE, but once we arrive in the
671 called method we'll have debugging information for the type of
672 "this" - and that'll match the value we produce here.
674 You can provoke this case by casting a Base::* to a Derived::*, for
676 *this_p = value_cast (builtin_type_void_data_ptr, *this_p);
677 adjval = value_from_longest (builtin_type_long, adjustment);
678 *this_p = value_ptradd (*this_p, adjval);
679 *this_p = value_cast (final_type, *this_p);
683 LONGEST voffset = ptr_value / TYPE_LENGTH (builtin_type_long);
684 return gnuv3_get_virtual_fn (value_ind (*this_p), method_type, voffset);
687 return value_from_pointer (lookup_pointer_type (method_type), ptr_value);
690 /* Determine if we are currently in a C++ thunk. If so, get the address
691 of the routine we are thunking to and continue to there instead. */
694 gnuv3_skip_trampoline (struct frame_info *frame, CORE_ADDR stop_pc)
696 CORE_ADDR real_stop_pc, method_stop_pc;
697 struct gdbarch *gdbarch = get_frame_arch (frame);
698 struct minimal_symbol *thunk_sym, *fn_sym;
699 struct obj_section *section;
700 char *thunk_name, *fn_name;
702 real_stop_pc = gdbarch_skip_trampoline_code (gdbarch, frame, stop_pc);
703 if (real_stop_pc == 0)
704 real_stop_pc = stop_pc;
706 /* Find the linker symbol for this potential thunk. */
707 thunk_sym = lookup_minimal_symbol_by_pc (real_stop_pc);
708 section = find_pc_section (real_stop_pc);
709 if (thunk_sym == NULL || section == NULL)
712 /* The symbol's demangled name should be something like "virtual
713 thunk to FUNCTION", where FUNCTION is the name of the function
715 thunk_name = SYMBOL_DEMANGLED_NAME (thunk_sym);
716 if (thunk_name == NULL || strstr (thunk_name, " thunk to ") == NULL)
719 fn_name = strstr (thunk_name, " thunk to ") + strlen (" thunk to ");
720 fn_sym = lookup_minimal_symbol (fn_name, NULL, section->objfile);
724 method_stop_pc = SYMBOL_VALUE_ADDRESS (fn_sym);
725 real_stop_pc = gdbarch_skip_trampoline_code
726 (gdbarch, frame, method_stop_pc);
727 if (real_stop_pc == 0)
728 real_stop_pc = method_stop_pc;
733 /* Return nonzero if a type should be passed by reference.
735 The rule in the v3 ABI document comes from section 3.1.1. If the
736 type has a non-trivial copy constructor or destructor, then the
737 caller must make a copy (by calling the copy constructor if there
738 is one or perform the copy itself otherwise), pass the address of
739 the copy, and then destroy the temporary (if necessary).
741 For return values with non-trivial copy constructors or
742 destructors, space will be allocated in the caller, and a pointer
743 will be passed as the first argument (preceding "this").
745 We don't have a bulletproof mechanism for determining whether a
746 constructor or destructor is trivial. For GCC and DWARF2 debug
747 information, we can check the artificial flag.
749 We don't do anything with the constructors or destructors,
750 but we have to get the argument passing right anyway. */
752 gnuv3_pass_by_reference (struct type *type)
754 int fieldnum, fieldelem;
756 CHECK_TYPEDEF (type);
758 /* We're only interested in things that can have methods. */
759 if (TYPE_CODE (type) != TYPE_CODE_STRUCT
760 && TYPE_CODE (type) != TYPE_CODE_CLASS
761 && TYPE_CODE (type) != TYPE_CODE_UNION)
764 for (fieldnum = 0; fieldnum < TYPE_NFN_FIELDS (type); fieldnum++)
765 for (fieldelem = 0; fieldelem < TYPE_FN_FIELDLIST_LENGTH (type, fieldnum);
768 struct fn_field *fn = TYPE_FN_FIELDLIST1 (type, fieldnum);
769 char *name = TYPE_FN_FIELDLIST_NAME (type, fieldnum);
770 struct type *fieldtype = TYPE_FN_FIELD_TYPE (fn, fieldelem);
772 /* If this function is marked as artificial, it is compiler-generated,
773 and we assume it is trivial. */
774 if (TYPE_FN_FIELD_ARTIFICIAL (fn, fieldelem))
777 /* If we've found a destructor, we must pass this by reference. */
781 /* If the mangled name of this method doesn't indicate that it
782 is a constructor, we're not interested.
784 FIXME drow/2007-09-23: We could do this using the name of
785 the method and the name of the class instead of dealing
786 with the mangled name. We don't have a convenient function
787 to strip off both leading scope qualifiers and trailing
788 template arguments yet. */
789 if (!is_constructor_name (TYPE_FN_FIELD_PHYSNAME (fn, fieldelem)))
792 /* If this method takes two arguments, and the second argument is
793 a reference to this class, then it is a copy constructor. */
794 if (TYPE_NFIELDS (fieldtype) == 2
795 && TYPE_CODE (TYPE_FIELD_TYPE (fieldtype, 1)) == TYPE_CODE_REF
796 && check_typedef (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (fieldtype, 1))) == type)
800 /* Even if all the constructors and destructors were artificial, one
801 of them may have invoked a non-artificial constructor or
802 destructor in a base class. If any base class needs to be passed
803 by reference, so does this class. Similarly for members, which
804 are constructed whenever this class is. We do not need to worry
805 about recursive loops here, since we are only looking at members
806 of complete class type. */
807 for (fieldnum = 0; fieldnum < TYPE_NFIELDS (type); fieldnum++)
808 if (gnuv3_pass_by_reference (TYPE_FIELD_TYPE (type, fieldnum)))
815 init_gnuv3_ops (void)
817 vtable_type_gdbarch_data = gdbarch_data_register_post_init (build_gdb_vtable_type);
819 gnu_v3_abi_ops.shortname = "gnu-v3";
820 gnu_v3_abi_ops.longname = "GNU G++ Version 3 ABI";
821 gnu_v3_abi_ops.doc = "G++ Version 3 ABI";
822 gnu_v3_abi_ops.is_destructor_name =
823 (enum dtor_kinds (*) (const char *))is_gnu_v3_mangled_dtor;
824 gnu_v3_abi_ops.is_constructor_name =
825 (enum ctor_kinds (*) (const char *))is_gnu_v3_mangled_ctor;
826 gnu_v3_abi_ops.is_vtable_name = gnuv3_is_vtable_name;
827 gnu_v3_abi_ops.is_operator_name = gnuv3_is_operator_name;
828 gnu_v3_abi_ops.rtti_type = gnuv3_rtti_type;
829 gnu_v3_abi_ops.virtual_fn_field = gnuv3_virtual_fn_field;
830 gnu_v3_abi_ops.baseclass_offset = gnuv3_baseclass_offset;
831 gnu_v3_abi_ops.print_method_ptr = gnuv3_print_method_ptr;
832 gnu_v3_abi_ops.method_ptr_size = gnuv3_method_ptr_size;
833 gnu_v3_abi_ops.make_method_ptr = gnuv3_make_method_ptr;
834 gnu_v3_abi_ops.method_ptr_to_value = gnuv3_method_ptr_to_value;
835 gnu_v3_abi_ops.skip_trampoline = gnuv3_skip_trampoline;
836 gnu_v3_abi_ops.pass_by_reference = gnuv3_pass_by_reference;
839 extern initialize_file_ftype _initialize_gnu_v3_abi; /* -Wmissing-prototypes */
842 _initialize_gnu_v3_abi (void)
846 register_cp_abi (&gnu_v3_abi_ops);