contrib/gdb-7/gdb/gnu-v3-abi.c

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