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_embedded_offset (vtable));
 274   if (! vtable_symbol)
 275     return NULL;
 276
 277   /* The symbol's demangled name should be something like "vtable for
 278      CLASS", where CLASS is the name of the run-time type of VALUE.
 279      If we didn't like this approach, we could instead look in the
 280      type_info object itself to get the class name.  But this way
 281      should work just as well, and doesn't read target memory.  */
 282   vtable_symbol_name = SYMBOL_DEMANGLED_NAME (vtable_symbol);
 283   if (vtable_symbol_name == NULL
 284       || strncmp (vtable_symbol_name, "vtable for ", 11))
 285     {
 286       warning (_("can't find linker symbol for virtual table for `%s' value"),
 287                TYPE_NAME (values_type));
 288       if (vtable_symbol_name)
 289         warning (_("  found `%s' instead"), vtable_symbol_name);
 290       return NULL;
 291     }
 292   class_name = vtable_symbol_name + 11;
 293
 294   /* Try to look up the class name as a type name.  */
 295   /* FIXME: chastain/2003-11-26: block=NULL is bogus.  See pr gdb/1465. */
 296   run_time_type = cp_lookup_rtti_type (class_name, NULL);
 297   if (run_time_type == NULL)
 298     return NULL;
 299
 300   /* Get the offset from VALUE to the top of the complete object.
 301      NOTE: this is the reverse of the meaning of *TOP_P.  */
 302   offset_to_top
 303     = value_as_long (value_field (vtable, vtable_field_offset_to_top));
 304
 305   if (full_p)
 306     *full_p = (- offset_to_top == value_embedded_offset (value)
 307                && (TYPE_LENGTH (value_enclosing_type (value))
 308                    >= TYPE_LENGTH (run_time_type)));
 309   if (top_p)
 310     *top_p = - offset_to_top;
 311
 312   return run_time_type;
 313 }
 314
 315 /* Find the vtable for CONTAINER and return a value of the correct
 316    vtable type for this architecture.  */
 317
 318 static struct value *
 319 gnuv3_get_vtable (struct gdbarch *gdbarch, struct value *container)
 320 {
 321   struct type *vtable_type = gdbarch_data (gdbarch, vtable_type_gdbarch_data);
 322   struct type *vtable_pointer_type;
 323   struct value *vtable_pointer;
 324   CORE_ADDR vtable_pointer_address, vtable_address;
 325
 326   /* We do not consult the debug information to find the virtual table.
 327      The ABI specifies that it is always at offset zero in any class,
 328      and debug information may not represent it.  We won't issue an
 329      error if there's a class with virtual functions but no virtual table
 330      pointer, but something's already gone seriously wrong if that
 331      happens.
 332
 333      We avoid using value_contents on principle, because the object might
 334      be large.  */
 335
 336   /* Find the type "pointer to virtual table".  */
 337   vtable_pointer_type = lookup_pointer_type (vtable_type);
 338
 339   /* Load it from the start of the class.  */
 340   vtable_pointer_address = value_as_address (value_addr (container));
 341   vtable_pointer = value_at (vtable_pointer_type, vtable_pointer_address);
 342   vtable_address = value_as_address (vtable_pointer);
 343
 344   /* Correct it to point at the start of the virtual table, rather
 345      than the address point.  */
 346   return value_at_lazy (vtable_type,
 347                         vtable_address - vtable_address_point_offset (gdbarch));
 348 }
 349
 350 /* Return a function pointer for CONTAINER's VTABLE_INDEX'th virtual
 351    function, of type FNTYPE.  */
 352
 353 static struct value *
 354 gnuv3_get_virtual_fn (struct gdbarch *gdbarch, struct value *container,
 355                       struct type *fntype, int vtable_index)
 356 {
 357   struct value *vtable = gnuv3_get_vtable (gdbarch, container);
 358   struct value *vfn;
 359
 360   /* Fetch the appropriate function pointer from the vtable.  */
 361   vfn = value_subscript (value_field (vtable, vtable_field_virtual_functions),
 362                          value_from_longest (builtin_type_int32, vtable_index));
 363
 364   /* If this architecture uses function descriptors directly in the vtable,
 365      then the address of the vtable entry is actually a "function pointer"
 366      (i.e. points to the descriptor).  We don't need to scale the index
 367      by the size of a function descriptor; GCC does that before outputing
 368      debug information.  */
 369   if (gdbarch_vtable_function_descriptors (gdbarch))
 370     vfn = value_addr (vfn);
 371
 372   /* Cast the function pointer to the appropriate type.  */
 373   vfn = value_cast (lookup_pointer_type (fntype), vfn);
 374
 375   return vfn;
 376 }
 377
 378 /* GNU v3 implementation of value_virtual_fn_field.  See cp-abi.h
 379    for a description of the arguments.  */
 380
 381 static struct value *
 382 gnuv3_virtual_fn_field (struct value **value_p,
 383                         struct fn_field *f, int j,
 384                         struct type *vfn_base, int offset)
 385 {
 386   struct type *values_type = check_typedef (value_type (*value_p));
 387   struct gdbarch *gdbarch;
 388
 389   /* Some simple sanity checks.  */
 390   if (TYPE_CODE (values_type) != TYPE_CODE_CLASS)
 391     error (_("Only classes can have virtual functions."));
 392
 393   /* Determine architecture.  */
 394   gdbarch = get_class_arch (values_type);
 395
 396   /* Cast our value to the base class which defines this virtual
 397      function.  This takes care of any necessary `this'
 398      adjustments.  */
 399   if (vfn_base != values_type)
 400     *value_p = value_cast (vfn_base, *value_p);
 401
 402   return gnuv3_get_virtual_fn (gdbarch, *value_p, TYPE_FN_FIELD_TYPE (f, j),
 403                                TYPE_FN_FIELD_VOFFSET (f, j));
 404 }
 405
 406 /* Compute the offset of the baseclass which is
 407    the INDEXth baseclass of class TYPE,
 408    for value at VALADDR (in host) at ADDRESS (in target).
 409    The result is the offset of the baseclass value relative
 410    to (the address of)(ARG) + OFFSET.
 411
 412    -1 is returned on error. */
 413 static int
 414 gnuv3_baseclass_offset (struct type *type, int index, const bfd_byte *valaddr,
 415                         CORE_ADDR address)
 416 {
 417   struct gdbarch *gdbarch;
 418   struct type *vtable_type;
 419   struct type *ptr_type;
 420   struct value *vtable;
 421   struct type *vbasetype;
 422   struct value *offset_val, *vbase_array;
 423   CORE_ADDR vtable_address;
 424   long int cur_base_offset, base_offset;
 425   int vbasetype_vptr_fieldno;
 426
 427   /* Determine architecture.  */
 428   gdbarch = get_class_arch (type);
 429   vtable_type = gdbarch_data (gdbarch, vtable_type_gdbarch_data);
 430   ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
 431
 432   /* If it isn't a virtual base, this is easy.  The offset is in the
 433      type definition.  */
 434   if (!BASETYPE_VIA_VIRTUAL (type, index))
 435     return TYPE_BASECLASS_BITPOS (type, index) / 8;
 436
 437   /* To access a virtual base, we need to use the vbase offset stored in
 438      our vtable.  Recent GCC versions provide this information.  If it isn't
 439      available, we could get what we needed from RTTI, or from drawing the
 440      complete inheritance graph based on the debug info.  Neither is
 441      worthwhile.  */
 442   cur_base_offset = TYPE_BASECLASS_BITPOS (type, index) / 8;
 443   if (cur_base_offset >= - vtable_address_point_offset (gdbarch))
 444     error (_("Expected a negative vbase offset (old compiler?)"));
 445
 446   cur_base_offset = cur_base_offset + vtable_address_point_offset (gdbarch);
 447   if ((- cur_base_offset) % TYPE_LENGTH (ptr_type) != 0)
 448     error (_("Misaligned vbase offset."));
 449   cur_base_offset = cur_base_offset / ((int) TYPE_LENGTH (ptr_type));
 450
 451   /* We're now looking for the cur_base_offset'th entry (negative index)
 452      in the vcall_and_vbase_offsets array.  We used to cast the object to
 453      its TYPE_VPTR_BASETYPE, and reference the vtable as TYPE_VPTR_FIELDNO;
 454      however, that cast can not be done without calling baseclass_offset again
 455      if the TYPE_VPTR_BASETYPE is a virtual base class, as described in the
 456      v3 C++ ABI Section 2.4.I.2.b.  Fortunately the ABI guarantees that the
 457      vtable pointer will be located at the beginning of the object, so we can
 458      bypass the casting.  Verify that the TYPE_VPTR_FIELDNO is in fact at the
 459      start of whichever baseclass it resides in, as a sanity measure - iff
 460      we have debugging information for that baseclass.  */
 461
 462   vbasetype = check_typedef (TYPE_VPTR_BASETYPE (type));
 463   vbasetype_vptr_fieldno = get_vptr_fieldno (vbasetype, NULL);
 464
 465   if (vbasetype_vptr_fieldno >= 0
 466       && TYPE_FIELD_BITPOS (vbasetype, vbasetype_vptr_fieldno) != 0)
 467     error (_("Illegal vptr offset in class %s"),
 468            TYPE_NAME (vbasetype) ? TYPE_NAME (vbasetype) : "<unknown>");
 469
 470   vtable_address = value_as_address (value_at_lazy (ptr_type, address));
 471   vtable
 472     = value_at_lazy (vtable_type,
 473                      vtable_address - vtable_address_point_offset (gdbarch));
 474   offset_val = value_from_longest (builtin_type_int32, cur_base_offset);
 475   vbase_array = value_field (vtable, vtable_field_vcall_and_vbase_offsets);
 476   base_offset = value_as_long (value_subscript (vbase_array, offset_val));
 477   return base_offset;
 478 }
 479
 480 /* Locate a virtual method in DOMAIN or its non-virtual base classes
 481    which has virtual table index VOFFSET.  The method has an associated
 482    "this" adjustment of ADJUSTMENT bytes.  */
 483
 484 static const char *
 485 gnuv3_find_method_in (struct type *domain, CORE_ADDR voffset,
 486                       LONGEST adjustment)
 487 {
 488   int i;
 489   const char *physname;
 490
 491   /* Search this class first.  */
 492   physname = NULL;
 493   if (adjustment == 0)
 494     {
 495       int len;
 496
 497       len = TYPE_NFN_FIELDS (domain);
 498       for (i = 0; i < len; i++)
 499         {
 500           int len2, j;
 501           struct fn_field *f;
 502
 503           f = TYPE_FN_FIELDLIST1 (domain, i);
 504           len2 = TYPE_FN_FIELDLIST_LENGTH (domain, i);
 505
 506           check_stub_method_group (domain, i);
 507           for (j = 0; j < len2; j++)
 508             if (TYPE_FN_FIELD_VOFFSET (f, j) == voffset)
 509               return TYPE_FN_FIELD_PHYSNAME (f, j);
 510         }
 511     }
 512
 513   /* Next search non-virtual bases.  If it's in a virtual base,
 514      we're out of luck.  */
 515   for (i = 0; i < TYPE_N_BASECLASSES (domain); i++)
 516     {
 517       int pos;
 518       struct type *basetype;
 519
 520       if (BASETYPE_VIA_VIRTUAL (domain, i))
 521         continue;
 522
 523       pos = TYPE_BASECLASS_BITPOS (domain, i) / 8;
 524       basetype = TYPE_FIELD_TYPE (domain, i);
 525       /* Recurse with a modified adjustment.  We don't need to adjust
 526          voffset.  */
 527       if (adjustment >= pos && adjustment < pos + TYPE_LENGTH (basetype))
 528         return gnuv3_find_method_in (basetype, voffset, adjustment - pos);
 529     }
 530
 531   return NULL;
 532 }
 533
 534 /* Decode GNU v3 method pointer.  */
 535
 536 static int
 537 gnuv3_decode_method_ptr (struct gdbarch *gdbarch,
 538                          const gdb_byte *contents,
 539                          CORE_ADDR *value_p,
 540                          LONGEST *adjustment_p)
 541 {
 542   struct type *funcptr_type = builtin_type (gdbarch)->builtin_func_ptr;
 543   struct type *offset_type = vtable_ptrdiff_type (gdbarch);
 544   CORE_ADDR ptr_value;
 545   LONGEST voffset, adjustment;
 546   int vbit;
 547
 548   /* Extract the pointer to member.  The first element is either a pointer
 549      or a vtable offset.  For pointers, we need to use extract_typed_address
 550      to allow the back-end to convert the pointer to a GDB address -- but
 551      vtable offsets we must handle as integers.  At this point, we do not
 552      yet know which case we have, so we extract the value under both
 553      interpretations and choose the right one later on.  */
 554   ptr_value = extract_typed_address (contents, funcptr_type);
 555   voffset = extract_signed_integer (contents, TYPE_LENGTH (funcptr_type));
 556   contents += TYPE_LENGTH (funcptr_type);
 557   adjustment = extract_signed_integer (contents, TYPE_LENGTH (offset_type));
 558
 559   if (!gdbarch_vbit_in_delta (gdbarch))
 560     {
 561       vbit = voffset & 1;
 562       voffset = voffset ^ vbit;
 563     }
 564   else
 565     {
 566       vbit = adjustment & 1;
 567       adjustment = adjustment >> 1;
 568     }
 569
 570   *value_p = vbit? voffset : ptr_value;
 571   *adjustment_p = adjustment;
 572   return vbit;
 573 }
 574
 575 /* GNU v3 implementation of cplus_print_method_ptr.  */
 576
 577 static void
 578 gnuv3_print_method_ptr (const gdb_byte *contents,
 579                         struct type *type,
 580                         struct ui_file *stream)
 581 {
 582   struct type *domain = TYPE_DOMAIN_TYPE (type);
 583   struct gdbarch *gdbarch = get_class_arch (domain);
 584   CORE_ADDR ptr_value;
 585   LONGEST adjustment;
 586   int vbit;
 587
 588   /* Extract the pointer to member.  */
 589   vbit = gnuv3_decode_method_ptr (gdbarch, contents, &ptr_value, &adjustment);
 590
 591   /* Check for NULL.  */
 592   if (ptr_value == 0 && vbit == 0)
 593     {
 594       fprintf_filtered (stream, "NULL");
 595       return;
 596     }
 597
 598   /* Search for a virtual method.  */
 599   if (vbit)
 600     {
 601       CORE_ADDR voffset;
 602       const char *physname;
 603
 604       /* It's a virtual table offset, maybe in this class.  Search
 605          for a field with the correct vtable offset.  First convert it
 606          to an index, as used in TYPE_FN_FIELD_VOFFSET.  */
 607       voffset = ptr_value / TYPE_LENGTH (vtable_ptrdiff_type (gdbarch));
 608
 609       physname = gnuv3_find_method_in (domain, voffset, adjustment);
 610
 611       /* If we found a method, print that.  We don't bother to disambiguate
 612          possible paths to the method based on the adjustment.  */
 613       if (physname)
 614         {
 615           char *demangled_name = cplus_demangle (physname,
 616                                                  DMGL_ANSI | DMGL_PARAMS);
 617           if (demangled_name != NULL)
 618             {
 619               fprintf_filtered (stream, "&virtual ");
 620               fputs_filtered (demangled_name, stream);
 621               xfree (demangled_name);
 622               return;
 623             }
 624         }
 625     }
 626
 627   /* We didn't find it; print the raw data.  */
 628   if (vbit)
 629     {
 630       fprintf_filtered (stream, "&virtual table offset ");
 631       print_longest (stream, 'd', 1, ptr_value);
 632     }
 633   else
 634     print_address_demangle (ptr_value, stream, demangle);
 635
 636   if (adjustment)
 637     {
 638       fprintf_filtered (stream, ", this adjustment ");
 639       print_longest (stream, 'd', 1, adjustment);
 640     }
 641 }
 642
 643 /* GNU v3 implementation of cplus_method_ptr_size.  */
 644
 645 static int
 646 gnuv3_method_ptr_size (struct type *type)
 647 {
 648   struct type *domain_type = check_typedef (TYPE_DOMAIN_TYPE (type));
 649   struct gdbarch *gdbarch = get_class_arch (domain_type);
 650   return 2 * TYPE_LENGTH (builtin_type (gdbarch)->builtin_data_ptr);
 651 }
 652
 653 /* GNU v3 implementation of cplus_make_method_ptr.  */
 654
 655 static void
 656 gnuv3_make_method_ptr (struct type *type, gdb_byte *contents,
 657                        CORE_ADDR value, int is_virtual)
 658 {
 659   struct type *domain_type = check_typedef (TYPE_DOMAIN_TYPE (type));
 660   struct gdbarch *gdbarch = get_class_arch (domain_type);
 661   int size = TYPE_LENGTH (builtin_type (gdbarch)->builtin_data_ptr);
 662
 663   /* FIXME drow/2006-12-24: The adjustment of "this" is currently
 664      always zero, since the method pointer is of the correct type.
 665      But if the method pointer came from a base class, this is
 666      incorrect - it should be the offset to the base.  The best
 667      fix might be to create the pointer to member pointing at the
 668      base class and cast it to the derived class, but that requires
 669      support for adjusting pointers to members when casting them -
 670      not currently supported by GDB.  */
 671
 672   if (!gdbarch_vbit_in_delta (gdbarch))
 673     {
 674       store_unsigned_integer (contents, size, value | is_virtual);
 675       store_unsigned_integer (contents + size, size, 0);
 676     }
 677   else
 678     {
 679       store_unsigned_integer (contents, size, value);
 680       store_unsigned_integer (contents + size, size, is_virtual);
 681     }
 682 }
 683
 684 /* GNU v3 implementation of cplus_method_ptr_to_value.  */
 685
 686 static struct value *
 687 gnuv3_method_ptr_to_value (struct value **this_p, struct value *method_ptr)
 688 {
 689   struct gdbarch *gdbarch;
 690   const gdb_byte *contents = value_contents (method_ptr);
 691   CORE_ADDR ptr_value;
 692   struct type *domain_type, *final_type, *method_type;
 693   LONGEST adjustment;
 694   struct value *adjval;
 695   int vbit;
 696
 697   domain_type = TYPE_DOMAIN_TYPE (check_typedef (value_type (method_ptr)));
 698   final_type = lookup_pointer_type (domain_type);
 699
 700   method_type = TYPE_TARGET_TYPE (check_typedef (value_type (method_ptr)));
 701
 702   /* Extract the pointer to member.  */
 703   gdbarch = get_class_arch (domain_type);
 704   vbit = gnuv3_decode_method_ptr (gdbarch, contents, &ptr_value, &adjustment);
 705
 706   /* First convert THIS to match the containing type of the pointer to
 707      member.  This cast may adjust the value of THIS.  */
 708   *this_p = value_cast (final_type, *this_p);
 709
 710   /* Then apply whatever adjustment is necessary.  This creates a somewhat
 711      strange pointer: it claims to have type FINAL_TYPE, but in fact it
 712      might not be a valid FINAL_TYPE.  For instance, it might be a
 713      base class of FINAL_TYPE.  And if it's not the primary base class,
 714      then printing it out as a FINAL_TYPE object would produce some pretty
 715      garbage.
 716
 717      But we don't really know the type of the first argument in
 718      METHOD_TYPE either, which is why this happens.  We can't
 719      dereference this later as a FINAL_TYPE, but once we arrive in the
 720      called method we'll have debugging information for the type of
 721      "this" - and that'll match the value we produce here.
 722
 723      You can provoke this case by casting a Base::* to a Derived::*, for
 724      instance.  */
 725   *this_p = value_cast (builtin_type (gdbarch)->builtin_data_ptr, *this_p);
 726   adjval = value_from_longest (builtin_type (gdbarch)->builtin_long,
 727                                adjustment);
 728   *this_p = value_ptradd (*this_p, adjval);
 729   *this_p = value_cast (final_type, *this_p);
 730
 731   if (vbit)
 732     {
 733       LONGEST voffset;
 734       voffset = ptr_value / TYPE_LENGTH (vtable_ptrdiff_type (gdbarch));
 735       return gnuv3_get_virtual_fn (gdbarch, value_ind (*this_p),
 736                                    method_type, voffset);
 737     }
 738   else
 739     return value_from_pointer (lookup_pointer_type (method_type), ptr_value);
 740 }
 741
 742 /* Determine if we are currently in a C++ thunk.  If so, get the address
 743    of the routine we are thunking to and continue to there instead.  */
 744
 745 static CORE_ADDR
 746 gnuv3_skip_trampoline (struct frame_info *frame, CORE_ADDR stop_pc)
 747 {
 748   CORE_ADDR real_stop_pc, method_stop_pc;
 749   struct gdbarch *gdbarch = get_frame_arch (frame);
 750   struct minimal_symbol *thunk_sym, *fn_sym;
 751   struct obj_section *section;
 752   char *thunk_name, *fn_name;
 753
 754   real_stop_pc = gdbarch_skip_trampoline_code (gdbarch, frame, stop_pc);
 755   if (real_stop_pc == 0)
 756     real_stop_pc = stop_pc;
 757
 758   /* Find the linker symbol for this potential thunk.  */
 759   thunk_sym = lookup_minimal_symbol_by_pc (real_stop_pc);
 760   section = find_pc_section (real_stop_pc);
 761   if (thunk_sym == NULL || section == NULL)
 762     return 0;
 763
 764   /* The symbol's demangled name should be something like "virtual
 765      thunk to FUNCTION", where FUNCTION is the name of the function
 766      being thunked to.  */
 767   thunk_name = SYMBOL_DEMANGLED_NAME (thunk_sym);
 768   if (thunk_name == NULL || strstr (thunk_name, " thunk to ") == NULL)
 769     return 0;
 770
 771   fn_name = strstr (thunk_name, " thunk to ") + strlen (" thunk to ");
 772   fn_sym = lookup_minimal_symbol (fn_name, NULL, section->objfile);
 773   if (fn_sym == NULL)
 774     return 0;
 775
 776   method_stop_pc = SYMBOL_VALUE_ADDRESS (fn_sym);
 777   real_stop_pc = gdbarch_skip_trampoline_code
 778                    (gdbarch, frame, method_stop_pc);
 779   if (real_stop_pc == 0)
 780     real_stop_pc = method_stop_pc;
 781
 782   return real_stop_pc;
 783 }
 784
 785 /* Return nonzero if a type should be passed by reference.
 786
 787    The rule in the v3 ABI document comes from section 3.1.1.  If the
 788    type has a non-trivial copy constructor or destructor, then the
 789    caller must make a copy (by calling the copy constructor if there
 790    is one or perform the copy itself otherwise), pass the address of
 791    the copy, and then destroy the temporary (if necessary).
 792
 793    For return values with non-trivial copy constructors or
 794    destructors, space will be allocated in the caller, and a pointer
 795    will be passed as the first argument (preceding "this").
 796
 797    We don't have a bulletproof mechanism for determining whether a
 798    constructor or destructor is trivial.  For GCC and DWARF2 debug
 799    information, we can check the artificial flag.
 800
 801    We don't do anything with the constructors or destructors,
 802    but we have to get the argument passing right anyway.  */
 803 static int
 804 gnuv3_pass_by_reference (struct type *type)
 805 {
 806   int fieldnum, fieldelem;
 807
 808   CHECK_TYPEDEF (type);
 809
 810   /* We're only interested in things that can have methods.  */
 811   if (TYPE_CODE (type) != TYPE_CODE_STRUCT
 812       && TYPE_CODE (type) != TYPE_CODE_CLASS
 813       && TYPE_CODE (type) != TYPE_CODE_UNION)
 814     return 0;
 815
 816   for (fieldnum = 0; fieldnum < TYPE_NFN_FIELDS (type); fieldnum++)
 817     for (fieldelem = 0; fieldelem < TYPE_FN_FIELDLIST_LENGTH (type, fieldnum);
 818          fieldelem++)
 819       {
 820         struct fn_field *fn = TYPE_FN_FIELDLIST1 (type, fieldnum);
 821         char *name = TYPE_FN_FIELDLIST_NAME (type, fieldnum);
 822         struct type *fieldtype = TYPE_FN_FIELD_TYPE (fn, fieldelem);
 823
 824         /* If this function is marked as artificial, it is compiler-generated,
 825            and we assume it is trivial.  */
 826         if (TYPE_FN_FIELD_ARTIFICIAL (fn, fieldelem))
 827           continue;
 828
 829         /* If we've found a destructor, we must pass this by reference.  */
 830         if (name[0] == '~')
 831           return 1;
 832
 833         /* If the mangled name of this method doesn't indicate that it
 834            is a constructor, we're not interested.
 835
 836            FIXME drow/2007-09-23: We could do this using the name of
 837            the method and the name of the class instead of dealing
 838            with the mangled name.  We don't have a convenient function
 839            to strip off both leading scope qualifiers and trailing
 840            template arguments yet.  */
 841         if (!is_constructor_name (TYPE_FN_FIELD_PHYSNAME (fn, fieldelem)))
 842           continue;
 843
 844         /* If this method takes two arguments, and the second argument is
 845            a reference to this class, then it is a copy constructor.  */
 846         if (TYPE_NFIELDS (fieldtype) == 2
 847             && TYPE_CODE (TYPE_FIELD_TYPE (fieldtype, 1)) == TYPE_CODE_REF
 848             && check_typedef (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (fieldtype, 1))) == type)
 849           return 1;
 850       }
 851
 852   /* Even if all the constructors and destructors were artificial, one
 853      of them may have invoked a non-artificial constructor or
 854      destructor in a base class.  If any base class needs to be passed
 855      by reference, so does this class.  Similarly for members, which
 856      are constructed whenever this class is.  We do not need to worry
 857      about recursive loops here, since we are only looking at members
 858      of complete class type.  */
 859   for (fieldnum = 0; fieldnum < TYPE_NFIELDS (type); fieldnum++)
 860     if (gnuv3_pass_by_reference (TYPE_FIELD_TYPE (type, fieldnum)))
 861       return 1;
 862
 863   return 0;
 864 }
 865
 866 static void
 867 init_gnuv3_ops (void)
 868 {
 869   vtable_type_gdbarch_data = gdbarch_data_register_post_init (build_gdb_vtable_type);
 870
 871   gnu_v3_abi_ops.shortname = "gnu-v3";
 872   gnu_v3_abi_ops.longname = "GNU G++ Version 3 ABI";
 873   gnu_v3_abi_ops.doc = "G++ Version 3 ABI";
 874   gnu_v3_abi_ops.is_destructor_name =
 875     (enum dtor_kinds (*) (const char *))is_gnu_v3_mangled_dtor;
 876   gnu_v3_abi_ops.is_constructor_name =
 877     (enum ctor_kinds (*) (const char *))is_gnu_v3_mangled_ctor;
 878   gnu_v3_abi_ops.is_vtable_name = gnuv3_is_vtable_name;
 879   gnu_v3_abi_ops.is_operator_name = gnuv3_is_operator_name;
 880   gnu_v3_abi_ops.rtti_type = gnuv3_rtti_type;
 881   gnu_v3_abi_ops.virtual_fn_field = gnuv3_virtual_fn_field;
 882   gnu_v3_abi_ops.baseclass_offset = gnuv3_baseclass_offset;
 883   gnu_v3_abi_ops.print_method_ptr = gnuv3_print_method_ptr;
 884   gnu_v3_abi_ops.method_ptr_size = gnuv3_method_ptr_size;
 885   gnu_v3_abi_ops.make_method_ptr = gnuv3_make_method_ptr;
 886   gnu_v3_abi_ops.method_ptr_to_value = gnuv3_method_ptr_to_value;
 887   gnu_v3_abi_ops.skip_trampoline = gnuv3_skip_trampoline;
 888   gnu_v3_abi_ops.pass_by_reference = gnuv3_pass_by_reference;
 889 }
 890
 891 extern initialize_file_ftype _initialize_gnu_v3_abi; /* -Wmissing-prototypes */
 892
 893 void
 894 _initialize_gnu_v3_abi (void)
 895 {
 896   init_gnuv3_ops ();
 897
 898   register_cp_abi (&gnu_v3_abi_ops);
 899 }