gdb/gnu-v3-abi.c - gdb

Global variables defined

Data types defined

Functions defined

Macros defined

Source code

  1. /* Abstraction of GNU v3 abi.
  2.    Contributed by Jim Blandy <jimb@redhat.com>

  4.    Copyright (C) 2001-2015 Free Software Foundation, Inc.

  6.    This file is part of GDB.

  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.

  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.

  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/>.  */

  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. #include "typeprint.h"

  31. ‌static struct cp_abi_ops gnu_v3_abi_ops;

  33. /* A gdbarch key for std::type_info, in the event that it can't be
  34.    found in the debug info.  */

  36. ‌static struct gdbarch_data *std_type_info_gdbarch_data;


  39. static int
  40. ‌gnuv3_is_vtable_name (const char *name)
  41. {
  42.   return strncmp (name, "_ZTV", 4) == 0;
  43. }

  45. static int
  46. ‌gnuv3_is_operator_name (const char *name)
  47. {
  48.   return strncmp (name, "operator", 8) == 0;
  49. }


  52. /* To help us find the components of a vtable, we build ourselves a
  53.    GDB type object representing the vtable structure.  Following the
  54.    V3 ABI, it goes something like this:

  56.    struct gdb_gnu_v3_abi_vtable {

  58.      / * An array of virtual call and virtual base offsets.  The real
  59.          length of this array depends on the class hierarchy; we use
  60.          negative subscripts to access the elements.  Yucky, but
  61.          better than the alternatives.  * /
  62.      ptrdiff_t vcall_and_vbase_offsets[0];

  64.      / * The offset from a virtual pointer referring to this table
  65.          to the top of the complete object.  * /
  66.      ptrdiff_t offset_to_top;

  68.      / * The type_info pointer for this class.  This is really a
  69.          std::type_info *, but GDB doesn't really look at the
  70.          type_info object itself, so we don't bother to get the type
  71.          exactly right.  * /
  72.      void *type_info;

  74.      / * Virtual table pointers in objects point here.  * /

  76.      / * Virtual function pointers.  Like the vcall/vbase array, the
  77.          real length of this table depends on the class hierarchy.  * /
  78.      void (*virtual_functions[0]) ();

  80.    };

  82.    The catch, of course, is that the exact layout of this table
  83.    depends on the ABI --- word size, endianness, alignment, etc.  So
  84.    the GDB type object is actually a per-architecture kind of thing.

  86.    vtable_type_gdbarch_data is a gdbarch per-architecture data pointer
  87.    which refers to the struct type * for this structure, laid out
  88.    appropriately for the architecture.  */
  89. ‌static struct gdbarch_data *vtable_type_gdbarch_data;


  92. /* Human-readable names for the numbers of the fields above.  */
  93. enum {
  94.   vtable_field_vcall_and_vbase_offsets,
  95.   vtable_field_offset_to_top,
  96.   vtable_field_type_info,
  97.   vtable_field_virtual_functions
  98. };


  101. /* Return a GDB type representing `struct gdb_gnu_v3_abi_vtable',
  102.    described above, laid out appropriately for ARCH.

  104.    We use this function as the gdbarch per-architecture data
  105.    initialization function.  */
  106. static void *
  107. ‌build_gdb_vtable_type (struct gdbarch *arch)
  108. {
  109.   struct type *t;
  110.   struct field *field_list, *field;
  111.   int offset;

  113.   struct type *void_ptr_type
  114.     = builtin_type (arch)->builtin_data_ptr;
  115.   struct type *ptr_to_void_fn_type
  116.     = builtin_type (arch)->builtin_func_ptr;

  118.   /* ARCH can't give us the true ptrdiff_t type, so we guess.  */
  119.   struct type *ptrdiff_type
  120.     = arch_integer_type (arch, gdbarch_ptr_bit (arch), 0, "ptrdiff_t");

  122.   /* We assume no padding is necessary, since GDB doesn't know
  123.      anything about alignment at the moment.  If this assumption bites
  124.      us, we should add a gdbarch method which, given a type, returns
  125.      the alignment that type requires, and then use that here.  */

  127.   /* Build the field list.  */
  128.   field_list = xmalloc (sizeof (struct field [4]));
  129.   memset (field_list, 0, sizeof (struct field [4]));
  130.   field = &field_list[0];
  131.   offset = 0;

  133.   /* ptrdiff_t vcall_and_vbase_offsets[0]; */
  134.   FIELD_NAME (*field) = "vcall_and_vbase_offsets";
  135.   FIELD_TYPE (*field) = lookup_array_range_type (ptrdiff_type, 0, -1);
  136.   SET_FIELD_BITPOS (*field, offset * TARGET_CHAR_BIT);
  137.   offset += TYPE_LENGTH (FIELD_TYPE (*field));
  138.   field++;

  140.   /* ptrdiff_t offset_to_top; */
  141.   FIELD_NAME (*field) = "offset_to_top";
  142.   FIELD_TYPE (*field) = ptrdiff_type;
  143.   SET_FIELD_BITPOS (*field, offset * TARGET_CHAR_BIT);
  144.   offset += TYPE_LENGTH (FIELD_TYPE (*field));
  145.   field++;

  147.   /* void *type_info; */
  148.   FIELD_NAME (*field) = "type_info";
  149.   FIELD_TYPE (*field) = void_ptr_type;
  150.   SET_FIELD_BITPOS (*field, offset * TARGET_CHAR_BIT);
  151.   offset += TYPE_LENGTH (FIELD_TYPE (*field));
  152.   field++;

  154.   /* void (*virtual_functions[0]) (); */
  155.   FIELD_NAME (*field) = "virtual_functions";
  156.   FIELD_TYPE (*field) = lookup_array_range_type (ptr_to_void_fn_type, 0, -1);
  157.   SET_FIELD_BITPOS (*field, offset * TARGET_CHAR_BIT);
  158.   offset += TYPE_LENGTH (FIELD_TYPE (*field));
  159.   field++;

  161.   /* We assumed in the allocation above that there were four fields.  */
  162.   gdb_assert (field == (field_list + 4));

  164.   t = arch_type (arch, TYPE_CODE_STRUCT, offset, NULL);
  165.   TYPE_NFIELDS (t) = field - field_list;
  166.   TYPE_FIELDS (t) = field_list;
  167.   TYPE_TAG_NAME (t) = "gdb_gnu_v3_abi_vtable";
  168.   INIT_CPLUS_SPECIFIC (t);

  170.   return make_type_with_address_space (t, TYPE_INSTANCE_FLAG_CODE_SPACE);
  171. }


  174. /* Return the ptrdiff_t type used in the vtable type.  */
  175. static struct type *
  176. ‌vtable_ptrdiff_type (struct gdbarch *gdbarch)
  177. {
  178.   struct type *vtable_type = gdbarch_data (gdbarch, vtable_type_gdbarch_data);

  180.   /* The "offset_to_top" field has the appropriate (ptrdiff_t) type.  */
  181.   return TYPE_FIELD_TYPE (vtable_type, vtable_field_offset_to_top);
  182. }

  184. /* Return the offset from the start of the imaginary `struct
  185.    gdb_gnu_v3_abi_vtable' object to the vtable's "address point"
  186.    (i.e., where objects' virtual table pointers point).  */
  187. static int
  188. ‌vtable_address_point_offset (struct gdbarch *gdbarch)
  189. {
  190.   struct type *vtable_type = gdbarch_data (gdbarch, vtable_type_gdbarch_data);

  192.   return (TYPE_FIELD_BITPOS (vtable_type, vtable_field_virtual_functions)
  193.           / TARGET_CHAR_BIT);
  194. }


  197. /* Determine whether structure TYPE is a dynamic class.  Cache the
  198.    result.  */

  200. static int
  201. ‌gnuv3_dynamic_class (struct type *type)
  202. {
  203.   int fieldnum, fieldelem;

  205.   if (TYPE_CPLUS_DYNAMIC (type))
  206.     return TYPE_CPLUS_DYNAMIC (type) == 1;

  208.   ALLOCATE_CPLUS_STRUCT_TYPE (type);

  210.   for (fieldnum = 0; fieldnum < TYPE_N_BASECLASSES (type); fieldnum++)
  211.     if (BASETYPE_VIA_VIRTUAL (type, fieldnum)
  212.         || gnuv3_dynamic_class (TYPE_FIELD_TYPE (type, fieldnum)))
  213.       {
  214.         TYPE_CPLUS_DYNAMIC (type) = 1;
  215.         return 1;
  216.       }

  218.   for (fieldnum = 0; fieldnum < TYPE_NFN_FIELDS (type); fieldnum++)
  219.     for (fieldelem = 0; fieldelem < TYPE_FN_FIELDLIST_LENGTH (type, fieldnum);
  220.          fieldelem++)
  221.       {
  222.         struct fn_field *f = TYPE_FN_FIELDLIST1 (type, fieldnum);

  224.         if (TYPE_FN_FIELD_VIRTUAL_P (f, fieldelem))
  225.           {
  226.             TYPE_CPLUS_DYNAMIC (type) = 1;
  227.             return 1;
  228.           }
  229.       }

  231.   TYPE_CPLUS_DYNAMIC (type) = -1;
  232.   return 0;
  233. }

  235. /* Find the vtable for a value of CONTAINER_TYPE located at
  236.    CONTAINER_ADDR.  Return a value of the correct vtable type for this
  237.    architecture, or NULL if CONTAINER does not have a vtable.  */

  239. static struct value *
  240. ‌gnuv3_get_vtable (struct gdbarch *gdbarch,
  241.                   struct type *container_type, CORE_ADDR container_addr)
  242. {
  243.   struct type *vtable_type = gdbarch_data (gdbarch,
  244.                                            vtable_type_gdbarch_data);
  245.   struct type *vtable_pointer_type;
  246.   struct value *vtable_pointer;
  247.   CORE_ADDR vtable_address;

  249.   /* If this type does not have a virtual table, don't read the first
  250.      field.  */
  251.   if (!gnuv3_dynamic_class (check_typedef (container_type)))
  252.     return NULL;

  254.   /* We do not consult the debug information to find the virtual table.
  255.      The ABI specifies that it is always at offset zero in any class,
  256.      and debug information may not represent it.

  258.      We avoid using value_contents on principle, because the object might
  259.      be large.  */

  261.   /* Find the type "pointer to virtual table".  */
  262.   vtable_pointer_type = lookup_pointer_type (vtable_type);

  264.   /* Load it from the start of the class.  */
  265.   vtable_pointer = value_at (vtable_pointer_type, container_addr);
  266.   vtable_address = value_as_address (vtable_pointer);

  268.   /* Correct it to point at the start of the virtual table, rather
  269.      than the address point.  */
  270.   return value_at_lazy (vtable_type,
  271.                         vtable_address
  272.                         - vtable_address_point_offset (gdbarch));
  273. }


  276. static struct type *
  277. ‌gnuv3_rtti_type (struct value *value,
  278.                  int *full_p, int *top_p, int *using_enc_p)
  279. {
  280.   struct gdbarch *gdbarch;
  281.   struct type *values_type = check_typedef (value_type (value));
  282.   struct value *vtable;
  283.   struct minimal_symbol *vtable_symbol;
  284.   const char *vtable_symbol_name;
  285.   const char *class_name;
  286.   struct type *run_time_type;
  287.   LONGEST offset_to_top;
  288.   char *atsign;

  290.   /* We only have RTTI for class objects.  */
  291.   if (TYPE_CODE (values_type) != TYPE_CODE_STRUCT)
  292.     return NULL;

  294.   /* Java doesn't have RTTI following the C++ ABI.  */
  295.   if (TYPE_CPLUS_REALLY_JAVA (values_type))
  296.     return NULL;

  298.   /* Determine architecture.  */
  299.   gdbarch = get_type_arch (values_type);

  301.   if (using_enc_p)
  302.     *using_enc_p = 0;

  304.   vtable = gnuv3_get_vtable (gdbarch, value_type (value),
  305.                              value_as_address (value_addr (value)));
  306.   if (vtable == NULL)
  307.     return NULL;

  309.   /* Find the linker symbol for this vtable.  */
  310.   vtable_symbol
  311.     = lookup_minimal_symbol_by_pc (value_address (vtable)
  312.                                    + value_embedded_offset (vtable)).minsym;
  313.   if (! vtable_symbol)
  314.     return NULL;

  316.   /* The symbol's demangled name should be something like "vtable for
  317.      CLASS", where CLASS is the name of the run-time type of VALUE.
  318.      If we didn't like this approach, we could instead look in the
  319.      type_info object itself to get the class name.  But this way
  320.      should work just as well, and doesn't read target memory.  */
  321.   vtable_symbol_name = MSYMBOL_DEMANGLED_NAME (vtable_symbol);
  322.   if (vtable_symbol_name == NULL
  323.       || strncmp (vtable_symbol_name, "vtable for ", 11))
  324.     {
  325.       warning (_("can't find linker symbol for virtual table for `%s' value"),
  326.                TYPE_SAFE_NAME (values_type));
  327.       if (vtable_symbol_name)
  328.         warning (_("  found `%s' instead"), vtable_symbol_name);
  329.       return NULL;
  330.     }
  331.   class_name = vtable_symbol_name + 11;

  333.   /* Strip off @plt and version suffixes.  */
  334.   atsign = strchr (class_name, '@');
  335.   if (atsign != NULL)
  336.     {
  337.       char *copy;

  339.       copy = alloca (atsign - class_name + 1);
  340.       memcpy (copy, class_name, atsign - class_name);
  341.       copy[atsign - class_name] = '\0';
  342.       class_name = copy;
  343.     }

  345.   /* Try to look up the class name as a type name.  */
  346.   /* FIXME: chastain/2003-11-26: block=NULL is bogus.  See pr gdb/1465.  */
  347.   run_time_type = cp_lookup_rtti_type (class_name, NULL);
  348.   if (run_time_type == NULL)
  349.     return NULL;

  351.   /* Get the offset from VALUE to the top of the complete object.
  352.      NOTE: this is the reverse of the meaning of *TOP_P.  */
  353.   offset_to_top
  354.     = value_as_long (value_field (vtable, vtable_field_offset_to_top));

  356.   if (full_p)
  357.     *full_p = (- offset_to_top == value_embedded_offset (value)
  358.                && (TYPE_LENGTH (value_enclosing_type (value))
  359.                    >= TYPE_LENGTH (run_time_type)));
  360.   if (top_p)
  361.     *top_p = - offset_to_top;
  362.   return run_time_type;
  363. }

  365. /* Return a function pointer for CONTAINER's VTABLE_INDEX'th virtual
  366.    function, of type FNTYPE.  */

  368. static struct value *
  369. ‌gnuv3_get_virtual_fn (struct gdbarch *gdbarch, struct value *container,
  370.                       struct type *fntype, int vtable_index)
  371. {
  372.   struct value *vtable, *vfn;

  374.   /* Every class with virtual functions must have a vtable.  */
  375.   vtable = gnuv3_get_vtable (gdbarch, value_type (container),
  376.                              value_as_address (value_addr (container)));
  377.   gdb_assert (vtable != NULL);

  379.   /* Fetch the appropriate function pointer from the vtable.  */
  380.   vfn = value_subscript (value_field (vtable, vtable_field_virtual_functions),
  381.                          vtable_index);

  383.   /* If this architecture uses function descriptors directly in the vtable,
  384.      then the address of the vtable entry is actually a "function pointer"
  385.      (i.e. points to the descriptor).  We don't need to scale the index
  386.      by the size of a function descriptor; GCC does that before outputing
  387.      debug information.  */
  388.   if (gdbarch_vtable_function_descriptors (gdbarch))
  389.     vfn = value_addr (vfn);

  391.   /* Cast the function pointer to the appropriate type.  */
  392.   vfn = value_cast (lookup_pointer_type (fntype), vfn);

  394.   return vfn;
  395. }

  397. /* GNU v3 implementation of value_virtual_fn_field.  See cp-abi.h
  398.    for a description of the arguments.  */

  400. static struct value *
  401. ‌gnuv3_virtual_fn_field (struct value **value_p,
  402.                         struct fn_field *f, int j,
  403.                         struct type *vfn_base, int offset)
  404. {
  405.   struct type *values_type = check_typedef (value_type (*value_p));
  406.   struct gdbarch *gdbarch;

  408.   /* Some simple sanity checks.  */
  409.   if (TYPE_CODE (values_type) != TYPE_CODE_STRUCT)
  410.     error (_("Only classes can have virtual functions."));

  412.   /* Determine architecture.  */
  413.   gdbarch = get_type_arch (values_type);

  415.   /* Cast our value to the base class which defines this virtual
  416.      function.  This takes care of any necessary `this'
  417.      adjustments.  */
  418.   if (vfn_base != values_type)
  419.     *value_p = value_cast (vfn_base, *value_p);

  421.   return gnuv3_get_virtual_fn (gdbarch, *value_p, TYPE_FN_FIELD_TYPE (f, j),
  422.                                TYPE_FN_FIELD_VOFFSET (f, j));
  423. }

  425. /* Compute the offset of the baseclass which is
  426.    the INDEXth baseclass of class TYPE,
  427.    for value at VALADDR (in host) at ADDRESS (in target).
  428.    The result is the offset of the baseclass value relative
  429.    to (the address of)(ARG) + OFFSET.

  431.    -1 is returned on error.  */

  433. static int
  434. ‌gnuv3_baseclass_offset (struct type *type, int index,
  435.                         const bfd_byte *valaddr, int embedded_offset,
  436.                         CORE_ADDR address, const struct value *val)
  437. {
  438.   struct gdbarch *gdbarch;
  439.   struct type *ptr_type;
  440.   struct value *vtable;
  441.   struct value *vbase_array;
  442.   long int cur_base_offset, base_offset;

  444.   /* Determine architecture.  */
  445.   gdbarch = get_type_arch (type);
  446.   ptr_type = builtin_type (gdbarch)->builtin_data_ptr;

  448.   /* If it isn't a virtual base, this is easy.  The offset is in the
  449.      type definition.  Likewise for Java, which doesn't really have
  450.      virtual inheritance in the C++ sense.  */
  451.   if (!BASETYPE_VIA_VIRTUAL (type, index) || TYPE_CPLUS_REALLY_JAVA (type))
  452.     return TYPE_BASECLASS_BITPOS (type, index) / 8;

  454.   /* To access a virtual base, we need to use the vbase offset stored in
  455.      our vtable.  Recent GCC versions provide this information.  If it isn't
  456.      available, we could get what we needed from RTTI, or from drawing the
  457.      complete inheritance graph based on the debug info.  Neither is
  458.      worthwhile.  */
  459.   cur_base_offset = TYPE_BASECLASS_BITPOS (type, index) / 8;
  460.   if (cur_base_offset >= - vtable_address_point_offset (gdbarch))
  461.     error (_("Expected a negative vbase offset (old compiler?)"));

  463.   cur_base_offset = cur_base_offset + vtable_address_point_offset (gdbarch);
  464.   if ((- cur_base_offset) % TYPE_LENGTH (ptr_type) != 0)
  465.     error (_("Misaligned vbase offset."));
  466.   cur_base_offset = cur_base_offset / ((int) TYPE_LENGTH (ptr_type));

  468.   vtable = gnuv3_get_vtable (gdbarch, type, address + embedded_offset);
  469.   gdb_assert (vtable != NULL);
  470.   vbase_array = value_field (vtable, vtable_field_vcall_and_vbase_offsets);
  471.   base_offset = value_as_long (value_subscript (vbase_array, cur_base_offset));
  472.   return base_offset;
  473. }

  475. /* Locate a virtual method in DOMAIN or its non-virtual base classes
  476.    which has virtual table index VOFFSET.  The method has an associated
  477.    "this" adjustment of ADJUSTMENT bytes.  */

  479. static const char *
  480. ‌gnuv3_find_method_in (struct type *domain, CORE_ADDR voffset,
  481.                       LONGEST adjustment)
  482. {
  483.   int i;

  485.   /* Search this class first.  */
  486.   if (adjustment == 0)
  487.     {
  488.       int len;

  490.       len = TYPE_NFN_FIELDS (domain);
  491.       for (i = 0; i < len; i++)
  492.         {
  493.           int len2, j;
  494.           struct fn_field *f;

  496.           f = TYPE_FN_FIELDLIST1 (domain, i);
  497.           len2 = TYPE_FN_FIELDLIST_LENGTH (domain, i);

  499.           check_stub_method_group (domain, i);
  500.           for (j = 0; j < len2; j++)
  501.             if (TYPE_FN_FIELD_VOFFSET (f, j) == voffset)
  502.               return TYPE_FN_FIELD_PHYSNAME (f, j);
  503.         }
  504.     }

  506.   /* Next search non-virtual bases.  If it's in a virtual base,
  507.      we're out of luck.  */
  508.   for (i = 0; i < TYPE_N_BASECLASSES (domain); i++)
  509.     {
  510.       int pos;
  511.       struct type *basetype;

  513.       if (BASETYPE_VIA_VIRTUAL (domain, i))
  514.         continue;

  516.       pos = TYPE_BASECLASS_BITPOS (domain, i) / 8;
  517.       basetype = TYPE_FIELD_TYPE (domain, i);
  518.       /* Recurse with a modified adjustment.  We don't need to adjust
  519.          voffset.  */
  520.       if (adjustment >= pos && adjustment < pos + TYPE_LENGTH (basetype))
  521.         return gnuv3_find_method_in (basetype, voffset, adjustment - pos);
  522.     }

  524.   return NULL;
  525. }

  527. /* Decode GNU v3 method pointer.  */

  529. static int
  530. ‌gnuv3_decode_method_ptr (struct gdbarch *gdbarch,
  531.                          const gdb_byte *contents,
  532.                          CORE_ADDR *value_p,
  533.                          LONGEST *adjustment_p)
  534. {
  535.   struct type *funcptr_type = builtin_type (gdbarch)->builtin_func_ptr;
  536.   struct type *offset_type = vtable_ptrdiff_type (gdbarch);
  537.   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
  538.   CORE_ADDR ptr_value;
  539.   LONGEST voffset, adjustment;
  540.   int vbit;

  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,
  550.                                     TYPE_LENGTH (funcptr_type), byte_order);
  551.   contents += TYPE_LENGTH (funcptr_type);
  552.   adjustment = extract_signed_integer (contents,
  553.                                        TYPE_LENGTH (offset_type), byte_order);

  555.   if (!gdbarch_vbit_in_delta (gdbarch))
  556.     {
  557.       vbit = voffset & 1;
  558.       voffset = voffset ^ vbit;
  559.     }
  560.   else
  561.     {
  562.       vbit = adjustment & 1;
  563.       adjustment = adjustment >> 1;
  564.     }

  566.   *value_p = vbit? voffset : ptr_value;
  567.   *adjustment_p = adjustment;
  568.   return vbit;
  569. }

  571. /* GNU v3 implementation of cplus_print_method_ptr.  */

  573. static void
  574. ‌gnuv3_print_method_ptr (const gdb_byte *contents,
  575.                         struct type *type,
  576.                         struct ui_file *stream)
  577. {
  578.   struct type *domain = TYPE_DOMAIN_TYPE (type);
  579.   struct gdbarch *gdbarch = get_type_arch (domain);
  580.   CORE_ADDR ptr_value;
  581.   LONGEST adjustment;
  582.   int vbit;

  584.   /* Extract the pointer to member.  */
  585.   vbit = gnuv3_decode_method_ptr (gdbarch, contents, &ptr_value, &adjustment);

  587.   /* Check for NULL.  */
  588.   if (ptr_value == 0 && vbit == 0)
  589.     {
  590.       fprintf_filtered (stream, "NULL");
  591.       return;
  592.     }

  594.   /* Search for a virtual method.  */
  595.   if (vbit)
  596.     {
  597.       CORE_ADDR voffset;
  598.       const char *physname;

  600.       /* It's a virtual table offset, maybe in this class.  Search
  601.          for a field with the correct vtable offset.  First convert it
  602.          to an index, as used in TYPE_FN_FIELD_VOFFSET.  */
  603.       voffset = ptr_value / TYPE_LENGTH (vtable_ptrdiff_type (gdbarch));

  605.       physname = gnuv3_find_method_in (domain, voffset, adjustment);

  607.       /* If we found a method, print that.  We don't bother to disambiguate
  608.          possible paths to the method based on the adjustment.  */
  609.       if (physname)
  610.         {
  611.           char *demangled_name = gdb_demangle (physname,
  612.                                                DMGL_ANSI | DMGL_PARAMS);

  614.           fprintf_filtered (stream, "&virtual ");
  615.           if (demangled_name == NULL)
  616.             fputs_filtered (physname, stream);
  617.           else
  618.             {
  619.               fputs_filtered (demangled_name, stream);
  620.               xfree (demangled_name);
  621.             }
  622.           return;
  623.         }
  624.     }
  625.   else if (ptr_value != 0)
  626.     {
  627.       /* Found a non-virtual function: print out the type.  */
  628.       fputs_filtered ("(", stream);
  629.       c_print_type (type, "", stream, -1, 0, &type_print_raw_options);
  630.       fputs_filtered (") ", stream);
  631.     }

  633.   /* We didn't find it; print the raw data.  */
  634.   if (vbit)
  635.     {
  636.       fprintf_filtered (stream, "&virtual table offset ");
  637.       print_longest (stream, 'd', 1, ptr_value);
  638.     }
  639.   else
  640.     {
  641.       struct value_print_options opts;

  643.       get_user_print_options (&opts);
  644.       print_address_demangle (&opts, gdbarch, ptr_value, stream, demangle);
  645.     }

  647.   if (adjustment)
  648.     {
  649.       fprintf_filtered (stream, ", this adjustment ");
  650.       print_longest (stream, 'd', 1, adjustment);
  651.     }
  652. }

  654. /* GNU v3 implementation of cplus_method_ptr_size.  */

  656. static int
  657. ‌gnuv3_method_ptr_size (struct type *type)
  658. {
  659.   struct gdbarch *gdbarch = get_type_arch (type);

  661.   return 2 * TYPE_LENGTH (builtin_type (gdbarch)->builtin_data_ptr);
  662. }

  664. /* GNU v3 implementation of cplus_make_method_ptr.  */

  666. static void
  667. ‌gnuv3_make_method_ptr (struct type *type, gdb_byte *contents,
  668.                        CORE_ADDR value, int is_virtual)
  669. {
  670.   struct gdbarch *gdbarch = get_type_arch (type);
  671.   int size = TYPE_LENGTH (builtin_type (gdbarch)->builtin_data_ptr);
  672.   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);

  674.   /* FIXME drow/2006-12-24: The adjustment of "this" is currently
  675.      always zero, since the method pointer is of the correct type.
  676.      But if the method pointer came from a base class, this is
  677.      incorrect - it should be the offset to the base.  The best
  678.      fix might be to create the pointer to member pointing at the
  679.      base class and cast it to the derived class, but that requires
  680.      support for adjusting pointers to members when casting them -
  681.      not currently supported by GDB.  */

  683.   if (!gdbarch_vbit_in_delta (gdbarch))
  684.     {
  685.       store_unsigned_integer (contents, size, byte_order, value | is_virtual);
  686.       store_unsigned_integer (contents + size, size, byte_order, 0);
  687.     }
  688.   else
  689.     {
  690.       store_unsigned_integer (contents, size, byte_order, value);
  691.       store_unsigned_integer (contents + size, size, byte_order, is_virtual);
  692.     }
  693. }

  695. /* GNU v3 implementation of cplus_method_ptr_to_value.  */

  697. static struct value *
  698. ‌gnuv3_method_ptr_to_value (struct value **this_p, struct value *method_ptr)
  699. {
  700.   struct gdbarch *gdbarch;
  701.   const gdb_byte *contents = value_contents (method_ptr);
  702.   CORE_ADDR ptr_value;
  703.   struct type *domain_type, *final_type, *method_type;
  704.   LONGEST adjustment;
  705.   int vbit;

  707.   domain_type = TYPE_DOMAIN_TYPE (check_typedef (value_type (method_ptr)));
  708.   final_type = lookup_pointer_type (domain_type);

  710.   method_type = TYPE_TARGET_TYPE (check_typedef (value_type (method_ptr)));

  712.   /* Extract the pointer to member.  */
  713.   gdbarch = get_type_arch (domain_type);
  714.   vbit = gnuv3_decode_method_ptr (gdbarch, contents, &ptr_value, &adjustment);

  716.   /* First convert THIS to match the containing type of the pointer to
  717.      member.  This cast may adjust the value of THIS.  */
  718.   *this_p = value_cast (final_type, *this_p);

  720.   /* Then apply whatever adjustment is necessary.  This creates a somewhat
  721.      strange pointer: it claims to have type FINAL_TYPE, but in fact it
  722.      might not be a valid FINAL_TYPE.  For instance, it might be a
  723.      base class of FINAL_TYPE.  And if it's not the primary base class,
  724.      then printing it out as a FINAL_TYPE object would produce some pretty
  725.      garbage.

  727.      But we don't really know the type of the first argument in
  728.      METHOD_TYPE either, which is why this happens.  We can't
  729.      dereference this later as a FINAL_TYPE, but once we arrive in the
  730.      called method we'll have debugging information for the type of
  731.      "this" - and that'll match the value we produce here.

  733.      You can provoke this case by casting a Base::* to a Derived::*, for
  734.      instance.  */
  735.   *this_p = value_cast (builtin_type (gdbarch)->builtin_data_ptr, *this_p);
  736.   *this_p = value_ptradd (*this_p, adjustment);
  737.   *this_p = value_cast (final_type, *this_p);

  739.   if (vbit)
  740.     {
  741.       LONGEST voffset;

  743.       voffset = ptr_value / TYPE_LENGTH (vtable_ptrdiff_type (gdbarch));
  744.       return gnuv3_get_virtual_fn (gdbarch, value_ind (*this_p),
  745.                                    method_type, voffset);
  746.     }
  747.   else
  748.     return value_from_pointer (lookup_pointer_type (method_type), ptr_value);
  749. }

  751. /* Objects of this type are stored in a hash table and a vector when
  752.    printing the vtables for a class.  */

  754. ‌struct value_and_voffset
  755. {
  756.   /* The value representing the object.  */
  757.   struct value *value;

  759.   /* The maximum vtable offset we've found for any object at this
  760.      offset in the outermost object.  */
  761.   int max_voffset;
  762. };

  764. ‌typedef struct value_and_voffset *value_and_voffset_p;
  765. ‌DEF_VEC_P (value_and_voffset_p);

  767. /* Hash function for value_and_voffset.  */

  769. static hashval_t
  770. ‌hash_value_and_voffset (const void *p)
  771. {
  772.   const struct value_and_voffset *o = p;

  774.   return value_address (o->value) + value_embedded_offset (o->value);
  775. }

  777. /* Equality function for value_and_voffset.  */

  779. static int
  780. ‌eq_value_and_voffset (const void *a, const void *b)
  781. {
  782.   const struct value_and_voffset *ova = a;
  783.   const struct value_and_voffset *ovb = b;

  785.   return (value_address (ova->value) + value_embedded_offset (ova->value)
  786.           == value_address (ovb->value) + value_embedded_offset (ovb->value));
  787. }

  789. /* qsort comparison function for value_and_voffset.  */

  791. static int
  792. ‌compare_value_and_voffset (const void *a, const void *b)
  793. {
  794.   const struct value_and_voffset * const *ova = a;
  795.   CORE_ADDR addra = (value_address ((*ova)->value)
  796.                      + value_embedded_offset ((*ova)->value));
  797.   const struct value_and_voffset * const *ovb = b;
  798.   CORE_ADDR addrb = (value_address ((*ovb)->value)
  799.                      + value_embedded_offset ((*ovb)->value));

  801.   if (addra < addrb)
  802.     return -1;
  803.   if (addra > addrb)
  804.     return 1;
  805.   return 0;
  806. }

  808. /* A helper function used when printing vtables.  This determines the
  809.    key (most derived) sub-object at each address and also computes the
  810.    maximum vtable offset seen for the corresponding vtable.  Updates
  811.    OFFSET_HASH and OFFSET_VEC with a new value_and_voffset object, if
  812.    needed.  VALUE is the object to examine.  */

  814. static void
  815. ‌compute_vtable_size (htab_t offset_hash,
  816.                      VEC (value_and_voffset_p) **offset_vec,
  817.                      struct value *value)
  818. {
  819.   int i;
  820.   struct type *type = check_typedef (value_type (value));
  821.   void **slot;
  822.   struct value_and_voffset search_vo, *current_vo;

  824.   /* If the object is not dynamic, then we are done; as it cannot have
  825.      dynamic base types either.  */
  826.   if (!gnuv3_dynamic_class (type))
  827.     return;

  829.   /* Update the hash and the vec, if needed.  */
  830.   search_vo.value = value;
  831.   slot = htab_find_slot (offset_hash, &search_vo, INSERT);
  832.   if (*slot)
  833.     current_vo = *slot;
  834.   else
  835.     {
  836.       current_vo = XNEW (struct value_and_voffset);
  837.       current_vo->value = value;
  838.       current_vo->max_voffset = -1;
  839.       *slot = current_vo;
  840.       VEC_safe_push (value_and_voffset_p, *offset_vec, current_vo);
  841.     }

  843.   /* Update the value_and_voffset object with the highest vtable
  844.      offset from this class.  */
  845.   for (i = 0; i < TYPE_NFN_FIELDS (type); ++i)
  846.     {
  847.       int j;
  848.       struct fn_field *fn = TYPE_FN_FIELDLIST1 (type, i);

  850.       for (j = 0; j < TYPE_FN_FIELDLIST_LENGTH (type, i); ++j)
  851.         {
  852.           if (TYPE_FN_FIELD_VIRTUAL_P (fn, j))
  853.             {
  854.               int voffset = TYPE_FN_FIELD_VOFFSET (fn, j);

  856.               if (voffset > current_vo->max_voffset)
  857.                 current_vo->max_voffset = voffset;
  858.             }
  859.         }
  860.     }

  862.   /* Recurse into base classes.  */
  863.   for (i = 0; i < TYPE_N_BASECLASSES (type); ++i)
  864.     compute_vtable_size (offset_hash, offset_vec, value_field (value, i));
  865. }

  867. /* Helper for gnuv3_print_vtable that prints a single vtable.  */

  869. static void
  870. ‌print_one_vtable (struct gdbarch *gdbarch, struct value *value,
  871.                   int max_voffset,
  872.                   struct value_print_options *opts)
  873. {
  874.   int i;
  875.   struct type *type = check_typedef (value_type (value));
  876.   struct value *vtable;
  877.   CORE_ADDR vt_addr;

  879.   vtable = gnuv3_get_vtable (gdbarch, type,
  880.                              value_address (value)
  881.                              + value_embedded_offset (value));
  882.   vt_addr = value_address (value_field (vtable,
  883.                                         vtable_field_virtual_functions));

  885.   printf_filtered (_("vtable for '%s' @ %s (subobject @ %s):\n"),
  886.                    TYPE_SAFE_NAME (type),
  887.                    paddress (gdbarch, vt_addr),
  888.                    paddress (gdbarch, (value_address (value)
  889.                                        + value_embedded_offset (value))));

  891.   for (i = 0; i <= max_voffset; ++i)
  892.     {
  893.       /* Initialize it just to avoid a GCC false warning.  */
  894.       CORE_ADDR addr = 0;
  895.       struct value *vfn;
  896.       volatile struct gdb_exception ex;

  898.       printf_filtered ("[%d]: ", i);

  900.       vfn = value_subscript (value_field (vtable,
  901.                                           vtable_field_virtual_functions),
  902.                              i);

  904.       if (gdbarch_vtable_function_descriptors (gdbarch))
  905.         vfn = value_addr (vfn);

  907.       TRY_CATCH (ex, RETURN_MASK_ERROR)
  908.         {
  909.           addr = value_as_address (vfn);
  910.         }
  911.       if (ex.reason < 0)
  912.         printf_filtered (_("<error: %s>"), ex.message);
  913.       else
  914.         print_function_pointer_address (opts, gdbarch, addr, gdb_stdout);
  915.       printf_filtered ("\n");
  916.     }
  917. }

  919. /* Implementation of the print_vtable method.  */

  921. static void
  922. ‌gnuv3_print_vtable (struct value *value)
  923. {
  924.   struct gdbarch *gdbarch;
  925.   struct type *type;
  926.   struct value *vtable;
  927.   struct value_print_options opts;
  928.   htab_t offset_hash;
  929.   struct cleanup *cleanup;
  930.   VEC (value_and_voffset_p) *result_vec = NULL;
  931.   struct value_and_voffset *iter;
  932.   int i, count;

  934.   value = coerce_ref (value);
  935.   type = check_typedef (value_type (value));
  936.   if (TYPE_CODE (type) == TYPE_CODE_PTR)
  937.     {
  938.       value = value_ind (value);
  939.       type = check_typedef (value_type (value));
  940.     }

  942.   get_user_print_options (&opts);

  944.   /* Respect 'set print object'.  */
  945.   if (opts.objectprint)
  946.     {
  947.       value = value_full_object (value, NULL, 0, 0, 0);
  948.       type = check_typedef (value_type (value));
  949.     }

  951.   gdbarch = get_type_arch (type);
  952.   vtable = gnuv3_get_vtable (gdbarch, type,
  953.                              value_as_address (value_addr (value)));

  955.   if (!vtable)
  956.     {
  957.       printf_filtered (_("This object does not have a virtual function table\n"));
  958.       return;
  959.     }

  961.   offset_hash = htab_create_alloc (1, hash_value_and_voffset,
  962.                                    eq_value_and_voffset,
  963.                                    xfree, xcalloc, xfree);
  964.   cleanup = make_cleanup_htab_delete (offset_hash);
  965.   make_cleanup (VEC_cleanup (value_and_voffset_p), &result_vec);

  967.   compute_vtable_size (offset_hash, &result_vec, value);

  969.   qsort (VEC_address (value_and_voffset_p, result_vec),
  970.          VEC_length (value_and_voffset_p, result_vec),
  971.          sizeof (value_and_voffset_p),
  972.          compare_value_and_voffset);

  974.   count = 0;
  975.   for (i = 0; VEC_iterate (value_and_voffset_p, result_vec, i, iter); ++i)
  976.     {
  977.       if (iter->max_voffset >= 0)
  978.         {
  979.           if (count > 0)
  980.             printf_filtered ("\n");
  981.           print_one_vtable (gdbarch, iter->value, iter->max_voffset, &opts);
  982.           ++count;
  983.         }
  984.     }

  986.   do_cleanups (cleanup);
  987. }

  989. /* Return a GDB type representing `struct std::type_info', laid out
  990.    appropriately for ARCH.

  992.    We use this function as the gdbarch per-architecture data
  993.    initialization function.  */

  995. static void *
  996. ‌build_std_type_info_type (struct gdbarch *arch)
  997. {
  998.   struct type *t;
  999.   struct field *field_list, *field;
  1000.   int offset;
  1001.   struct type *void_ptr_type
  1002.     = builtin_type (arch)->builtin_data_ptr;
  1003.   struct type *char_type
  1004.     = builtin_type (arch)->builtin_char;
  1005.   struct type *char_ptr_type
  1006.     = make_pointer_type (make_cv_type (1, 0, char_type, NULL), NULL);

  1008.   field_list = xmalloc (sizeof (struct field [2]));
  1009.   memset (field_list, 0, sizeof (struct field [2]));
  1010.   field = &field_list[0];
  1011.   offset = 0;

  1013.   /* The vtable.  */
  1014.   FIELD_NAME (*field) = "_vptr.type_info";
  1015.   FIELD_TYPE (*field) = void_ptr_type;
  1016.   SET_FIELD_BITPOS (*field, offset * TARGET_CHAR_BIT);
  1017.   offset += TYPE_LENGTH (FIELD_TYPE (*field));
  1018.   field++;

  1020.   /* The name.  */
  1021.   FIELD_NAME (*field) = "__name";
  1022.   FIELD_TYPE (*field) = char_ptr_type;
  1023.   SET_FIELD_BITPOS (*field, offset * TARGET_CHAR_BIT);
  1024.   offset += TYPE_LENGTH (FIELD_TYPE (*field));
  1025.   field++;

  1027.   gdb_assert (field == (field_list + 2));

  1029.   t = arch_type (arch, TYPE_CODE_STRUCT, offset, NULL);
  1030.   TYPE_NFIELDS (t) = field - field_list;
  1031.   TYPE_FIELDS (t) = field_list;
  1032.   TYPE_TAG_NAME (t) = "gdb_gnu_v3_type_info";
  1033.   INIT_CPLUS_SPECIFIC (t);

  1035.   return t;
  1036. }

  1038. /* Implement the 'get_typeid_type' method.  */

  1040. static struct type *
  1041. ‌gnuv3_get_typeid_type (struct gdbarch *gdbarch)
  1042. {
  1043.   struct symbol *typeinfo;
  1044.   struct type *typeinfo_type;

  1046.   typeinfo = lookup_symbol ("std::type_info", NULL, STRUCT_DOMAIN, NULL);
  1047.   if (typeinfo == NULL)
  1048.     typeinfo_type = gdbarch_data (gdbarch, std_type_info_gdbarch_data);
  1049.   else
  1050.     typeinfo_type = SYMBOL_TYPE (typeinfo);

  1052.   return typeinfo_type;
  1053. }

  1055. /* Implement the 'get_typeid' method.  */

  1057. static struct value *
  1058. ‌gnuv3_get_typeid (struct value *value)
  1059. {
  1060.   struct type *typeinfo_type;
  1061.   struct type *type;
  1062.   struct gdbarch *gdbarch;
  1063.   struct cleanup *cleanup;
  1064.   struct value *result;
  1065.   char *typename, *canonical;

  1067.   /* We have to handle values a bit trickily here, to allow this code
  1068.      to work properly with non_lvalue values that are really just
  1069.      disguised types.  */
  1070.   if (value_lval_const (value) == lval_memory)
  1071.     value = coerce_ref (value);

  1073.   type = check_typedef (value_type (value));

  1075.   /* In the non_lvalue case, a reference might have slipped through
  1076.      here.  */
  1077.   if (TYPE_CODE (type) == TYPE_CODE_REF)
  1078.     type = check_typedef (TYPE_TARGET_TYPE (type));

  1080.   /* Ignore top-level cv-qualifiers.  */
  1081.   type = make_cv_type (0, 0, type, NULL);
  1082.   gdbarch = get_type_arch (type);

  1084.   typename = type_to_string (type);
  1085.   if (typename == NULL)
  1086.     error (_("cannot find typeinfo for unnamed type"));
  1087.   cleanup = make_cleanup (xfree, typename);

  1089.   /* We need to canonicalize the type name here, because we do lookups
  1090.      using the demangled name, and so we must match the format it
  1091.      uses.  E.g., GDB tends to use "const char *" as a type name, but
  1092.      the demangler uses "char const *".  */
  1093.   canonical = cp_canonicalize_string (typename);
  1094.   if (canonical != NULL)
  1095.     {
  1096.       make_cleanup (xfree, canonical);
  1097.       typename = canonical;
  1098.     }

  1100.   typeinfo_type = gnuv3_get_typeid_type (gdbarch);

  1102.   /* We check for lval_memory because in the "typeid (type-id)" case,
  1103.      the type is passed via a not_lval value object.  */
  1104.   if (TYPE_CODE (type) == TYPE_CODE_STRUCT
  1105.       && value_lval_const (value) == lval_memory
  1106.       && gnuv3_dynamic_class (type))
  1107.     {
  1108.       struct value *vtable, *typeinfo_value;
  1109.       CORE_ADDR address = value_address (value) + value_embedded_offset (value);

  1111.       vtable = gnuv3_get_vtable (gdbarch, type, address);
  1112.       if (vtable == NULL)
  1113.         error (_("cannot find typeinfo for object of type '%s'"), typename);
  1114.       typeinfo_value = value_field (vtable, vtable_field_type_info);
  1115.       result = value_ind (value_cast (make_pointer_type (typeinfo_type, NULL),
  1116.                                       typeinfo_value));
  1117.     }
  1118.   else
  1119.     {
  1120.       char *sym_name;
  1121.       struct bound_minimal_symbol minsym;

  1123.       sym_name = concat ("typeinfo for ", typename, (char *) NULL);
  1124.       make_cleanup (xfree, sym_name);
  1125.       minsym = lookup_minimal_symbol (sym_name, NULL, NULL);

  1127.       if (minsym.minsym == NULL)
  1128.         error (_("could not find typeinfo symbol for '%s'"), typename);

  1130.       result = value_at_lazy (typeinfo_type, BMSYMBOL_VALUE_ADDRESS (minsym));
  1131.     }

  1133.   do_cleanups (cleanup);
  1134.   return result;
  1135. }

  1137. /* Implement the 'get_typename_from_type_info' method.  */

  1139. static char *
  1140. ‌gnuv3_get_typename_from_type_info (struct value *type_info_ptr)
  1141. {
  1142.   struct gdbarch *gdbarch = get_type_arch (value_type (type_info_ptr));
  1143.   struct bound_minimal_symbol typeinfo_sym;
  1144.   CORE_ADDR addr;
  1145.   const char *symname;
  1146.   const char *class_name;
  1147.   const char *atsign;

  1149.   addr = value_as_address (type_info_ptr);
  1150.   typeinfo_sym = lookup_minimal_symbol_by_pc (addr);
  1151.   if (typeinfo_sym.minsym == NULL)
  1152.     error (_("could not find minimal symbol for typeinfo address %s"),
  1153.            paddress (gdbarch, addr));

  1155. ‌#define TYPEINFO_PREFIX "typeinfo for "
  1156. ‌#define TYPEINFO_PREFIX_LEN (sizeof (TYPEINFO_PREFIX) - 1)
  1157.   symname = MSYMBOL_DEMANGLED_NAME (typeinfo_sym.minsym);
  1158.   if (symname == NULL || strncmp (symname, TYPEINFO_PREFIX,
  1159.                                   TYPEINFO_PREFIX_LEN))
  1160.     error (_("typeinfo symbol '%s' has unexpected name"),
  1161.            MSYMBOL_LINKAGE_NAME (typeinfo_sym.minsym));
  1162.   class_name = symname + TYPEINFO_PREFIX_LEN;

  1164.   /* Strip off @plt and version suffixes.  */
  1165.   atsign = strchr (class_name, '@');
  1166.   if (atsign != NULL)
  1167.     return savestring (class_name, atsign - class_name);
  1168.   return xstrdup (class_name);
  1169. }

  1171. /* Implement the 'get_type_from_type_info' method.  */

  1173. static struct type *
  1174. ‌gnuv3_get_type_from_type_info (struct value *type_info_ptr)
  1175. {
  1176.   char *typename;
  1177.   struct cleanup *cleanup;
  1178.   struct value *type_val;
  1179.   struct expression *expr;
  1180.   struct type *result;

  1182.   typename = gnuv3_get_typename_from_type_info (type_info_ptr);
  1183.   cleanup = make_cleanup (xfree, typename);

  1185.   /* We have to parse the type name, since in general there is not a
  1186.      symbol for a type.  This is somewhat bogus since there may be a
  1187.      mis-parse.  Another approach might be to re-use the demangler's
  1188.      internal form to reconstruct the type somehow.  */

  1190.   expr = parse_expression (typename);
  1191.   make_cleanup (xfree, expr);

  1193.   type_val = evaluate_type (expr);
  1194.   result = value_type (type_val);

  1196.   do_cleanups (cleanup);
  1197.   return result;
  1198. }

  1200. /* Determine if we are currently in a C++ thunk.  If so, get the address
  1201.    of the routine we are thunking to and continue to there instead.  */

  1203. static CORE_ADDR
  1204. ‌gnuv3_skip_trampoline (struct frame_info *frame, CORE_ADDR stop_pc)
  1205. {
  1206.   CORE_ADDR real_stop_pc, method_stop_pc, func_addr;
  1207.   struct gdbarch *gdbarch = get_frame_arch (frame);
  1208.   struct bound_minimal_symbol thunk_sym, fn_sym;
  1209.   struct obj_section *section;
  1210.   const char *thunk_name, *fn_name;

  1212.   real_stop_pc = gdbarch_skip_trampoline_code (gdbarch, frame, stop_pc);
  1213.   if (real_stop_pc == 0)
  1214.     real_stop_pc = stop_pc;

  1216.   /* Find the linker symbol for this potential thunk.  */
  1217.   thunk_sym = lookup_minimal_symbol_by_pc (real_stop_pc);
  1218.   section = find_pc_section (real_stop_pc);
  1219.   if (thunk_sym.minsym == NULL || section == NULL)
  1220.     return 0;

  1222.   /* The symbol's demangled name should be something like "virtual
  1223.      thunk to FUNCTION", where FUNCTION is the name of the function
  1224.      being thunked to.  */
  1225.   thunk_name = MSYMBOL_DEMANGLED_NAME (thunk_sym.minsym);
  1226.   if (thunk_name == NULL || strstr (thunk_name, " thunk to ") == NULL)
  1227.     return 0;

  1229.   fn_name = strstr (thunk_name, " thunk to ") + strlen (" thunk to ");
  1230.   fn_sym = lookup_minimal_symbol (fn_name, NULL, section->objfile);
  1231.   if (fn_sym.minsym == NULL)
  1232.     return 0;

  1234.   method_stop_pc = BMSYMBOL_VALUE_ADDRESS (fn_sym);

  1236.   /* Some targets have minimal symbols pointing to function descriptors
  1237.      (powerpc 64 for example).  Make sure to retrieve the address
  1238.      of the real function from the function descriptor before passing on
  1239.      the address to other layers of GDB.  */
  1240.   func_addr = gdbarch_convert_from_func_ptr_addr (gdbarch, method_stop_pc,
  1241.                                                   &current_target);
  1242.   if (func_addr != 0)
  1243.     method_stop_pc = func_addr;

  1245.   real_stop_pc = gdbarch_skip_trampoline_code
  1246.                    (gdbarch, frame, method_stop_pc);
  1247.   if (real_stop_pc == 0)
  1248.     real_stop_pc = method_stop_pc;

  1250.   return real_stop_pc;
  1251. }

  1253. /* Return nonzero if a type should be passed by reference.

  1255.    The rule in the v3 ABI document comes from section 3.1.1.  If the
  1256.    type has a non-trivial copy constructor or destructor, then the
  1257.    caller must make a copy (by calling the copy constructor if there
  1258.    is one or perform the copy itself otherwise), pass the address of
  1259.    the copy, and then destroy the temporary (if necessary).

  1261.    For return values with non-trivial copy constructors or
  1262.    destructors, space will be allocated in the caller, and a pointer
  1263.    will be passed as the first argument (preceding "this").

  1265.    We don't have a bulletproof mechanism for determining whether a
  1266.    constructor or destructor is trivial.  For GCC and DWARF2 debug
  1267.    information, we can check the artificial flag.

  1269.    We don't do anything with the constructors or destructors,
  1270.    but we have to get the argument passing right anyway.  */
  1271. static int
  1272. ‌gnuv3_pass_by_reference (struct type *type)
  1273. {
  1274.   int fieldnum, fieldelem;

  1276.   CHECK_TYPEDEF (type);

  1278.   /* We're only interested in things that can have methods.  */
  1279.   if (TYPE_CODE (type) != TYPE_CODE_STRUCT
  1280.       && TYPE_CODE (type) != TYPE_CODE_UNION)
  1281.     return 0;

  1283.   /* A dynamic class has a non-trivial copy constructor.
  1284.      See c++98 section 12.8 Copying class objects [class.copy].  */
  1285.   if (gnuv3_dynamic_class (type))
  1286.     return 1;

  1288.   for (fieldnum = 0; fieldnum < TYPE_NFN_FIELDS (type); fieldnum++)
  1289.     for (fieldelem = 0; fieldelem < TYPE_FN_FIELDLIST_LENGTH (type, fieldnum);
  1290.          fieldelem++)
  1291.       {
  1292.         struct fn_field *fn = TYPE_FN_FIELDLIST1 (type, fieldnum);
  1293.         const char *name = TYPE_FN_FIELDLIST_NAME (type, fieldnum);
  1294.         struct type *fieldtype = TYPE_FN_FIELD_TYPE (fn, fieldelem);

  1296.         /* If this function is marked as artificial, it is compiler-generated,
  1297.            and we assume it is trivial.  */
  1298.         if (TYPE_FN_FIELD_ARTIFICIAL (fn, fieldelem))
  1299.           continue;

  1301.         /* If we've found a destructor, we must pass this by reference.  */
  1302.         if (name[0] == '~')
  1303.           return 1;

  1305.         /* If the mangled name of this method doesn't indicate that it
  1306.            is a constructor, we're not interested.

  1308.            FIXME drow/2007-09-23: We could do this using the name of
  1309.            the method and the name of the class instead of dealing
  1310.            with the mangled name.  We don't have a convenient function
  1311.            to strip off both leading scope qualifiers and trailing
  1312.            template arguments yet.  */
  1313.         if (!is_constructor_name (TYPE_FN_FIELD_PHYSNAME (fn, fieldelem))
  1314.             && !TYPE_FN_FIELD_CONSTRUCTOR (fn, fieldelem))
  1315.           continue;

  1317.         /* If this method takes two arguments, and the second argument is
  1318.            a reference to this class, then it is a copy constructor.  */
  1319.         if (TYPE_NFIELDS (fieldtype) == 2)
  1320.           {
  1321.             struct type *arg_type = TYPE_FIELD_TYPE (fieldtype, 1);

  1323.             if (TYPE_CODE (arg_type) == TYPE_CODE_REF)
  1324.               {
  1325.                 struct type *arg_target_type;

  1327.                 arg_target_type = check_typedef (TYPE_TARGET_TYPE (arg_type));
  1328.                 if (class_types_same_p (arg_target_type, type))
  1329.                   return 1;
  1330.               }
  1331.           }
  1332.       }

  1334.   /* Even if all the constructors and destructors were artificial, one
  1335.      of them may have invoked a non-artificial constructor or
  1336.      destructor in a base class.  If any base class needs to be passed
  1337.      by reference, so does this class.  Similarly for members, which
  1338.      are constructed whenever this class is.  We do not need to worry
  1339.      about recursive loops here, since we are only looking at members
  1340.      of complete class type.  Also ignore any static members.  */
  1341.   for (fieldnum = 0; fieldnum < TYPE_NFIELDS (type); fieldnum++)
  1342.     if (! field_is_static (&TYPE_FIELD (type, fieldnum))
  1343.         && gnuv3_pass_by_reference (TYPE_FIELD_TYPE (type, fieldnum)))
  1344.       return 1;

  1346.   return 0;
  1347. }

  1349. static void
  1350. ‌init_gnuv3_ops (void)
  1351. {
  1352.   vtable_type_gdbarch_data
  1353.     = gdbarch_data_register_post_init (build_gdb_vtable_type);
  1354.   std_type_info_gdbarch_data
  1355.     = gdbarch_data_register_post_init (build_std_type_info_type);

  1357.   gnu_v3_abi_ops.shortname = "gnu-v3";
  1358.   gnu_v3_abi_ops.longname = "GNU G++ Version 3 ABI";
  1359.   gnu_v3_abi_ops.doc = "G++ Version 3 ABI";
  1360.   gnu_v3_abi_ops.is_destructor_name =
  1361.     (enum dtor_kinds (*) (const char *))is_gnu_v3_mangled_dtor;
  1362.   gnu_v3_abi_ops.is_constructor_name =
  1363.     (enum ctor_kinds (*) (const char *))is_gnu_v3_mangled_ctor;
  1364.   gnu_v3_abi_ops.is_vtable_name = gnuv3_is_vtable_name;
  1365.   gnu_v3_abi_ops.is_operator_name = gnuv3_is_operator_name;
  1366.   gnu_v3_abi_ops.rtti_type = gnuv3_rtti_type;
  1367.   gnu_v3_abi_ops.virtual_fn_field = gnuv3_virtual_fn_field;
  1368.   gnu_v3_abi_ops.baseclass_offset = gnuv3_baseclass_offset;
  1369.   gnu_v3_abi_ops.print_method_ptr = gnuv3_print_method_ptr;
  1370.   gnu_v3_abi_ops.method_ptr_size = gnuv3_method_ptr_size;
  1371.   gnu_v3_abi_ops.make_method_ptr = gnuv3_make_method_ptr;
  1372.   gnu_v3_abi_ops.method_ptr_to_value = gnuv3_method_ptr_to_value;
  1373.   gnu_v3_abi_ops.print_vtable = gnuv3_print_vtable;
  1374.   gnu_v3_abi_ops.get_typeid = gnuv3_get_typeid;
  1375.   gnu_v3_abi_ops.get_typeid_type = gnuv3_get_typeid_type;
  1376.   gnu_v3_abi_ops.get_type_from_type_info = gnuv3_get_type_from_type_info;
  1377.   gnu_v3_abi_ops.get_typename_from_type_info
  1378.     = gnuv3_get_typename_from_type_info;
  1379.   gnu_v3_abi_ops.skip_trampoline = gnuv3_skip_trampoline;
  1380.   gnu_v3_abi_ops.pass_by_reference = gnuv3_pass_by_reference;
  1381. }

  1383. extern initialize_file_ftype _initialize_gnu_v3_abi; /* -Wmissing-prototypes */

  1385. void
  1386. ‌_initialize_gnu_v3_abi (void)
  1387. {
  1388.   init_gnuv3_ops ();

  1390.   register_cp_abi (&gnu_v3_abi_ops);
  1391.   set_cp_abi_as_auto_default (gnu_v3_abi_ops.shortname);
  1392. }