gdb/gnu-v3-abi.c

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