gdb/gnu-v3-abi.c

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