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 = XCNEWVEC (struct field, 4);
 129   field = &field_list[0];
 130   offset = 0;
 131
 132   /* ptrdiff_t vcall_and_vbase_offsets[0]; */
 133   FIELD_NAME (*field) = "vcall_and_vbase_offsets";
 134   FIELD_TYPE (*field) = lookup_array_range_type (ptrdiff_type, 0, -1);
 135   SET_FIELD_BITPOS (*field, offset * TARGET_CHAR_BIT);
 136   offset += TYPE_LENGTH (FIELD_TYPE (*field));
 137   field++;
 138
 139   /* ptrdiff_t offset_to_top; */
 140   FIELD_NAME (*field) = "offset_to_top";
 141   FIELD_TYPE (*field) = ptrdiff_type;
 142   SET_FIELD_BITPOS (*field, offset * TARGET_CHAR_BIT);
 143   offset += TYPE_LENGTH (FIELD_TYPE (*field));
 144   field++;
 145
 146   /* void *type_info; */
 147   FIELD_NAME (*field) = "type_info";
 148   FIELD_TYPE (*field) = void_ptr_type;
 149   SET_FIELD_BITPOS (*field, offset * TARGET_CHAR_BIT);
 150   offset += TYPE_LENGTH (FIELD_TYPE (*field));
 151   field++;
 152
 153   /* void (*virtual_functions[0]) (); */
 154   FIELD_NAME (*field) = "virtual_functions";
 155   FIELD_TYPE (*field) = lookup_array_range_type (ptr_to_void_fn_type, 0, -1);
 156   SET_FIELD_BITPOS (*field, offset * TARGET_CHAR_BIT);
 157   offset += TYPE_LENGTH (FIELD_TYPE (*field));
 158   field++;
 159
 160   /* We assumed in the allocation above that there were four fields.  */
 161   gdb_assert (field == (field_list + 4));
 162
 163   t = arch_type (arch, TYPE_CODE_STRUCT, offset, NULL);
 164   TYPE_NFIELDS (t) = field - field_list;
 165   TYPE_FIELDS (t) = field_list;
 166   TYPE_TAG_NAME (t) = "gdb_gnu_v3_abi_vtable";
 167   INIT_CPLUS_SPECIFIC (t);
 168
 169   return make_type_with_address_space (t, TYPE_INSTANCE_FLAG_CODE_SPACE);
 170 }
 171
 172
 173 /* Return the ptrdiff_t type used in the vtable type.  */
 174 static struct type *
 175 vtable_ptrdiff_type (struct gdbarch *gdbarch)
 176 {
 177   struct type *vtable_type = gdbarch_data (gdbarch, vtable_type_gdbarch_data);
 178
 179   /* The "offset_to_top" field has the appropriate (ptrdiff_t) type.  */
 180   return TYPE_FIELD_TYPE (vtable_type, vtable_field_offset_to_top);
 181 }
 182
 183 /* Return the offset from the start of the imaginary `struct
 184    gdb_gnu_v3_abi_vtable' object to the vtable's "address point"
 185    (i.e., where objects' virtual table pointers point).  */
 186 static int
 187 vtable_address_point_offset (struct gdbarch *gdbarch)
 188 {
 189   struct type *vtable_type = gdbarch_data (gdbarch, vtable_type_gdbarch_data);
 190
 191   return (TYPE_FIELD_BITPOS (vtable_type, vtable_field_virtual_functions)
 192           / TARGET_CHAR_BIT);
 193 }
 194
 195
 196 /* Determine whether structure TYPE is a dynamic class.  Cache the
 197    result.  */
 198
 199 static int
 200 gnuv3_dynamic_class (struct type *type)
 201 {
 202   int fieldnum, fieldelem;
 203
 204   type = check_typedef (type);
 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   container_type = 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       || !startswith (vtable_symbol_name, "vtable for "))
 333     {
 334       warning (_("can't find linker symbol for virtual table for `%s' value"),
 335                TYPE_SAFE_NAME (values_type));
 336       if (vtable_symbol_name)
 337         warning (_("  found `%s' instead"), vtable_symbol_name);
 338       return NULL;
 339     }
 340   class_name = vtable_symbol_name + 11;
 341
 342   /* Strip off @plt and version suffixes.  */
 343   atsign = strchr (class_name, '@');
 344   if (atsign != NULL)
 345     {
 346       char *copy;
 347
 348       copy = (char *) alloca (atsign - class_name + 1);
 349       memcpy (copy, class_name, atsign - class_name);
 350       copy[atsign - class_name] = '\0';
 351       class_name = copy;
 352     }
 353
 354   /* Try to look up the class name as a type name.  */
 355   /* FIXME: chastain/2003-11-26: block=NULL is bogus.  See pr gdb/1465.  */
 356   run_time_type = cp_lookup_rtti_type (class_name, NULL);
 357   if (run_time_type == NULL)
 358     return NULL;
 359
 360   /* Get the offset from VALUE to the top of the complete object.
 361      NOTE: this is the reverse of the meaning of *TOP_P.  */
 362   offset_to_top
 363     = value_as_long (value_field (vtable, vtable_field_offset_to_top));
 364
 365   if (full_p)
 366     *full_p = (- offset_to_top == value_embedded_offset (value)
 367                && (TYPE_LENGTH (value_enclosing_type (value))
 368                    >= TYPE_LENGTH (run_time_type)));
 369   if (top_p)
 370     *top_p = - offset_to_top;
 371   return run_time_type;
 372 }
 373
 374 /* Return a function pointer for CONTAINER's VTABLE_INDEX'th virtual
 375    function, of type FNTYPE.  */
 376
 377 static struct value *
 378 gnuv3_get_virtual_fn (struct gdbarch *gdbarch, struct value *container,
 379                       struct type *fntype, int vtable_index)
 380 {
 381   struct value *vtable, *vfn;
 382
 383   /* Every class with virtual functions must have a vtable.  */
 384   vtable = gnuv3_get_vtable (gdbarch, value_type (container),
 385                              value_as_address (value_addr (container)));
 386   gdb_assert (vtable != NULL);
 387
 388   /* Fetch the appropriate function pointer from the vtable.  */
 389   vfn = value_subscript (value_field (vtable, vtable_field_virtual_functions),
 390                          vtable_index);
 391
 392   /* If this architecture uses function descriptors directly in the vtable,
 393      then the address of the vtable entry is actually a "function pointer"
 394      (i.e. points to the descriptor).  We don't need to scale the index
 395      by the size of a function descriptor; GCC does that before outputing
 396      debug information.  */
 397   if (gdbarch_vtable_function_descriptors (gdbarch))
 398     vfn = value_addr (vfn);
 399
 400   /* Cast the function pointer to the appropriate type.  */
 401   vfn = value_cast (lookup_pointer_type (fntype), vfn);
 402
 403   return vfn;
 404 }
 405
 406 /* GNU v3 implementation of value_virtual_fn_field.  See cp-abi.h
 407    for a description of the arguments.  */
 408
 409 static struct value *
 410 gnuv3_virtual_fn_field (struct value **value_p,
 411                         struct fn_field *f, int j,
 412                         struct type *vfn_base, int offset)
 413 {
 414   struct type *values_type = check_typedef (value_type (*value_p));
 415   struct gdbarch *gdbarch;
 416
 417   /* Some simple sanity checks.  */
 418   if (TYPE_CODE (values_type) != TYPE_CODE_STRUCT)
 419     error (_("Only classes can have virtual functions."));
 420
 421   /* Determine architecture.  */
 422   gdbarch = get_type_arch (values_type);
 423
 424   /* Cast our value to the base class which defines this virtual
 425      function.  This takes care of any necessary `this'
 426      adjustments.  */
 427   if (vfn_base != values_type)
 428     *value_p = value_cast (vfn_base, *value_p);
 429
 430   return gnuv3_get_virtual_fn (gdbarch, *value_p, TYPE_FN_FIELD_TYPE (f, j),
 431                                TYPE_FN_FIELD_VOFFSET (f, j));
 432 }
 433
 434 /* Compute the offset of the baseclass which is
 435    the INDEXth baseclass of class TYPE,
 436    for value at VALADDR (in host) at ADDRESS (in target).
 437    The result is the offset of the baseclass value relative
 438    to (the address of)(ARG) + OFFSET.
 439
 440    -1 is returned on error.  */
 441
 442 static int
 443 gnuv3_baseclass_offset (struct type *type, int index,
 444                         const bfd_byte *valaddr, 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 *self_type = TYPE_SELF_TYPE (type);
 588   struct gdbarch *gdbarch = get_type_arch (self_type);
 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 (self_type, 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 *self_type, *final_type, *method_type;
 713   LONGEST adjustment;
 714   int vbit;
 715
 716   self_type = TYPE_SELF_TYPE (check_typedef (value_type (method_ptr)));
 717   final_type = lookup_pointer_type (self_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 (self_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       int got_error = 0;
 907       struct value *vfn;
 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
 919         {
 920           addr = value_as_address (vfn);
 921         }
 922       CATCH (ex, RETURN_MASK_ERROR)
 923         {
 924           printf_filtered (_("<error: %s>"), ex.message);
 925           got_error = 1;
 926         }
 927       END_CATCH
 928
 929       if (!got_error)
 930         print_function_pointer_address (opts, gdbarch, addr, gdb_stdout);
 931       printf_filtered ("\n");
 932     }
 933 }
 934
 935 /* Implementation of the print_vtable method.  */
 936
 937 static void
 938 gnuv3_print_vtable (struct value *value)
 939 {
 940   struct gdbarch *gdbarch;
 941   struct type *type;
 942   struct value *vtable;
 943   struct value_print_options opts;
 944   htab_t offset_hash;
 945   struct cleanup *cleanup;
 946   VEC (value_and_voffset_p) *result_vec = NULL;
 947   struct value_and_voffset *iter;
 948   int i, count;
 949
 950   value = coerce_ref (value);
 951   type = check_typedef (value_type (value));
 952   if (TYPE_CODE (type) == TYPE_CODE_PTR)
 953     {
 954       value = value_ind (value);
 955       type = check_typedef (value_type (value));
 956     }
 957
 958   get_user_print_options (&opts);
 959
 960   /* Respect 'set print object'.  */
 961   if (opts.objectprint)
 962     {
 963       value = value_full_object (value, NULL, 0, 0, 0);
 964       type = check_typedef (value_type (value));
 965     }
 966
 967   gdbarch = get_type_arch (type);
 968
 969   vtable = NULL;
 970   if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
 971     vtable = gnuv3_get_vtable (gdbarch, type,
 972                                value_as_address (value_addr (value)));
 973
 974   if (!vtable)
 975     {
 976       printf_filtered (_("This object does not have a virtual function table\n"));
 977       return;
 978     }
 979
 980   offset_hash = htab_create_alloc (1, hash_value_and_voffset,
 981                                    eq_value_and_voffset,
 982                                    xfree, xcalloc, xfree);
 983   cleanup = make_cleanup_htab_delete (offset_hash);
 984   make_cleanup (VEC_cleanup (value_and_voffset_p), &result_vec);
 985
 986   compute_vtable_size (offset_hash, &result_vec, value);
 987
 988   qsort (VEC_address (value_and_voffset_p, result_vec),
 989          VEC_length (value_and_voffset_p, result_vec),
 990          sizeof (value_and_voffset_p),
 991          compare_value_and_voffset);
 992
 993   count = 0;
 994   for (i = 0; VEC_iterate (value_and_voffset_p, result_vec, i, iter); ++i)
 995     {
 996       if (iter->max_voffset >= 0)
 997         {
 998           if (count > 0)
 999             printf_filtered ("\n");
1000           print_one_vtable (gdbarch, iter->value, iter->max_voffset, &opts);
1001           ++count;
1002         }
1003     }
1004
1005   do_cleanups (cleanup);
1006 }
1007
1008 /* Return a GDB type representing `struct std::type_info', laid out
1009    appropriately for ARCH.
1010
1011    We use this function as the gdbarch per-architecture data
1012    initialization function.  */
1013
1014 static void *
1015 build_std_type_info_type (struct gdbarch *arch)
1016 {
1017   struct type *t;
1018   struct field *field_list, *field;
1019   int offset;
1020   struct type *void_ptr_type
1021     = builtin_type (arch)->builtin_data_ptr;
1022   struct type *char_type
1023     = builtin_type (arch)->builtin_char;
1024   struct type *char_ptr_type
1025     = make_pointer_type (make_cv_type (1, 0, char_type, NULL), NULL);
1026
1027   field_list = XCNEWVEC (struct field, 2);
1028   field = &field_list[0];
1029   offset = 0;
1030
1031   /* The vtable.  */
1032   FIELD_NAME (*field) = "_vptr.type_info";
1033   FIELD_TYPE (*field) = void_ptr_type;
1034   SET_FIELD_BITPOS (*field, offset * TARGET_CHAR_BIT);
1035   offset += TYPE_LENGTH (FIELD_TYPE (*field));
1036   field++;
1037
1038   /* The name.  */
1039   FIELD_NAME (*field) = "__name";
1040   FIELD_TYPE (*field) = char_ptr_type;
1041   SET_FIELD_BITPOS (*field, offset * TARGET_CHAR_BIT);
1042   offset += TYPE_LENGTH (FIELD_TYPE (*field));
1043   field++;
1044
1045   gdb_assert (field == (field_list + 2));
1046
1047   t = arch_type (arch, TYPE_CODE_STRUCT, offset, NULL);
1048   TYPE_NFIELDS (t) = field - field_list;
1049   TYPE_FIELDS (t) = field_list;
1050   TYPE_TAG_NAME (t) = "gdb_gnu_v3_type_info";
1051   INIT_CPLUS_SPECIFIC (t);
1052
1053   return t;
1054 }
1055
1056 /* Implement the 'get_typeid_type' method.  */
1057
1058 static struct type *
1059 gnuv3_get_typeid_type (struct gdbarch *gdbarch)
1060 {
1061   struct symbol *typeinfo;
1062   struct type *typeinfo_type;
1063
1064   typeinfo = lookup_symbol ("std::type_info", NULL, STRUCT_DOMAIN,
1065                             NULL).symbol;
1066   if (typeinfo == NULL)
1067     typeinfo_type = gdbarch_data (gdbarch, std_type_info_gdbarch_data);
1068   else
1069     typeinfo_type = SYMBOL_TYPE (typeinfo);
1070
1071   return typeinfo_type;
1072 }
1073
1074 /* Implement the 'get_typeid' method.  */
1075
1076 static struct value *
1077 gnuv3_get_typeid (struct value *value)
1078 {
1079   struct type *typeinfo_type;
1080   struct type *type;
1081   struct gdbarch *gdbarch;
1082   struct cleanup *cleanup;
1083   struct value *result;
1084   char *type_name, *canonical;
1085
1086   /* We have to handle values a bit trickily here, to allow this code
1087      to work properly with non_lvalue values that are really just
1088      disguised types.  */
1089   if (value_lval_const (value) == lval_memory)
1090     value = coerce_ref (value);
1091
1092   type = check_typedef (value_type (value));
1093
1094   /* In the non_lvalue case, a reference might have slipped through
1095      here.  */
1096   if (TYPE_CODE (type) == TYPE_CODE_REF)
1097     type = check_typedef (TYPE_TARGET_TYPE (type));
1098
1099   /* Ignore top-level cv-qualifiers.  */
1100   type = make_cv_type (0, 0, type, NULL);
1101   gdbarch = get_type_arch (type);
1102
1103   type_name = type_to_string (type);
1104   if (type_name == NULL)
1105     error (_("cannot find typeinfo for unnamed type"));
1106   cleanup = make_cleanup (xfree, type_name);
1107
1108   /* We need to canonicalize the type name here, because we do lookups
1109      using the demangled name, and so we must match the format it
1110      uses.  E.g., GDB tends to use "const char *" as a type name, but
1111      the demangler uses "char const *".  */
1112   canonical = cp_canonicalize_string (type_name);
1113   if (canonical != NULL)
1114     {
1115       make_cleanup (xfree, canonical);
1116       type_name = canonical;
1117     }
1118
1119   typeinfo_type = gnuv3_get_typeid_type (gdbarch);
1120
1121   /* We check for lval_memory because in the "typeid (type-id)" case,
1122      the type is passed via a not_lval value object.  */
1123   if (TYPE_CODE (type) == TYPE_CODE_STRUCT
1124       && value_lval_const (value) == lval_memory
1125       && gnuv3_dynamic_class (type))
1126     {
1127       struct value *vtable, *typeinfo_value;
1128       CORE_ADDR address = value_address (value) + value_embedded_offset (value);
1129
1130       vtable = gnuv3_get_vtable (gdbarch, type, address);
1131       if (vtable == NULL)
1132         error (_("cannot find typeinfo for object of type '%s'"), type_name);
1133       typeinfo_value = value_field (vtable, vtable_field_type_info);
1134       result = value_ind (value_cast (make_pointer_type (typeinfo_type, NULL),
1135                                       typeinfo_value));
1136     }
1137   else
1138     {
1139       char *sym_name;
1140       struct bound_minimal_symbol minsym;
1141
1142       sym_name = concat ("typeinfo for ", type_name, (char *) NULL);
1143       make_cleanup (xfree, sym_name);
1144       minsym = lookup_minimal_symbol (sym_name, NULL, NULL);
1145
1146       if (minsym.minsym == NULL)
1147         error (_("could not find typeinfo symbol for '%s'"), type_name);
1148
1149       result = value_at_lazy (typeinfo_type, BMSYMBOL_VALUE_ADDRESS (minsym));
1150     }
1151
1152   do_cleanups (cleanup);
1153   return result;
1154 }
1155
1156 /* Implement the 'get_typename_from_type_info' method.  */
1157
1158 static char *
1159 gnuv3_get_typename_from_type_info (struct value *type_info_ptr)
1160 {
1161   struct gdbarch *gdbarch = get_type_arch (value_type (type_info_ptr));
1162   struct bound_minimal_symbol typeinfo_sym;
1163   CORE_ADDR addr;
1164   const char *symname;
1165   const char *class_name;
1166   const char *atsign;
1167
1168   addr = value_as_address (type_info_ptr);
1169   typeinfo_sym = lookup_minimal_symbol_by_pc (addr);
1170   if (typeinfo_sym.minsym == NULL)
1171     error (_("could not find minimal symbol for typeinfo address %s"),
1172            paddress (gdbarch, addr));
1173
1174 #define TYPEINFO_PREFIX "typeinfo for "
1175 #define TYPEINFO_PREFIX_LEN (sizeof (TYPEINFO_PREFIX) - 1)
1176   symname = MSYMBOL_DEMANGLED_NAME (typeinfo_sym.minsym);
1177   if (symname == NULL || strncmp (symname, TYPEINFO_PREFIX,
1178                                   TYPEINFO_PREFIX_LEN))
1179     error (_("typeinfo symbol '%s' has unexpected name"),
1180            MSYMBOL_LINKAGE_NAME (typeinfo_sym.minsym));
1181   class_name = symname + TYPEINFO_PREFIX_LEN;
1182
1183   /* Strip off @plt and version suffixes.  */
1184   atsign = strchr (class_name, '@');
1185   if (atsign != NULL)
1186     return savestring (class_name, atsign - class_name);
1187   return xstrdup (class_name);
1188 }
1189
1190 /* Implement the 'get_type_from_type_info' method.  */
1191
1192 static struct type *
1193 gnuv3_get_type_from_type_info (struct value *type_info_ptr)
1194 {
1195   char *type_name;
1196   struct cleanup *cleanup;
1197   struct value *type_val;
1198   struct expression *expr;
1199   struct type *result;
1200
1201   type_name = gnuv3_get_typename_from_type_info (type_info_ptr);
1202   cleanup = make_cleanup (xfree, type_name);
1203
1204   /* We have to parse the type name, since in general there is not a
1205      symbol for a type.  This is somewhat bogus since there may be a
1206      mis-parse.  Another approach might be to re-use the demangler's
1207      internal form to reconstruct the type somehow.  */
1208
1209   expr = parse_expression (type_name);
1210   make_cleanup (xfree, expr);
1211
1212   type_val = evaluate_type (expr);
1213   result = value_type (type_val);
1214
1215   do_cleanups (cleanup);
1216   return result;
1217 }
1218
1219 /* Determine if we are currently in a C++ thunk.  If so, get the address
1220    of the routine we are thunking to and continue to there instead.  */
1221
1222 static CORE_ADDR
1223 gnuv3_skip_trampoline (struct frame_info *frame, CORE_ADDR stop_pc)
1224 {
1225   CORE_ADDR real_stop_pc, method_stop_pc, func_addr;
1226   struct gdbarch *gdbarch = get_frame_arch (frame);
1227   struct bound_minimal_symbol thunk_sym, fn_sym;
1228   struct obj_section *section;
1229   const char *thunk_name, *fn_name;
1230
1231   real_stop_pc = gdbarch_skip_trampoline_code (gdbarch, frame, stop_pc);
1232   if (real_stop_pc == 0)
1233     real_stop_pc = stop_pc;
1234
1235   /* Find the linker symbol for this potential thunk.  */
1236   thunk_sym = lookup_minimal_symbol_by_pc (real_stop_pc);
1237   section = find_pc_section (real_stop_pc);
1238   if (thunk_sym.minsym == NULL || section == NULL)
1239     return 0;
1240
1241   /* The symbol's demangled name should be something like "virtual
1242      thunk to FUNCTION", where FUNCTION is the name of the function
1243      being thunked to.  */
1244   thunk_name = MSYMBOL_DEMANGLED_NAME (thunk_sym.minsym);
1245   if (thunk_name == NULL || strstr (thunk_name, " thunk to ") == NULL)
1246     return 0;
1247
1248   fn_name = strstr (thunk_name, " thunk to ") + strlen (" thunk to ");
1249   fn_sym = lookup_minimal_symbol (fn_name, NULL, section->objfile);
1250   if (fn_sym.minsym == NULL)
1251     return 0;
1252
1253   method_stop_pc = BMSYMBOL_VALUE_ADDRESS (fn_sym);
1254
1255   /* Some targets have minimal symbols pointing to function descriptors
1256      (powerpc 64 for example).  Make sure to retrieve the address
1257      of the real function from the function descriptor before passing on
1258      the address to other layers of GDB.  */
1259   func_addr = gdbarch_convert_from_func_ptr_addr (gdbarch, method_stop_pc,
1260                                                   &current_target);
1261   if (func_addr != 0)
1262     method_stop_pc = func_addr;
1263
1264   real_stop_pc = gdbarch_skip_trampoline_code
1265                    (gdbarch, frame, method_stop_pc);
1266   if (real_stop_pc == 0)
1267     real_stop_pc = method_stop_pc;
1268
1269   return real_stop_pc;
1270 }
1271
1272 /* Return nonzero if a type should be passed by reference.
1273
1274    The rule in the v3 ABI document comes from section 3.1.1.  If the
1275    type has a non-trivial copy constructor or destructor, then the
1276    caller must make a copy (by calling the copy constructor if there
1277    is one or perform the copy itself otherwise), pass the address of
1278    the copy, and then destroy the temporary (if necessary).
1279
1280    For return values with non-trivial copy constructors or
1281    destructors, space will be allocated in the caller, and a pointer
1282    will be passed as the first argument (preceding "this").
1283
1284    We don't have a bulletproof mechanism for determining whether a
1285    constructor or destructor is trivial.  For GCC and DWARF2 debug
1286    information, we can check the artificial flag.
1287
1288    We don't do anything with the constructors or destructors,
1289    but we have to get the argument passing right anyway.  */
1290 static int
1291 gnuv3_pass_by_reference (struct type *type)
1292 {
1293   int fieldnum, fieldelem;
1294
1295   type = check_typedef (type);
1296
1297   /* We're only interested in things that can have methods.  */
1298   if (TYPE_CODE (type) != TYPE_CODE_STRUCT
1299       && TYPE_CODE (type) != TYPE_CODE_UNION)
1300     return 0;
1301
1302   /* A dynamic class has a non-trivial copy constructor.
1303      See c++98 section 12.8 Copying class objects [class.copy].  */
1304   if (gnuv3_dynamic_class (type))
1305     return 1;
1306
1307   for (fieldnum = 0; fieldnum < TYPE_NFN_FIELDS (type); fieldnum++)
1308     for (fieldelem = 0; fieldelem < TYPE_FN_FIELDLIST_LENGTH (type, fieldnum);
1309          fieldelem++)
1310       {
1311         struct fn_field *fn = TYPE_FN_FIELDLIST1 (type, fieldnum);
1312         const char *name = TYPE_FN_FIELDLIST_NAME (type, fieldnum);
1313         struct type *fieldtype = TYPE_FN_FIELD_TYPE (fn, fieldelem);
1314
1315         /* If this function is marked as artificial, it is compiler-generated,
1316            and we assume it is trivial.  */
1317         if (TYPE_FN_FIELD_ARTIFICIAL (fn, fieldelem))
1318           continue;
1319
1320         /* If we've found a destructor, we must pass this by reference.  */
1321         if (name[0] == '~')
1322           return 1;
1323
1324         /* If the mangled name of this method doesn't indicate that it
1325            is a constructor, we're not interested.
1326
1327            FIXME drow/2007-09-23: We could do this using the name of
1328            the method and the name of the class instead of dealing
1329            with the mangled name.  We don't have a convenient function
1330            to strip off both leading scope qualifiers and trailing
1331            template arguments yet.  */
1332         if (!is_constructor_name (TYPE_FN_FIELD_PHYSNAME (fn, fieldelem))
1333             && !TYPE_FN_FIELD_CONSTRUCTOR (fn, fieldelem))
1334           continue;
1335
1336         /* If this method takes two arguments, and the second argument is
1337            a reference to this class, then it is a copy constructor.  */
1338         if (TYPE_NFIELDS (fieldtype) == 2)
1339           {
1340             struct type *arg_type = TYPE_FIELD_TYPE (fieldtype, 1);
1341
1342             if (TYPE_CODE (arg_type) == TYPE_CODE_REF)
1343               {
1344                 struct type *arg_target_type;
1345
1346                 arg_target_type = check_typedef (TYPE_TARGET_TYPE (arg_type));
1347                 if (class_types_same_p (arg_target_type, type))
1348                   return 1;
1349               }
1350           }
1351       }
1352
1353   /* Even if all the constructors and destructors were artificial, one
1354      of them may have invoked a non-artificial constructor or
1355      destructor in a base class.  If any base class needs to be passed
1356      by reference, so does this class.  Similarly for members, which
1357      are constructed whenever this class is.  We do not need to worry
1358      about recursive loops here, since we are only looking at members
1359      of complete class type.  Also ignore any static members.  */
1360   for (fieldnum = 0; fieldnum < TYPE_NFIELDS (type); fieldnum++)
1361     if (! field_is_static (&TYPE_FIELD (type, fieldnum))
1362         && gnuv3_pass_by_reference (TYPE_FIELD_TYPE (type, fieldnum)))
1363       return 1;
1364
1365   return 0;
1366 }
1367
1368 static void
1369 init_gnuv3_ops (void)
1370 {
1371   vtable_type_gdbarch_data
1372     = gdbarch_data_register_post_init (build_gdb_vtable_type);
1373   std_type_info_gdbarch_data
1374     = gdbarch_data_register_post_init (build_std_type_info_type);
1375
1376   gnu_v3_abi_ops.shortname = "gnu-v3";
1377   gnu_v3_abi_ops.longname = "GNU G++ Version 3 ABI";
1378   gnu_v3_abi_ops.doc = "G++ Version 3 ABI";
1379   gnu_v3_abi_ops.is_destructor_name =
1380     (enum dtor_kinds (*) (const char *))is_gnu_v3_mangled_dtor;
1381   gnu_v3_abi_ops.is_constructor_name =
1382     (enum ctor_kinds (*) (const char *))is_gnu_v3_mangled_ctor;
1383   gnu_v3_abi_ops.is_vtable_name = gnuv3_is_vtable_name;
1384   gnu_v3_abi_ops.is_operator_name = gnuv3_is_operator_name;
1385   gnu_v3_abi_ops.rtti_type = gnuv3_rtti_type;
1386   gnu_v3_abi_ops.virtual_fn_field = gnuv3_virtual_fn_field;
1387   gnu_v3_abi_ops.baseclass_offset = gnuv3_baseclass_offset;
1388   gnu_v3_abi_ops.print_method_ptr = gnuv3_print_method_ptr;
1389   gnu_v3_abi_ops.method_ptr_size = gnuv3_method_ptr_size;
1390   gnu_v3_abi_ops.make_method_ptr = gnuv3_make_method_ptr;
1391   gnu_v3_abi_ops.method_ptr_to_value = gnuv3_method_ptr_to_value;
1392   gnu_v3_abi_ops.print_vtable = gnuv3_print_vtable;
1393   gnu_v3_abi_ops.get_typeid = gnuv3_get_typeid;
1394   gnu_v3_abi_ops.get_typeid_type = gnuv3_get_typeid_type;
1395   gnu_v3_abi_ops.get_type_from_type_info = gnuv3_get_type_from_type_info;
1396   gnu_v3_abi_ops.get_typename_from_type_info
1397     = gnuv3_get_typename_from_type_info;
1398   gnu_v3_abi_ops.skip_trampoline = gnuv3_skip_trampoline;
1399   gnu_v3_abi_ops.pass_by_reference = gnuv3_pass_by_reference;
1400 }
1401
1402 extern initialize_file_ftype _initialize_gnu_v3_abi; /* -Wmissing-prototypes */
1403
1404 void
1405 _initialize_gnu_v3_abi (void)
1406 {
1407   init_gnuv3_ops ();
1408
1409   register_cp_abi (&gnu_v3_abi_ops);
1410   set_cp_abi_as_auto_default (gnu_v3_abi_ops.shortname);
1411 }