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