gdb/gnu-v3-abi.c

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