gdb/gnu-v3-abi.c

   1 /* Abstraction of GNU v3 abi.
   2    Contributed by Jim Blandy <jimb@redhat.com>
   3
   4    Copyright (C) 2001-2018 Free Software Foundation, Inc.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  20
  21 #include "defs.h"
  22 #include "value.h"
  23 #include "cp-abi.h"
  24 #include "cp-support.h"
  25 #include "demangle.h"
  26 #include "objfiles.h"
  27 #include "valprint.h"
  28 #include "c-lang.h"
  29 #include "typeprint.h"
  30 #include <algorithm>
  31
  32 static struct cp_abi_ops gnu_v3_abi_ops;
  33
  34 /* A gdbarch key for std::type_info, in the event that it can't be
  35    found in the debug info.  */
  36
  37 static struct gdbarch_data *std_type_info_gdbarch_data;
  38
  39
  40 static int
  41 gnuv3_is_vtable_name (const char *name)
  42 {
  43   return startswith (name, "_ZTV");
  44 }
  45
  46 static int
  47 gnuv3_is_operator_name (const char *name)
  48 {
  49   return startswith (name, CP_OPERATOR_STR);
  50 }
  51
  52
  53 /* To help us find the components of a vtable, we build ourselves a
  54    GDB type object representing the vtable structure.  Following the
  55    V3 ABI, it goes something like this:
  56
  57    struct gdb_gnu_v3_abi_vtable {
  58
  59      / * An array of virtual call and virtual base offsets.  The real
  60          length of this array depends on the class hierarchy; we use
  61          negative subscripts to access the elements.  Yucky, but
  62          better than the alternatives.  * /
  63      ptrdiff_t vcall_and_vbase_offsets[0];
  64
  65      / * The offset from a virtual pointer referring to this table
  66          to the top of the complete object.  * /
  67      ptrdiff_t offset_to_top;
  68
  69      / * The type_info pointer for this class.  This is really a
  70          std::type_info *, but GDB doesn't really look at the
  71          type_info object itself, so we don't bother to get the type
  72          exactly right.  * /
  73      void *type_info;
  74
  75      / * Virtual table pointers in objects point here.  * /
  76
  77      / * Virtual function pointers.  Like the vcall/vbase array, the
  78          real length of this table depends on the class hierarchy.  * /
  79      void (*virtual_functions[0]) ();
  80
  81    };
  82
  83    The catch, of course, is that the exact layout of this table
  84    depends on the ABI --- word size, endianness, alignment, etc.  So
  85    the GDB type object is actually a per-architecture kind of thing.
  86
  87    vtable_type_gdbarch_data is a gdbarch per-architecture data pointer
  88    which refers to the struct type * for this structure, laid out
  89    appropriately for the architecture.  */
  90 static struct gdbarch_data *vtable_type_gdbarch_data;
  91
  92
  93 /* Human-readable names for the numbers of the fields above.  */
  94 enum {
  95   vtable_field_vcall_and_vbase_offsets,
  96   vtable_field_offset_to_top,
  97   vtable_field_type_info,
  98   vtable_field_virtual_functions
  99 };
 100
 101
 102 /* Return a GDB type representing `struct gdb_gnu_v3_abi_vtable',
 103    described above, laid out appropriately for ARCH.
 104
 105    We use this function as the gdbarch per-architecture data
 106    initialization function.  */
 107 static void *
 108 build_gdb_vtable_type (struct gdbarch *arch)
 109 {
 110   struct type *t;
 111   struct field *field_list, *field;
 112   int offset;
 113
 114   struct type *void_ptr_type
 115     = builtin_type (arch)->builtin_data_ptr;
 116   struct type *ptr_to_void_fn_type
 117     = builtin_type (arch)->builtin_func_ptr;
 118
 119   /* ARCH can't give us the true ptrdiff_t type, so we guess.  */
 120   struct type *ptrdiff_type
 121     = arch_integer_type (arch, gdbarch_ptr_bit (arch), 0, "ptrdiff_t");
 122
 123   /* We assume no padding is necessary, since GDB doesn't know
 124      anything about alignment at the moment.  If this assumption bites
 125      us, we should add a gdbarch method which, given a type, returns
 126      the alignment that type requires, and then use that here.  */
 127
 128   /* Build the field list.  */
 129   field_list = XCNEWVEC (struct field, 4);
 130   field = &field_list[0];
 131   offset = 0;
 132
 133   /* ptrdiff_t vcall_and_vbase_offsets[0]; */
 134   FIELD_NAME (*field) = "vcall_and_vbase_offsets";
 135   FIELD_TYPE (*field) = lookup_array_range_type (ptrdiff_type, 0, -1);
 136   SET_FIELD_BITPOS (*field, offset * TARGET_CHAR_BIT);
 137   offset += TYPE_LENGTH (FIELD_TYPE (*field));
 138   field++;
 139
 140   /* ptrdiff_t offset_to_top; */
 141   FIELD_NAME (*field) = "offset_to_top";
 142   FIELD_TYPE (*field) = ptrdiff_type;
 143   SET_FIELD_BITPOS (*field, offset * TARGET_CHAR_BIT);
 144   offset += TYPE_LENGTH (FIELD_TYPE (*field));
 145   field++;
 146
 147   /* void *type_info; */
 148   FIELD_NAME (*field) = "type_info";
 149   FIELD_TYPE (*field) = void_ptr_type;
 150   SET_FIELD_BITPOS (*field, offset * TARGET_CHAR_BIT);
 151   offset += TYPE_LENGTH (FIELD_TYPE (*field));
 152   field++;
 153
 154   /* void (*virtual_functions[0]) (); */
 155   FIELD_NAME (*field) = "virtual_functions";
 156   FIELD_TYPE (*field) = lookup_array_range_type (ptr_to_void_fn_type, 0, -1);
 157   SET_FIELD_BITPOS (*field, offset * TARGET_CHAR_BIT);
 158   offset += TYPE_LENGTH (FIELD_TYPE (*field));
 159   field++;
 160
 161   /* We assumed in the allocation above that there were four fields.  */
 162   gdb_assert (field == (field_list + 4));
 163
 164   t = arch_type (arch, TYPE_CODE_STRUCT, offset * TARGET_CHAR_BIT, NULL);
 165   TYPE_NFIELDS (t) = field - field_list;
 166   TYPE_FIELDS (t) = field_list;
 167   TYPE_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 (ex, RETURN_MASK_ERROR)
 914         {
 915           printf_filtered (_("<error: %s>"), ex.message);
 916           got_error = 1;
 917         }
 918       END_CATCH
 919
 920       if (!got_error)
 921         print_function_pointer_address (opts, gdbarch, addr, gdb_stdout);
 922       printf_filtered ("\n");
 923     }
 924 }
 925
 926 /* Implementation of the print_vtable method.  */
 927
 928 static void
 929 gnuv3_print_vtable (struct value *value)
 930 {
 931   struct gdbarch *gdbarch;
 932   struct type *type;
 933   struct value *vtable;
 934   struct value_print_options opts;
 935   int count;
 936
 937   value = coerce_ref (value);
 938   type = check_typedef (value_type (value));
 939   if (TYPE_CODE (type) == TYPE_CODE_PTR)
 940     {
 941       value = value_ind (value);
 942       type = check_typedef (value_type (value));
 943     }
 944
 945   get_user_print_options (&opts);
 946
 947   /* Respect 'set print object'.  */
 948   if (opts.objectprint)
 949     {
 950       value = value_full_object (value, NULL, 0, 0, 0);
 951       type = check_typedef (value_type (value));
 952     }
 953
 954   gdbarch = get_type_arch (type);
 955
 956   vtable = NULL;
 957   if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
 958     vtable = gnuv3_get_vtable (gdbarch, type,
 959                                value_as_address (value_addr (value)));
 960
 961   if (!vtable)
 962     {
 963       printf_filtered (_("This object does not have a virtual function table\n"));
 964       return;
 965     }
 966
 967   htab_up offset_hash (htab_create_alloc (1, hash_value_and_voffset,
 968                                           eq_value_and_voffset,
 969                                           xfree, xcalloc, xfree));
 970   std::vector<value_and_voffset *> result_vec;
 971
 972   compute_vtable_size (offset_hash.get (), &result_vec, value);
 973   std::sort (result_vec.begin (), result_vec.end (),
 974              compare_value_and_voffset);
 975
 976   count = 0;
 977   for (value_and_voffset *iter : result_vec)
 978     {
 979       if (iter->max_voffset >= 0)
 980         {
 981           if (count > 0)
 982             printf_filtered ("\n");
 983           print_one_vtable (gdbarch, iter->value, iter->max_voffset, &opts);
 984           ++count;
 985         }
 986     }
 987 }
 988
 989 /* Return a GDB type representing `struct std::type_info', laid out
 990    appropriately for ARCH.
 991
 992    We use this function as the gdbarch per-architecture data
 993    initialization function.  */
 994
 995 static void *
 996 build_std_type_info_type (struct gdbarch *arch)
 997 {
 998   struct type *t;
 999   struct field *field_list, *field;
1000   int offset;
1001   struct type *void_ptr_type
1002     = builtin_type (arch)->builtin_data_ptr;
1003   struct type *char_type
1004     = builtin_type (arch)->builtin_char;
1005   struct type *char_ptr_type
1006     = make_pointer_type (make_cv_type (1, 0, char_type, NULL), NULL);
1007
1008   field_list = XCNEWVEC (struct field, 2);
1009   field = &field_list[0];
1010   offset = 0;
1011
1012   /* The vtable.  */
1013   FIELD_NAME (*field) = "_vptr.type_info";
1014   FIELD_TYPE (*field) = void_ptr_type;
1015   SET_FIELD_BITPOS (*field, offset * TARGET_CHAR_BIT);
1016   offset += TYPE_LENGTH (FIELD_TYPE (*field));
1017   field++;
1018
1019   /* The name.  */
1020   FIELD_NAME (*field) = "__name";
1021   FIELD_TYPE (*field) = char_ptr_type;
1022   SET_FIELD_BITPOS (*field, offset * TARGET_CHAR_BIT);
1023   offset += TYPE_LENGTH (FIELD_TYPE (*field));
1024   field++;
1025
1026   gdb_assert (field == (field_list + 2));
1027
1028   t = arch_type (arch, TYPE_CODE_STRUCT, offset * TARGET_CHAR_BIT, NULL);
1029   TYPE_NFIELDS (t) = field - field_list;
1030   TYPE_FIELDS (t) = field_list;
1031   TYPE_NAME (t) = "gdb_gnu_v3_type_info";
1032   INIT_CPLUS_SPECIFIC (t);
1033
1034   return t;
1035 }
1036
1037 /* Implement the 'get_typeid_type' method.  */
1038
1039 static struct type *
1040 gnuv3_get_typeid_type (struct gdbarch *gdbarch)
1041 {
1042   struct symbol *typeinfo;
1043   struct type *typeinfo_type;
1044
1045   typeinfo = lookup_symbol ("std::type_info", NULL, STRUCT_DOMAIN,
1046                             NULL).symbol;
1047   if (typeinfo == NULL)
1048     typeinfo_type
1049       = (struct type *) gdbarch_data (gdbarch, std_type_info_gdbarch_data);
1050   else
1051     typeinfo_type = SYMBOL_TYPE (typeinfo);
1052
1053   return typeinfo_type;
1054 }
1055
1056 /* Implement the 'get_typeid' method.  */
1057
1058 static struct value *
1059 gnuv3_get_typeid (struct value *value)
1060 {
1061   struct type *typeinfo_type;
1062   struct type *type;
1063   struct gdbarch *gdbarch;
1064   struct value *result;
1065   std::string type_name, canonical;
1066
1067   /* We have to handle values a bit trickily here, to allow this code
1068      to work properly with non_lvalue values that are really just
1069      disguised types.  */
1070   if (value_lval_const (value) == lval_memory)
1071     value = coerce_ref (value);
1072
1073   type = check_typedef (value_type (value));
1074
1075   /* In the non_lvalue case, a reference might have slipped through
1076      here.  */
1077   if (TYPE_CODE (type) == TYPE_CODE_REF)
1078     type = check_typedef (TYPE_TARGET_TYPE (type));
1079
1080   /* Ignore top-level cv-qualifiers.  */
1081   type = make_cv_type (0, 0, type, NULL);
1082   gdbarch = get_type_arch (type);
1083
1084   type_name = type_to_string (type);
1085   if (type_name.empty ())
1086     error (_("cannot find typeinfo for unnamed type"));
1087
1088   /* We need to canonicalize the type name here, because we do lookups
1089      using the demangled name, and so we must match the format it
1090      uses.  E.g., GDB tends to use "const char *" as a type name, but
1091      the demangler uses "char const *".  */
1092   canonical = cp_canonicalize_string (type_name.c_str ());
1093   if (!canonical.empty ())
1094     type_name = canonical;
1095
1096   typeinfo_type = gnuv3_get_typeid_type (gdbarch);
1097
1098   /* We check for lval_memory because in the "typeid (type-id)" case,
1099      the type is passed via a not_lval value object.  */
1100   if (TYPE_CODE (type) == TYPE_CODE_STRUCT
1101       && value_lval_const (value) == lval_memory
1102       && gnuv3_dynamic_class (type))
1103     {
1104       struct value *vtable, *typeinfo_value;
1105       CORE_ADDR address = value_address (value) + value_embedded_offset (value);
1106
1107       vtable = gnuv3_get_vtable (gdbarch, type, address);
1108       if (vtable == NULL)
1109         error (_("cannot find typeinfo for object of type '%s'"),
1110                type_name.c_str ());
1111       typeinfo_value = value_field (vtable, vtable_field_type_info);
1112       result = value_ind (value_cast (make_pointer_type (typeinfo_type, NULL),
1113                                       typeinfo_value));
1114     }
1115   else
1116     {
1117       std::string sym_name = std::string ("typeinfo for ") + type_name;
1118       bound_minimal_symbol minsym
1119         = lookup_minimal_symbol (sym_name.c_str (), NULL, NULL);
1120
1121       if (minsym.minsym == NULL)
1122         error (_("could not find typeinfo symbol for '%s'"), type_name.c_str ());
1123
1124       result = value_at_lazy (typeinfo_type, BMSYMBOL_VALUE_ADDRESS (minsym));
1125     }
1126
1127   return result;
1128 }
1129
1130 /* Implement the 'get_typename_from_type_info' method.  */
1131
1132 static std::string
1133 gnuv3_get_typename_from_type_info (struct value *type_info_ptr)
1134 {
1135   struct gdbarch *gdbarch = get_type_arch (value_type (type_info_ptr));
1136   struct bound_minimal_symbol typeinfo_sym;
1137   CORE_ADDR addr;
1138   const char *symname;
1139   const char *class_name;
1140   const char *atsign;
1141
1142   addr = value_as_address (type_info_ptr);
1143   typeinfo_sym = lookup_minimal_symbol_by_pc (addr);
1144   if (typeinfo_sym.minsym == NULL)
1145     error (_("could not find minimal symbol for typeinfo address %s"),
1146            paddress (gdbarch, addr));
1147
1148 #define TYPEINFO_PREFIX "typeinfo for "
1149 #define TYPEINFO_PREFIX_LEN (sizeof (TYPEINFO_PREFIX) - 1)
1150   symname = MSYMBOL_DEMANGLED_NAME (typeinfo_sym.minsym);
1151   if (symname == NULL || strncmp (symname, TYPEINFO_PREFIX,
1152                                   TYPEINFO_PREFIX_LEN))
1153     error (_("typeinfo symbol '%s' has unexpected name"),
1154            MSYMBOL_LINKAGE_NAME (typeinfo_sym.minsym));
1155   class_name = symname + TYPEINFO_PREFIX_LEN;
1156
1157   /* Strip off @plt and version suffixes.  */
1158   atsign = strchr (class_name, '@');
1159   if (atsign != NULL)
1160     return std::string (class_name, atsign - class_name);
1161   return class_name;
1162 }
1163
1164 /* Implement the 'get_type_from_type_info' method.  */
1165
1166 static struct type *
1167 gnuv3_get_type_from_type_info (struct value *type_info_ptr)
1168 {
1169   /* We have to parse the type name, since in general there is not a
1170      symbol for a type.  This is somewhat bogus since there may be a
1171      mis-parse.  Another approach might be to re-use the demangler's
1172      internal form to reconstruct the type somehow.  */
1173   std::string type_name = gnuv3_get_typename_from_type_info (type_info_ptr);
1174   expression_up expr (parse_expression (type_name.c_str ()));
1175   struct value *type_val = evaluate_type (expr.get ());
1176   return value_type (type_val);
1177 }
1178
1179 /* Determine if we are currently in a C++ thunk.  If so, get the address
1180    of the routine we are thunking to and continue to there instead.  */
1181
1182 static CORE_ADDR
1183 gnuv3_skip_trampoline (struct frame_info *frame, CORE_ADDR stop_pc)
1184 {
1185   CORE_ADDR real_stop_pc, method_stop_pc, func_addr;
1186   struct gdbarch *gdbarch = get_frame_arch (frame);
1187   struct bound_minimal_symbol thunk_sym, fn_sym;
1188   struct obj_section *section;
1189   const char *thunk_name, *fn_name;
1190
1191   real_stop_pc = gdbarch_skip_trampoline_code (gdbarch, frame, stop_pc);
1192   if (real_stop_pc == 0)
1193     real_stop_pc = stop_pc;
1194
1195   /* Find the linker symbol for this potential thunk.  */
1196   thunk_sym = lookup_minimal_symbol_by_pc (real_stop_pc);
1197   section = find_pc_section (real_stop_pc);
1198   if (thunk_sym.minsym == NULL || section == NULL)
1199     return 0;
1200
1201   /* The symbol's demangled name should be something like "virtual
1202      thunk to FUNCTION", where FUNCTION is the name of the function
1203      being thunked to.  */
1204   thunk_name = MSYMBOL_DEMANGLED_NAME (thunk_sym.minsym);
1205   if (thunk_name == NULL || strstr (thunk_name, " thunk to ") == NULL)
1206     return 0;
1207
1208   fn_name = strstr (thunk_name, " thunk to ") + strlen (" thunk to ");
1209   fn_sym = lookup_minimal_symbol (fn_name, NULL, section->objfile);
1210   if (fn_sym.minsym == NULL)
1211     return 0;
1212
1213   method_stop_pc = BMSYMBOL_VALUE_ADDRESS (fn_sym);
1214
1215   /* Some targets have minimal symbols pointing to function descriptors
1216      (powerpc 64 for example).  Make sure to retrieve the address
1217      of the real function from the function descriptor before passing on
1218      the address to other layers of GDB.  */
1219   func_addr = gdbarch_convert_from_func_ptr_addr (gdbarch, method_stop_pc,
1220                                                   current_top_target ());
1221   if (func_addr != 0)
1222     method_stop_pc = func_addr;
1223
1224   real_stop_pc = gdbarch_skip_trampoline_code
1225                    (gdbarch, frame, method_stop_pc);
1226   if (real_stop_pc == 0)
1227     real_stop_pc = method_stop_pc;
1228
1229   return real_stop_pc;
1230 }
1231
1232 /* Return nonzero if a type should be passed by reference.
1233
1234    The rule in the v3 ABI document comes from section 3.1.1.  If the
1235    type has a non-trivial copy constructor or destructor, then the
1236    caller must make a copy (by calling the copy constructor if there
1237    is one or perform the copy itself otherwise), pass the address of
1238    the copy, and then destroy the temporary (if necessary).
1239
1240    For return values with non-trivial copy constructors or
1241    destructors, space will be allocated in the caller, and a pointer
1242    will be passed as the first argument (preceding "this").
1243
1244    We don't have a bulletproof mechanism for determining whether a
1245    constructor or destructor is trivial.  For GCC and DWARF2 debug
1246    information, we can check the artificial flag.
1247
1248    We don't do anything with the constructors or destructors,
1249    but we have to get the argument passing right anyway.  */
1250 static int
1251 gnuv3_pass_by_reference (struct type *type)
1252 {
1253   int fieldnum, fieldelem;
1254
1255   type = check_typedef (type);
1256
1257   /* We're only interested in things that can have methods.  */
1258   if (TYPE_CODE (type) != TYPE_CODE_STRUCT
1259       && TYPE_CODE (type) != TYPE_CODE_UNION)
1260     return 0;
1261
1262   /* A dynamic class has a non-trivial copy constructor.
1263      See c++98 section 12.8 Copying class objects [class.copy].  */
1264   if (gnuv3_dynamic_class (type))
1265     return 1;
1266
1267   for (fieldnum = 0; fieldnum < TYPE_NFN_FIELDS (type); fieldnum++)
1268     for (fieldelem = 0; fieldelem < TYPE_FN_FIELDLIST_LENGTH (type, fieldnum);
1269          fieldelem++)
1270       {
1271         struct fn_field *fn = TYPE_FN_FIELDLIST1 (type, fieldnum);
1272         const char *name = TYPE_FN_FIELDLIST_NAME (type, fieldnum);
1273         struct type *fieldtype = TYPE_FN_FIELD_TYPE (fn, fieldelem);
1274
1275         /* If this function is marked as artificial, it is compiler-generated,
1276            and we assume it is trivial.  */
1277         if (TYPE_FN_FIELD_ARTIFICIAL (fn, fieldelem))
1278           continue;
1279
1280         /* If we've found a destructor, we must pass this by reference.  */
1281         if (name[0] == '~')
1282           return 1;
1283
1284         /* If the mangled name of this method doesn't indicate that it
1285            is a constructor, we're not interested.
1286
1287            FIXME drow/2007-09-23: We could do this using the name of
1288            the method and the name of the class instead of dealing
1289            with the mangled name.  We don't have a convenient function
1290            to strip off both leading scope qualifiers and trailing
1291            template arguments yet.  */
1292         if (!is_constructor_name (TYPE_FN_FIELD_PHYSNAME (fn, fieldelem))
1293             && !TYPE_FN_FIELD_CONSTRUCTOR (fn, fieldelem))
1294           continue;
1295
1296         /* If this method takes two arguments, and the second argument is
1297            a reference to this class, then it is a copy constructor.  */
1298         if (TYPE_NFIELDS (fieldtype) == 2)
1299           {
1300             struct type *arg_type = TYPE_FIELD_TYPE (fieldtype, 1);
1301
1302             if (TYPE_CODE (arg_type) == TYPE_CODE_REF)
1303               {
1304                 struct type *arg_target_type;
1305
1306                 arg_target_type = check_typedef (TYPE_TARGET_TYPE (arg_type));
1307                 if (class_types_same_p (arg_target_type, type))
1308                   return 1;
1309               }
1310           }
1311       }
1312
1313   /* Even if all the constructors and destructors were artificial, one
1314      of them may have invoked a non-artificial constructor or
1315      destructor in a base class.  If any base class needs to be passed
1316      by reference, so does this class.  Similarly for members, which
1317      are constructed whenever this class is.  We do not need to worry
1318      about recursive loops here, since we are only looking at members
1319      of complete class type.  Also ignore any static members.  */
1320   for (fieldnum = 0; fieldnum < TYPE_NFIELDS (type); fieldnum++)
1321     if (! field_is_static (&TYPE_FIELD (type, fieldnum))
1322         && gnuv3_pass_by_reference (TYPE_FIELD_TYPE (type, fieldnum)))
1323       return 1;
1324
1325   return 0;
1326 }
1327
1328 static void
1329 init_gnuv3_ops (void)
1330 {
1331   vtable_type_gdbarch_data
1332     = gdbarch_data_register_post_init (build_gdb_vtable_type);
1333   std_type_info_gdbarch_data
1334     = gdbarch_data_register_post_init (build_std_type_info_type);
1335
1336   gnu_v3_abi_ops.shortname = "gnu-v3";
1337   gnu_v3_abi_ops.longname = "GNU G++ Version 3 ABI";
1338   gnu_v3_abi_ops.doc = "G++ Version 3 ABI";
1339   gnu_v3_abi_ops.is_destructor_name =
1340     (enum dtor_kinds (*) (const char *))is_gnu_v3_mangled_dtor;
1341   gnu_v3_abi_ops.is_constructor_name =
1342     (enum ctor_kinds (*) (const char *))is_gnu_v3_mangled_ctor;
1343   gnu_v3_abi_ops.is_vtable_name = gnuv3_is_vtable_name;
1344   gnu_v3_abi_ops.is_operator_name = gnuv3_is_operator_name;
1345   gnu_v3_abi_ops.rtti_type = gnuv3_rtti_type;
1346   gnu_v3_abi_ops.virtual_fn_field = gnuv3_virtual_fn_field;
1347   gnu_v3_abi_ops.baseclass_offset = gnuv3_baseclass_offset;
1348   gnu_v3_abi_ops.print_method_ptr = gnuv3_print_method_ptr;
1349   gnu_v3_abi_ops.method_ptr_size = gnuv3_method_ptr_size;
1350   gnu_v3_abi_ops.make_method_ptr = gnuv3_make_method_ptr;
1351   gnu_v3_abi_ops.method_ptr_to_value = gnuv3_method_ptr_to_value;
1352   gnu_v3_abi_ops.print_vtable = gnuv3_print_vtable;
1353   gnu_v3_abi_ops.get_typeid = gnuv3_get_typeid;
1354   gnu_v3_abi_ops.get_typeid_type = gnuv3_get_typeid_type;
1355   gnu_v3_abi_ops.get_type_from_type_info = gnuv3_get_type_from_type_info;
1356   gnu_v3_abi_ops.get_typename_from_type_info
1357     = gnuv3_get_typename_from_type_info;
1358   gnu_v3_abi_ops.skip_trampoline = gnuv3_skip_trampoline;
1359   gnu_v3_abi_ops.pass_by_reference = gnuv3_pass_by_reference;
1360 }
1361
1362 void
1363 _initialize_gnu_v3_abi (void)
1364 {
1365   init_gnuv3_ops ();
1366
1367   register_cp_abi (&gnu_v3_abi_ops);
1368   set_cp_abi_as_auto_default (gnu_v3_abi_ops.shortname);
1369 }