contrib/gdb-7/gdb/gnu-v3-abi.c

   1 /* Abstraction of GNU v3 abi.
   2    Contributed by Jim Blandy <jimb@redhat.com>
   3
   4    Copyright (C) 2001, 2002, 2003, 2005, 2006, 2007, 2008, 2009, 2010, 2011
   5    Free Software Foundation, Inc.
   6
   7    This file is part of GDB.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  21
  22 #include "defs.h"
  23 #include "value.h"
  24 #include "cp-abi.h"
  25 #include "cp-support.h"
  26 #include "demangle.h"
  27 #include "objfiles.h"
  28 #include "valprint.h"
  29 #include "c-lang.h"
  30
  31 #include "gdb_assert.h"
  32 #include "gdb_string.h"
  33
  34 static struct cp_abi_ops gnu_v3_abi_ops;
  35
  36 static int
  37 gnuv3_is_vtable_name (const char *name)
  38 {
  39   return strncmp (name, "_ZTV", 4) == 0;
  40 }
  41
  42 static int
  43 gnuv3_is_operator_name (const char *name)
  44 {
  45   return strncmp (name, "operator", 8) == 0;
  46 }
  47
  48
  49 /* To help us find the components of a vtable, we build ourselves a
  50    GDB type object representing the vtable structure.  Following the
  51    V3 ABI, it goes something like this:
  52
  53    struct gdb_gnu_v3_abi_vtable {
  54
  55      / * An array of virtual call and virtual base offsets.  The real
  56          length of this array depends on the class hierarchy; we use
  57          negative subscripts to access the elements.  Yucky, but
  58          better than the alternatives.  * /
  59      ptrdiff_t vcall_and_vbase_offsets[0];
  60
  61      / * The offset from a virtual pointer referring to this table
  62          to the top of the complete object.  * /
  63      ptrdiff_t offset_to_top;
  64
  65      / * The type_info pointer for this class.  This is really a
  66          std::type_info *, but GDB doesn't really look at the
  67          type_info object itself, so we don't bother to get the type
  68          exactly right.  * /
  69      void *type_info;
  70
  71      / * Virtual table pointers in objects point here.  * /
  72
  73      / * Virtual function pointers.  Like the vcall/vbase array, the
  74          real length of this table depends on the class hierarchy.  * /
  75      void (*virtual_functions[0]) ();
  76
  77    };
  78
  79    The catch, of course, is that the exact layout of this table
  80    depends on the ABI --- word size, endianness, alignment, etc.  So
  81    the GDB type object is actually a per-architecture kind of thing.
  82
  83    vtable_type_gdbarch_data is a gdbarch per-architecture data pointer
  84    which refers to the struct type * for this structure, laid out
  85    appropriately for the architecture.  */
  86 static struct gdbarch_data *vtable_type_gdbarch_data;
  87
  88
  89 /* Human-readable names for the numbers of the fields above.  */
  90 enum {
  91   vtable_field_vcall_and_vbase_offsets,
  92   vtable_field_offset_to_top,
  93   vtable_field_type_info,
  94   vtable_field_virtual_functions
  95 };
  96
  97
  98 /* Return a GDB type representing `struct gdb_gnu_v3_abi_vtable',
  99    described above, laid out appropriately for ARCH.
 100
 101    We use this function as the gdbarch per-architecture data
 102    initialization function.  */
 103 static void *
 104 build_gdb_vtable_type (struct gdbarch *arch)
 105 {
 106   struct type *t;
 107   struct field *field_list, *field;
 108   int offset;
 109
 110   struct type *void_ptr_type
 111     = builtin_type (arch)->builtin_data_ptr;
 112   struct type *ptr_to_void_fn_type
 113     = builtin_type (arch)->builtin_func_ptr;
 114
 115   /* ARCH can't give us the true ptrdiff_t type, so we guess.  */
 116   struct type *ptrdiff_type
 117     = arch_integer_type (arch, gdbarch_ptr_bit (arch), 0, "ptrdiff_t");
 118
 119   /* We assume no padding is necessary, since GDB doesn't know
 120      anything about alignment at the moment.  If this assumption bites
 121      us, we should add a gdbarch method which, given a type, returns
 122      the alignment that type requires, and then use that here.  */
 123
 124   /* Build the field list.  */
 125   field_list = xmalloc (sizeof (struct field [4]));
 126   memset (field_list, 0, sizeof (struct field [4]));
 127   field = &field_list[0];
 128   offset = 0;
 129
 130   /* ptrdiff_t vcall_and_vbase_offsets[0]; */
 131   FIELD_NAME (*field) = "vcall_and_vbase_offsets";
 132   FIELD_TYPE (*field) = lookup_array_range_type (ptrdiff_type, 0, -1);
 133   FIELD_BITPOS (*field) = offset * TARGET_CHAR_BIT;
 134   offset += TYPE_LENGTH (FIELD_TYPE (*field));
 135   field++;
 136
 137   /* ptrdiff_t offset_to_top; */
 138   FIELD_NAME (*field) = "offset_to_top";
 139   FIELD_TYPE (*field) = ptrdiff_type;
 140   FIELD_BITPOS (*field) = offset * TARGET_CHAR_BIT;
 141   offset += TYPE_LENGTH (FIELD_TYPE (*field));
 142   field++;
 143
 144   /* void *type_info; */
 145   FIELD_NAME (*field) = "type_info";
 146   FIELD_TYPE (*field) = void_ptr_type;
 147   FIELD_BITPOS (*field) = offset * TARGET_CHAR_BIT;
 148   offset += TYPE_LENGTH (FIELD_TYPE (*field));
 149   field++;
 150
 151   /* void (*virtual_functions[0]) (); */
 152   FIELD_NAME (*field) = "virtual_functions";
 153   FIELD_TYPE (*field) = lookup_array_range_type (ptr_to_void_fn_type, 0, -1);
 154   FIELD_BITPOS (*field) = offset * TARGET_CHAR_BIT;
 155   offset += TYPE_LENGTH (FIELD_TYPE (*field));
 156   field++;
 157
 158   /* We assumed in the allocation above that there were four fields.  */
 159   gdb_assert (field == (field_list + 4));
 160
 161   t = arch_type (arch, TYPE_CODE_STRUCT, offset, NULL);
 162   TYPE_NFIELDS (t) = field - field_list;
 163   TYPE_FIELDS (t) = field_list;
 164   TYPE_TAG_NAME (t) = "gdb_gnu_v3_abi_vtable";
 165   INIT_CPLUS_SPECIFIC (t);
 166
 167   return t;
 168 }
 169
 170
 171 /* Return the ptrdiff_t type used in the vtable type.  */
 172 static struct type *
 173 vtable_ptrdiff_type (struct gdbarch *gdbarch)
 174 {
 175   struct type *vtable_type = gdbarch_data (gdbarch, vtable_type_gdbarch_data);
 176
 177   /* The "offset_to_top" field has the appropriate (ptrdiff_t) type.  */
 178   return TYPE_FIELD_TYPE (vtable_type, vtable_field_offset_to_top);
 179 }
 180
 181 /* Return the offset from the start of the imaginary `struct
 182    gdb_gnu_v3_abi_vtable' object to the vtable's "address point"
 183    (i.e., where objects' virtual table pointers point).  */
 184 static int
 185 vtable_address_point_offset (struct gdbarch *gdbarch)
 186 {
 187   struct type *vtable_type = gdbarch_data (gdbarch, vtable_type_gdbarch_data);
 188
 189   return (TYPE_FIELD_BITPOS (vtable_type, vtable_field_virtual_functions)
 190           / TARGET_CHAR_BIT);
 191 }
 192
 193
 194 /* Determine whether structure TYPE is a dynamic class.  Cache the
 195    result.  */
 196
 197 static int
 198 gnuv3_dynamic_class (struct type *type)
 199 {
 200   int fieldnum, fieldelem;
 201
 202   if (TYPE_CPLUS_DYNAMIC (type))
 203     return TYPE_CPLUS_DYNAMIC (type) == 1;
 204
 205   ALLOCATE_CPLUS_STRUCT_TYPE (type);
 206
 207   for (fieldnum = 0; fieldnum < TYPE_N_BASECLASSES (type); fieldnum++)
 208     if (BASETYPE_VIA_VIRTUAL (type, fieldnum)
 209         || gnuv3_dynamic_class (TYPE_FIELD_TYPE (type, fieldnum)))
 210       {
 211         TYPE_CPLUS_DYNAMIC (type) = 1;
 212         return 1;
 213       }
 214
 215   for (fieldnum = 0; fieldnum < TYPE_NFN_FIELDS (type); fieldnum++)
 216     for (fieldelem = 0; fieldelem < TYPE_FN_FIELDLIST_LENGTH (type, fieldnum);
 217          fieldelem++)
 218       {
 219         struct fn_field *f = TYPE_FN_FIELDLIST1 (type, fieldnum);
 220
 221         if (TYPE_FN_FIELD_VIRTUAL_P (f, fieldelem))
 222           {
 223             TYPE_CPLUS_DYNAMIC (type) = 1;
 224             return 1;
 225           }
 226       }
 227
 228   TYPE_CPLUS_DYNAMIC (type) = -1;
 229   return 0;
 230 }
 231
 232 /* Find the vtable for a value of CONTAINER_TYPE located at
 233    CONTAINER_ADDR.  Return a value of the correct vtable type for this
 234    architecture, or NULL if CONTAINER does not have a vtable.  */
 235
 236 static struct value *
 237 gnuv3_get_vtable (struct gdbarch *gdbarch,
 238                   struct type *container_type, CORE_ADDR container_addr)
 239 {
 240   struct type *vtable_type = gdbarch_data (gdbarch,
 241                                            vtable_type_gdbarch_data);
 242   struct type *vtable_pointer_type;
 243   struct value *vtable_pointer;
 244   CORE_ADDR vtable_address;
 245
 246   /* If this type does not have a virtual table, don't read the first
 247      field.  */
 248   if (!gnuv3_dynamic_class (check_typedef (container_type)))
 249     return NULL;
 250
 251   /* We do not consult the debug information to find the virtual table.
 252      The ABI specifies that it is always at offset zero in any class,
 253      and debug information may not represent it.
 254
 255      We avoid using value_contents on principle, because the object might
 256      be large.  */
 257
 258   /* Find the type "pointer to virtual table".  */
 259   vtable_pointer_type = lookup_pointer_type (vtable_type);
 260
 261   /* Load it from the start of the class.  */
 262   vtable_pointer = value_at (vtable_pointer_type, container_addr);
 263   vtable_address = value_as_address (vtable_pointer);
 264
 265   /* Correct it to point at the start of the virtual table, rather
 266      than the address point.  */
 267   return value_at_lazy (vtable_type,
 268                         vtable_address
 269                         - vtable_address_point_offset (gdbarch));
 270 }
 271
 272
 273 static struct type *
 274 gnuv3_rtti_type (struct value *value,
 275                  int *full_p, int *top_p, int *using_enc_p)
 276 {
 277   struct gdbarch *gdbarch;
 278   struct type *values_type = check_typedef (value_type (value));
 279   struct value *vtable;
 280   struct minimal_symbol *vtable_symbol;
 281   const char *vtable_symbol_name;
 282   const char *class_name;
 283   struct type *run_time_type;
 284   LONGEST offset_to_top;
 285
 286   /* We only have RTTI for class objects.  */
 287   if (TYPE_CODE (values_type) != TYPE_CODE_CLASS)
 288     return NULL;
 289
 290   /* Determine architecture.  */
 291   gdbarch = get_type_arch (values_type);
 292
 293   if (using_enc_p)
 294     *using_enc_p = 0;
 295
 296   vtable = gnuv3_get_vtable (gdbarch, value_type (value),
 297                              value_as_address (value_addr (value)));
 298   if (vtable == NULL)
 299     return NULL;
 300
 301   /* Find the linker symbol for this vtable.  */
 302   vtable_symbol
 303     = lookup_minimal_symbol_by_pc (value_address (vtable)
 304                                    + value_embedded_offset (vtable));
 305   if (! vtable_symbol)
 306     return NULL;
 307
 308   /* The symbol's demangled name should be something like "vtable for
 309      CLASS", where CLASS is the name of the run-time type of VALUE.
 310      If we didn't like this approach, we could instead look in the
 311      type_info object itself to get the class name.  But this way
 312      should work just as well, and doesn't read target memory.  */
 313   vtable_symbol_name = SYMBOL_DEMANGLED_NAME (vtable_symbol);
 314   if (vtable_symbol_name == NULL
 315       || strncmp (vtable_symbol_name, "vtable for ", 11))
 316     {
 317       warning (_("can't find linker symbol for virtual table for `%s' value"),
 318                TYPE_NAME (values_type));
 319       if (vtable_symbol_name)
 320         warning (_("  found `%s' instead"), vtable_symbol_name);
 321       return NULL;
 322     }
 323   class_name = vtable_symbol_name + 11;
 324
 325   /* Try to look up the class name as a type name.  */
 326   /* FIXME: chastain/2003-11-26: block=NULL is bogus.  See pr gdb/1465.  */
 327   run_time_type = cp_lookup_rtti_type (class_name, NULL);
 328   if (run_time_type == NULL)
 329     return NULL;
 330
 331   /* Get the offset from VALUE to the top of the complete object.
 332      NOTE: this is the reverse of the meaning of *TOP_P.  */
 333   offset_to_top
 334     = value_as_long (value_field (vtable, vtable_field_offset_to_top));
 335
 336   if (full_p)
 337     *full_p = (- offset_to_top == value_embedded_offset (value)
 338                && (TYPE_LENGTH (value_enclosing_type (value))
 339                    >= TYPE_LENGTH (run_time_type)));
 340   if (top_p)
 341     *top_p = - offset_to_top;
 342   return run_time_type;
 343 }
 344
 345 /* Return a function pointer for CONTAINER's VTABLE_INDEX'th virtual
 346    function, of type FNTYPE.  */
 347
 348 static struct value *
 349 gnuv3_get_virtual_fn (struct gdbarch *gdbarch, struct value *container,
 350                       struct type *fntype, int vtable_index)
 351 {
 352   struct value *vtable, *vfn;
 353
 354   /* Every class with virtual functions must have a vtable.  */
 355   vtable = gnuv3_get_vtable (gdbarch, value_type (container),
 356                              value_as_address (value_addr (container)));
 357   gdb_assert (vtable != NULL);
 358
 359   /* Fetch the appropriate function pointer from the vtable.  */
 360   vfn = value_subscript (value_field (vtable, vtable_field_virtual_functions),
 361                          vtable_index);
 362
 363   /* If this architecture uses function descriptors directly in the vtable,
 364      then the address of the vtable entry is actually a "function pointer"
 365      (i.e. points to the descriptor).  We don't need to scale the index
 366      by the size of a function descriptor; GCC does that before outputing
 367      debug information.  */
 368   if (gdbarch_vtable_function_descriptors (gdbarch))
 369     vfn = value_addr (vfn);
 370
 371   /* Cast the function pointer to the appropriate type.  */
 372   vfn = value_cast (lookup_pointer_type (fntype), vfn);
 373
 374   return vfn;
 375 }
 376
 377 /* GNU v3 implementation of value_virtual_fn_field.  See cp-abi.h
 378    for a description of the arguments.  */
 379
 380 static struct value *
 381 gnuv3_virtual_fn_field (struct value **value_p,
 382                         struct fn_field *f, int j,
 383                         struct type *vfn_base, int offset)
 384 {
 385   struct type *values_type = check_typedef (value_type (*value_p));
 386   struct gdbarch *gdbarch;
 387
 388   /* Some simple sanity checks.  */
 389   if (TYPE_CODE (values_type) != TYPE_CODE_CLASS)
 390     error (_("Only classes can have virtual functions."));
 391
 392   /* Determine architecture.  */
 393   gdbarch = get_type_arch (values_type);
 394
 395   /* Cast our value to the base class which defines this virtual
 396      function.  This takes care of any necessary `this'
 397      adjustments.  */
 398   if (vfn_base != values_type)
 399     *value_p = value_cast (vfn_base, *value_p);
 400
 401   return gnuv3_get_virtual_fn (gdbarch, *value_p, TYPE_FN_FIELD_TYPE (f, j),
 402                                TYPE_FN_FIELD_VOFFSET (f, j));
 403 }
 404
 405 /* Compute the offset of the baseclass which is
 406    the INDEXth baseclass of class TYPE,
 407    for value at VALADDR (in host) at ADDRESS (in target).
 408    The result is the offset of the baseclass value relative
 409    to (the address of)(ARG) + OFFSET.
 410
 411    -1 is returned on error.  */
 412
 413 static int
 414 gnuv3_baseclass_offset (struct type *type, int index,
 415                         const bfd_byte *valaddr, int embedded_offset,
 416                         CORE_ADDR address, const struct value *val)
 417 {
 418   struct gdbarch *gdbarch;
 419   struct type *ptr_type;
 420   struct value *vtable;
 421   struct value *vbase_array;
 422   long int cur_base_offset, base_offset;
 423
 424   /* Determine architecture.  */
 425   gdbarch = get_type_arch (type);
 426   ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
 427
 428   /* If it isn't a virtual base, this is easy.  The offset is in the
 429      type definition.  */
 430   if (!BASETYPE_VIA_VIRTUAL (type, index))
 431     return TYPE_BASECLASS_BITPOS (type, index) / 8;
 432
 433   /* To access a virtual base, we need to use the vbase offset stored in
 434      our vtable.  Recent GCC versions provide this information.  If it isn't
 435      available, we could get what we needed from RTTI, or from drawing the
 436      complete inheritance graph based on the debug info.  Neither is
 437      worthwhile.  */
 438   cur_base_offset = TYPE_BASECLASS_BITPOS (type, index) / 8;
 439   if (cur_base_offset >= - vtable_address_point_offset (gdbarch))
 440     error (_("Expected a negative vbase offset (old compiler?)"));
 441
 442   cur_base_offset = cur_base_offset + vtable_address_point_offset (gdbarch);
 443   if ((- cur_base_offset) % TYPE_LENGTH (ptr_type) != 0)
 444     error (_("Misaligned vbase offset."));
 445   cur_base_offset = cur_base_offset / ((int) TYPE_LENGTH (ptr_type));
 446
 447   vtable = gnuv3_get_vtable (gdbarch, type, address + embedded_offset);
 448   gdb_assert (vtable != NULL);
 449   vbase_array = value_field (vtable, vtable_field_vcall_and_vbase_offsets);
 450   base_offset = value_as_long (value_subscript (vbase_array, cur_base_offset));
 451   return base_offset;
 452 }
 453
 454 /* Locate a virtual method in DOMAIN or its non-virtual base classes
 455    which has virtual table index VOFFSET.  The method has an associated
 456    "this" adjustment of ADJUSTMENT bytes.  */
 457
 458 static const char *
 459 gnuv3_find_method_in (struct type *domain, CORE_ADDR voffset,
 460                       LONGEST adjustment)
 461 {
 462   int i;
 463
 464   /* Search this class first.  */
 465   if (adjustment == 0)
 466     {
 467       int len;
 468
 469       len = TYPE_NFN_FIELDS (domain);
 470       for (i = 0; i < len; i++)
 471         {
 472           int len2, j;
 473           struct fn_field *f;
 474
 475           f = TYPE_FN_FIELDLIST1 (domain, i);
 476           len2 = TYPE_FN_FIELDLIST_LENGTH (domain, i);
 477
 478           check_stub_method_group (domain, i);
 479           for (j = 0; j < len2; j++)
 480             if (TYPE_FN_FIELD_VOFFSET (f, j) == voffset)
 481               return TYPE_FN_FIELD_PHYSNAME (f, j);
 482         }
 483     }
 484
 485   /* Next search non-virtual bases.  If it's in a virtual base,
 486      we're out of luck.  */
 487   for (i = 0; i < TYPE_N_BASECLASSES (domain); i++)
 488     {
 489       int pos;
 490       struct type *basetype;
 491
 492       if (BASETYPE_VIA_VIRTUAL (domain, i))
 493         continue;
 494
 495       pos = TYPE_BASECLASS_BITPOS (domain, i) / 8;
 496       basetype = TYPE_FIELD_TYPE (domain, i);
 497       /* Recurse with a modified adjustment.  We don't need to adjust
 498          voffset.  */
 499       if (adjustment >= pos && adjustment < pos + TYPE_LENGTH (basetype))
 500         return gnuv3_find_method_in (basetype, voffset, adjustment - pos);
 501     }
 502
 503   return NULL;
 504 }
 505
 506 /* Decode GNU v3 method pointer.  */
 507
 508 static int
 509 gnuv3_decode_method_ptr (struct gdbarch *gdbarch,
 510                          const gdb_byte *contents,
 511                          CORE_ADDR *value_p,
 512                          LONGEST *adjustment_p)
 513 {
 514   struct type *funcptr_type = builtin_type (gdbarch)->builtin_func_ptr;
 515   struct type *offset_type = vtable_ptrdiff_type (gdbarch);
 516   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 517   CORE_ADDR ptr_value;
 518   LONGEST voffset, adjustment;
 519   int vbit;
 520
 521   /* Extract the pointer to member.  The first element is either a pointer
 522      or a vtable offset.  For pointers, we need to use extract_typed_address
 523      to allow the back-end to convert the pointer to a GDB address -- but
 524      vtable offsets we must handle as integers.  At this point, we do not
 525      yet know which case we have, so we extract the value under both
 526      interpretations and choose the right one later on.  */
 527   ptr_value = extract_typed_address (contents, funcptr_type);
 528   voffset = extract_signed_integer (contents,
 529                                     TYPE_LENGTH (funcptr_type), byte_order);
 530   contents += TYPE_LENGTH (funcptr_type);
 531   adjustment = extract_signed_integer (contents,
 532                                        TYPE_LENGTH (offset_type), byte_order);
 533
 534   if (!gdbarch_vbit_in_delta (gdbarch))
 535     {
 536       vbit = voffset & 1;
 537       voffset = voffset ^ vbit;
 538     }
 539   else
 540     {
 541       vbit = adjustment & 1;
 542       adjustment = adjustment >> 1;
 543     }
 544
 545   *value_p = vbit? voffset : ptr_value;
 546   *adjustment_p = adjustment;
 547   return vbit;
 548 }
 549
 550 /* GNU v3 implementation of cplus_print_method_ptr.  */
 551
 552 static void
 553 gnuv3_print_method_ptr (const gdb_byte *contents,
 554                         struct type *type,
 555                         struct ui_file *stream)
 556 {
 557   struct type *domain = TYPE_DOMAIN_TYPE (type);
 558   struct gdbarch *gdbarch = get_type_arch (domain);
 559   CORE_ADDR ptr_value;
 560   LONGEST adjustment;
 561   int vbit;
 562
 563   /* Extract the pointer to member.  */
 564   vbit = gnuv3_decode_method_ptr (gdbarch, contents, &ptr_value, &adjustment);
 565
 566   /* Check for NULL.  */
 567   if (ptr_value == 0 && vbit == 0)
 568     {
 569       fprintf_filtered (stream, "NULL");
 570       return;
 571     }
 572
 573   /* Search for a virtual method.  */
 574   if (vbit)
 575     {
 576       CORE_ADDR voffset;
 577       const char *physname;
 578
 579       /* It's a virtual table offset, maybe in this class.  Search
 580          for a field with the correct vtable offset.  First convert it
 581          to an index, as used in TYPE_FN_FIELD_VOFFSET.  */
 582       voffset = ptr_value / TYPE_LENGTH (vtable_ptrdiff_type (gdbarch));
 583
 584       physname = gnuv3_find_method_in (domain, voffset, adjustment);
 585
 586       /* If we found a method, print that.  We don't bother to disambiguate
 587          possible paths to the method based on the adjustment.  */
 588       if (physname)
 589         {
 590           char *demangled_name = cplus_demangle (physname,
 591                                                  DMGL_ANSI | DMGL_PARAMS);
 592
 593           fprintf_filtered (stream, "&virtual ");
 594           if (demangled_name == NULL)
 595             fputs_filtered (physname, stream);
 596           else
 597             {
 598               fputs_filtered (demangled_name, stream);
 599               xfree (demangled_name);
 600             }
 601           return;
 602         }
 603     }
 604   else if (ptr_value != 0)
 605     {
 606       /* Found a non-virtual function: print out the type.  */
 607       fputs_filtered ("(", stream);
 608       c_print_type (type, "", stream, -1, 0);
 609       fputs_filtered (") ", stream);
 610     }
 611
 612   /* We didn't find it; print the raw data.  */
 613   if (vbit)
 614     {
 615       fprintf_filtered (stream, "&virtual table offset ");
 616       print_longest (stream, 'd', 1, ptr_value);
 617     }
 618   else
 619     print_address_demangle (gdbarch, ptr_value, stream, demangle);
 620
 621   if (adjustment)
 622     {
 623       fprintf_filtered (stream, ", this adjustment ");
 624       print_longest (stream, 'd', 1, adjustment);
 625     }
 626 }
 627
 628 /* GNU v3 implementation of cplus_method_ptr_size.  */
 629
 630 static int
 631 gnuv3_method_ptr_size (struct type *type)
 632 {
 633   struct gdbarch *gdbarch = get_type_arch (type);
 634
 635   return 2 * TYPE_LENGTH (builtin_type (gdbarch)->builtin_data_ptr);
 636 }
 637
 638 /* GNU v3 implementation of cplus_make_method_ptr.  */
 639
 640 static void
 641 gnuv3_make_method_ptr (struct type *type, gdb_byte *contents,
 642                        CORE_ADDR value, int is_virtual)
 643 {
 644   struct gdbarch *gdbarch = get_type_arch (type);
 645   int size = TYPE_LENGTH (builtin_type (gdbarch)->builtin_data_ptr);
 646   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 647
 648   /* FIXME drow/2006-12-24: The adjustment of "this" is currently
 649      always zero, since the method pointer is of the correct type.
 650      But if the method pointer came from a base class, this is
 651      incorrect - it should be the offset to the base.  The best
 652      fix might be to create the pointer to member pointing at the
 653      base class and cast it to the derived class, but that requires
 654      support for adjusting pointers to members when casting them -
 655      not currently supported by GDB.  */
 656
 657   if (!gdbarch_vbit_in_delta (gdbarch))
 658     {
 659       store_unsigned_integer (contents, size, byte_order, value | is_virtual);
 660       store_unsigned_integer (contents + size, size, byte_order, 0);
 661     }
 662   else
 663     {
 664       store_unsigned_integer (contents, size, byte_order, value);
 665       store_unsigned_integer (contents + size, size, byte_order, is_virtual);
 666     }
 667 }
 668
 669 /* GNU v3 implementation of cplus_method_ptr_to_value.  */
 670
 671 static struct value *
 672 gnuv3_method_ptr_to_value (struct value **this_p, struct value *method_ptr)
 673 {
 674   struct gdbarch *gdbarch;
 675   const gdb_byte *contents = value_contents (method_ptr);
 676   CORE_ADDR ptr_value;
 677   struct type *domain_type, *final_type, *method_type;
 678   LONGEST adjustment;
 679   int vbit;
 680
 681   domain_type = TYPE_DOMAIN_TYPE (check_typedef (value_type (method_ptr)));
 682   final_type = lookup_pointer_type (domain_type);
 683
 684   method_type = TYPE_TARGET_TYPE (check_typedef (value_type (method_ptr)));
 685
 686   /* Extract the pointer to member.  */
 687   gdbarch = get_type_arch (domain_type);
 688   vbit = gnuv3_decode_method_ptr (gdbarch, contents, &ptr_value, &adjustment);
 689
 690   /* First convert THIS to match the containing type of the pointer to
 691      member.  This cast may adjust the value of THIS.  */
 692   *this_p = value_cast (final_type, *this_p);
 693
 694   /* Then apply whatever adjustment is necessary.  This creates a somewhat
 695      strange pointer: it claims to have type FINAL_TYPE, but in fact it
 696      might not be a valid FINAL_TYPE.  For instance, it might be a
 697      base class of FINAL_TYPE.  And if it's not the primary base class,
 698      then printing it out as a FINAL_TYPE object would produce some pretty
 699      garbage.
 700
 701      But we don't really know the type of the first argument in
 702      METHOD_TYPE either, which is why this happens.  We can't
 703      dereference this later as a FINAL_TYPE, but once we arrive in the
 704      called method we'll have debugging information for the type of
 705      "this" - and that'll match the value we produce here.
 706
 707      You can provoke this case by casting a Base::* to a Derived::*, for
 708      instance.  */
 709   *this_p = value_cast (builtin_type (gdbarch)->builtin_data_ptr, *this_p);
 710   *this_p = value_ptradd (*this_p, adjustment);
 711   *this_p = value_cast (final_type, *this_p);
 712
 713   if (vbit)
 714     {
 715       LONGEST voffset;
 716
 717       voffset = ptr_value / TYPE_LENGTH (vtable_ptrdiff_type (gdbarch));
 718       return gnuv3_get_virtual_fn (gdbarch, value_ind (*this_p),
 719                                    method_type, voffset);
 720     }
 721   else
 722     return value_from_pointer (lookup_pointer_type (method_type), ptr_value);
 723 }
 724
 725 /* Determine if we are currently in a C++ thunk.  If so, get the address
 726    of the routine we are thunking to and continue to there instead.  */
 727
 728 static CORE_ADDR
 729 gnuv3_skip_trampoline (struct frame_info *frame, CORE_ADDR stop_pc)
 730 {
 731   CORE_ADDR real_stop_pc, method_stop_pc;
 732   struct gdbarch *gdbarch = get_frame_arch (frame);
 733   struct minimal_symbol *thunk_sym, *fn_sym;
 734   struct obj_section *section;
 735   char *thunk_name, *fn_name;
 736
 737   real_stop_pc = gdbarch_skip_trampoline_code (gdbarch, frame, stop_pc);
 738   if (real_stop_pc == 0)
 739     real_stop_pc = stop_pc;
 740
 741   /* Find the linker symbol for this potential thunk.  */
 742   thunk_sym = lookup_minimal_symbol_by_pc (real_stop_pc);
 743   section = find_pc_section (real_stop_pc);
 744   if (thunk_sym == NULL || section == NULL)
 745     return 0;
 746
 747   /* The symbol's demangled name should be something like "virtual
 748      thunk to FUNCTION", where FUNCTION is the name of the function
 749      being thunked to.  */
 750   thunk_name = SYMBOL_DEMANGLED_NAME (thunk_sym);
 751   if (thunk_name == NULL || strstr (thunk_name, " thunk to ") == NULL)
 752     return 0;
 753
 754   fn_name = strstr (thunk_name, " thunk to ") + strlen (" thunk to ");
 755   fn_sym = lookup_minimal_symbol (fn_name, NULL, section->objfile);
 756   if (fn_sym == NULL)
 757     return 0;
 758
 759   method_stop_pc = SYMBOL_VALUE_ADDRESS (fn_sym);
 760   real_stop_pc = gdbarch_skip_trampoline_code
 761                    (gdbarch, frame, method_stop_pc);
 762   if (real_stop_pc == 0)
 763     real_stop_pc = method_stop_pc;
 764
 765   return real_stop_pc;
 766 }
 767
 768 /* Return nonzero if a type should be passed by reference.
 769
 770    The rule in the v3 ABI document comes from section 3.1.1.  If the
 771    type has a non-trivial copy constructor or destructor, then the
 772    caller must make a copy (by calling the copy constructor if there
 773    is one or perform the copy itself otherwise), pass the address of
 774    the copy, and then destroy the temporary (if necessary).
 775
 776    For return values with non-trivial copy constructors or
 777    destructors, space will be allocated in the caller, and a pointer
 778    will be passed as the first argument (preceding "this").
 779
 780    We don't have a bulletproof mechanism for determining whether a
 781    constructor or destructor is trivial.  For GCC and DWARF2 debug
 782    information, we can check the artificial flag.
 783
 784    We don't do anything with the constructors or destructors,
 785    but we have to get the argument passing right anyway.  */
 786 static int
 787 gnuv3_pass_by_reference (struct type *type)
 788 {
 789   int fieldnum, fieldelem;
 790
 791   CHECK_TYPEDEF (type);
 792
 793   /* We're only interested in things that can have methods.  */
 794   if (TYPE_CODE (type) != TYPE_CODE_STRUCT
 795       && TYPE_CODE (type) != TYPE_CODE_CLASS
 796       && TYPE_CODE (type) != TYPE_CODE_UNION)
 797     return 0;
 798
 799   for (fieldnum = 0; fieldnum < TYPE_NFN_FIELDS (type); fieldnum++)
 800     for (fieldelem = 0; fieldelem < TYPE_FN_FIELDLIST_LENGTH (type, fieldnum);
 801          fieldelem++)
 802       {
 803         struct fn_field *fn = TYPE_FN_FIELDLIST1 (type, fieldnum);
 804         char *name = TYPE_FN_FIELDLIST_NAME (type, fieldnum);
 805         struct type *fieldtype = TYPE_FN_FIELD_TYPE (fn, fieldelem);
 806
 807         /* If this function is marked as artificial, it is compiler-generated,
 808            and we assume it is trivial.  */
 809         if (TYPE_FN_FIELD_ARTIFICIAL (fn, fieldelem))
 810           continue;
 811
 812         /* If we've found a destructor, we must pass this by reference.  */
 813         if (name[0] == '~')
 814           return 1;
 815
 816         /* If the mangled name of this method doesn't indicate that it
 817            is a constructor, we're not interested.
 818
 819            FIXME drow/2007-09-23: We could do this using the name of
 820            the method and the name of the class instead of dealing
 821            with the mangled name.  We don't have a convenient function
 822            to strip off both leading scope qualifiers and trailing
 823            template arguments yet.  */
 824         if (!is_constructor_name (TYPE_FN_FIELD_PHYSNAME (fn, fieldelem)))
 825           continue;
 826
 827         /* If this method takes two arguments, and the second argument is
 828            a reference to this class, then it is a copy constructor.  */
 829         if (TYPE_NFIELDS (fieldtype) == 2
 830             && TYPE_CODE (TYPE_FIELD_TYPE (fieldtype, 1)) == TYPE_CODE_REF
 831             && check_typedef (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (fieldtype,
 832                                                                  1))) == type)
 833           return 1;
 834       }
 835
 836   /* Even if all the constructors and destructors were artificial, one
 837      of them may have invoked a non-artificial constructor or
 838      destructor in a base class.  If any base class needs to be passed
 839      by reference, so does this class.  Similarly for members, which
 840      are constructed whenever this class is.  We do not need to worry
 841      about recursive loops here, since we are only looking at members
 842      of complete class type.  Also ignore any static members.  */
 843   for (fieldnum = 0; fieldnum < TYPE_NFIELDS (type); fieldnum++)
 844     if (! field_is_static (&TYPE_FIELD (type, fieldnum))
 845         && gnuv3_pass_by_reference (TYPE_FIELD_TYPE (type, fieldnum)))
 846       return 1;
 847
 848   return 0;
 849 }
 850
 851 static void
 852 init_gnuv3_ops (void)
 853 {
 854   vtable_type_gdbarch_data
 855     = gdbarch_data_register_post_init (build_gdb_vtable_type);
 856
 857   gnu_v3_abi_ops.shortname = "gnu-v3";
 858   gnu_v3_abi_ops.longname = "GNU G++ Version 3 ABI";
 859   gnu_v3_abi_ops.doc = "G++ Version 3 ABI";
 860   gnu_v3_abi_ops.is_destructor_name =
 861     (enum dtor_kinds (*) (const char *))is_gnu_v3_mangled_dtor;
 862   gnu_v3_abi_ops.is_constructor_name =
 863     (enum ctor_kinds (*) (const char *))is_gnu_v3_mangled_ctor;
 864   gnu_v3_abi_ops.is_vtable_name = gnuv3_is_vtable_name;
 865   gnu_v3_abi_ops.is_operator_name = gnuv3_is_operator_name;
 866   gnu_v3_abi_ops.rtti_type = gnuv3_rtti_type;
 867   gnu_v3_abi_ops.virtual_fn_field = gnuv3_virtual_fn_field;
 868   gnu_v3_abi_ops.baseclass_offset = gnuv3_baseclass_offset;
 869   gnu_v3_abi_ops.print_method_ptr = gnuv3_print_method_ptr;
 870   gnu_v3_abi_ops.method_ptr_size = gnuv3_method_ptr_size;
 871   gnu_v3_abi_ops.make_method_ptr = gnuv3_make_method_ptr;
 872   gnu_v3_abi_ops.method_ptr_to_value = gnuv3_method_ptr_to_value;
 873   gnu_v3_abi_ops.skip_trampoline = gnuv3_skip_trampoline;
 874   gnu_v3_abi_ops.pass_by_reference = gnuv3_pass_by_reference;
 875 }
 876
 877 extern initialize_file_ftype _initialize_gnu_v3_abi; /* -Wmissing-prototypes */
 878
 879 void
 880 _initialize_gnu_v3_abi (void)
 881 {
 882   init_gnuv3_ops ();
 883
 884   register_cp_abi (&gnu_v3_abi_ops);
 885 }