gdb/gnu-v3-abi.c

   1 /* Abstraction of GNU v3 abi.
   2    Contributed by Jim Blandy <jimb@redhat.com>
   3
   4    Copyright (C) 2001-2019 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_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 dynamic class objects.  */
 303   if (TYPE_CODE (values_type) != TYPE_CODE_STRUCT
 304       || !gnuv3_dynamic_class (values_type))
 305     return NULL;
 306
 307   /* Determine architecture.  */
 308   gdbarch = get_type_arch (values_type);
 309
 310   if (using_enc_p)
 311     *using_enc_p = 0;
 312
 313   vtable = gnuv3_get_vtable (gdbarch, values_type,
 314                              value_as_address (value_addr (value)));
 315   if (vtable == NULL)
 316     return NULL;
 317
 318   /* Find the linker symbol for this vtable.  */
 319   vtable_symbol
 320     = lookup_minimal_symbol_by_pc (value_address (vtable)
 321                                    + value_embedded_offset (vtable)).minsym;
 322   if (! vtable_symbol)
 323     return NULL;
 324
 325   /* The symbol's demangled name should be something like "vtable for
 326      CLASS", where CLASS is the name of the run-time type of VALUE.
 327      If we didn't like this approach, we could instead look in the
 328      type_info object itself to get the class name.  But this way
 329      should work just as well, and doesn't read target memory.  */
 330   vtable_symbol_name = MSYMBOL_DEMANGLED_NAME (vtable_symbol);
 331   if (vtable_symbol_name == NULL
 332       || !startswith (vtable_symbol_name, "vtable for "))
 333     {
 334       warning (_("can't find linker symbol for virtual table for `%s' value"),
 335                TYPE_SAFE_NAME (values_type));
 336       if (vtable_symbol_name)
 337         warning (_("  found `%s' instead"), vtable_symbol_name);
 338       return NULL;
 339     }
 340   class_name = vtable_symbol_name + 11;
 341
 342   /* Strip off @plt and version suffixes.  */
 343   atsign = strchr (class_name, '@');
 344   if (atsign != NULL)
 345     {
 346       char *copy;
 347
 348       copy = (char *) alloca (atsign - class_name + 1);
 349       memcpy (copy, class_name, atsign - class_name);
 350       copy[atsign - class_name] = '\0';
 351       class_name = copy;
 352     }
 353
 354   /* Try to look up the class name as a type name.  */
 355   /* FIXME: chastain/2003-11-26: block=NULL is bogus.  See pr gdb/1465.  */
 356   run_time_type = cp_lookup_rtti_type (class_name, NULL);
 357   if (run_time_type == NULL)
 358     return NULL;
 359
 360   /* Get the offset from VALUE to the top of the complete object.
 361      NOTE: this is the reverse of the meaning of *TOP_P.  */
 362   offset_to_top
 363     = value_as_long (value_field (vtable, vtable_field_offset_to_top));
 364
 365   if (full_p)
 366     *full_p = (- offset_to_top == value_embedded_offset (value)
 367                && (TYPE_LENGTH (value_enclosing_type (value))
 368                    >= TYPE_LENGTH (run_time_type)));
 369   if (top_p)
 370     *top_p = - offset_to_top;
 371   return run_time_type;
 372 }
 373
 374 /* Return a function pointer for CONTAINER's VTABLE_INDEX'th virtual
 375    function, of type FNTYPE.  */
 376
 377 static struct value *
 378 gnuv3_get_virtual_fn (struct gdbarch *gdbarch, struct value *container,
 379                       struct type *fntype, int vtable_index)
 380 {
 381   struct value *vtable, *vfn;
 382
 383   /* Every class with virtual functions must have a vtable.  */
 384   vtable = gnuv3_get_vtable (gdbarch, value_type (container),
 385                              value_as_address (value_addr (container)));
 386   gdb_assert (vtable != NULL);
 387
 388   /* Fetch the appropriate function pointer from the vtable.  */
 389   vfn = value_subscript (value_field (vtable, vtable_field_virtual_functions),
 390                          vtable_index);
 391
 392   /* If this architecture uses function descriptors directly in the vtable,
 393      then the address of the vtable entry is actually a "function pointer"
 394      (i.e. points to the descriptor).  We don't need to scale the index
 395      by the size of a function descriptor; GCC does that before outputing
 396      debug information.  */
 397   if (gdbarch_vtable_function_descriptors (gdbarch))
 398     vfn = value_addr (vfn);
 399
 400   /* Cast the function pointer to the appropriate type.  */
 401   vfn = value_cast (lookup_pointer_type (fntype), vfn);
 402
 403   return vfn;
 404 }
 405
 406 /* GNU v3 implementation of value_virtual_fn_field.  See cp-abi.h
 407    for a description of the arguments.  */
 408
 409 static struct value *
 410 gnuv3_virtual_fn_field (struct value **value_p,
 411                         struct fn_field *f, int j,
 412                         struct type *vfn_base, int offset)
 413 {
 414   struct type *values_type = check_typedef (value_type (*value_p));
 415   struct gdbarch *gdbarch;
 416
 417   /* Some simple sanity checks.  */
 418   if (TYPE_CODE (values_type) != TYPE_CODE_STRUCT)
 419     error (_("Only classes can have virtual functions."));
 420
 421   /* Determine architecture.  */
 422   gdbarch = get_type_arch (values_type);
 423
 424   /* Cast our value to the base class which defines this virtual
 425      function.  This takes care of any necessary `this'
 426      adjustments.  */
 427   if (vfn_base != values_type)
 428     *value_p = value_cast (vfn_base, *value_p);
 429
 430   return gnuv3_get_virtual_fn (gdbarch, *value_p, TYPE_FN_FIELD_TYPE (f, j),
 431                                TYPE_FN_FIELD_VOFFSET (f, j));
 432 }
 433
 434 /* Compute the offset of the baseclass which is
 435    the INDEXth baseclass of class TYPE,
 436    for value at VALADDR (in host) at ADDRESS (in target).
 437    The result is the offset of the baseclass value relative
 438    to (the address of)(ARG) + OFFSET.
 439
 440    -1 is returned on error.  */
 441
 442 static int
 443 gnuv3_baseclass_offset (struct type *type, int index,
 444                         const bfd_byte *valaddr, LONGEST embedded_offset,
 445                         CORE_ADDR address, const struct value *val)
 446 {
 447   struct gdbarch *gdbarch;
 448   struct type *ptr_type;
 449   struct value *vtable;
 450   struct value *vbase_array;
 451   long int cur_base_offset, base_offset;
 452
 453   /* Determine architecture.  */
 454   gdbarch = get_type_arch (type);
 455   ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
 456
 457   /* If it isn't a virtual base, this is easy.  The offset is in the
 458      type definition.  */
 459   if (!BASETYPE_VIA_VIRTUAL (type, index))
 460     return TYPE_BASECLASS_BITPOS (type, index) / 8;
 461
 462   /* To access a virtual base, we need to use the vbase offset stored in
 463      our vtable.  Recent GCC versions provide this information.  If it isn't
 464      available, we could get what we needed from RTTI, or from drawing the
 465      complete inheritance graph based on the debug info.  Neither is
 466      worthwhile.  */
 467   cur_base_offset = TYPE_BASECLASS_BITPOS (type, index) / 8;
 468   if (cur_base_offset >= - vtable_address_point_offset (gdbarch))
 469     error (_("Expected a negative vbase offset (old compiler?)"));
 470
 471   cur_base_offset = cur_base_offset + vtable_address_point_offset (gdbarch);
 472   if ((- cur_base_offset) % TYPE_LENGTH (ptr_type) != 0)
 473     error (_("Misaligned vbase offset."));
 474   cur_base_offset = cur_base_offset / ((int) TYPE_LENGTH (ptr_type));
 475
 476   vtable = gnuv3_get_vtable (gdbarch, type, address + embedded_offset);
 477   gdb_assert (vtable != NULL);
 478   vbase_array = value_field (vtable, vtable_field_vcall_and_vbase_offsets);
 479   base_offset = value_as_long (value_subscript (vbase_array, cur_base_offset));
 480   return base_offset;
 481 }
 482
 483 /* Locate a virtual method in DOMAIN or its non-virtual base classes
 484    which has virtual table index VOFFSET.  The method has an associated
 485    "this" adjustment of ADJUSTMENT bytes.  */
 486
 487 static const char *
 488 gnuv3_find_method_in (struct type *domain, CORE_ADDR voffset,
 489                       LONGEST adjustment)
 490 {
 491   int i;
 492
 493   /* Search this class first.  */
 494   if (adjustment == 0)
 495     {
 496       int len;
 497
 498       len = TYPE_NFN_FIELDS (domain);
 499       for (i = 0; i < len; i++)
 500         {
 501           int len2, j;
 502           struct fn_field *f;
 503
 504           f = TYPE_FN_FIELDLIST1 (domain, i);
 505           len2 = TYPE_FN_FIELDLIST_LENGTH (domain, i);
 506
 507           check_stub_method_group (domain, i);
 508           for (j = 0; j < len2; j++)
 509             if (TYPE_FN_FIELD_VOFFSET (f, j) == voffset)
 510               return TYPE_FN_FIELD_PHYSNAME (f, j);
 511         }
 512     }
 513
 514   /* Next search non-virtual bases.  If it's in a virtual base,
 515      we're out of luck.  */
 516   for (i = 0; i < TYPE_N_BASECLASSES (domain); i++)
 517     {
 518       int pos;
 519       struct type *basetype;
 520
 521       if (BASETYPE_VIA_VIRTUAL (domain, i))
 522         continue;
 523
 524       pos = TYPE_BASECLASS_BITPOS (domain, i) / 8;
 525       basetype = TYPE_FIELD_TYPE (domain, i);
 526       /* Recurse with a modified adjustment.  We don't need to adjust
 527          voffset.  */
 528       if (adjustment >= pos && adjustment < pos + TYPE_LENGTH (basetype))
 529         return gnuv3_find_method_in (basetype, voffset, adjustment - pos);
 530     }
 531
 532   return NULL;
 533 }
 534
 535 /* Decode GNU v3 method pointer.  */
 536
 537 static int
 538 gnuv3_decode_method_ptr (struct gdbarch *gdbarch,
 539                          const gdb_byte *contents,
 540                          CORE_ADDR *value_p,
 541                          LONGEST *adjustment_p)
 542 {
 543   struct type *funcptr_type = builtin_type (gdbarch)->builtin_func_ptr;
 544   struct type *offset_type = vtable_ptrdiff_type (gdbarch);
 545   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 546   CORE_ADDR ptr_value;
 547   LONGEST voffset, adjustment;
 548   int vbit;
 549
 550   /* Extract the pointer to member.  The first element is either a pointer
 551      or a vtable offset.  For pointers, we need to use extract_typed_address
 552      to allow the back-end to convert the pointer to a GDB address -- but
 553      vtable offsets we must handle as integers.  At this point, we do not
 554      yet know which case we have, so we extract the value under both
 555      interpretations and choose the right one later on.  */
 556   ptr_value = extract_typed_address (contents, funcptr_type);
 557   voffset = extract_signed_integer (contents,
 558                                     TYPE_LENGTH (funcptr_type), byte_order);
 559   contents += TYPE_LENGTH (funcptr_type);
 560   adjustment = extract_signed_integer (contents,
 561                                        TYPE_LENGTH (offset_type), byte_order);
 562
 563   if (!gdbarch_vbit_in_delta (gdbarch))
 564     {
 565       vbit = voffset & 1;
 566       voffset = voffset ^ vbit;
 567     }
 568   else
 569     {
 570       vbit = adjustment & 1;
 571       adjustment = adjustment >> 1;
 572     }
 573
 574   *value_p = vbit? voffset : ptr_value;
 575   *adjustment_p = adjustment;
 576   return vbit;
 577 }
 578
 579 /* GNU v3 implementation of cplus_print_method_ptr.  */
 580
 581 static void
 582 gnuv3_print_method_ptr (const gdb_byte *contents,
 583                         struct type *type,
 584                         struct ui_file *stream)
 585 {
 586   struct type *self_type = TYPE_SELF_TYPE (type);
 587   struct gdbarch *gdbarch = get_type_arch (self_type);
 588   CORE_ADDR ptr_value;
 589   LONGEST adjustment;
 590   int vbit;
 591
 592   /* Extract the pointer to member.  */
 593   vbit = gnuv3_decode_method_ptr (gdbarch, contents, &ptr_value, &adjustment);
 594
 595   /* Check for NULL.  */
 596   if (ptr_value == 0 && vbit == 0)
 597     {
 598       fprintf_filtered (stream, "NULL");
 599       return;
 600     }
 601
 602   /* Search for a virtual method.  */
 603   if (vbit)
 604     {
 605       CORE_ADDR voffset;
 606       const char *physname;
 607
 608       /* It's a virtual table offset, maybe in this class.  Search
 609          for a field with the correct vtable offset.  First convert it
 610          to an index, as used in TYPE_FN_FIELD_VOFFSET.  */
 611       voffset = ptr_value / TYPE_LENGTH (vtable_ptrdiff_type (gdbarch));
 612
 613       physname = gnuv3_find_method_in (self_type, voffset, adjustment);
 614
 615       /* If we found a method, print that.  We don't bother to disambiguate
 616          possible paths to the method based on the adjustment.  */
 617       if (physname)
 618         {
 619           char *demangled_name = gdb_demangle (physname,
 620                                                DMGL_ANSI | DMGL_PARAMS);
 621
 622           fprintf_filtered (stream, "&virtual ");
 623           if (demangled_name == NULL)
 624             fputs_filtered (physname, stream);
 625           else
 626             {
 627               fputs_filtered (demangled_name, stream);
 628               xfree (demangled_name);
 629             }
 630           return;
 631         }
 632     }
 633   else if (ptr_value != 0)
 634     {
 635       /* Found a non-virtual function: print out the type.  */
 636       fputs_filtered ("(", stream);
 637       c_print_type (type, "", stream, -1, 0, &type_print_raw_options);
 638       fputs_filtered (") ", stream);
 639     }
 640
 641   /* We didn't find it; print the raw data.  */
 642   if (vbit)
 643     {
 644       fprintf_filtered (stream, "&virtual table offset ");
 645       print_longest (stream, 'd', 1, ptr_value);
 646     }
 647   else
 648     {
 649       struct value_print_options opts;
 650
 651       get_user_print_options (&opts);
 652       print_address_demangle (&opts, gdbarch, ptr_value, stream, demangle);
 653     }
 654
 655   if (adjustment)
 656     {
 657       fprintf_filtered (stream, ", this adjustment ");
 658       print_longest (stream, 'd', 1, adjustment);
 659     }
 660 }
 661
 662 /* GNU v3 implementation of cplus_method_ptr_size.  */
 663
 664 static int
 665 gnuv3_method_ptr_size (struct type *type)
 666 {
 667   struct gdbarch *gdbarch = get_type_arch (type);
 668
 669   return 2 * TYPE_LENGTH (builtin_type (gdbarch)->builtin_data_ptr);
 670 }
 671
 672 /* GNU v3 implementation of cplus_make_method_ptr.  */
 673
 674 static void
 675 gnuv3_make_method_ptr (struct type *type, gdb_byte *contents,
 676                        CORE_ADDR value, int is_virtual)
 677 {
 678   struct gdbarch *gdbarch = get_type_arch (type);
 679   int size = TYPE_LENGTH (builtin_type (gdbarch)->builtin_data_ptr);
 680   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 681
 682   /* FIXME drow/2006-12-24: The adjustment of "this" is currently
 683      always zero, since the method pointer is of the correct type.
 684      But if the method pointer came from a base class, this is
 685      incorrect - it should be the offset to the base.  The best
 686      fix might be to create the pointer to member pointing at the
 687      base class and cast it to the derived class, but that requires
 688      support for adjusting pointers to members when casting them -
 689      not currently supported by GDB.  */
 690
 691   if (!gdbarch_vbit_in_delta (gdbarch))
 692     {
 693       store_unsigned_integer (contents, size, byte_order, value | is_virtual);
 694       store_unsigned_integer (contents + size, size, byte_order, 0);
 695     }
 696   else
 697     {
 698       store_unsigned_integer (contents, size, byte_order, value);
 699       store_unsigned_integer (contents + size, size, byte_order, is_virtual);
 700     }
 701 }
 702
 703 /* GNU v3 implementation of cplus_method_ptr_to_value.  */
 704
 705 static struct value *
 706 gnuv3_method_ptr_to_value (struct value **this_p, struct value *method_ptr)
 707 {
 708   struct gdbarch *gdbarch;
 709   const gdb_byte *contents = value_contents (method_ptr);
 710   CORE_ADDR ptr_value;
 711   struct type *self_type, *final_type, *method_type;
 712   LONGEST adjustment;
 713   int vbit;
 714
 715   self_type = TYPE_SELF_TYPE (check_typedef (value_type (method_ptr)));
 716   final_type = lookup_pointer_type (self_type);
 717
 718   method_type = TYPE_TARGET_TYPE (check_typedef (value_type (method_ptr)));
 719
 720   /* Extract the pointer to member.  */
 721   gdbarch = get_type_arch (self_type);
 722   vbit = gnuv3_decode_method_ptr (gdbarch, contents, &ptr_value, &adjustment);
 723
 724   /* First convert THIS to match the containing type of the pointer to
 725      member.  This cast may adjust the value of THIS.  */
 726   *this_p = value_cast (final_type, *this_p);
 727
 728   /* Then apply whatever adjustment is necessary.  This creates a somewhat
 729      strange pointer: it claims to have type FINAL_TYPE, but in fact it
 730      might not be a valid FINAL_TYPE.  For instance, it might be a
 731      base class of FINAL_TYPE.  And if it's not the primary base class,
 732      then printing it out as a FINAL_TYPE object would produce some pretty
 733      garbage.
 734
 735      But we don't really know the type of the first argument in
 736      METHOD_TYPE either, which is why this happens.  We can't
 737      dereference this later as a FINAL_TYPE, but once we arrive in the
 738      called method we'll have debugging information for the type of
 739      "this" - and that'll match the value we produce here.
 740
 741      You can provoke this case by casting a Base::* to a Derived::*, for
 742      instance.  */
 743   *this_p = value_cast (builtin_type (gdbarch)->builtin_data_ptr, *this_p);
 744   *this_p = value_ptradd (*this_p, adjustment);
 745   *this_p = value_cast (final_type, *this_p);
 746
 747   if (vbit)
 748     {
 749       LONGEST voffset;
 750
 751       voffset = ptr_value / TYPE_LENGTH (vtable_ptrdiff_type (gdbarch));
 752       return gnuv3_get_virtual_fn (gdbarch, value_ind (*this_p),
 753                                    method_type, voffset);
 754     }
 755   else
 756     return value_from_pointer (lookup_pointer_type (method_type), ptr_value);
 757 }
 758
 759 /* Objects of this type are stored in a hash table and a vector when
 760    printing the vtables for a class.  */
 761
 762 struct value_and_voffset
 763 {
 764   /* The value representing the object.  */
 765   struct value *value;
 766
 767   /* The maximum vtable offset we've found for any object at this
 768      offset in the outermost object.  */
 769   int max_voffset;
 770 };
 771
 772 /* Hash function for value_and_voffset.  */
 773
 774 static hashval_t
 775 hash_value_and_voffset (const void *p)
 776 {
 777   const struct value_and_voffset *o = (const struct value_and_voffset *) p;
 778
 779   return value_address (o->value) + value_embedded_offset (o->value);
 780 }
 781
 782 /* Equality function for value_and_voffset.  */
 783
 784 static int
 785 eq_value_and_voffset (const void *a, const void *b)
 786 {
 787   const struct value_and_voffset *ova = (const struct value_and_voffset *) a;
 788   const struct value_and_voffset *ovb = (const struct value_and_voffset *) b;
 789
 790   return (value_address (ova->value) + value_embedded_offset (ova->value)
 791           == value_address (ovb->value) + value_embedded_offset (ovb->value));
 792 }
 793
 794 /* Comparison function for value_and_voffset.  */
 795
 796 static bool
 797 compare_value_and_voffset (const struct value_and_voffset *va,
 798                            const struct value_and_voffset *vb)
 799 {
 800   CORE_ADDR addra = (value_address (va->value)
 801                      + value_embedded_offset (va->value));
 802   CORE_ADDR addrb = (value_address (vb->value)
 803                      + value_embedded_offset (vb->value));
 804
 805   return addra < addrb;
 806 }
 807
 808 /* A helper function used when printing vtables.  This determines the
 809    key (most derived) sub-object at each address and also computes the
 810    maximum vtable offset seen for the corresponding vtable.  Updates
 811    OFFSET_HASH and OFFSET_VEC with a new value_and_voffset object, if
 812    needed.  VALUE is the object to examine.  */
 813
 814 static void
 815 compute_vtable_size (htab_t offset_hash,
 816                      std::vector<value_and_voffset *> *offset_vec,
 817                      struct value *value)
 818 {
 819   int i;
 820   struct type *type = check_typedef (value_type (value));
 821   void **slot;
 822   struct value_and_voffset search_vo, *current_vo;
 823
 824   gdb_assert (TYPE_CODE (type) == TYPE_CODE_STRUCT);
 825
 826   /* If the object is not dynamic, then we are done; as it cannot have
 827      dynamic base types either.  */
 828   if (!gnuv3_dynamic_class (type))
 829     return;
 830
 831   /* Update the hash and the vec, if needed.  */
 832   search_vo.value = value;
 833   slot = htab_find_slot (offset_hash, &search_vo, INSERT);
 834   if (*slot)
 835     current_vo = (struct value_and_voffset *) *slot;
 836   else
 837     {
 838       current_vo = XNEW (struct value_and_voffset);
 839       current_vo->value = value;
 840       current_vo->max_voffset = -1;
 841       *slot = current_vo;
 842       offset_vec->push_back (current_vo);
 843     }
 844
 845   /* Update the value_and_voffset object with the highest vtable
 846      offset from this class.  */
 847   for (i = 0; i < TYPE_NFN_FIELDS (type); ++i)
 848     {
 849       int j;
 850       struct fn_field *fn = TYPE_FN_FIELDLIST1 (type, i);
 851
 852       for (j = 0; j < TYPE_FN_FIELDLIST_LENGTH (type, i); ++j)
 853         {
 854           if (TYPE_FN_FIELD_VIRTUAL_P (fn, j))
 855             {
 856               int voffset = TYPE_FN_FIELD_VOFFSET (fn, j);
 857
 858               if (voffset > current_vo->max_voffset)
 859                 current_vo->max_voffset = voffset;
 860             }
 861         }
 862     }
 863
 864   /* Recurse into base classes.  */
 865   for (i = 0; i < TYPE_N_BASECLASSES (type); ++i)
 866     compute_vtable_size (offset_hash, offset_vec, value_field (value, i));
 867 }
 868
 869 /* Helper for gnuv3_print_vtable that prints a single vtable.  */
 870
 871 static void
 872 print_one_vtable (struct gdbarch *gdbarch, struct value *value,
 873                   int max_voffset,
 874                   struct value_print_options *opts)
 875 {
 876   int i;
 877   struct type *type = check_typedef (value_type (value));
 878   struct value *vtable;
 879   CORE_ADDR vt_addr;
 880
 881   vtable = gnuv3_get_vtable (gdbarch, type,
 882                              value_address (value)
 883                              + value_embedded_offset (value));
 884   vt_addr = value_address (value_field (vtable,
 885                                         vtable_field_virtual_functions));
 886
 887   printf_filtered (_("vtable for '%s' @ %s (subobject @ %s):\n"),
 888                    TYPE_SAFE_NAME (type),
 889                    paddress (gdbarch, vt_addr),
 890                    paddress (gdbarch, (value_address (value)
 891                                        + value_embedded_offset (value))));
 892
 893   for (i = 0; i <= max_voffset; ++i)
 894     {
 895       /* Initialize it just to avoid a GCC false warning.  */
 896       CORE_ADDR addr = 0;
 897       int got_error = 0;
 898       struct value *vfn;
 899
 900       printf_filtered ("[%d]: ", i);
 901
 902       vfn = value_subscript (value_field (vtable,
 903                                           vtable_field_virtual_functions),
 904                              i);
 905
 906       if (gdbarch_vtable_function_descriptors (gdbarch))
 907         vfn = value_addr (vfn);
 908
 909       try
 910         {
 911           addr = value_as_address (vfn);
 912         }
 913       catch (const gdb_exception_error &ex)
 914         {
 915           printf_filtered (_("<error: %s>"), ex.what ());
 916           got_error = 1;
 917         }
 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_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_top_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 }