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