gdb/gnu-v3-abi.c

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