gdb/gnu-v3-abi.c

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