1 /* Abstraction of GNU v3 abi.
2 Contributed by Jim Blandy <jimb@redhat.com>
4 Copyright (C) 2001, 2002, 2003, 2005, 2006, 2007
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. We assume that the gdbarch framework
102 calls the per-architecture data initialization functions after it
103 sets current_gdbarch to the new architecture. */
105 build_gdb_vtable_type (struct gdbarch *arch)
108 struct field *field_list, *field;
111 struct type *void_ptr_type
112 = lookup_pointer_type (builtin_type_void);
113 struct type *ptr_to_void_fn_type
114 = lookup_pointer_type (lookup_function_type (builtin_type_void));
116 /* ARCH can't give us the true ptrdiff_t type, so we guess. */
117 struct type *ptrdiff_type
118 = init_type (TYPE_CODE_INT,
119 gdbarch_ptr_bit (current_gdbarch) / TARGET_CHAR_BIT, 0,
122 /* We assume no padding is necessary, since GDB doesn't know
123 anything about alignment at the moment. If this assumption bites
124 us, we should add a gdbarch method which, given a type, returns
125 the alignment that type requires, and then use that here. */
127 /* Build the field list. */
128 field_list = xmalloc (sizeof (struct field [4]));
129 memset (field_list, 0, sizeof (struct field [4]));
130 field = &field_list[0];
133 /* ptrdiff_t vcall_and_vbase_offsets[0]; */
134 FIELD_NAME (*field) = "vcall_and_vbase_offsets";
136 = create_array_type (0, ptrdiff_type,
137 create_range_type (0, builtin_type_int, 0, -1));
138 FIELD_BITPOS (*field) = offset * TARGET_CHAR_BIT;
139 offset += TYPE_LENGTH (FIELD_TYPE (*field));
142 /* ptrdiff_t offset_to_top; */
143 FIELD_NAME (*field) = "offset_to_top";
144 FIELD_TYPE (*field) = ptrdiff_type;
145 FIELD_BITPOS (*field) = offset * TARGET_CHAR_BIT;
146 offset += TYPE_LENGTH (FIELD_TYPE (*field));
149 /* void *type_info; */
150 FIELD_NAME (*field) = "type_info";
151 FIELD_TYPE (*field) = void_ptr_type;
152 FIELD_BITPOS (*field) = offset * TARGET_CHAR_BIT;
153 offset += TYPE_LENGTH (FIELD_TYPE (*field));
156 /* void (*virtual_functions[0]) (); */
157 FIELD_NAME (*field) = "virtual_functions";
159 = create_array_type (0, ptr_to_void_fn_type,
160 create_range_type (0, builtin_type_int, 0, -1));
161 FIELD_BITPOS (*field) = offset * TARGET_CHAR_BIT;
162 offset += TYPE_LENGTH (FIELD_TYPE (*field));
165 /* We assumed in the allocation above that there were four fields. */
166 gdb_assert (field == (field_list + 4));
168 t = init_type (TYPE_CODE_STRUCT, offset, 0, 0, 0);
169 TYPE_NFIELDS (t) = field - field_list;
170 TYPE_FIELDS (t) = field_list;
171 TYPE_TAG_NAME (t) = "gdb_gnu_v3_abi_vtable";
177 /* Return the offset from the start of the imaginary `struct
178 gdb_gnu_v3_abi_vtable' object to the vtable's "address point"
179 (i.e., where objects' virtual table pointers point). */
181 vtable_address_point_offset (void)
183 struct type *vtable_type = gdbarch_data (current_gdbarch,
184 vtable_type_gdbarch_data);
186 return (TYPE_FIELD_BITPOS (vtable_type, vtable_field_virtual_functions)
192 gnuv3_rtti_type (struct value *value,
193 int *full_p, int *top_p, int *using_enc_p)
195 struct type *vtable_type = gdbarch_data (current_gdbarch,
196 vtable_type_gdbarch_data);
197 struct type *values_type = check_typedef (value_type (value));
198 CORE_ADDR vtable_address;
199 struct value *vtable;
200 struct minimal_symbol *vtable_symbol;
201 const char *vtable_symbol_name;
202 const char *class_name;
203 struct type *run_time_type;
204 struct type *base_type;
205 LONGEST offset_to_top;
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 fill_in_vptr_fieldno (values_type);
214 if (TYPE_VPTR_FIELDNO (values_type) == -1)
220 /* Fetch VALUE's virtual table pointer, and tweak it to point at
221 an instance of our imaginary gdb_gnu_v3_abi_vtable structure. */
222 base_type = check_typedef (TYPE_VPTR_BASETYPE (values_type));
223 if (values_type != base_type)
225 value = value_cast (base_type, value);
230 = value_as_address (value_field (value, TYPE_VPTR_FIELDNO (values_type)));
231 vtable = value_at_lazy (vtable_type,
232 vtable_address - vtable_address_point_offset ());
234 /* Find the linker symbol for this vtable. */
236 = lookup_minimal_symbol_by_pc (VALUE_ADDRESS (vtable)
237 + value_offset (vtable)
238 + value_embedded_offset (vtable));
242 /* The symbol's demangled name should be something like "vtable for
243 CLASS", where CLASS is the name of the run-time type of VALUE.
244 If we didn't like this approach, we could instead look in the
245 type_info object itself to get the class name. But this way
246 should work just as well, and doesn't read target memory. */
247 vtable_symbol_name = SYMBOL_DEMANGLED_NAME (vtable_symbol);
248 if (vtable_symbol_name == NULL
249 || strncmp (vtable_symbol_name, "vtable for ", 11))
251 warning (_("can't find linker symbol for virtual table for `%s' value"),
252 TYPE_NAME (values_type));
253 if (vtable_symbol_name)
254 warning (_(" found `%s' instead"), vtable_symbol_name);
257 class_name = vtable_symbol_name + 11;
259 /* Try to look up the class name as a type name. */
260 /* FIXME: chastain/2003-11-26: block=NULL is bogus. See pr gdb/1465. */
261 run_time_type = cp_lookup_rtti_type (class_name, NULL);
262 if (run_time_type == NULL)
265 /* Get the offset from VALUE to the top of the complete object.
266 NOTE: this is the reverse of the meaning of *TOP_P. */
268 = value_as_long (value_field (vtable, vtable_field_offset_to_top));
271 *full_p = (- offset_to_top == value_embedded_offset (value)
272 && (TYPE_LENGTH (value_enclosing_type (value))
273 >= TYPE_LENGTH (run_time_type)));
275 *top_p = - offset_to_top;
277 return run_time_type;
280 /* Find the vtable for CONTAINER and return a value of the correct
281 vtable type for this architecture. */
283 static struct value *
284 gnuv3_get_vtable (struct value *container)
286 struct type *vtable_type = gdbarch_data (current_gdbarch,
287 vtable_type_gdbarch_data);
288 struct type *vtable_pointer_type;
289 struct value *vtable_pointer;
290 CORE_ADDR vtable_pointer_address, vtable_address;
292 /* We do not consult the debug information to find the virtual table.
293 The ABI specifies that it is always at offset zero in any class,
294 and debug information may not represent it. We won't issue an
295 error if there's a class with virtual functions but no virtual table
296 pointer, but something's already gone seriously wrong if that
299 We avoid using value_contents on principle, because the object might
302 /* Find the type "pointer to virtual table". */
303 vtable_pointer_type = lookup_pointer_type (vtable_type);
305 /* Load it from the start of the class. */
306 vtable_pointer_address = value_as_address (value_addr (container));
307 vtable_pointer = value_at (vtable_pointer_type, vtable_pointer_address);
308 vtable_address = value_as_address (vtable_pointer);
310 /* Correct it to point at the start of the virtual table, rather
311 than the address point. */
312 return value_at_lazy (vtable_type,
313 vtable_address - vtable_address_point_offset ());
316 /* Return a function pointer for CONTAINER's VTABLE_INDEX'th virtual
317 function, of type FNTYPE. */
319 static struct value *
320 gnuv3_get_virtual_fn (struct value *container, struct type *fntype,
323 struct value *vtable = gnuv3_get_vtable (container);
326 /* Fetch the appropriate function pointer from the vtable. */
327 vfn = value_subscript (value_field (vtable, vtable_field_virtual_functions),
328 value_from_longest (builtin_type_int, vtable_index));
330 /* If this architecture uses function descriptors directly in the vtable,
331 then the address of the vtable entry is actually a "function pointer"
332 (i.e. points to the descriptor). We don't need to scale the index
333 by the size of a function descriptor; GCC does that before outputing
334 debug information. */
335 if (gdbarch_vtable_function_descriptors (current_gdbarch))
336 vfn = value_addr (vfn);
338 /* Cast the function pointer to the appropriate type. */
339 vfn = value_cast (lookup_pointer_type (fntype), vfn);
344 /* GNU v3 implementation of value_virtual_fn_field. See cp-abi.h
345 for a description of the arguments. */
347 static struct value *
348 gnuv3_virtual_fn_field (struct value **value_p,
349 struct fn_field *f, int j,
350 struct type *vfn_base, int offset)
352 struct type *values_type = check_typedef (value_type (*value_p));
354 /* Some simple sanity checks. */
355 if (TYPE_CODE (values_type) != TYPE_CODE_CLASS)
356 error (_("Only classes can have virtual functions."));
358 /* Cast our value to the base class which defines this virtual
359 function. This takes care of any necessary `this'
361 if (vfn_base != values_type)
362 *value_p = value_cast (vfn_base, *value_p);
364 return gnuv3_get_virtual_fn (*value_p, TYPE_FN_FIELD_TYPE (f, j),
365 TYPE_FN_FIELD_VOFFSET (f, j));
368 /* Compute the offset of the baseclass which is
369 the INDEXth baseclass of class TYPE,
370 for value at VALADDR (in host) at ADDRESS (in target).
371 The result is the offset of the baseclass value relative
372 to (the address of)(ARG) + OFFSET.
374 -1 is returned on error. */
376 gnuv3_baseclass_offset (struct type *type, int index, const bfd_byte *valaddr,
379 struct type *vtable_type = gdbarch_data (current_gdbarch,
380 vtable_type_gdbarch_data);
381 struct value *vtable;
382 struct type *vbasetype;
383 struct value *offset_val, *vbase_array;
384 CORE_ADDR vtable_address;
385 long int cur_base_offset, base_offset;
387 /* If it isn't a virtual base, this is easy. The offset is in the
389 if (!BASETYPE_VIA_VIRTUAL (type, index))
390 return TYPE_BASECLASS_BITPOS (type, index) / 8;
392 /* To access a virtual base, we need to use the vbase offset stored in
393 our vtable. Recent GCC versions provide this information. If it isn't
394 available, we could get what we needed from RTTI, or from drawing the
395 complete inheritance graph based on the debug info. Neither is
397 cur_base_offset = TYPE_BASECLASS_BITPOS (type, index) / 8;
398 if (cur_base_offset >= - vtable_address_point_offset ())
399 error (_("Expected a negative vbase offset (old compiler?)"));
401 cur_base_offset = cur_base_offset + vtable_address_point_offset ();
402 if ((- cur_base_offset) % TYPE_LENGTH (builtin_type_void_data_ptr) != 0)
403 error (_("Misaligned vbase offset."));
404 cur_base_offset = cur_base_offset
405 / ((int) TYPE_LENGTH (builtin_type_void_data_ptr));
407 /* We're now looking for the cur_base_offset'th entry (negative index)
408 in the vcall_and_vbase_offsets array. We used to cast the object to
409 its TYPE_VPTR_BASETYPE, and reference the vtable as TYPE_VPTR_FIELDNO;
410 however, that cast can not be done without calling baseclass_offset again
411 if the TYPE_VPTR_BASETYPE is a virtual base class, as described in the
412 v3 C++ ABI Section 2.4.I.2.b. Fortunately the ABI guarantees that the
413 vtable pointer will be located at the beginning of the object, so we can
414 bypass the casting. Verify that the TYPE_VPTR_FIELDNO is in fact at the
415 start of whichever baseclass it resides in, as a sanity measure - iff
416 we have debugging information for that baseclass. */
418 vbasetype = TYPE_VPTR_BASETYPE (type);
419 if (TYPE_VPTR_FIELDNO (vbasetype) < 0)
420 fill_in_vptr_fieldno (vbasetype);
422 if (TYPE_VPTR_FIELDNO (vbasetype) >= 0
423 && TYPE_FIELD_BITPOS (vbasetype, TYPE_VPTR_FIELDNO (vbasetype)) != 0)
424 error (_("Illegal vptr offset in class %s"),
425 TYPE_NAME (vbasetype) ? TYPE_NAME (vbasetype) : "<unknown>");
427 vtable_address = value_as_address (value_at_lazy (builtin_type_void_data_ptr,
429 vtable = value_at_lazy (vtable_type,
430 vtable_address - vtable_address_point_offset ());
431 offset_val = value_from_longest(builtin_type_int, cur_base_offset);
432 vbase_array = value_field (vtable, vtable_field_vcall_and_vbase_offsets);
433 base_offset = value_as_long (value_subscript (vbase_array, offset_val));
437 /* Locate a virtual method in DOMAIN or its non-virtual base classes
438 which has virtual table index VOFFSET. The method has an associated
439 "this" adjustment of ADJUSTMENT bytes. */
442 gnuv3_find_method_in (struct type *domain, CORE_ADDR voffset,
446 const char *physname;
448 /* Search this class first. */
454 len = TYPE_NFN_FIELDS (domain);
455 for (i = 0; i < len; i++)
460 f = TYPE_FN_FIELDLIST1 (domain, i);
461 len2 = TYPE_FN_FIELDLIST_LENGTH (domain, i);
463 check_stub_method_group (domain, i);
464 for (j = 0; j < len2; j++)
465 if (TYPE_FN_FIELD_VOFFSET (f, j) == voffset)
466 return TYPE_FN_FIELD_PHYSNAME (f, j);
470 /* Next search non-virtual bases. If it's in a virtual base,
471 we're out of luck. */
472 for (i = 0; i < TYPE_N_BASECLASSES (domain); i++)
475 struct type *basetype;
477 if (BASETYPE_VIA_VIRTUAL (domain, i))
480 pos = TYPE_BASECLASS_BITPOS (domain, i) / 8;
481 basetype = TYPE_FIELD_TYPE (domain, i);
482 /* Recurse with a modified adjustment. We don't need to adjust
484 if (adjustment >= pos && adjustment < pos + TYPE_LENGTH (basetype))
485 return gnuv3_find_method_in (basetype, voffset, adjustment - pos);
491 /* GNU v3 implementation of cplus_print_method_ptr. */
494 gnuv3_print_method_ptr (const gdb_byte *contents,
496 struct ui_file *stream)
503 domain = TYPE_DOMAIN_TYPE (type);
505 /* Extract the pointer to member. */
506 ptr_value = extract_typed_address (contents, builtin_type_void_func_ptr);
507 contents += TYPE_LENGTH (builtin_type_void_func_ptr);
508 adjustment = extract_signed_integer (contents,
509 TYPE_LENGTH (builtin_type_long));
511 if (!gdbarch_vbit_in_delta (current_gdbarch))
513 vbit = ptr_value & 1;
514 ptr_value = ptr_value ^ vbit;
518 vbit = adjustment & 1;
519 adjustment = adjustment >> 1;
522 /* Check for NULL. */
523 if (ptr_value == 0 && vbit == 0)
525 fprintf_filtered (stream, "NULL");
529 /* Search for a virtual method. */
533 const char *physname;
535 /* It's a virtual table offset, maybe in this class. Search
536 for a field with the correct vtable offset. First convert it
537 to an index, as used in TYPE_FN_FIELD_VOFFSET. */
538 voffset = ptr_value / TYPE_LENGTH (builtin_type_long);
540 physname = gnuv3_find_method_in (domain, voffset, adjustment);
542 /* If we found a method, print that. We don't bother to disambiguate
543 possible paths to the method based on the adjustment. */
546 char *demangled_name = cplus_demangle (physname,
547 DMGL_ANSI | DMGL_PARAMS);
548 if (demangled_name != NULL)
550 fprintf_filtered (stream, "&virtual ");
551 fputs_filtered (demangled_name, stream);
552 xfree (demangled_name);
558 /* We didn't find it; print the raw data. */
561 fprintf_filtered (stream, "&virtual table offset ");
562 print_longest (stream, 'd', 1, ptr_value);
565 print_address_demangle (ptr_value, stream, demangle);
569 fprintf_filtered (stream, ", this adjustment ");
570 print_longest (stream, 'd', 1, adjustment);
574 /* GNU v3 implementation of cplus_method_ptr_size. */
577 gnuv3_method_ptr_size (void)
579 return 2 * TYPE_LENGTH (builtin_type_void_data_ptr);
582 /* GNU v3 implementation of cplus_make_method_ptr. */
585 gnuv3_make_method_ptr (gdb_byte *contents, CORE_ADDR value, int is_virtual)
587 int size = TYPE_LENGTH (builtin_type_void_data_ptr);
589 /* FIXME drow/2006-12-24: The adjustment of "this" is currently
590 always zero, since the method pointer is of the correct type.
591 But if the method pointer came from a base class, this is
592 incorrect - it should be the offset to the base. The best
593 fix might be to create the pointer to member pointing at the
594 base class and cast it to the derived class, but that requires
595 support for adjusting pointers to members when casting them -
596 not currently supported by GDB. */
598 if (!gdbarch_vbit_in_delta (current_gdbarch))
600 store_unsigned_integer (contents, size, value | is_virtual);
601 store_unsigned_integer (contents + size, size, 0);
605 store_unsigned_integer (contents, size, value);
606 store_unsigned_integer (contents + size, size, is_virtual);
610 /* GNU v3 implementation of cplus_method_ptr_to_value. */
612 static struct value *
613 gnuv3_method_ptr_to_value (struct value **this_p, struct value *method_ptr)
615 const gdb_byte *contents = value_contents (method_ptr);
617 struct type *final_type, *method_type;
619 struct value *adjval;
622 final_type = TYPE_DOMAIN_TYPE (check_typedef (value_type (method_ptr)));
623 final_type = lookup_pointer_type (final_type);
625 method_type = TYPE_TARGET_TYPE (check_typedef (value_type (method_ptr)));
627 ptr_value = extract_typed_address (contents, builtin_type_void_func_ptr);
628 contents += TYPE_LENGTH (builtin_type_void_func_ptr);
629 adjustment = extract_signed_integer (contents,
630 TYPE_LENGTH (builtin_type_long));
632 if (!gdbarch_vbit_in_delta (current_gdbarch))
634 vbit = ptr_value & 1;
635 ptr_value = ptr_value ^ vbit;
639 vbit = adjustment & 1;
640 adjustment = adjustment >> 1;
643 /* First convert THIS to match the containing type of the pointer to
644 member. This cast may adjust the value of THIS. */
645 *this_p = value_cast (final_type, *this_p);
647 /* Then apply whatever adjustment is necessary. This creates a somewhat
648 strange pointer: it claims to have type FINAL_TYPE, but in fact it
649 might not be a valid FINAL_TYPE. For instance, it might be a
650 base class of FINAL_TYPE. And if it's not the primary base class,
651 then printing it out as a FINAL_TYPE object would produce some pretty
654 But we don't really know the type of the first argument in
655 METHOD_TYPE either, which is why this happens. We can't
656 dereference this later as a FINAL_TYPE, but once we arrive in the
657 called method we'll have debugging information for the type of
658 "this" - and that'll match the value we produce here.
660 You can provoke this case by casting a Base::* to a Derived::*, for
662 *this_p = value_cast (builtin_type_void_data_ptr, *this_p);
663 adjval = value_from_longest (builtin_type_long, adjustment);
664 *this_p = value_add (*this_p, adjval);
665 *this_p = value_cast (final_type, *this_p);
669 LONGEST voffset = ptr_value / TYPE_LENGTH (builtin_type_long);
670 return gnuv3_get_virtual_fn (value_ind (*this_p), method_type, voffset);
673 return value_from_pointer (lookup_pointer_type (method_type), ptr_value);
676 /* Determine if we are currently in a C++ thunk. If so, get the address
677 of the routine we are thunking to and continue to there instead. */
680 gnuv3_skip_trampoline (struct frame_info *frame, CORE_ADDR stop_pc)
682 CORE_ADDR real_stop_pc, method_stop_pc;
683 struct minimal_symbol *thunk_sym, *fn_sym;
684 struct obj_section *section;
685 char *thunk_name, *fn_name;
687 real_stop_pc = gdbarch_skip_trampoline_code
688 (current_gdbarch, frame, stop_pc);
689 if (real_stop_pc == 0)
690 real_stop_pc = stop_pc;
692 /* Find the linker symbol for this potential thunk. */
693 thunk_sym = lookup_minimal_symbol_by_pc (real_stop_pc);
694 section = find_pc_section (real_stop_pc);
695 if (thunk_sym == NULL || section == NULL)
698 /* The symbol's demangled name should be something like "virtual
699 thunk to FUNCTION", where FUNCTION is the name of the function
701 thunk_name = SYMBOL_DEMANGLED_NAME (thunk_sym);
702 if (thunk_name == NULL || strstr (thunk_name, " thunk to ") == NULL)
705 fn_name = strstr (thunk_name, " thunk to ") + strlen (" thunk to ");
706 fn_sym = lookup_minimal_symbol (fn_name, NULL, section->objfile);
710 method_stop_pc = SYMBOL_VALUE_ADDRESS (fn_sym);
711 real_stop_pc = gdbarch_skip_trampoline_code
712 (current_gdbarch, frame, method_stop_pc);
713 if (real_stop_pc == 0)
714 real_stop_pc = method_stop_pc;
719 /* Return nonzero if a type should be passed by reference.
721 The rule in the v3 ABI document comes from section 3.1.1. If the
722 type has a non-trivial copy constructor or destructor, then the
723 caller must make a copy (by calling the copy constructor if there
724 is one or perform the copy itself otherwise), pass the address of
725 the copy, and then destroy the temporary (if necessary).
727 For return values with non-trivial copy constructors or
728 destructors, space will be allocated in the caller, and a pointer
729 will be passed as the first argument (preceding "this").
731 We don't have a bulletproof mechanism for determining whether a
732 constructor or destructor is trivial. For GCC and DWARF2 debug
733 information, we can check the artificial flag.
735 We don't do anything with the constructors or destructors,
736 but we have to get the argument passing right anyway. */
738 gnuv3_pass_by_reference (struct type *type)
740 int fieldnum, fieldelem;
742 CHECK_TYPEDEF (type);
744 /* We're only interested in things that can have methods. */
745 if (TYPE_CODE (type) != TYPE_CODE_STRUCT
746 && TYPE_CODE (type) != TYPE_CODE_CLASS
747 && TYPE_CODE (type) != TYPE_CODE_UNION)
750 for (fieldnum = 0; fieldnum < TYPE_NFN_FIELDS (type); fieldnum++)
751 for (fieldelem = 0; fieldelem < TYPE_FN_FIELDLIST_LENGTH (type, fieldnum);
754 struct fn_field *fn = TYPE_FN_FIELDLIST1 (type, fieldnum);
755 char *name = TYPE_FN_FIELDLIST_NAME (type, fieldnum);
756 struct type *fieldtype = TYPE_FN_FIELD_TYPE (fn, fieldelem);
758 /* If this function is marked as artificial, it is compiler-generated,
759 and we assume it is trivial. */
760 if (TYPE_FN_FIELD_ARTIFICIAL (fn, fieldelem))
763 /* If we've found a destructor, we must pass this by reference. */
767 /* If the mangled name of this method doesn't indicate that it
768 is a constructor, we're not interested.
770 FIXME drow/2007-09-23: We could do this using the name of
771 the method and the name of the class instead of dealing
772 with the mangled name. We don't have a convenient function
773 to strip off both leading scope qualifiers and trailing
774 template arguments yet. */
775 if (!is_constructor_name (TYPE_FN_FIELD_PHYSNAME (fn, fieldelem)))
778 /* If this method takes two arguments, and the second argument is
779 a reference to this class, then it is a copy constructor. */
780 if (TYPE_NFIELDS (fieldtype) == 2
781 && TYPE_CODE (TYPE_FIELD_TYPE (fieldtype, 1)) == TYPE_CODE_REF
782 && check_typedef (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (fieldtype, 1))) == type)
786 /* Even if all the constructors and destructors were artificial, one
787 of them may have invoked a non-artificial constructor or
788 destructor in a base class. If any base class needs to be passed
789 by reference, so does this class. Similarly for members, which
790 are constructed whenever this class is. We do not need to worry
791 about recursive loops here, since we are only looking at members
792 of complete class type. */
793 for (fieldnum = 0; fieldnum < TYPE_NFIELDS (type); fieldnum++)
794 if (gnuv3_pass_by_reference (TYPE_FIELD_TYPE (type, fieldnum)))
801 init_gnuv3_ops (void)
803 vtable_type_gdbarch_data = gdbarch_data_register_post_init (build_gdb_vtable_type);
805 gnu_v3_abi_ops.shortname = "gnu-v3";
806 gnu_v3_abi_ops.longname = "GNU G++ Version 3 ABI";
807 gnu_v3_abi_ops.doc = "G++ Version 3 ABI";
808 gnu_v3_abi_ops.is_destructor_name =
809 (enum dtor_kinds (*) (const char *))is_gnu_v3_mangled_dtor;
810 gnu_v3_abi_ops.is_constructor_name =
811 (enum ctor_kinds (*) (const char *))is_gnu_v3_mangled_ctor;
812 gnu_v3_abi_ops.is_vtable_name = gnuv3_is_vtable_name;
813 gnu_v3_abi_ops.is_operator_name = gnuv3_is_operator_name;
814 gnu_v3_abi_ops.rtti_type = gnuv3_rtti_type;
815 gnu_v3_abi_ops.virtual_fn_field = gnuv3_virtual_fn_field;
816 gnu_v3_abi_ops.baseclass_offset = gnuv3_baseclass_offset;
817 gnu_v3_abi_ops.print_method_ptr = gnuv3_print_method_ptr;
818 gnu_v3_abi_ops.method_ptr_size = gnuv3_method_ptr_size;
819 gnu_v3_abi_ops.make_method_ptr = gnuv3_make_method_ptr;
820 gnu_v3_abi_ops.method_ptr_to_value = gnuv3_method_ptr_to_value;
821 gnu_v3_abi_ops.skip_trampoline = gnuv3_skip_trampoline;
822 gnu_v3_abi_ops.pass_by_reference = gnuv3_pass_by_reference;
825 extern initialize_file_ftype _initialize_gnu_v3_abi; /* -Wmissing-prototypes */
828 _initialize_gnu_v3_abi (void)
832 register_cp_abi (&gnu_v3_abi_ops);