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