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