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