gdb/gnu-v3-abi.c

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