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   type = 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   container_type = 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       int got_error = 0;
 908       struct value *vfn;
 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
 920         {
 921           addr = value_as_address (vfn);
 922         }
 923       CATCH (ex, RETURN_MASK_ERROR)
 924         {
 925           printf_filtered (_("<error: %s>"), ex.message);
 926           got_error = 1;
 927         }
 928       END_CATCH
 929
 930       if (!got_error)
 931         print_function_pointer_address (opts, gdbarch, addr, gdb_stdout);
 932       printf_filtered ("\n");
 933     }
 934 }
 935
 936 /* Implementation of the print_vtable method.  */
 937
 938 static void
 939 gnuv3_print_vtable (struct value *value)
 940 {
 941   struct gdbarch *gdbarch;
 942   struct type *type;
 943   struct value *vtable;
 944   struct value_print_options opts;
 945   htab_t offset_hash;
 946   struct cleanup *cleanup;
 947   VEC (value_and_voffset_p) *result_vec = NULL;
 948   struct value_and_voffset *iter;
 949   int i, count;
 950
 951   value = coerce_ref (value);
 952   type = check_typedef (value_type (value));
 953   if (TYPE_CODE (type) == TYPE_CODE_PTR)
 954     {
 955       value = value_ind (value);
 956       type = check_typedef (value_type (value));
 957     }
 958
 959   get_user_print_options (&opts);
 960
 961   /* Respect 'set print object'.  */
 962   if (opts.objectprint)
 963     {
 964       value = value_full_object (value, NULL, 0, 0, 0);
 965       type = check_typedef (value_type (value));
 966     }
 967
 968   gdbarch = get_type_arch (type);
 969
 970   vtable = NULL;
 971   if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
 972     vtable = gnuv3_get_vtable (gdbarch, type,
 973                                value_as_address (value_addr (value)));
 974
 975   if (!vtable)
 976     {
 977       printf_filtered (_("This object does not have a virtual function table\n"));
 978       return;
 979     }
 980
 981   offset_hash = htab_create_alloc (1, hash_value_and_voffset,
 982                                    eq_value_and_voffset,
 983                                    xfree, xcalloc, xfree);
 984   cleanup = make_cleanup_htab_delete (offset_hash);
 985   make_cleanup (VEC_cleanup (value_and_voffset_p), &result_vec);
 986
 987   compute_vtable_size (offset_hash, &result_vec, value);
 988
 989   qsort (VEC_address (value_and_voffset_p, result_vec),
 990          VEC_length (value_and_voffset_p, result_vec),
 991          sizeof (value_and_voffset_p),
 992          compare_value_and_voffset);
 993
 994   count = 0;
 995   for (i = 0; VEC_iterate (value_and_voffset_p, result_vec, i, iter); ++i)
 996     {
 997       if (iter->max_voffset >= 0)
 998         {
 999           if (count > 0)
1000             printf_filtered ("\n");
1001           print_one_vtable (gdbarch, iter->value, iter->max_voffset, &opts);
1002           ++count;
1003         }
1004     }
1005
1006   do_cleanups (cleanup);
1007 }
1008
1009 /* Return a GDB type representing `struct std::type_info', laid out
1010    appropriately for ARCH.
1011
1012    We use this function as the gdbarch per-architecture data
1013    initialization function.  */
1014
1015 static void *
1016 build_std_type_info_type (struct gdbarch *arch)
1017 {
1018   struct type *t;
1019   struct field *field_list, *field;
1020   int offset;
1021   struct type *void_ptr_type
1022     = builtin_type (arch)->builtin_data_ptr;
1023   struct type *char_type
1024     = builtin_type (arch)->builtin_char;
1025   struct type *char_ptr_type
1026     = make_pointer_type (make_cv_type (1, 0, char_type, NULL), NULL);
1027
1028   field_list = xmalloc (sizeof (struct field [2]));
1029   memset (field_list, 0, sizeof (struct field [2]));
1030   field = &field_list[0];
1031   offset = 0;
1032
1033   /* The vtable.  */
1034   FIELD_NAME (*field) = "_vptr.type_info";
1035   FIELD_TYPE (*field) = void_ptr_type;
1036   SET_FIELD_BITPOS (*field, offset * TARGET_CHAR_BIT);
1037   offset += TYPE_LENGTH (FIELD_TYPE (*field));
1038   field++;
1039
1040   /* The name.  */
1041   FIELD_NAME (*field) = "__name";
1042   FIELD_TYPE (*field) = char_ptr_type;
1043   SET_FIELD_BITPOS (*field, offset * TARGET_CHAR_BIT);
1044   offset += TYPE_LENGTH (FIELD_TYPE (*field));
1045   field++;
1046
1047   gdb_assert (field == (field_list + 2));
1048
1049   t = arch_type (arch, TYPE_CODE_STRUCT, offset, NULL);
1050   TYPE_NFIELDS (t) = field - field_list;
1051   TYPE_FIELDS (t) = field_list;
1052   TYPE_TAG_NAME (t) = "gdb_gnu_v3_type_info";
1053   INIT_CPLUS_SPECIFIC (t);
1054
1055   return t;
1056 }
1057
1058 /* Implement the 'get_typeid_type' method.  */
1059
1060 static struct type *
1061 gnuv3_get_typeid_type (struct gdbarch *gdbarch)
1062 {
1063   struct symbol *typeinfo;
1064   struct type *typeinfo_type;
1065
1066   typeinfo = lookup_symbol ("std::type_info", NULL, STRUCT_DOMAIN,
1067                             NULL).symbol;
1068   if (typeinfo == NULL)
1069     typeinfo_type = gdbarch_data (gdbarch, std_type_info_gdbarch_data);
1070   else
1071     typeinfo_type = SYMBOL_TYPE (typeinfo);
1072
1073   return typeinfo_type;
1074 }
1075
1076 /* Implement the 'get_typeid' method.  */
1077
1078 static struct value *
1079 gnuv3_get_typeid (struct value *value)
1080 {
1081   struct type *typeinfo_type;
1082   struct type *type;
1083   struct gdbarch *gdbarch;
1084   struct cleanup *cleanup;
1085   struct value *result;
1086   char *type_name, *canonical;
1087
1088   /* We have to handle values a bit trickily here, to allow this code
1089      to work properly with non_lvalue values that are really just
1090      disguised types.  */
1091   if (value_lval_const (value) == lval_memory)
1092     value = coerce_ref (value);
1093
1094   type = check_typedef (value_type (value));
1095
1096   /* In the non_lvalue case, a reference might have slipped through
1097      here.  */
1098   if (TYPE_CODE (type) == TYPE_CODE_REF)
1099     type = check_typedef (TYPE_TARGET_TYPE (type));
1100
1101   /* Ignore top-level cv-qualifiers.  */
1102   type = make_cv_type (0, 0, type, NULL);
1103   gdbarch = get_type_arch (type);
1104
1105   type_name = type_to_string (type);
1106   if (type_name == NULL)
1107     error (_("cannot find typeinfo for unnamed type"));
1108   cleanup = make_cleanup (xfree, type_name);
1109
1110   /* We need to canonicalize the type name here, because we do lookups
1111      using the demangled name, and so we must match the format it
1112      uses.  E.g., GDB tends to use "const char *" as a type name, but
1113      the demangler uses "char const *".  */
1114   canonical = cp_canonicalize_string (type_name);
1115   if (canonical != NULL)
1116     {
1117       make_cleanup (xfree, canonical);
1118       type_name = canonical;
1119     }
1120
1121   typeinfo_type = gnuv3_get_typeid_type (gdbarch);
1122
1123   /* We check for lval_memory because in the "typeid (type-id)" case,
1124      the type is passed via a not_lval value object.  */
1125   if (TYPE_CODE (type) == TYPE_CODE_STRUCT
1126       && value_lval_const (value) == lval_memory
1127       && gnuv3_dynamic_class (type))
1128     {
1129       struct value *vtable, *typeinfo_value;
1130       CORE_ADDR address = value_address (value) + value_embedded_offset (value);
1131
1132       vtable = gnuv3_get_vtable (gdbarch, type, address);
1133       if (vtable == NULL)
1134         error (_("cannot find typeinfo for object of type '%s'"), type_name);
1135       typeinfo_value = value_field (vtable, vtable_field_type_info);
1136       result = value_ind (value_cast (make_pointer_type (typeinfo_type, NULL),
1137                                       typeinfo_value));
1138     }
1139   else
1140     {
1141       char *sym_name;
1142       struct bound_minimal_symbol minsym;
1143
1144       sym_name = concat ("typeinfo for ", type_name, (char *) NULL);
1145       make_cleanup (xfree, sym_name);
1146       minsym = lookup_minimal_symbol (sym_name, NULL, NULL);
1147
1148       if (minsym.minsym == NULL)
1149         error (_("could not find typeinfo symbol for '%s'"), type_name);
1150
1151       result = value_at_lazy (typeinfo_type, BMSYMBOL_VALUE_ADDRESS (minsym));
1152     }
1153
1154   do_cleanups (cleanup);
1155   return result;
1156 }
1157
1158 /* Implement the 'get_typename_from_type_info' method.  */
1159
1160 static char *
1161 gnuv3_get_typename_from_type_info (struct value *type_info_ptr)
1162 {
1163   struct gdbarch *gdbarch = get_type_arch (value_type (type_info_ptr));
1164   struct bound_minimal_symbol typeinfo_sym;
1165   CORE_ADDR addr;
1166   const char *symname;
1167   const char *class_name;
1168   const char *atsign;
1169
1170   addr = value_as_address (type_info_ptr);
1171   typeinfo_sym = lookup_minimal_symbol_by_pc (addr);
1172   if (typeinfo_sym.minsym == NULL)
1173     error (_("could not find minimal symbol for typeinfo address %s"),
1174            paddress (gdbarch, addr));
1175
1176 #define TYPEINFO_PREFIX "typeinfo for "
1177 #define TYPEINFO_PREFIX_LEN (sizeof (TYPEINFO_PREFIX) - 1)
1178   symname = MSYMBOL_DEMANGLED_NAME (typeinfo_sym.minsym);
1179   if (symname == NULL || strncmp (symname, TYPEINFO_PREFIX,
1180                                   TYPEINFO_PREFIX_LEN))
1181     error (_("typeinfo symbol '%s' has unexpected name"),
1182            MSYMBOL_LINKAGE_NAME (typeinfo_sym.minsym));
1183   class_name = symname + TYPEINFO_PREFIX_LEN;
1184
1185   /* Strip off @plt and version suffixes.  */
1186   atsign = strchr (class_name, '@');
1187   if (atsign != NULL)
1188     return savestring (class_name, atsign - class_name);
1189   return xstrdup (class_name);
1190 }
1191
1192 /* Implement the 'get_type_from_type_info' method.  */
1193
1194 static struct type *
1195 gnuv3_get_type_from_type_info (struct value *type_info_ptr)
1196 {
1197   char *type_name;
1198   struct cleanup *cleanup;
1199   struct value *type_val;
1200   struct expression *expr;
1201   struct type *result;
1202
1203   type_name = gnuv3_get_typename_from_type_info (type_info_ptr);
1204   cleanup = make_cleanup (xfree, type_name);
1205
1206   /* We have to parse the type name, since in general there is not a
1207      symbol for a type.  This is somewhat bogus since there may be a
1208      mis-parse.  Another approach might be to re-use the demangler's
1209      internal form to reconstruct the type somehow.  */
1210
1211   expr = parse_expression (type_name);
1212   make_cleanup (xfree, expr);
1213
1214   type_val = evaluate_type (expr);
1215   result = value_type (type_val);
1216
1217   do_cleanups (cleanup);
1218   return result;
1219 }
1220
1221 /* Determine if we are currently in a C++ thunk.  If so, get the address
1222    of the routine we are thunking to and continue to there instead.  */
1223
1224 static CORE_ADDR
1225 gnuv3_skip_trampoline (struct frame_info *frame, CORE_ADDR stop_pc)
1226 {
1227   CORE_ADDR real_stop_pc, method_stop_pc, func_addr;
1228   struct gdbarch *gdbarch = get_frame_arch (frame);
1229   struct bound_minimal_symbol thunk_sym, fn_sym;
1230   struct obj_section *section;
1231   const char *thunk_name, *fn_name;
1232
1233   real_stop_pc = gdbarch_skip_trampoline_code (gdbarch, frame, stop_pc);
1234   if (real_stop_pc == 0)
1235     real_stop_pc = stop_pc;
1236
1237   /* Find the linker symbol for this potential thunk.  */
1238   thunk_sym = lookup_minimal_symbol_by_pc (real_stop_pc);
1239   section = find_pc_section (real_stop_pc);
1240   if (thunk_sym.minsym == NULL || section == NULL)
1241     return 0;
1242
1243   /* The symbol's demangled name should be something like "virtual
1244      thunk to FUNCTION", where FUNCTION is the name of the function
1245      being thunked to.  */
1246   thunk_name = MSYMBOL_DEMANGLED_NAME (thunk_sym.minsym);
1247   if (thunk_name == NULL || strstr (thunk_name, " thunk to ") == NULL)
1248     return 0;
1249
1250   fn_name = strstr (thunk_name, " thunk to ") + strlen (" thunk to ");
1251   fn_sym = lookup_minimal_symbol (fn_name, NULL, section->objfile);
1252   if (fn_sym.minsym == NULL)
1253     return 0;
1254
1255   method_stop_pc = BMSYMBOL_VALUE_ADDRESS (fn_sym);
1256
1257   /* Some targets have minimal symbols pointing to function descriptors
1258      (powerpc 64 for example).  Make sure to retrieve the address
1259      of the real function from the function descriptor before passing on
1260      the address to other layers of GDB.  */
1261   func_addr = gdbarch_convert_from_func_ptr_addr (gdbarch, method_stop_pc,
1262                                                   &current_target);
1263   if (func_addr != 0)
1264     method_stop_pc = func_addr;
1265
1266   real_stop_pc = gdbarch_skip_trampoline_code
1267                    (gdbarch, frame, method_stop_pc);
1268   if (real_stop_pc == 0)
1269     real_stop_pc = method_stop_pc;
1270
1271   return real_stop_pc;
1272 }
1273
1274 /* Return nonzero if a type should be passed by reference.
1275
1276    The rule in the v3 ABI document comes from section 3.1.1.  If the
1277    type has a non-trivial copy constructor or destructor, then the
1278    caller must make a copy (by calling the copy constructor if there
1279    is one or perform the copy itself otherwise), pass the address of
1280    the copy, and then destroy the temporary (if necessary).
1281
1282    For return values with non-trivial copy constructors or
1283    destructors, space will be allocated in the caller, and a pointer
1284    will be passed as the first argument (preceding "this").
1285
1286    We don't have a bulletproof mechanism for determining whether a
1287    constructor or destructor is trivial.  For GCC and DWARF2 debug
1288    information, we can check the artificial flag.
1289
1290    We don't do anything with the constructors or destructors,
1291    but we have to get the argument passing right anyway.  */
1292 static int
1293 gnuv3_pass_by_reference (struct type *type)
1294 {
1295   int fieldnum, fieldelem;
1296
1297   type = check_typedef (type);
1298
1299   /* We're only interested in things that can have methods.  */
1300   if (TYPE_CODE (type) != TYPE_CODE_STRUCT
1301       && TYPE_CODE (type) != TYPE_CODE_UNION)
1302     return 0;
1303
1304   /* A dynamic class has a non-trivial copy constructor.
1305      See c++98 section 12.8 Copying class objects [class.copy].  */
1306   if (gnuv3_dynamic_class (type))
1307     return 1;
1308
1309   for (fieldnum = 0; fieldnum < TYPE_NFN_FIELDS (type); fieldnum++)
1310     for (fieldelem = 0; fieldelem < TYPE_FN_FIELDLIST_LENGTH (type, fieldnum);
1311          fieldelem++)
1312       {
1313         struct fn_field *fn = TYPE_FN_FIELDLIST1 (type, fieldnum);
1314         const char *name = TYPE_FN_FIELDLIST_NAME (type, fieldnum);
1315         struct type *fieldtype = TYPE_FN_FIELD_TYPE (fn, fieldelem);
1316
1317         /* If this function is marked as artificial, it is compiler-generated,
1318            and we assume it is trivial.  */
1319         if (TYPE_FN_FIELD_ARTIFICIAL (fn, fieldelem))
1320           continue;
1321
1322         /* If we've found a destructor, we must pass this by reference.  */
1323         if (name[0] == '~')
1324           return 1;
1325
1326         /* If the mangled name of this method doesn't indicate that it
1327            is a constructor, we're not interested.
1328
1329            FIXME drow/2007-09-23: We could do this using the name of
1330            the method and the name of the class instead of dealing
1331            with the mangled name.  We don't have a convenient function
1332            to strip off both leading scope qualifiers and trailing
1333            template arguments yet.  */
1334         if (!is_constructor_name (TYPE_FN_FIELD_PHYSNAME (fn, fieldelem))
1335             && !TYPE_FN_FIELD_CONSTRUCTOR (fn, fieldelem))
1336           continue;
1337
1338         /* If this method takes two arguments, and the second argument is
1339            a reference to this class, then it is a copy constructor.  */
1340         if (TYPE_NFIELDS (fieldtype) == 2)
1341           {
1342             struct type *arg_type = TYPE_FIELD_TYPE (fieldtype, 1);
1343
1344             if (TYPE_CODE (arg_type) == TYPE_CODE_REF)
1345               {
1346                 struct type *arg_target_type;
1347
1348                 arg_target_type = check_typedef (TYPE_TARGET_TYPE (arg_type));
1349                 if (class_types_same_p (arg_target_type, type))
1350                   return 1;
1351               }
1352           }
1353       }
1354
1355   /* Even if all the constructors and destructors were artificial, one
1356      of them may have invoked a non-artificial constructor or
1357      destructor in a base class.  If any base class needs to be passed
1358      by reference, so does this class.  Similarly for members, which
1359      are constructed whenever this class is.  We do not need to worry
1360      about recursive loops here, since we are only looking at members
1361      of complete class type.  Also ignore any static members.  */
1362   for (fieldnum = 0; fieldnum < TYPE_NFIELDS (type); fieldnum++)
1363     if (! field_is_static (&TYPE_FIELD (type, fieldnum))
1364         && gnuv3_pass_by_reference (TYPE_FIELD_TYPE (type, fieldnum)))
1365       return 1;
1366
1367   return 0;
1368 }
1369
1370 static void
1371 init_gnuv3_ops (void)
1372 {
1373   vtable_type_gdbarch_data
1374     = gdbarch_data_register_post_init (build_gdb_vtable_type);
1375   std_type_info_gdbarch_data
1376     = gdbarch_data_register_post_init (build_std_type_info_type);
1377
1378   gnu_v3_abi_ops.shortname = "gnu-v3";
1379   gnu_v3_abi_ops.longname = "GNU G++ Version 3 ABI";
1380   gnu_v3_abi_ops.doc = "G++ Version 3 ABI";
1381   gnu_v3_abi_ops.is_destructor_name =
1382     (enum dtor_kinds (*) (const char *))is_gnu_v3_mangled_dtor;
1383   gnu_v3_abi_ops.is_constructor_name =
1384     (enum ctor_kinds (*) (const char *))is_gnu_v3_mangled_ctor;
1385   gnu_v3_abi_ops.is_vtable_name = gnuv3_is_vtable_name;
1386   gnu_v3_abi_ops.is_operator_name = gnuv3_is_operator_name;
1387   gnu_v3_abi_ops.rtti_type = gnuv3_rtti_type;
1388   gnu_v3_abi_ops.virtual_fn_field = gnuv3_virtual_fn_field;
1389   gnu_v3_abi_ops.baseclass_offset = gnuv3_baseclass_offset;
1390   gnu_v3_abi_ops.print_method_ptr = gnuv3_print_method_ptr;
1391   gnu_v3_abi_ops.method_ptr_size = gnuv3_method_ptr_size;
1392   gnu_v3_abi_ops.make_method_ptr = gnuv3_make_method_ptr;
1393   gnu_v3_abi_ops.method_ptr_to_value = gnuv3_method_ptr_to_value;
1394   gnu_v3_abi_ops.print_vtable = gnuv3_print_vtable;
1395   gnu_v3_abi_ops.get_typeid = gnuv3_get_typeid;
1396   gnu_v3_abi_ops.get_typeid_type = gnuv3_get_typeid_type;
1397   gnu_v3_abi_ops.get_type_from_type_info = gnuv3_get_type_from_type_info;
1398   gnu_v3_abi_ops.get_typename_from_type_info
1399     = gnuv3_get_typename_from_type_info;
1400   gnu_v3_abi_ops.skip_trampoline = gnuv3_skip_trampoline;
1401   gnu_v3_abi_ops.pass_by_reference = gnuv3_pass_by_reference;
1402 }
1403
1404 extern initialize_file_ftype _initialize_gnu_v3_abi; /* -Wmissing-prototypes */
1405
1406 void
1407 _initialize_gnu_v3_abi (void)
1408 {
1409   init_gnuv3_ops ();
1410
1411   register_cp_abi (&gnu_v3_abi_ops);
1412   set_cp_abi_as_auto_default (gnu_v3_abi_ops.shortname);
1413 }