GDB (xrefs)

/tmp/gdb-8.1/gdb/gnu-v3-abi.c
Go to the documentation of this file.
1 /* Abstraction of GNU v3 abi.
2 Contributed by Jim Blandy <jimb@redhat.com>
3
4 Copyright (C) 2001-2018 Free Software Foundation, Inc.
5
6 This file is part of GDB.
7
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.
12
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.
17
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/>. */
20
21 #include "defs.h"
22 #include "value.h"
23 #include "cp-abi.h"
24 #include "cp-support.h"
25 #include "demangle.h"
26 #include "objfiles.h"
27 #include "valprint.h"
28 #include "c-lang.h"
29 #include "typeprint.h"
30 #include <algorithm>
31
32 static struct cp_abi_ops gnu_v3_abi_ops;
33
34 /* A gdbarch key for std::type_info, in the event that it can't be
35 found in the debug info. */
36
37 static struct gdbarch_data *std_type_info_gdbarch_data;
38
39
40 static int
41 gnuv3_is_vtable_name (const char *name)
42 {
43 return startswith (name, "_ZTV");
44 }
45
46 static int
47 gnuv3_is_operator_name (const char *name)
48 {
49 return startswith (name, CP_OPERATOR_STR);
50 }
51
52
53 /* To help us find the components of a vtable, we build ourselves a
54 GDB type object representing the vtable structure. Following the
55 V3 ABI, it goes something like this:
56
57 struct gdb_gnu_v3_abi_vtable {
58
59 / * An array of virtual call and virtual base offsets. The real
60 length of this array depends on the class hierarchy; we use
61 negative subscripts to access the elements. Yucky, but
62 better than the alternatives. * /
63 ptrdiff_t vcall_and_vbase_offsets[0];
64
65 / * The offset from a virtual pointer referring to this table
66 to the top of the complete object. * /
67 ptrdiff_t offset_to_top;
68
69 / * The type_info pointer for this class. This is really a
70 std::type_info *, but GDB doesn't really look at the
71 type_info object itself, so we don't bother to get the type
72 exactly right. * /
73 void *type_info;
74
75 / * Virtual table pointers in objects point here. * /
76
77 / * Virtual function pointers. Like the vcall/vbase array, the
78 real length of this table depends on the class hierarchy. * /
79 void (*virtual_functions[0]) ();
80
81 };
82
83 The catch, of course, is that the exact layout of this table
84 depends on the ABI --- word size, endianness, alignment, etc. So
85 the GDB type object is actually a per-architecture kind of thing.
86
87 vtable_type_gdbarch_data is a gdbarch per-architecture data pointer
88 which refers to the struct type * for this structure, laid out
89 appropriately for the architecture. */
90 static struct gdbarch_data *vtable_type_gdbarch_data;
91
92
93 /* Human-readable names for the numbers of the fields above. */
94 enum {
95 vtable_field_vcall_and_vbase_offsets,
96 vtable_field_offset_to_top,
97 vtable_field_type_info,
98 vtable_field_virtual_functions
99 };
100
101
102 /* Return a GDB type representing `struct gdb_gnu_v3_abi_vtable',
103 described above, laid out appropriately for ARCH.
104
105 We use this function as the gdbarch per-architecture data
106 initialization function. */
107 static void *
108 build_gdb_vtable_type (struct gdbarch *arch)
109 {
110 struct type *t;
111 struct field *field_list, *field;
112 int offset;
113
114 struct type *void_ptr_type
115 = builtin_type (arch)->builtin_data_ptr;
116 struct type *ptr_to_void_fn_type
117 = builtin_type (arch)->builtin_func_ptr;
118
119 /* ARCH can't give us the true ptrdiff_t type, so we guess. */
120 struct type *ptrdiff_type
121 = arch_integer_type (arch, gdbarch_ptr_bit (arch), 0, "ptrdiff_t");
122
123 /* We assume no padding is necessary, since GDB doesn't know
124 anything about alignment at the moment. If this assumption bites
125 us, we should add a gdbarch method which, given a type, returns
126 the alignment that type requires, and then use that here. */
127
128 /* Build the field list. */
129 field_list = XCNEWVEC (struct field, 4);
130 field = &field_list[0];
131 offset = 0;
132
133 /* ptrdiff_t vcall_and_vbase_offsets[0]; */
134 FIELD_NAME (*field) = "vcall_and_vbase_offsets";
135 FIELD_TYPE (*field) = lookup_array_range_type (ptrdiff_type, 0, -1);
136 SET_FIELD_BITPOS (*field, offset * TARGET_CHAR_BIT);
137 offset += TYPE_LENGTH (FIELD_TYPE (*field));
138 field++;
139
140 /* ptrdiff_t offset_to_top; */
141 FIELD_NAME (*field) = "offset_to_top";
142 FIELD_TYPE (*field) = ptrdiff_type;
143 SET_FIELD_BITPOS (*field, offset * TARGET_CHAR_BIT);
144 offset += TYPE_LENGTH (FIELD_TYPE (*field));
145 field++;
146
147 /* void *type_info; */
148 FIELD_NAME (*field) = "type_info";
149 FIELD_TYPE (*field) = void_ptr_type;
150 SET_FIELD_BITPOS (*field, offset * TARGET_CHAR_BIT);
151 offset += TYPE_LENGTH (FIELD_TYPE (*field));
152 field++;
153
154 /* void (*virtual_functions[0]) (); */
155 FIELD_NAME (*field) = "virtual_functions";
156 FIELD_TYPE (*field) = lookup_array_range_type (ptr_to_void_fn_type, 0, -1);
157 SET_FIELD_BITPOS (*field, offset * TARGET_CHAR_BIT);
158 offset += TYPE_LENGTH (FIELD_TYPE (*field));
159 field++;
160
161 /* We assumed in the allocation above that there were four fields. */
162 gdb_assert (field == (field_list + 4));
163
164 t = arch_type (arch, TYPE_CODE_STRUCT, offset * TARGET_CHAR_BIT, NULL);
165 TYPE_NFIELDS (t) = field - field_list;
166 TYPE_FIELDS (t) = field_list;
167 TYPE_TAG_NAME (t) = "gdb_gnu_v3_abi_vtable";
168 INIT_CPLUS_SPECIFIC (t);
169
170 return make_type_with_address_space (t, TYPE_INSTANCE_FLAG_CODE_SPACE);
171 }
172
173
174 /* Return the ptrdiff_t type used in the vtable type. */
175 static struct type *
176 vtable_ptrdiff_type (struct gdbarch *gdbarch)
177 {
178 struct type *vtable_type
179 = (struct type *) gdbarch_data (gdbarch, vtable_type_gdbarch_data);
180
181 /* The "offset_to_top" field has the appropriate (ptrdiff_t) type. */
182 return TYPE_FIELD_TYPE (vtable_type, vtable_field_offset_to_top);
183 }
184
185 /* Return the offset from the start of the imaginary `struct
186 gdb_gnu_v3_abi_vtable' object to the vtable's "address point"
187 (i.e., where objects' virtual table pointers point). */
188 static int
189 vtable_address_point_offset (struct gdbarch *gdbarch)
190 {
191 struct type *vtable_type
192 = (struct type *) gdbarch_data (gdbarch, vtable_type_gdbarch_data);
193
194 return (TYPE_FIELD_BITPOS (vtable_type, vtable_field_virtual_functions)
195 / TARGET_CHAR_BIT);
196 }
197
198
199 /* Determine whether structure TYPE is a dynamic class. Cache the
200 result. */
201
202 static int
203 gnuv3_dynamic_class (struct type *type)
204 {
205 int fieldnum, fieldelem;
206
207 type = check_typedef (type);
208 gdb_assert (TYPE_CODE (type) == TYPE_CODE_STRUCT
209 || TYPE_CODE (type) == TYPE_CODE_UNION);
210
211 if (TYPE_CODE (type) == TYPE_CODE_UNION)
212 return 0;
213
214 if (TYPE_CPLUS_DYNAMIC (type))
215 return TYPE_CPLUS_DYNAMIC (type) == 1;
216
217 ALLOCATE_CPLUS_STRUCT_TYPE (type);
218
219 for (fieldnum = 0; fieldnum < TYPE_N_BASECLASSES (type); fieldnum++)
220 if (BASETYPE_VIA_VIRTUAL (type, fieldnum)
221 || gnuv3_dynamic_class (TYPE_FIELD_TYPE (type, fieldnum)))
222 {
223 TYPE_CPLUS_DYNAMIC (type) = 1;
224 return 1;
225 }
226
227 for (fieldnum = 0; fieldnum < TYPE_NFN_FIELDS (type); fieldnum++)
228 for (fieldelem = 0; fieldelem < TYPE_FN_FIELDLIST_LENGTH (type, fieldnum);
229 fieldelem++)
230 {
231 struct fn_field *f = TYPE_FN_FIELDLIST1 (type, fieldnum);
232
233 if (TYPE_FN_FIELD_VIRTUAL_P (f, fieldelem))
234 {
235 TYPE_CPLUS_DYNAMIC (type) = 1;
236 return 1;
237 }
238 }
239
240 TYPE_CPLUS_DYNAMIC (type) = -1;
241 return 0;
242 }
243
244 /* Find the vtable for a value of CONTAINER_TYPE located at
245 CONTAINER_ADDR. Return a value of the correct vtable type for this
246 architecture, or NULL if CONTAINER does not have a vtable. */
247
248 static struct value *
249 gnuv3_get_vtable (struct gdbarch *gdbarch,
250 struct type *container_type, CORE_ADDR container_addr)
251 {
252 struct type *vtable_type
253 = (struct type *) gdbarch_data (gdbarch, vtable_type_gdbarch_data);
254 struct type *vtable_pointer_type;
255 struct value *vtable_pointer;
256 CORE_ADDR vtable_address;
257
258 container_type = check_typedef (container_type);
259 gdb_assert (TYPE_CODE (container_type) == TYPE_CODE_STRUCT);
260
261 /* If this type does not have a virtual table, don't read the first
262 field. */
263 if (!gnuv3_dynamic_class (container_type))
264 return NULL;
265
266 /* We do not consult the debug information to find the virtual table.
267 The ABI specifies that it is always at offset zero in any class,
268 and debug information may not represent it.
269
270 We avoid using value_contents on principle, because the object might
271 be large. */
272
273 /* Find the type "pointer to virtual table". */
274 vtable_pointer_type = lookup_pointer_type (vtable_type);
275
276 /* Load it from the start of the class. */
277 vtable_pointer = value_at (vtable_pointer_type, container_addr);
278 vtable_address = value_as_address (vtable_pointer);
279
280 /* Correct it to point at the start of the virtual table, rather
281 than the address point. */
282 return value_at_lazy (vtable_type,
283 vtable_address
284 - vtable_address_point_offset (gdbarch));
285 }
286
287
288 static struct type *
289 gnuv3_rtti_type (struct value *value,
290 int *full_p, LONGEST *top_p, int *using_enc_p)
291 {
292 struct gdbarch *gdbarch;
293 struct type *values_type = check_typedef (value_type (value));
294 struct value *vtable;
295 struct minimal_symbol *vtable_symbol;
296 const char *vtable_symbol_name;
297 const char *class_name;
298 struct type *run_time_type;
299 LONGEST offset_to_top;
300 const char *atsign;
301
302 /* We only have RTTI for class objects. */
303 if (TYPE_CODE (values_type) != TYPE_CODE_STRUCT)
304 return NULL;
305
306 /* Determine architecture. */
307 gdbarch = get_type_arch (values_type);
308
309 if (using_enc_p)
310 *using_enc_p = 0;
311
312 vtable = gnuv3_get_vtable (gdbarch, values_type,
313 value_as_address (value_addr (value)));
314 if (vtable == NULL)
315 return NULL;
316
317 /* Find the linker symbol for this vtable. */
318 vtable_symbol
319 = lookup_minimal_symbol_by_pc (value_address (vtable)
320 + value_embedded_offset (vtable)).minsym;
321 if (! vtable_symbol)
322 return NULL;
323
324 /* The symbol's demangled name should be something like "vtable for
325 CLASS", where CLASS is the name of the run-time type of VALUE.
326 If we didn't like this approach, we could instead look in the
327 type_info object itself to get the class name. But this way
328 should work just as well, and doesn't read target memory. */
329 vtable_symbol_name = MSYMBOL_DEMANGLED_NAME (vtable_symbol);
330 if (vtable_symbol_name == NULL
331 || !startswith (vtable_symbol_name, "vtable for "))
332 {
333 warning (_("can't find linker symbol for virtual table for `%s' value"),
334 TYPE_SAFE_NAME (values_type));
335 if (vtable_symbol_name)
336 warning (_(" found `%s' instead"), vtable_symbol_name);
337 return NULL;
338 }
339 class_name = vtable_symbol_name + 11;
340
341 /* Strip off @plt and version suffixes. */
342 atsign = strchr (class_name, '@');
343 if (atsign != NULL)
344 {
345 char *copy;
346
347 copy = (char *) alloca (atsign - class_name + 1);
348 memcpy (copy, class_name, atsign - class_name);
349 copy[atsign - class_name] = '\0';
350 class_name = copy;
351 }
352
353 /* Try to look up the class name as a type name. */
354 /* FIXME: chastain/2003-11-26: block=NULL is bogus. See pr gdb/1465. */
355 run_time_type = cp_lookup_rtti_type (class_name, NULL);
356 if (run_time_type == NULL)
357 return NULL;
358
359 /* Get the offset from VALUE to the top of the complete object.
360 NOTE: this is the reverse of the meaning of *TOP_P. */
361 offset_to_top
362 = value_as_long (value_field (vtable, vtable_field_offset_to_top));
363
364 if (full_p)
365 *full_p = (- offset_to_top == value_embedded_offset (value)
366 && (TYPE_LENGTH (value_enclosing_type (value))
367 >= TYPE_LENGTH (run_time_type)));
368 if (top_p)
369 *top_p = - offset_to_top;
370 return run_time_type;
371 }
372
373 /* Return a function pointer for CONTAINER's VTABLE_INDEX'th virtual
374 function, of type FNTYPE. */
375
376 static struct value *
377 gnuv3_get_virtual_fn (struct gdbarch *gdbarch, struct value *container,
378 struct type *fntype, int vtable_index)
379 {
380 struct value *vtable, *vfn;
381
382 /* Every class with virtual functions must have a vtable. */
383 vtable = gnuv3_get_vtable (gdbarch, value_type (container),
384 value_as_address (value_addr (container)));
385 gdb_assert (vtable != NULL);
386
387 /* Fetch the appropriate function pointer from the vtable. */
388 vfn = value_subscript (value_field (vtable, vtable_field_virtual_functions),
389 vtable_index);
390
391 /* If this architecture uses function descriptors directly in the vtable,
392 then the address of the vtable entry is actually a "function pointer"
393 (i.e. points to the descriptor). We don't need to scale the index
394 by the size of a function descriptor; GCC does that before outputing
395 debug information. */
396 if (gdbarch_vtable_function_descriptors (gdbarch))
397 vfn = value_addr (vfn);
398
399 /* Cast the function pointer to the appropriate type. */
400 vfn = value_cast (lookup_pointer_type (fntype), vfn);
401
402 return vfn;
403 }
404
405 /* GNU v3 implementation of value_virtual_fn_field. See cp-abi.h
406 for a description of the arguments. */
407
408 static struct value *
409 gnuv3_virtual_fn_field (struct value **value_p,
410 struct fn_field *f, int j,
411 struct type *vfn_base, int offset)
412 {
413 struct type *values_type = check_typedef (value_type (*value_p));
414 struct gdbarch *gdbarch;
415
416 /* Some simple sanity checks. */
417 if (TYPE_CODE (values_type) != TYPE_CODE_STRUCT)
418 error (_("Only classes can have virtual functions."));
419
420 /* Determine architecture. */
421 gdbarch = get_type_arch (values_type);
422
423 /* Cast our value to the base class which defines this virtual
424 function. This takes care of any necessary `this'
425 adjustments. */
426 if (vfn_base != values_type)
427 *value_p = value_cast (vfn_base, *value_p);
428
429 return gnuv3_get_virtual_fn (gdbarch, *value_p, TYPE_FN_FIELD_TYPE (f, j),
430 TYPE_FN_FIELD_VOFFSET (f, j));
431 }
432
433 /* Compute the offset of the baseclass which is
434 the INDEXth baseclass of class TYPE,
435 for value at VALADDR (in host) at ADDRESS (in target).
436 The result is the offset of the baseclass value relative
437 to (the address of)(ARG) + OFFSET.
438
439 -1 is returned on error. */
440
441 static int
442 gnuv3_baseclass_offset (struct type *type, int index,
443 const bfd_byte *valaddr, LONGEST embedded_offset,
444 CORE_ADDR address, const struct value *val)
445 {
446 struct gdbarch *gdbarch;
447 struct type *ptr_type;
448 struct value *vtable;
449 struct value *vbase_array;
450 long int cur_base_offset, base_offset;
451
452 /* Determine architecture. */
453 gdbarch = get_type_arch (type);
454 ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
455
456 /* If it isn't a virtual base, this is easy. The offset is in the
457 type definition. */
458 if (!BASETYPE_VIA_VIRTUAL (type, index))
459 return TYPE_BASECLASS_BITPOS (type, index) / 8;
460
461 /* To access a virtual base, we need to use the vbase offset stored in
462 our vtable. Recent GCC versions provide this information. If it isn't
463 available, we could get what we needed from RTTI, or from drawing the
464 complete inheritance graph based on the debug info. Neither is
465 worthwhile. */
466 cur_base_offset = TYPE_BASECLASS_BITPOS (type, index) / 8;
467 if (cur_base_offset >= - vtable_address_point_offset (gdbarch))
468 error (_("Expected a negative vbase offset (old compiler?)"));
469
470 cur_base_offset = cur_base_offset + vtable_address_point_offset (gdbarch);
471 if ((- cur_base_offset) % TYPE_LENGTH (ptr_type) != 0)
472 error (_("Misaligned vbase offset."));
473 cur_base_offset = cur_base_offset / ((int) TYPE_LENGTH (ptr_type));
474
475 vtable = gnuv3_get_vtable (gdbarch, type, address + embedded_offset);
476 gdb_assert (vtable != NULL);
477 vbase_array = value_field (vtable, vtable_field_vcall_and_vbase_offsets);
478 base_offset = value_as_long (value_subscript (vbase_array, cur_base_offset));
479 return base_offset;
480 }
481
482 /* Locate a virtual method in DOMAIN or its non-virtual base classes
483 which has virtual table index VOFFSET. The method has an associated
484 "this" adjustment of ADJUSTMENT bytes. */
485
486 static const char *
487 gnuv3_find_method_in (struct type *domain, CORE_ADDR voffset,
488 LONGEST adjustment)
489 {
490 int i;
491
492 /* Search this class first. */
493 if (adjustment == 0)
494 {
495 int len;
496
497 len = TYPE_NFN_FIELDS (domain);
498 for (i = 0; i < len; i++)
499 {
500 int len2, j;
501 struct fn_field *f;
502
503 f = TYPE_FN_FIELDLIST1 (domain, i);
504 len2 = TYPE_FN_FIELDLIST_LENGTH (domain, i);
505
506 check_stub_method_group (domain, i);
507 for (j = 0; j < len2; j++)
508 if (TYPE_FN_FIELD_VOFFSET (f, j) == voffset)
509 return TYPE_FN_FIELD_PHYSNAME (f, j);
510 }
511 }
512
513 /* Next search non-virtual bases. If it's in a virtual base,
514 we're out of luck. */
515 for (i = 0; i < TYPE_N_BASECLASSES (domain); i++)
516 {
517 int pos;
518 struct type *basetype;
519
520 if (BASETYPE_VIA_VIRTUAL (domain, i))
521 continue;
522
523 pos = TYPE_BASECLASS_BITPOS (domain, i) / 8;
524 basetype = TYPE_FIELD_TYPE (domain, i);
525 /* Recurse with a modified adjustment. We don't need to adjust
526 voffset. */
527 if (adjustment >= pos && adjustment < pos + TYPE_LENGTH (basetype))
528 return gnuv3_find_method_in (basetype, voffset, adjustment - pos);
529 }
530
531 return NULL;
532 }
533
534 /* Decode GNU v3 method pointer. */
535
536 static int
537 gnuv3_decode_method_ptr (struct gdbarch *gdbarch,
538 const gdb_byte *contents,
539 CORE_ADDR *value_p,
540 LONGEST *adjustment_p)
541 {
542 struct type *funcptr_type = builtin_type (gdbarch)->builtin_func_ptr;
543 struct type *offset_type = vtable_ptrdiff_type (gdbarch);
544 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
545 CORE_ADDR ptr_value;
546 LONGEST voffset, adjustment;
547 int vbit;
548
549 /* Extract the pointer to member. The first element is either a pointer
550 or a vtable offset. For pointers, we need to use extract_typed_address
551 to allow the back-end to convert the pointer to a GDB address -- but
552 vtable offsets we must handle as integers. At this point, we do not
553 yet know which case we have, so we extract the value under both
554 interpretations and choose the right one later on. */
555 ptr_value = extract_typed_address (contents, funcptr_type);
556 voffset = extract_signed_integer (contents,
557 TYPE_LENGTH (funcptr_type), byte_order);
558 contents += TYPE_LENGTH (funcptr_type);
559 adjustment = extract_signed_integer (contents,
560 TYPE_LENGTH (offset_type), byte_order);
561
562 if (!gdbarch_vbit_in_delta (gdbarch))
563 {
564 vbit = voffset & 1;
565 voffset = voffset ^ vbit;
566 }
567 else
568 {
569 vbit = adjustment & 1;
570 adjustment = adjustment >> 1;
571 }
572
573 *value_p = vbit? voffset : ptr_value;
574 *adjustment_p = adjustment;
575 return vbit;
576 }
577
578 /* GNU v3 implementation of cplus_print_method_ptr. */
579
580 static void
581 gnuv3_print_method_ptr (const gdb_byte *contents,
582 struct type *type,
583 struct ui_file *stream)
584 {
585 struct type *self_type = TYPE_SELF_TYPE (type);
586 struct gdbarch *gdbarch = get_type_arch (self_type);
587 CORE_ADDR ptr_value;
588 LONGEST adjustment;
589 int vbit;
590
591 /* Extract the pointer to member. */
592 vbit = gnuv3_decode_method_ptr (gdbarch, contents, &ptr_value, &adjustment);
593
594 /* Check for NULL. */
595 if (ptr_value == 0 && vbit == 0)
596 {
597 fprintf_filtered (stream, "NULL");
598 return;
599 }
600
601 /* Search for a virtual method. */
602 if (vbit)
603 {
604 CORE_ADDR voffset;
605 const char *physname;
606
607 /* It's a virtual table offset, maybe in this class. Search
608 for a field with the correct vtable offset. First convert it
609 to an index, as used in TYPE_FN_FIELD_VOFFSET. */
610 voffset = ptr_value / TYPE_LENGTH (vtable_ptrdiff_type (gdbarch));
611
612 physname = gnuv3_find_method_in (self_type, voffset, adjustment);
613
614 /* If we found a method, print that. We don't bother to disambiguate
615 possible paths to the method based on the adjustment. */
616 if (physname)
617 {
618 char *demangled_name = gdb_demangle (physname,
619 DMGL_ANSI | DMGL_PARAMS);
620
621 fprintf_filtered (stream, "&virtual ");
622 if (demangled_name == NULL)
623 fputs_filtered (physname, stream);
624 else
625 {
626 fputs_filtered (demangled_name, stream);
627 xfree (demangled_name);
628 }
629 return;
630 }
631 }
632 else if (ptr_value != 0)
633 {
634 /* Found a non-virtual function: print out the type. */
635 fputs_filtered ("(", stream);
636 c_print_type (type, "", stream, -1, 0, &type_print_raw_options);
637 fputs_filtered (") ", stream);
638 }
639
640 /* We didn't find it; print the raw data. */
641 if (vbit)
642 {
643 fprintf_filtered (stream, "&virtual table offset ");
644 print_longest (stream, 'd', 1, ptr_value);
645 }
646 else
647 {
648 struct value_print_options opts;
649
650 get_user_print_options (&opts);
651 print_address_demangle (&opts, gdbarch, ptr_value, stream, demangle);
652 }
653
654 if (adjustment)
655 {
656 fprintf_filtered (stream, ", this adjustment ");
657 print_longest (stream, 'd', 1, adjustment);
658 }
659 }
660
661 /* GNU v3 implementation of cplus_method_ptr_size. */
662
663 static int
664 gnuv3_method_ptr_size (struct type *type)
665 {
666 struct gdbarch *gdbarch = get_type_arch (type);
667
668 return 2 * TYPE_LENGTH (builtin_type (gdbarch)->builtin_data_ptr);
669 }
670
671 /* GNU v3 implementation of cplus_make_method_ptr. */
672
673 static void
674 gnuv3_make_method_ptr (struct type *type, gdb_byte *contents,
675 CORE_ADDR value, int is_virtual)
676 {
677 struct gdbarch *gdbarch = get_type_arch (type);
678 int size = TYPE_LENGTH (builtin_type (gdbarch)->builtin_data_ptr);
679 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
680
681 /* FIXME drow/2006-12-24: The adjustment of "this" is currently
682 always zero, since the method pointer is of the correct type.
683 But if the method pointer came from a base class, this is
684 incorrect - it should be the offset to the base. The best
685 fix might be to create the pointer to member pointing at the
686 base class and cast it to the derived class, but that requires
687 support for adjusting pointers to members when casting them -
688 not currently supported by GDB. */
689
690 if (!gdbarch_vbit_in_delta (gdbarch))
691 {
692 store_unsigned_integer (contents, size, byte_order, value | is_virtual);
693 store_unsigned_integer (contents + size, size, byte_order, 0);
694 }
695 else
696 {
697 store_unsigned_integer (contents, size, byte_order, value);
698 store_unsigned_integer (contents + size, size, byte_order, is_virtual);
699 }
700 }
701
702 /* GNU v3 implementation of cplus_method_ptr_to_value. */
703
704 static struct value *
705 gnuv3_method_ptr_to_value (struct value **this_p, struct value *method_ptr)
706 {
707 struct gdbarch *gdbarch;
708 const gdb_byte *contents = value_contents (method_ptr);
709 CORE_ADDR ptr_value;
710 struct type *self_type, *final_type, *method_type;
711 LONGEST adjustment;
712 int vbit;
713
714 self_type = TYPE_SELF_TYPE (check_typedef (value_type (method_ptr)));
715 final_type = lookup_pointer_type (self_type);
716
717 method_type = TYPE_TARGET_TYPE (check_typedef (value_type (method_ptr)));
718
719 /* Extract the pointer to member. */
720 gdbarch = get_type_arch (self_type);
721 vbit = gnuv3_decode_method_ptr (gdbarch, contents, &ptr_value, &adjustment);
722
723 /* First convert THIS to match the containing type of the pointer to
724 member. This cast may adjust the value of THIS. */
725 *this_p = value_cast (final_type, *this_p);
726
727 /* Then apply whatever adjustment is necessary. This creates a somewhat
728 strange pointer: it claims to have type FINAL_TYPE, but in fact it
729 might not be a valid FINAL_TYPE. For instance, it might be a
730 base class of FINAL_TYPE. And if it's not the primary base class,
731 then printing it out as a FINAL_TYPE object would produce some pretty
732 garbage.
733
734 But we don't really know the type of the first argument in
735 METHOD_TYPE either, which is why this happens. We can't
736 dereference this later as a FINAL_TYPE, but once we arrive in the
737 called method we'll have debugging information for the type of
738 "this" - and that'll match the value we produce here.
739
740 You can provoke this case by casting a Base::* to a Derived::*, for
741 instance. */
742 *this_p = value_cast (builtin_type (gdbarch)->builtin_data_ptr, *this_p);
743 *this_p = value_ptradd (*this_p, adjustment);
744 *this_p = value_cast (final_type, *this_p);
745
746 if (vbit)
747 {
748 LONGEST voffset;
749
750 voffset = ptr_value / TYPE_LENGTH (vtable_ptrdiff_type (gdbarch));
751 return gnuv3_get_virtual_fn (gdbarch, value_ind (*this_p),
752 method_type, voffset);
753 }
754 else
755 return value_from_pointer (lookup_pointer_type (method_type), ptr_value);
756 }
757
758 /* Objects of this type are stored in a hash table and a vector when
759 printing the vtables for a class. */
760
761 struct value_and_voffset
762 {
763 /* The value representing the object. */
764 struct value *value;
765
766 /* The maximum vtable offset we've found for any object at this
767 offset in the outermost object. */
768 int max_voffset;
769 };
770
771 /* Hash function for value_and_voffset. */
772
773 static hashval_t
774 hash_value_and_voffset (const void *p)
775 {
776 const struct value_and_voffset *o = (const struct value_and_voffset *) p;
777
778 return value_address (o->value) + value_embedded_offset (o->value);
779 }
780
781 /* Equality function for value_and_voffset. */
782
783 static int
784 eq_value_and_voffset (const void *a, const void *b)
785 {
786 const struct value_and_voffset *ova = (const struct value_and_voffset *) a;
787 const struct value_and_voffset *ovb = (const struct value_and_voffset *) b;
788
789 return (value_address (ova->value) + value_embedded_offset (ova->value)
790 == value_address (ovb->value) + value_embedded_offset (ovb->value));
791 }
792
793 /* Comparison function for value_and_voffset. */
794
795 static bool
796 compare_value_and_voffset (const struct value_and_voffset *va,
797 const struct value_and_voffset *vb)
798 {
799 CORE_ADDR addra = (value_address (va->value)
800 + value_embedded_offset (va->value));
801 CORE_ADDR addrb = (value_address (vb->value)
802 + value_embedded_offset (vb->value));
803
804 return addra < addrb;
805 }
806
807 /* A helper function used when printing vtables. This determines the
808 key (most derived) sub-object at each address and also computes the
809 maximum vtable offset seen for the corresponding vtable. Updates
810 OFFSET_HASH and OFFSET_VEC with a new value_and_voffset object, if
811 needed. VALUE is the object to examine. */
812
813 static void
814 compute_vtable_size (htab_t offset_hash,
815 std::vector<value_and_voffset *> *offset_vec,
816 struct value *value)
817 {
818 int i;
819 struct type *type = check_typedef (value_type (value));
820 void **slot;
821 struct value_and_voffset search_vo, *current_vo;
822
823 gdb_assert (TYPE_CODE (type) == TYPE_CODE_STRUCT);
824
825 /* If the object is not dynamic, then we are done; as it cannot have
826 dynamic base types either. */
827 if (!gnuv3_dynamic_class (type))
828 return;
829
830 /* Update the hash and the vec, if needed. */
831 search_vo.value = value;
832 slot = htab_find_slot (offset_hash, &search_vo, INSERT);
833 if (*slot)
834 current_vo = (struct value_and_voffset *) *slot;
835 else
836 {
837 current_vo = XNEW (struct value_and_voffset);
838 current_vo->value = value;
839 current_vo->max_voffset = -1;
840 *slot = current_vo;
841 offset_vec->push_back (current_vo);
842 }
843
844 /* Update the value_and_voffset object with the highest vtable
845 offset from this class. */
846 for (i = 0; i < TYPE_NFN_FIELDS (type); ++i)
847 {
848 int j;
849 struct fn_field *fn = TYPE_FN_FIELDLIST1 (type, i);
850
851 for (j = 0; j < TYPE_FN_FIELDLIST_LENGTH (type, i); ++j)
852 {
853 if (TYPE_FN_FIELD_VIRTUAL_P (fn, j))
854 {
855 int voffset = TYPE_FN_FIELD_VOFFSET (fn, j);
856
857 if (voffset > current_vo->max_voffset)
858 current_vo->max_voffset = voffset;
859 }
860 }
861 }
862
863 /* Recurse into base classes. */
864 for (i = 0; i < TYPE_N_BASECLASSES (type); ++i)
865 compute_vtable_size (offset_hash, offset_vec, value_field (value, i));
866 }
867
868 /* Helper for gnuv3_print_vtable that prints a single vtable. */
869
870 static void
871 print_one_vtable (struct gdbarch *gdbarch, struct value *value,
872 int max_voffset,
873 struct value_print_options *opts)
874 {
875 int i;
876 struct type *type = check_typedef (value_type (value));
877 struct value *vtable;
878 CORE_ADDR vt_addr;
879
880 vtable = gnuv3_get_vtable (gdbarch, type,
881 value_address (value)
882 + value_embedded_offset (value));
883 vt_addr = value_address (value_field (vtable,
884 vtable_field_virtual_functions));
885
886 printf_filtered (_("vtable for '%s' @ %s (subobject @ %s):\n"),
887 TYPE_SAFE_NAME (type),
888 paddress (gdbarch, vt_addr),
889 paddress (gdbarch, (value_address (value)
890 + value_embedded_offset (value))));
891
892 for (i = 0; i <= max_voffset; ++i)
893 {
894 /* Initialize it just to avoid a GCC false warning. */
895 CORE_ADDR addr = 0;
896 int got_error = 0;
897 struct value *vfn;
898
899 printf_filtered ("[%d]: ", i);
900
901 vfn = value_subscript (value_field (vtable,
902 vtable_field_virtual_functions),
903 i);
904
905 if (gdbarch_vtable_function_descriptors (gdbarch))
906 vfn = value_addr (vfn);
907
908 TRY
909 {
910 addr = value_as_address (vfn);
911 }
912 CATCH (ex, RETURN_MASK_ERROR)
913 {
914 printf_filtered (_("<error: %s>"), ex.message);
915 got_error = 1;
916 }
917 END_CATCH
918
919 if (!got_error)
920 print_function_pointer_address (opts, gdbarch, addr, gdb_stdout);
921 printf_filtered ("\n");
922 }
923 }
924
925 /* Implementation of the print_vtable method. */
926
927 static void
928 gnuv3_print_vtable (struct value *value)
929 {
930 struct gdbarch *gdbarch;
931 struct type *type;
932 struct value *vtable;
933 struct value_print_options opts;
934 int count;
935
936 value = coerce_ref (value);
937 type = check_typedef (value_type (value));
938 if (TYPE_CODE (type) == TYPE_CODE_PTR)
939 {
940 value = value_ind (value);
941 type = check_typedef (value_type (value));
942 }
943
944 get_user_print_options (&opts);
945
946 /* Respect 'set print object'. */
947 if (opts.objectprint)
948 {
949 value = value_full_object (value, NULL, 0, 0, 0);
950 type = check_typedef (value_type (value));
951 }
952
953 gdbarch = get_type_arch (type);
954
955 vtable = NULL;
956 if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
957 vtable = gnuv3_get_vtable (gdbarch, type,
958 value_as_address (value_addr (value)));
959
960 if (!vtable)
961 {
962 printf_filtered (_("This object does not have a virtual function table\n"));
963 return;
964 }
965
966 htab_up offset_hash (htab_create_alloc (1, hash_value_and_voffset,
967 eq_value_and_voffset,
968 xfree, xcalloc, xfree));
969 std::vector<value_and_voffset *> result_vec;
970
971 compute_vtable_size (offset_hash.get (), &result_vec, value);
972 std::sort (result_vec.begin (), result_vec.end (),
973 compare_value_and_voffset);
974
975 count = 0;
976 for (value_and_voffset *iter : result_vec)
977 {
978 if (iter->max_voffset >= 0)
979 {
980 if (count > 0)
981 printf_filtered ("\n");
982 print_one_vtable (gdbarch, iter->value, iter->max_voffset, &opts);
983 ++count;
984 }
985 }
986 }
987
988 /* Return a GDB type representing `struct std::type_info', laid out
989 appropriately for ARCH.
990
991 We use this function as the gdbarch per-architecture data
992 initialization function. */
993
994 static void *
995 build_std_type_info_type (struct gdbarch *arch)
996 {
997 struct type *t;
998 struct field *field_list, *field;
999 int offset;
1000 struct type *void_ptr_type
1001 = builtin_type (arch)->builtin_data_ptr;
1002 struct type *char_type
1003 = builtin_type (arch)->builtin_char;
1004 struct type *char_ptr_type
1005 = make_pointer_type (make_cv_type (1, 0, char_type, NULL), NULL);
1006
1007 field_list = XCNEWVEC (struct field, 2);
1008 field = &field_list[0];
1009 offset = 0;
1010
1011 /* The vtable. */
1012 FIELD_NAME (*field) = "_vptr.type_info";
1013 FIELD_TYPE (*field) = void_ptr_type;
1014 SET_FIELD_BITPOS (*field, offset * TARGET_CHAR_BIT);
1015 offset += TYPE_LENGTH (FIELD_TYPE (*field));
1016 field++;
1017
1018 /* The name. */
1019 FIELD_NAME (*field) = "__name";
1020 FIELD_TYPE (*field) = char_ptr_type;
1021 SET_FIELD_BITPOS (*field, offset * TARGET_CHAR_BIT);
1022 offset += TYPE_LENGTH (FIELD_TYPE (*field));
1023 field++;
1024
1025 gdb_assert (field == (field_list + 2));
1026
1027 t = arch_type (arch, TYPE_CODE_STRUCT, offset * TARGET_CHAR_BIT, NULL);
1028 TYPE_NFIELDS (t) = field - field_list;
1029 TYPE_FIELDS (t) = field_list;
1030 TYPE_TAG_NAME (t) = "gdb_gnu_v3_type_info";
1031 INIT_CPLUS_SPECIFIC (t);
1032
1033 return t;
1034 }
1035
1036 /* Implement the 'get_typeid_type' method. */
1037
1038 static struct type *
1039 gnuv3_get_typeid_type (struct gdbarch *gdbarch)
1040 {
1041 struct symbol *typeinfo;
1042 struct type *typeinfo_type;
1043
1044 typeinfo = lookup_symbol ("std::type_info", NULL, STRUCT_DOMAIN,
1045 NULL).symbol;
1046 if (typeinfo == NULL)
1047 typeinfo_type
1048 = (struct type *) gdbarch_data (gdbarch, std_type_info_gdbarch_data);
1049 else
1050 typeinfo_type = SYMBOL_TYPE (typeinfo);
1051
1052 return typeinfo_type;
1053 }
1054
1055 /* Implement the 'get_typeid' method. */
1056
1057 static struct value *
1058 gnuv3_get_typeid (struct value *value)
1059 {
1060 struct type *typeinfo_type;
1061 struct type *type;
1062 struct gdbarch *gdbarch;
1063 struct value *result;
1064 std::string type_name, canonical;
1065
1066 /* We have to handle values a bit trickily here, to allow this code
1067 to work properly with non_lvalue values that are really just
1068 disguised types. */
1069 if (value_lval_const (value) == lval_memory)
1070 value = coerce_ref (value);
1071
1072 type = check_typedef (value_type (value));
1073
1074 /* In the non_lvalue case, a reference might have slipped through
1075 here. */
1076 if (TYPE_CODE (type) == TYPE_CODE_REF)
1077 type = check_typedef (TYPE_TARGET_TYPE (type));
1078
1079 /* Ignore top-level cv-qualifiers. */
1080 type = make_cv_type (0, 0, type, NULL);
1081 gdbarch = get_type_arch (type);
1082
1083 type_name = type_to_string (type);
1084 if (type_name.empty ())
1085 error (_("cannot find typeinfo for unnamed type"));
1086
1087 /* We need to canonicalize the type name here, because we do lookups
1088 using the demangled name, and so we must match the format it
1089 uses. E.g., GDB tends to use "const char *" as a type name, but
1090 the demangler uses "char const *". */
1091 canonical = cp_canonicalize_string (type_name.c_str ());
1092 if (!canonical.empty ())
1093 type_name = canonical;
1094
1095 typeinfo_type = gnuv3_get_typeid_type (gdbarch);
1096
1097 /* We check for lval_memory because in the "typeid (type-id)" case,
1098 the type is passed via a not_lval value object. */
1099 if (TYPE_CODE (type) == TYPE_CODE_STRUCT
1100 && value_lval_const (value) == lval_memory
1101 && gnuv3_dynamic_class (type))
1102 {
1103 struct value *vtable, *typeinfo_value;
1104 CORE_ADDR address = value_address (value) + value_embedded_offset (value);
1105
1106 vtable = gnuv3_get_vtable (gdbarch, type, address);
1107 if (vtable == NULL)
1108 error (_("cannot find typeinfo for object of type '%s'"),
1109 type_name.c_str ());
1110 typeinfo_value = value_field (vtable, vtable_field_type_info);
1111 result = value_ind (value_cast (make_pointer_type (typeinfo_type, NULL),
1112 typeinfo_value));
1113 }
1114 else
1115 {
1116 std::string sym_name = std::string ("typeinfo for ") + type_name;
1117 bound_minimal_symbol minsym
1118 = lookup_minimal_symbol (sym_name.c_str (), NULL, NULL);
1119
1120 if (minsym.minsym == NULL)
1121 error (_("could not find typeinfo symbol for '%s'"), type_name.c_str ());
1122
1123 result = value_at_lazy (typeinfo_type, BMSYMBOL_VALUE_ADDRESS (minsym));
1124 }
1125
1126 return result;
1127 }
1128
1129 /* Implement the 'get_typename_from_type_info' method. */
1130
1131 static std::string
1132 gnuv3_get_typename_from_type_info (struct value *type_info_ptr)
1133 {
1134 struct gdbarch *gdbarch = get_type_arch (value_type (type_info_ptr));
1135 struct bound_minimal_symbol typeinfo_sym;
1136 CORE_ADDR addr;
1137 const char *symname;
1138 const char *class_name;
1139 const char *atsign;
1140
1141 addr = value_as_address (type_info_ptr);
1142 typeinfo_sym = lookup_minimal_symbol_by_pc (addr);
1143 if (typeinfo_sym.minsym == NULL)
1144 error (_("could not find minimal symbol for typeinfo address %s"),
1145 paddress (gdbarch, addr));
1146
1147 #define TYPEINFO_PREFIX "typeinfo for "
1148 #define TYPEINFO_PREFIX_LEN (sizeof (TYPEINFO_PREFIX) - 1)
1149 symname = MSYMBOL_DEMANGLED_NAME (typeinfo_sym.minsym);
1150 if (symname == NULL || strncmp (symname, TYPEINFO_PREFIX,
1151 TYPEINFO_PREFIX_LEN))
1152 error (_("typeinfo symbol '%s' has unexpected name"),
1153 MSYMBOL_LINKAGE_NAME (typeinfo_sym.minsym));
1154 class_name = symname + TYPEINFO_PREFIX_LEN;
1155
1156 /* Strip off @plt and version suffixes. */
1157 atsign = strchr (class_name, '@');
1158 if (atsign != NULL)
1159 return std::string (class_name, atsign - class_name);
1160 return class_name;
1161 }
1162
1163 /* Implement the 'get_type_from_type_info' method. */
1164
1165 static struct type *
1166 gnuv3_get_type_from_type_info (struct value *type_info_ptr)
1167 {
1168 /* We have to parse the type name, since in general there is not a
1169 symbol for a type. This is somewhat bogus since there may be a
1170 mis-parse. Another approach might be to re-use the demangler's
1171 internal form to reconstruct the type somehow. */
1172 std::string type_name = gnuv3_get_typename_from_type_info (type_info_ptr);
1173 expression_up expr (parse_expression (type_name.c_str ()));
1174 struct value *type_val = evaluate_type (expr.get ());
1175 return value_type (type_val);
1176 }
1177
1178 /* Determine if we are currently in a C++ thunk. If so, get the address
1179 of the routine we are thunking to and continue to there instead. */
1180
1181 static CORE_ADDR
1182 gnuv3_skip_trampoline (struct frame_info *frame, CORE_ADDR stop_pc)
1183 {
1184 CORE_ADDR real_stop_pc, method_stop_pc, func_addr;
1185 struct gdbarch *gdbarch = get_frame_arch (frame);
1186 struct bound_minimal_symbol thunk_sym, fn_sym;
1187 struct obj_section *section;
1188 const char *thunk_name, *fn_name;
1189
1190 real_stop_pc = gdbarch_skip_trampoline_code (gdbarch, frame, stop_pc);
1191 if (real_stop_pc == 0)
1192 real_stop_pc = stop_pc;
1193
1194 /* Find the linker symbol for this potential thunk. */
1195 thunk_sym = lookup_minimal_symbol_by_pc (real_stop_pc);
1196 section = find_pc_section (real_stop_pc);
1197 if (thunk_sym.minsym == NULL || section == NULL)
1198 return 0;
1199
1200 /* The symbol's demangled name should be something like "virtual
1201 thunk to FUNCTION", where FUNCTION is the name of the function
1202 being thunked to. */
1203 thunk_name = MSYMBOL_DEMANGLED_NAME (thunk_sym.minsym);
1204 if (thunk_name == NULL || strstr (thunk_name, " thunk to ") == NULL)
1205 return 0;
1206
1207 fn_name = strstr (thunk_name, " thunk to ") + strlen (" thunk to ");
1208 fn_sym = lookup_minimal_symbol (fn_name, NULL, section->objfile);
1209 if (fn_sym.minsym == NULL)
1210 return 0;
1211
1212 method_stop_pc = BMSYMBOL_VALUE_ADDRESS (fn_sym);
1213
1214 /* Some targets have minimal symbols pointing to function descriptors
1215 (powerpc 64 for example). Make sure to retrieve the address
1216 of the real function from the function descriptor before passing on
1217 the address to other layers of GDB. */
1218 func_addr = gdbarch_convert_from_func_ptr_addr (gdbarch, method_stop_pc,
1219 &current_target);
1220 if (func_addr != 0)
1221 method_stop_pc = func_addr;
1222
1223 real_stop_pc = gdbarch_skip_trampoline_code
1224 (gdbarch, frame, method_stop_pc);
1225 if (real_stop_pc == 0)
1226 real_stop_pc = method_stop_pc;
1227
1228 return real_stop_pc;
1229 }
1230
1231 /* Return nonzero if a type should be passed by reference.
1232
1233 The rule in the v3 ABI document comes from section 3.1.1. If the
1234 type has a non-trivial copy constructor or destructor, then the
1235 caller must make a copy (by calling the copy constructor if there
1236 is one or perform the copy itself otherwise), pass the address of
1237 the copy, and then destroy the temporary (if necessary).
1238
1239 For return values with non-trivial copy constructors or
1240 destructors, space will be allocated in the caller, and a pointer
1241 will be passed as the first argument (preceding "this").
1242
1243 We don't have a bulletproof mechanism for determining whether a
1244 constructor or destructor is trivial. For GCC and DWARF2 debug
1245 information, we can check the artificial flag.
1246
1247 We don't do anything with the constructors or destructors,
1248 but we have to get the argument passing right anyway. */
1249 static int
1250 gnuv3_pass_by_reference (struct type *type)
1251 {
1252 int fieldnum, fieldelem;
1253
1254 type = check_typedef (type);
1255
1256 /* We're only interested in things that can have methods. */
1257 if (TYPE_CODE (type) != TYPE_CODE_STRUCT
1258 && TYPE_CODE (type) != TYPE_CODE_UNION)
1259 return 0;
1260
1261 /* A dynamic class has a non-trivial copy constructor.
1262 See c++98 section 12.8 Copying class objects [class.copy]. */
1263 if (gnuv3_dynamic_class (type))
1264 return 1;
1265
1266 for (fieldnum = 0; fieldnum < TYPE_NFN_FIELDS (type); fieldnum++)
1267 for (fieldelem = 0; fieldelem < TYPE_FN_FIELDLIST_LENGTH (type, fieldnum);
1268 fieldelem++)
1269 {
1270 struct fn_field *fn = TYPE_FN_FIELDLIST1 (type, fieldnum);
1271 const char *name = TYPE_FN_FIELDLIST_NAME (type, fieldnum);
1272 struct type *fieldtype = TYPE_FN_FIELD_TYPE (fn, fieldelem);
1273
1274 /* If this function is marked as artificial, it is compiler-generated,
1275 and we assume it is trivial. */
1276 if (TYPE_FN_FIELD_ARTIFICIAL (fn, fieldelem))
1277 continue;
1278
1279 /* If we've found a destructor, we must pass this by reference. */
1280 if (name[0] == '~')
1281 return 1;
1282
1283 /* If the mangled name of this method doesn't indicate that it
1284 is a constructor, we're not interested.
1285
1286 FIXME drow/2007-09-23: We could do this using the name of
1287 the method and the name of the class instead of dealing
1288 with the mangled name. We don't have a convenient function
1289 to strip off both leading scope qualifiers and trailing
1290 template arguments yet. */
1291 if (!is_constructor_name (TYPE_FN_FIELD_PHYSNAME (fn, fieldelem))
1292 && !TYPE_FN_FIELD_CONSTRUCTOR (fn, fieldelem))
1293 continue;
1294
1295 /* If this method takes two arguments, and the second argument is
1296 a reference to this class, then it is a copy constructor. */
1297 if (TYPE_NFIELDS (fieldtype) == 2)
1298 {
1299 struct type *arg_type = TYPE_FIELD_TYPE (fieldtype, 1);
1300
1301 if (TYPE_CODE (arg_type) == TYPE_CODE_REF)
1302 {
1303 struct type *arg_target_type;
1304
1305 arg_target_type = check_typedef (TYPE_TARGET_TYPE (arg_type));
1306 if (class_types_same_p (arg_target_type, type))
1307 return 1;
1308 }
1309 }
1310 }
1311
1312 /* Even if all the constructors and destructors were artificial, one
1313 of them may have invoked a non-artificial constructor or
1314 destructor in a base class. If any base class needs to be passed
1315 by reference, so does this class. Similarly for members, which
1316 are constructed whenever this class is. We do not need to worry
1317 about recursive loops here, since we are only looking at members
1318 of complete class type. Also ignore any static members. */
1319 for (fieldnum = 0; fieldnum < TYPE_NFIELDS (type); fieldnum++)
1320 if (! field_is_static (&TYPE_FIELD (type, fieldnum))
1321 && gnuv3_pass_by_reference (TYPE_FIELD_TYPE (type, fieldnum)))
1322 return 1;
1323
1324 return 0;
1325 }
1326
1327 static void
1328 init_gnuv3_ops (void)
1329 {
1330 vtable_type_gdbarch_data
1331 = gdbarch_data_register_post_init (build_gdb_vtable_type);
1332 std_type_info_gdbarch_data
1333 = gdbarch_data_register_post_init (build_std_type_info_type);
1334
1335 gnu_v3_abi_ops.shortname = "gnu-v3";
1336 gnu_v3_abi_ops.longname = "GNU G++ Version 3 ABI";
1337 gnu_v3_abi_ops.doc = "G++ Version 3 ABI";
1338 gnu_v3_abi_ops.is_destructor_name =
1339 (enum dtor_kinds (*) (const char *))is_gnu_v3_mangled_dtor;
1340 gnu_v3_abi_ops.is_constructor_name =
1341 (enum ctor_kinds (*) (const char *))is_gnu_v3_mangled_ctor;
1342 gnu_v3_abi_ops.is_vtable_name = gnuv3_is_vtable_name;
1343 gnu_v3_abi_ops.is_operator_name = gnuv3_is_operator_name;
1344 gnu_v3_abi_ops.rtti_type = gnuv3_rtti_type;
1345 gnu_v3_abi_ops.virtual_fn_field = gnuv3_virtual_fn_field;
1346 gnu_v3_abi_ops.baseclass_offset = gnuv3_baseclass_offset;
1347 gnu_v3_abi_ops.print_method_ptr = gnuv3_print_method_ptr;
1348 gnu_v3_abi_ops.method_ptr_size = gnuv3_method_ptr_size;
1349 gnu_v3_abi_ops.make_method_ptr = gnuv3_make_method_ptr;
1350 gnu_v3_abi_ops.method_ptr_to_value = gnuv3_method_ptr_to_value;
1351 gnu_v3_abi_ops.print_vtable = gnuv3_print_vtable;
1352 gnu_v3_abi_ops.get_typeid = gnuv3_get_typeid;
1353 gnu_v3_abi_ops.get_typeid_type = gnuv3_get_typeid_type;
1354 gnu_v3_abi_ops.get_type_from_type_info = gnuv3_get_type_from_type_info;
1355 gnu_v3_abi_ops.get_typename_from_type_info
1356 = gnuv3_get_typename_from_type_info;
1357 gnu_v3_abi_ops.skip_trampoline = gnuv3_skip_trampoline;
1358 gnu_v3_abi_ops.pass_by_reference = gnuv3_pass_by_reference;
1359 }
1360
1361 void
1362 _initialize_gnu_v3_abi (void)
1363 {
1364 init_gnuv3_ops ();
1365
1366 register_cp_abi (&gnu_v3_abi_ops);
1367 set_cp_abi_as_auto_default (gnu_v3_abi_ops.shortname);
1368 }
gdbarch
Definition: gdbarch.c:127
string
const char * string
Definition: signals.c:50
gnuv3_rtti_type
static struct type * gnuv3_rtti_type(struct value *value, int *full_p, LONGEST *top_p, int *using_enc_p)
Definition: gnu-v3-abi.c:289
compare_value_and_voffset
static bool compare_value_and_voffset(const struct value_and_voffset *va, const struct value_and_voffset *vb)
Definition: gnu-v3-abi.c:796
demangle
int demangle
Definition: demangle.c:47
lookup_array_range_type
struct type * lookup_array_range_type(struct type *element_type, LONGEST low_bound, LONGEST high_bound)
Definition: gdbtypes.c:1232
value_and_voffset::max_voffset
int max_voffset
Definition: gnu-v3-abi.c:768
cp_abi_ops::doc
const char * doc
Definition: cp-abi.h:218
extract_typed_address
CORE_ADDR extract_typed_address(const gdb_byte *buf, struct type *type)
Definition: findvar.c:154
arch_type
struct type * arch_type(struct gdbarch *gdbarch, enum type_code code, int bit, const char *name)
Definition: gdbtypes.c:4941
value_addr
struct value * value_addr(struct value *arg1)
Definition: valops.c:1462
vtable_field_type_info
Definition: gnu-v3-abi.c:97
std_type_info_gdbarch_data
static struct gdbarch_data * std_type_info_gdbarch_data
Definition: gnu-v3-abi.c:37
cp_abi_ops::is_vtable_name
int(* is_vtable_name)(const char *name)
Definition: cp-abi.h:224
gnuv3_baseclass_offset
static int gnuv3_baseclass_offset(struct type *type, int index, const bfd_byte *valaddr, LONGEST embedded_offset, CORE_ADDR address, const struct value *val)
Definition: gnu-v3-abi.c:442
builtin_type::builtin_func_ptr
struct type * builtin_func_ptr
Definition: gdbtypes.h:1565
compute_vtable_size
static void compute_vtable_size(htab_t offset_hash, std::vector< value_and_voffset *> *offset_vec, struct value *value)
Definition: gnu-v3-abi.c:814
vtable_field_virtual_functions
Definition: gnu-v3-abi.c:98
value_subscript
struct value * value_subscript(struct value *array, LONGEST index)
Definition: valarith.c:142
MSYMBOL_LINKAGE_NAME
#define MSYMBOL_LINKAGE_NAME(symbol)
Definition: symtab.h:707
CORE_ADDR
bfd_vma CORE_ADDR
Definition: common-types.h:41
TYPEINFO_PREFIX
#define TYPEINFO_PREFIX
TYPE_N_BASECLASSES
#define TYPE_N_BASECLASSES(thistype)
Definition: gdbtypes.h:1331
expression_up
gdb::unique_xmalloc_ptr< expression > expression_up
Definition: expression.h:87
xfree
void xfree(void *)
gnuv3_pass_by_reference
static int gnuv3_pass_by_reference(struct type *type)
Definition: gnu-v3-abi.c:1250
gnuv3_decode_method_ptr
static int gnuv3_decode_method_ptr(struct gdbarch *gdbarch, const gdb_byte *contents, CORE_ADDR *value_p, LONGEST *adjustment_p)
Definition: gnu-v3-abi.c:537
TYPE_NFN_FIELDS
#define TYPE_NFN_FIELDS(thistype)
Definition: gdbtypes.h:1311
value::embedded_offset
LONGEST embedded_offset
Definition: value.c:309
value_as_long
LONGEST value_as_long(struct value *val)
Definition: value.c:2749
BMSYMBOL_VALUE_ADDRESS
#define BMSYMBOL_VALUE_ADDRESS(symbol)
Definition: symtab.h:691
warning
void warning(const char *fmt,...)
Definition: errors.c:26
value_embedded_offset
LONGEST value_embedded_offset(const struct value *value)
Definition: value.c:1477
INIT_CPLUS_SPECIFIC
#define INIT_CPLUS_SPECIFIC(type)
Definition: gdbtypes.h:1192
gdbarch_ptr_bit
int gdbarch_ptr_bit(struct gdbarch *gdbarch)
Definition: gdbarch.c:1831
value_enclosing_type
struct type * value_enclosing_type(const struct value *value)
Definition: value.c:1175
value_at
struct value * value_at(struct type *type, CORE_ADDR addr)
Definition: valops.c:933
value_and_voffset
Definition: gnu-v3-abi.c:761
type_print_raw_options
const struct type_print_options type_print_raw_options
Definition: typeprint.c:40
builtin_type
const struct builtin_type * builtin_type(struct gdbarch *gdbarch)
Definition: gdbtypes.c:5217
RETURN_MASK_ERROR
Definition: common-exceptions.h:43
gnuv3_dynamic_class
static int gnuv3_dynamic_class(struct type *type)
Definition: gnu-v3-abi.c:203
gnuv3_get_typename_from_type_info
static std::string gnuv3_get_typename_from_type_info(struct value *type_info_ptr)
Definition: gnu-v3-abi.c:1132
BASETYPE_VIA_VIRTUAL
#define BASETYPE_VIA_VIRTUAL(thistype, index)
Definition: gdbtypes.h:1338
set_cp_abi_as_auto_default
void set_cp_abi_as_auto_default(const char *short_name)
Definition: cp-abi.c:265
init_gnuv3_ops
static void init_gnuv3_ops(void)
Definition: gnu-v3-abi.c:1328
coerce_ref
struct value * coerce_ref(struct value *arg)
Definition: value.c:3755
make_pointer_type
struct type * make_pointer_type(struct type *type, struct type **typeptr)
Definition: gdbtypes.c:319
fn_field::voffset
unsigned int voffset
Definition: gdbtypes.h:883
value_ind
struct value * value_ind(struct value *arg1)
Definition: valops.c:1542
frame_info
Definition: frame.c:85
cp-support.h
cp_abi_ops::method_ptr_size
int(* method_ptr_size)(struct type *)
Definition: cp-abi.h:238
cp_abi_ops::is_constructor_name
enum ctor_kinds(* is_constructor_name)(const char *name)
Definition: cp-abi.h:222
lookup_symbol
struct block_symbol lookup_symbol(const char *name, const struct block *block, domain_enum domain, struct field_of_this_result *is_a_field_of_this)
Definition: symtab.c:1893
STRUCT_DOMAIN
Definition: symtab.h:745
_
#define _(String)
Definition: gdb_locale.h:35
cp_abi_ops::print_vtable
void(* print_vtable)(struct value *)
Definition: cp-abi.h:243
MSYMBOL_DEMANGLED_NAME
#define MSYMBOL_DEMANGLED_NAME(symbol)
Definition: symtab.h:710
ui_file
Definition: ui-file.h:26
vtable_type_gdbarch_data
static struct gdbarch_data * vtable_type_gdbarch_data
Definition: gnu-v3-abi.c:90
SET_FIELD_BITPOS
#define SET_FIELD_BITPOS(thisfld, bitpos)
Definition: gdbtypes.h:1352
defs.h
TYPE_FIELD
#define TYPE_FIELD(thistype, n)
Definition: gdbtypes.h:1370
builtin_type
Definition: gdbtypes.h:1495
fn_field
Definition: gdbtypes.h:832
gdbarch_vtable_function_descriptors
int gdbarch_vtable_function_descriptors(struct gdbarch *gdbarch)
Definition: gdbarch.c:3847
END_CATCH
#define END_CATCH
Definition: common-exceptions.h:259
TYPE_FIELD_TYPE
#define TYPE_FIELD_TYPE(thistype, n)
Definition: gdbtypes.h:1371
cp_abi_ops::is_destructor_name
enum dtor_kinds(* is_destructor_name)(const char *name)
Definition: cp-abi.h:223
printf_filtered
void printf_filtered(const char *format,...)
Definition: utils.c:2045
paddress
const char * paddress(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition: utils.c:2745
objfiles.h
offset_type
uint32_t offset_type
Definition: dwarf2read.c:164
arch_integer_type
struct type * arch_integer_type(struct gdbarch *gdbarch, int bit, int unsigned_p, const char *name)
Definition: gdbtypes.c:4962
value_lval_const
enum lval_type value_lval_const(const struct value *value)
Definition: value.c:1523
XNEW
#define XNEW(T)
Definition: poison.h:109
vtable_field_vcall_and_vbase_offsets
Definition: gnu-v3-abi.c:95
XCNEWVEC
#define XCNEWVEC(T, N)
Definition: poison.h:157
TRY
#define TRY
Definition: common-exceptions.h:246
value_ptradd
struct value * value_ptradd(struct value *arg1, LONGEST arg2)
Definition: valarith.c:80
gdbarch_vbit_in_delta
int gdbarch_vbit_in_delta(struct gdbarch *gdbarch)
Definition: gdbarch.c:3864
lval_memory
Definition: defs.h:383
name
const char *const name
Definition: aarch64-tdep.c:76
cp_abi_ops::method_ptr_to_value
struct value *(* method_ptr_to_value)(struct value **, struct value *)
Definition: cp-abi.h:241
gdb_demangle
char * gdb_demangle(const char *name, int options)
Definition: cp-support.c:1518
dtor_kinds
dtor_kinds
Definition: cp-abi.h:61
TYPE_FN_FIELD_PHYSNAME
#define TYPE_FN_FIELD_PHYSNAME(thisfn, n)
Definition: gdbtypes.h:1426
cp_abi_ops
Definition: cp-abi.h:214
check_typedef
struct type * check_typedef(struct type *type)
Definition: gdbtypes.c:2421
TYPE_FN_FIELD_VIRTUAL_P
#define TYPE_FN_FIELD_VIRTUAL_P(thisfn, n)
Definition: gdbtypes.h:1438
value_contents
const gdb_byte * value_contents(struct value *value)
Definition: value.c:1407
CATCH
#define CATCH(EXCEPTION, MASK)
Definition: common-exceptions.h:254
value_field
struct value * value_field(struct value *arg1, int fieldno)
Definition: value.c:3152
gnuv3_find_method_in
static const char * gnuv3_find_method_in(struct type *domain, CORE_ADDR voffset, LONGEST adjustment)
Definition: gnu-v3-abi.c:487
value_print_options
Definition: valprint.h:25
gnuv3_make_method_ptr
static void gnuv3_make_method_ptr(struct type *type, gdb_byte *contents, CORE_ADDR value, int is_virtual)
Definition: gnu-v3-abi.c:674
cp_lookup_rtti_type
struct type * cp_lookup_rtti_type(const char *name, struct block *block)
Definition: cp-support.c:1440
current_target
struct target_ops current_target
TYPE_FN_FIELD_ARTIFICIAL
#define TYPE_FN_FIELD_ARTIFICIAL(thisfn, n)
Definition: gdbtypes.h:1433
field_is_static
int field_is_static(struct field *f)
Definition: gdbtypes.c:4224
register_cp_abi
int register_cp_abi(struct cp_abi_ops *abi)
Definition: cp-abi.c:250
fprintf_filtered
void fprintf_filtered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2008
gnuv3_method_ptr_to_value
static struct value * gnuv3_method_ptr_to_value(struct value **this_p, struct value *method_ptr)
Definition: gnu-v3-abi.c:705
is_constructor_name
enum ctor_kinds is_constructor_name(const char *name)
Definition: cp-abi.c:36
cp_abi_ops::get_type_from_type_info
struct type *(* get_type_from_type_info)(struct value *value)
Definition: cp-abi.h:246
cp_abi_ops::get_typeid
struct value *(* get_typeid)(struct value *value)
Definition: cp-abi.h:244
print_one_vtable
static void print_one_vtable(struct gdbarch *gdbarch, struct value *value, int max_voffset, struct value_print_options *opts)
Definition: gnu-v3-abi.c:871
bound_minimal_symbol
Definition: minsyms.h:29
htab_up
std::unique_ptr< htab, htab_deleter > htab_up
Definition: utils.h:266
gnuv3_skip_trampoline
static CORE_ADDR gnuv3_skip_trampoline(struct frame_info *frame, CORE_ADDR stop_pc)
Definition: gnu-v3-abi.c:1182
gnuv3_is_operator_name
static int gnuv3_is_operator_name(const char *name)
Definition: gnu-v3-abi.c:47
gdbarch_convert_from_func_ptr_addr
CORE_ADDR gdbarch_convert_from_func_ptr_addr(struct gdbarch *gdbarch, CORE_ADDR addr, struct target_ops *targ)
Definition: gdbarch.c:3191
fputs_filtered
void fputs_filtered(const char *linebuffer, struct ui_file *stream)
Definition: utils.c:1811
ALLOCATE_CPLUS_STRUCT_TYPE
#define ALLOCATE_CPLUS_STRUCT_TYPE(type)
Definition: gdbtypes.h:1197
build_std_type_info_type
static void * build_std_type_info_type(struct gdbarch *arch)
Definition: gnu-v3-abi.c:995
vtable_address_point_offset
static int vtable_address_point_offset(struct gdbarch *gdbarch)
Definition: gnu-v3-abi.c:189
gdbarch_byte_order
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition: gdbarch.c:1509
TYPE_CODE_UNION
Definition: gdbtypes.h:107
TARGET_CHAR_BIT
#define TARGET_CHAR_BIT
Definition: host-defs.h:29
type
Definition: gdbtypes.h:749
cp_abi_ops::baseclass_offset
int(* baseclass_offset)(struct type *type, int index, const bfd_byte *valaddr, LONGEST embedded_offset, CORE_ADDR address, const struct value *val)
Definition: cp-abi.h:232
TYPE_CPLUS_DYNAMIC
#define TYPE_CPLUS_DYNAMIC(thistype)
Definition: gdbtypes.h:1336
get_type_arch
struct gdbarch * get_type_arch(const struct type *type)
Definition: gdbtypes.c:234
cp_abi_ops::longname
const char * longname
Definition: cp-abi.h:217
type
static const char * type
Definition: language.c:113
field
Definition: gdbtypes.h:517
startswith
static int startswith(const char *string, const char *pattern)
Definition: common-utils.h:107
value_at_lazy
struct value * value_at_lazy(struct type *type, CORE_ADDR addr)
Definition: valops.c:944
value_cast
struct value * value_cast(struct type *type, struct value *arg2)
Definition: valops.c:351
TYPEINFO_PREFIX_LEN
#define TYPEINFO_PREFIX_LEN
hash_value_and_voffset
static hashval_t hash_value_and_voffset(const void *p)
Definition: gnu-v3-abi.c:774
class_types_same_p
int class_types_same_p(const struct type *a, const struct type *b)
Definition: gdbtypes.c:3125
vtable_ptrdiff_type
static struct type * vtable_ptrdiff_type(struct gdbarch *gdbarch)
Definition: gnu-v3-abi.c:176
TYPE_FIELDS
#define TYPE_FIELDS(thistype)
Definition: gdbtypes.h:1240
find_pc_section
struct obj_section * find_pc_section(CORE_ADDR pc)
Definition: objfiles.c:1395
TYPE_CODE_STRUCT
Definition: gdbtypes.h:106
value_full_object
struct value * value_full_object(struct value *argp, struct type *rtype, int xfull, int xtop, int xusing_enc)
Definition: valops.c:3662
TYPE_CODE_REF
Definition: gdbtypes.h:156
TYPE_FIELD_BITPOS
#define TYPE_FIELD_BITPOS(thistype, n)
Definition: gdbtypes.h:1374
block_symbol::symbol
struct symbol * symbol
Definition: symtab.h:1136
cp_abi_ops::print_method_ptr
void(* print_method_ptr)(const gdb_byte *contents, struct type *type, struct ui_file *stream)
Definition: cp-abi.h:235
eq_value_and_voffset
static int eq_value_and_voffset(const void *a, const void *b)
Definition: gnu-v3-abi.c:784
gdb_assert
#define gdb_assert(expr)
Definition: gdb_assert.h:32
value
Definition: value.c:169
TYPE_INSTANCE_FLAG_CODE_SPACE
Definition: gdbtypes.h:191
CP_OPERATOR_STR
#define CP_OPERATOR_STR
Definition: cp-support.h:51
TYPE_FN_FIELD_VOFFSET
#define TYPE_FN_FIELD_VOFFSET(thisfn, n)
Definition: gdbtypes.h:1437
gnuv3_get_typeid
static struct value * gnuv3_get_typeid(struct value *value)
Definition: gnu-v3-abi.c:1058
gnuv3_get_virtual_fn
static struct value * gnuv3_get_virtual_fn(struct gdbarch *gdbarch, struct value *container, struct type *fntype, int vtable_index)
Definition: gnu-v3-abi.c:377
TYPE_CODE_PTR
Definition: gdbtypes.h:84
obj_section
Definition: objfiles.h:123
gdb_byte
bfd_byte gdb_byte
Definition: common-types.h:38
gnuv3_print_vtable
static void gnuv3_print_vtable(struct value *value)
Definition: gnu-v3-abi.c:928
TYPE_FN_FIELD_TYPE
#define TYPE_FN_FIELD_TYPE(thisfn, n)
Definition: gdbtypes.h:1427
cp_abi_ops::is_operator_name
int(* is_operator_name)(const char *name)
Definition: cp-abi.h:225
value_from_pointer
struct value * value_from_pointer(struct type *type, CORE_ADDR addr)
Definition: value.c:3560
gnuv3_method_ptr_size
static int gnuv3_method_ptr_size(struct type *type)
Definition: gnu-v3-abi.c:664
make_cv_type
struct type * make_cv_type(int cnst, int voltl, struct type *type, struct type **typeptr)
Definition: gdbtypes.c:691
builtin_type::builtin_char
struct type * builtin_char
Definition: gdbtypes.h:1501
TYPE_TARGET_TYPE
#define TYPE_TARGET_TYPE(thistype)
Definition: gdbtypes.h:1226
print_longest
void print_longest(struct ui_file *stream, int format, int use_c_format, LONGEST val_long)
Definition: valprint.c:1303
lookup_minimal_symbol_by_pc
struct bound_minimal_symbol lookup_minimal_symbol_by_pc(CORE_ADDR pc)
Definition: minsyms.c:928
TYPE_CODE
#define TYPE_CODE(thistype)
Definition: gdbtypes.h:1238
cp_abi_ops::rtti_type
struct type *(* rtti_type)(struct value *v, int *full, LONGEST *top, int *using_enc)
Definition: cp-abi.h:230
gnuv3_virtual_fn_field
static struct value * gnuv3_virtual_fn_field(struct value **value_p, struct fn_field *f, int j, struct type *vfn_base, int offset)
Definition: gnu-v3-abi.c:409
c-lang.h
builtin_type::builtin_data_ptr
struct type * builtin_data_ptr
Definition: gdbtypes.h:1554
bound_minimal_symbol::minsym
struct minimal_symbol * minsym
Definition: minsyms.h:34
ctor_kinds
ctor_kinds
Definition: cp-abi.h:40
c_print_type
void c_print_type(struct type *, const char *, struct ui_file *, int, int, const struct type_print_options *)
Definition: c-typeprint.c:164
get_user_print_options
void get_user_print_options(struct value_print_options *opts)
Definition: valprint.c:120
offset
int offset
Definition: agent.c:65
obj_section::objfile
struct objfile * objfile
Definition: objfiles.h:129
TYPE_NFIELDS
#define TYPE_NFIELDS(thistype)
Definition: gdbtypes.h:1239
cp_abi_ops::get_typename_from_type_info
std::string(* get_typename_from_type_info)(struct value *value)
Definition: cp-abi.h:247
make_type_with_address_space
struct type * make_type_with_address_space(struct type *type, int space_flag)
Definition: gdbtypes.c:667
stop_pc
CORE_ADDR stop_pc
Definition: infcmd.c:98
cp_abi_ops::shortname
const char * shortname
Definition: cp-abi.h:216
cp_canonicalize_string
std::string cp_canonicalize_string(const char *string)
Definition: cp-support.c:552
print_address_demangle
int print_address_demangle(const struct value_print_options *opts, struct gdbarch *gdbarch, CORE_ADDR addr, struct ui_file *stream, int do_demangle)
Definition: printcmd.c:736
extract_signed_integer
static LONGEST extract_signed_integer(const gdb_byte *addr, int len, enum bfd_endian byte_order)
Definition: defs.h:570
value.h
check_stub_method_group
void check_stub_method_group(struct type *type, int method_id)
Definition: gdbtypes.c:2740
TYPE_TAG_NAME
#define TYPE_TAG_NAME(type)
Definition: gdbtypes.h:1225
cp_abi_ops::pass_by_reference
int(* pass_by_reference)(struct type *type)
Definition: cp-abi.h:249
gnu_v3_abi_ops
static struct cp_abi_ops gnu_v3_abi_ops
Definition: gnu-v3-abi.c:32
FIELD_NAME
#define FIELD_NAME(thisfld)
Definition: gdbtypes.h:1343
typeprint.h
parse_expression
expression_up parse_expression(const char *)
Definition: parse.c:1237
value_type
struct type * value_type(const struct value *value)
Definition: value.c:1095
gnuv3_get_type_from_type_info
static struct type * gnuv3_get_type_from_type_info(struct value *type_info_ptr)
Definition: gnu-v3-abi.c:1166
SYMBOL_TYPE
#define SYMBOL_TYPE(symbol)
Definition: symtab.h:1161
cp_abi_ops::make_method_ptr
void(* make_method_ptr)(struct type *, gdb_byte *, CORE_ADDR, int)
Definition: cp-abi.h:239
symbol
Definition: symtab.h:1049
gdbarch_skip_trampoline_code
CORE_ADDR gdbarch_skip_trampoline_code(struct gdbarch *gdbarch, struct frame_info *frame, CORE_ADDR pc)
Definition: gdbarch.c:3306
build_gdb_vtable_type
static void * build_gdb_vtable_type(struct gdbarch *arch)
Definition: gnu-v3-abi.c:108
value_as_address
CORE_ADDR value_as_address(struct value *val)
Definition: value.c:2762
evaluate_type
struct value * evaluate_type(struct expression *exp)
Definition: eval.c:155
TYPE_FN_FIELDLIST_NAME
#define TYPE_FN_FIELDLIST_NAME(thistype, n)
Definition: gdbtypes.h:1415
TYPE_LENGTH
#define TYPE_LENGTH(thistype)
Definition: gdbtypes.h:1235
minimal_symbol
Definition: symtab.h:623
TYPE_BASECLASS_BITPOS
#define TYPE_BASECLASS_BITPOS(thistype, index)
Definition: gdbtypes.h:1333
gnuv3_is_vtable_name
static int gnuv3_is_vtable_name(const char *name)
Definition: gnu-v3-abi.c:41
value::address
CORE_ADDR address
Definition: value.c:208
type_to_string
std::string type_to_string(struct type *type)
Definition: typeprint.c:368
print_function_pointer_address
void print_function_pointer_address(const struct value_print_options *options, struct gdbarch *gdbarch, CORE_ADDR address, struct ui_file *stream)
Definition: valprint.c:1884
TYPE_FN_FIELDLIST_LENGTH
#define TYPE_FN_FIELDLIST_LENGTH(thistype, n)
Definition: gdbtypes.h:1416
gnuv3_get_vtable
static struct value * gnuv3_get_vtable(struct gdbarch *gdbarch, struct type *container_type, CORE_ADDR container_addr)
Definition: gnu-v3-abi.c:249
TYPE_FN_FIELD_CONSTRUCTOR
#define TYPE_FN_FIELD_CONSTRUCTOR(thisfn, n)
Definition: gdbtypes.h:1435
valprint.h
value_address
CORE_ADDR value_address(const struct value *value)
Definition: value.c:1529
gdbarch_data
Definition: gdbarch.c:5084
vtable_field_offset_to_top
Definition: gnu-v3-abi.c:96
lookup_minimal_symbol
struct bound_minimal_symbol lookup_minimal_symbol(const char *name, const char *sfile, struct objfile *objf)
Definition: minsyms.c:311
xcalloc
PTR xcalloc(size_t number, size_t size)
Definition: common-utils.c:72
gdbarch::byte_order
enum bfd_endian byte_order
Definition: gdbarch.c:137
value_print_options::objectprint
int objectprint
Definition: valprint.h:47
value_and_voffset::value
struct value * value
Definition: gnu-v3-abi.c:764
TYPE_SELF_TYPE
#define TYPE_SELF_TYPE(thistype)
Definition: gdbtypes.h:1299
error
void error(const char *fmt,...)
Definition: errors.c:38
gnuv3_get_typeid_type
static struct type * gnuv3_get_typeid_type(struct gdbarch *gdbarch)
Definition: gnu-v3-abi.c:1039
size
size_t size
Definition: go32-nat.c:242
gdbarch_data_register_post_init
struct gdbarch_data * gdbarch_data_register_post_init(gdbarch_data_post_init_ftype *post_init)
Definition: gdbarch.c:5136
lookup_pointer_type
struct type * lookup_pointer_type(struct type *type)
Definition: gdbtypes.c:381
get_frame_arch
struct gdbarch * get_frame_arch(struct frame_info *this_frame)
Definition: frame.c:2691
TYPE_FN_FIELDLIST1
#define TYPE_FN_FIELDLIST1(thistype, n)
Definition: gdbtypes.h:1414
LONGEST
long long LONGEST
Definition: common-types.h:52
cp-abi.h
cp_abi_ops::virtual_fn_field
struct value *(* virtual_fn_field)(struct value **arg1p, struct fn_field *f, int j, struct type *type, int offset)
Definition: cp-abi.h:226
cp_abi_ops::skip_trampoline
CORE_ADDR(* skip_trampoline)(struct frame_info *, CORE_ADDR)
Definition: cp-abi.h:248
FIELD_TYPE
#define FIELD_TYPE(thisfld)
Definition: gdbtypes.h:1342
cp_abi_ops::get_typeid_type
struct type *(* get_typeid_type)(struct gdbarch *gdbarch)
Definition: cp-abi.h:245
TYPE_SAFE_NAME
#define TYPE_SAFE_NAME(type)
Definition: gdbtypes.h:1483
store_unsigned_integer
static void store_unsigned_integer(gdb_byte *addr, int len, enum bfd_endian byte_order, ULONGEST val)
Definition: defs.h:604
gdb_stdout
#define gdb_stdout
Definition: utils.h:340
gnuv3_print_method_ptr
static void gnuv3_print_method_ptr(const gdb_byte *contents, struct type *type, struct ui_file *stream)
Definition: gnu-v3-abi.c:581
_initialize_gnu_v3_abi
void _initialize_gnu_v3_abi(void)
Definition: gnu-v3-abi.c:1362