gdb/gnu-v3-abi.c

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