gdb/gnu-v3-abi.c

   1 /* Abstraction of GNU v3 abi.
   2    Contributed by Jim Blandy <jimb@redhat.com>
   3    Copyright 2001 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or
   8    modify it under the terms of the GNU General Public License as
   9    published by the Free Software Foundation; either version 2 of the
  10    License, or (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 59 Temple Place - Suite 330,
  20    Boston, MA 02111-1307, USA.  */
  21
  22 #include "defs.h"
  23 #include "value.h"
  24 #include "cp-abi.h"
  25 #include "demangle.h"
  26 #include "gdb_assert.h"
  27
  28 static struct cp_abi_ops gnu_v3_abi_ops;
  29
  30 static int
  31 gnuv3_is_vtable_name (const char *name)
  32 {
  33   return strncmp (name, "_ZTV", 4) == 0;
  34 }
  35
  36 static int
  37 gnuv3_is_operator_name (const char *name)
  38 {
  39   return strncmp (name, "operator", 8) == 0;
  40 }
  41
  42
  43 /* To help us find the components of a vtable, we build ourselves a
  44    GDB type object representing the vtable structure.  Following the
  45    V3 ABI, it goes something like this:
  46
  47    struct gdb_gnu_v3_abi_vtable {
  48
  49      / * An array of virtual call and virtual base offsets.  The real
  50          length of this array depends on the class hierarchy; we use
  51          negative subscripts to access the elements.  Yucky, but
  52          better than the alternatives.  * /
  53      ptrdiff_t vcall_and_vbase_offsets[0];
  54
  55      / * The offset from a virtual pointer referring to this table
  56          to the top of the complete object.  * /
  57      ptrdiff_t offset_to_top;
  58
  59      / * The type_info pointer for this class.  This is really a
  60          std::type_info *, but GDB doesn't really look at the
  61          type_info object itself, so we don't bother to get the type
  62          exactly right.  * /
  63      void *type_info;
  64
  65      / * Virtual table pointers in objects point here.  * /
  66
  67      / * Virtual function pointers.  Like the vcall/vbase array, the
  68          real length of this table depends on the class hierarchy.  * /
  69      void (*virtual_functions[0]) ();
  70
  71    };
  72
  73    The catch, of course, is that the exact layout of this table
  74    depends on the ABI --- word size, endianness, alignment, etc.  So
  75    the GDB type object is actually a per-architecture kind of thing.
  76
  77    vtable_type_gdbarch_data is a gdbarch per-architecture data pointer
  78    which refers to the struct type * for this structure, laid out
  79    appropriately for the architecture.  */
  80 static struct gdbarch_data *vtable_type_gdbarch_data;
  81
  82
  83 /* Human-readable names for the numbers of the fields above.  */
  84 enum {
  85   vtable_field_vcall_and_vbase_offsets,
  86   vtable_field_offset_to_top,
  87   vtable_field_type_info,
  88   vtable_field_virtual_functions
  89 };
  90
  91
  92 /* Return a GDB type representing `struct gdb_gnu_v3_abi_vtable',
  93    described above, laid out appropriately for ARCH.
  94
  95    We use this function as the gdbarch per-architecture data
  96    initialization function.  We assume that the gdbarch framework
  97    calls the per-architecture data initialization functions after it
  98    sets current_gdbarch to the new architecture.  */
  99 static void *
 100 build_gdb_vtable_type (struct gdbarch *arch)
 101 {
 102   struct type *t;
 103   struct field *field_list, *field;
 104   int offset;
 105
 106   struct type *void_ptr_type
 107     = lookup_pointer_type (builtin_type_void);
 108   struct type *ptr_to_void_fn_type
 109     = lookup_pointer_type (lookup_function_type (builtin_type_void));
 110
 111   /* ARCH can't give us the true ptrdiff_t type, so we guess.  */
 112   struct type *ptrdiff_type
 113     = init_type (TYPE_CODE_INT, TARGET_PTR_BIT / TARGET_CHAR_BIT, 0,
 114                  "ptrdiff_t", 0);
 115
 116   /* We assume no padding is necessary, since GDB doesn't know
 117      anything about alignment at the moment.  If this assumption bites
 118      us, we should add a gdbarch method which, given a type, returns
 119      the alignment that type requires, and then use that here.  */
 120
 121   /* Build the field list.  */
 122   field_list = xmalloc (sizeof (struct field [4]));
 123   memset (field_list, 0, sizeof (struct field [4]));
 124   field = &field_list[0];
 125   offset = 0;
 126
 127   /* ptrdiff_t vcall_and_vbase_offsets[0]; */
 128   FIELD_NAME (*field) = "vcall_and_vbase_offsets";
 129   FIELD_TYPE (*field)
 130     = create_array_type (0, ptrdiff_type,
 131                          create_range_type (0, builtin_type_int, 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)
 153     = create_array_type (0, ptr_to_void_fn_type,
 154                          create_range_type (0, builtin_type_int, 0, -1));
 155   FIELD_BITPOS (*field) = offset * TARGET_CHAR_BIT;
 156   offset += TYPE_LENGTH (FIELD_TYPE (*field));
 157   field++;
 158
 159   /* We assumed in the allocation above that there were four fields.  */
 160   gdb_assert (field == (field_list + 4));
 161
 162   t = init_type (TYPE_CODE_STRUCT, offset, 0, 0, 0);
 163   TYPE_NFIELDS (t) = field - field_list;
 164   TYPE_FIELDS (t) = field_list;
 165   TYPE_TAG_NAME (t) = "gdb_gnu_v3_abi_vtable";
 166
 167   return t;
 168 }
 169
 170
 171 /* Return the offset from the start of the imaginary `struct
 172    gdb_gnu_v3_abi_vtable' object to the vtable's "address point"
 173    (i.e., where objects' virtual table pointers point).  */
 174 static int
 175 vtable_address_point_offset ()
 176 {
 177   struct type *vtable_type = gdbarch_data (vtable_type_gdbarch_data);
 178
 179   return (TYPE_FIELD_BITPOS (vtable_type, vtable_field_virtual_functions)
 180           / TARGET_CHAR_BIT);
 181 }
 182
 183
 184 static struct type *
 185 gnuv3_rtti_type (struct value *value,
 186                  int *full_p, int *top_p, int *using_enc_p)
 187 {
 188   struct type *vtable_type = gdbarch_data (vtable_type_gdbarch_data);
 189   struct type *value_type = check_typedef (VALUE_TYPE (value));
 190   CORE_ADDR vtable_address;
 191   struct value *vtable;
 192   struct minimal_symbol *vtable_symbol;
 193   const char *vtable_symbol_name;
 194   const char *class_name;
 195   struct symbol *class_symbol;
 196   struct type *run_time_type;
 197   struct type *base_type;
 198   LONGEST offset_to_top;
 199
 200   /* We only have RTTI for class objects.  */
 201   if (TYPE_CODE (value_type) != TYPE_CODE_CLASS)
 202     return NULL;
 203
 204   /* If we can't find the virtual table pointer for value_type, we
 205      can't find the RTTI.  */
 206   fill_in_vptr_fieldno (value_type);
 207   if (TYPE_VPTR_FIELDNO (value_type) == -1)
 208     return NULL;
 209
 210   if (using_enc_p)
 211     *using_enc_p = 0;
 212
 213   /* Fetch VALUE's virtual table pointer, and tweak it to point at
 214      an instance of our imaginary gdb_gnu_v3_abi_vtable structure.  */
 215   base_type = check_typedef (TYPE_VPTR_BASETYPE (value_type));
 216   if (value_type != base_type)
 217     {
 218       value = value_cast (base_type, value);
 219       if (using_enc_p)
 220         *using_enc_p = 1;
 221     }
 222   vtable_address
 223     = value_as_address (value_field (value, TYPE_VPTR_FIELDNO (value_type)));
 224   vtable = value_at_lazy (vtable_type,
 225                           vtable_address - vtable_address_point_offset (),
 226                           VALUE_BFD_SECTION (value));
 227
 228   /* Find the linker symbol for this vtable.  */
 229   vtable_symbol
 230     = lookup_minimal_symbol_by_pc (VALUE_ADDRESS (vtable)
 231                                    + VALUE_OFFSET (vtable)
 232                                    + VALUE_EMBEDDED_OFFSET (vtable));
 233   if (! vtable_symbol)
 234     return NULL;
 235
 236   /* The symbol's demangled name should be something like "vtable for
 237      CLASS", where CLASS is the name of the run-time type of VALUE.
 238      If we didn't like this approach, we could instead look in the
 239      type_info object itself to get the class name.  But this way
 240      should work just as well, and doesn't read target memory.  */
 241   vtable_symbol_name = SYMBOL_DEMANGLED_NAME (vtable_symbol);
 242   if (vtable_symbol_name == NULL
 243       || strncmp (vtable_symbol_name, "vtable for ", 11))
 244     error ("can't find linker symbol for virtual table for `%s' value",
 245            TYPE_NAME (value_type));
 246   class_name = vtable_symbol_name + 11;
 247
 248   /* Try to look up the class name as a type name.  */
 249   class_symbol = lookup_symbol (class_name, 0, STRUCT_NAMESPACE, 0, 0);
 250   if (! class_symbol)
 251     error ("can't find class named `%s', as given by C++ RTTI", class_name);
 252
 253   /* Make sure the type symbol is sane.  (An earlier version of this
 254      code would find constructor functions, who have the same name as
 255      the class.)  */
 256   if (SYMBOL_CLASS (class_symbol) != LOC_TYPEDEF
 257       || TYPE_CODE (SYMBOL_TYPE (class_symbol)) != TYPE_CODE_CLASS)
 258     error ("C++ RTTI gives a class name of `%s', but that isn't a type name",
 259            class_name);
 260
 261   /* This is the object's run-time type!  */
 262   run_time_type = SYMBOL_TYPE (class_symbol);
 263
 264   /* Get the offset from VALUE to the top of the complete object.
 265      NOTE: this is the reverse of the meaning of *TOP_P.  */
 266   offset_to_top
 267     = value_as_long (value_field (vtable, vtable_field_offset_to_top));
 268
 269   if (full_p)
 270     *full_p = (- offset_to_top == VALUE_EMBEDDED_OFFSET (value)
 271                && (TYPE_LENGTH (VALUE_ENCLOSING_TYPE (value))
 272                    >= TYPE_LENGTH (run_time_type)));
 273   if (top_p)
 274     *top_p = - offset_to_top;
 275
 276   return run_time_type;
 277 }
 278
 279
 280 static struct value *
 281 gnuv3_virtual_fn_field (struct value **value_p,
 282                         struct fn_field *f, int j,
 283                         struct type *type, int offset)
 284 {
 285   struct type *vtable_type = gdbarch_data (vtable_type_gdbarch_data);
 286   struct value *value = *value_p;
 287   struct type *value_type = check_typedef (VALUE_TYPE (value));
 288   struct type *vfn_base;
 289   CORE_ADDR vtable_address;
 290   struct value *vtable;
 291   struct value *vfn;
 292
 293   /* Some simple sanity checks.  */
 294   if (TYPE_CODE (value_type) != TYPE_CODE_CLASS)
 295     error ("Only classes can have virtual functions.");
 296
 297   /* Find the base class that defines this virtual function.  */
 298   vfn_base = TYPE_FN_FIELD_FCONTEXT (f, j);
 299   if (! vfn_base)
 300     /* In programs compiled with G++ version 1, the debug info doesn't
 301        say which base class defined the virtual function.  We'll guess
 302        it's the same base class that has our vtable; this is wrong for
 303        multiple inheritance, but it's better than nothing.  */
 304     vfn_base = TYPE_VPTR_BASETYPE (type);
 305
 306   /* This type may have been defined before its virtual function table
 307      was.  If so, fill in the virtual function table entry for the
 308      type now.  */
 309   if (TYPE_VPTR_FIELDNO (vfn_base) < 0)
 310     fill_in_vptr_fieldno (vfn_base);
 311
 312   /* Now that we know which base class is defining our virtual
 313      function, cast our value to that baseclass.  This takes care of
 314      any necessary `this' adjustments.  */
 315   if (vfn_base != value_type)
 316     value = value_cast (vfn_base, value);
 317
 318   /* Now value is an object of the appropriate base type.  Fetch its
 319      virtual table.  */
 320   /* It might be possible to do this cast at the same time as the above.
 321      Does multiple inheritance affect this?
 322      Can this even trigger, or is TYPE_VPTR_BASETYPE idempotent?
 323   */
 324   if (TYPE_VPTR_BASETYPE (vfn_base) != vfn_base)
 325     value = value_cast (TYPE_VPTR_BASETYPE (vfn_base), value);
 326   vtable_address
 327     = value_as_address (value_field (value, TYPE_VPTR_FIELDNO (vfn_base)));
 328
 329   vtable = value_at_lazy (vtable_type,
 330                           vtable_address - vtable_address_point_offset (),
 331                           VALUE_BFD_SECTION (value));
 332
 333   /* Fetch the appropriate function pointer from the vtable.  */
 334   vfn = value_subscript (value_field (vtable, vtable_field_virtual_functions),
 335                          value_from_longest (builtin_type_int,
 336                                              TYPE_FN_FIELD_VOFFSET (f, j)));
 337
 338   /* Cast the function pointer to the appropriate type.  */
 339   vfn = value_cast (lookup_pointer_type (TYPE_FN_FIELD_TYPE (f, j)),
 340                     vfn);
 341
 342   /* Is (type)value always numerically the same as (vfn_base)value?
 343      If so we can spare this cast and use one of the ones above.  */
 344   *value_p = value_addr (value_cast (type, *value_p));
 345
 346   return vfn;
 347 }
 348
 349 /* Compute the offset of the baseclass which is
 350    the INDEXth baseclass of class TYPE,
 351    for value at VALADDR (in host) at ADDRESS (in target).
 352    The result is the offset of the baseclass value relative
 353    to (the address of)(ARG) + OFFSET.
 354
 355    -1 is returned on error. */
 356 int
 357 gnuv3_baseclass_offset (struct type *type, int index, char *valaddr,
 358                         CORE_ADDR address)
 359 {
 360   struct type *vtable_type = gdbarch_data (vtable_type_gdbarch_data);
 361   struct type *basetype = TYPE_BASECLASS (type, index);
 362   struct value *full_object, *vbase_object, *orig_object;
 363   struct value *vtable, *orig_typeinfo, *orig_base_info;
 364   struct type *orig_type, *vbasetype;
 365   struct value *offset_val, *vbase_array;
 366   CORE_ADDR vtable_address;
 367   long int cur_base_offset, base_offset;
 368   int to_top;
 369   int baseclasses, i;
 370
 371   /* If it isn't a virtual base, this is easy.  The offset is in the
 372      type definition.  */
 373   if (!BASETYPE_VIA_VIRTUAL (type, index))
 374     return TYPE_BASECLASS_BITPOS (type, index) / 8;
 375
 376   /* To access a virtual base, we need to use the vbase offset stored in
 377      our vtable.  Recent GCC versions provide this information.  If it isn't
 378      available, we could get what we needed from RTTI, or from drawing the
 379      complete inheritance graph based on the debug info.  Neither is
 380      worthwhile.  */
 381   cur_base_offset = TYPE_BASECLASS_BITPOS (type, index) / 8;
 382   if (cur_base_offset >= - vtable_address_point_offset ())
 383     error ("Expected a negative vbase offset (old compiler?)");
 384
 385   cur_base_offset = cur_base_offset + vtable_address_point_offset ();
 386   if ((- cur_base_offset) % TYPE_LENGTH (builtin_type_void_data_ptr) != 0)
 387     error ("Misaligned vbase offset.");
 388   cur_base_offset = cur_base_offset
 389     / ((int) TYPE_LENGTH (builtin_type_void_data_ptr));
 390
 391   /* We're now looking for the cur_base_offset'th entry (negative index)
 392      in the vcall_and_vbase_offsets array.  */
 393
 394   orig_object = value_at_lazy (type, address, NULL);
 395   vbasetype = TYPE_VPTR_BASETYPE (VALUE_TYPE (orig_object));
 396   vbase_object = value_cast (vbasetype, orig_object);
 397
 398   vtable_address
 399     = value_as_address (value_field (vbase_object,
 400                                      TYPE_VPTR_FIELDNO (vbasetype)));
 401   vtable = value_at_lazy (vtable_type,
 402                           vtable_address - vtable_address_point_offset (),
 403                           NULL);
 404   offset_val = value_from_longest(builtin_type_int, cur_base_offset);
 405   vbase_array = value_field (vtable, vtable_field_vcall_and_vbase_offsets);
 406   base_offset = value_as_long (value_subscript (vbase_array, offset_val));
 407   return base_offset;
 408 }
 409
 410 static void
 411 init_gnuv3_ops (void)
 412 {
 413   vtable_type_gdbarch_data = register_gdbarch_data (build_gdb_vtable_type, 0);
 414
 415   gnu_v3_abi_ops.shortname = "gnu-v3";
 416   gnu_v3_abi_ops.longname = "GNU G++ Version 3 ABI";
 417   gnu_v3_abi_ops.doc = "G++ Version 3 ABI";
 418   gnu_v3_abi_ops.is_destructor_name = is_gnu_v3_mangled_dtor;
 419   gnu_v3_abi_ops.is_constructor_name = is_gnu_v3_mangled_ctor;
 420   gnu_v3_abi_ops.is_vtable_name = gnuv3_is_vtable_name;
 421   gnu_v3_abi_ops.is_operator_name = gnuv3_is_operator_name;
 422   gnu_v3_abi_ops.rtti_type = gnuv3_rtti_type;
 423   gnu_v3_abi_ops.virtual_fn_field = gnuv3_virtual_fn_field;
 424   gnu_v3_abi_ops.baseclass_offset = gnuv3_baseclass_offset;
 425 }
 426
 427
 428 void
 429 _initialize_gnu_v3_abi (void)
 430 {
 431   init_gnuv3_ops ();
 432
 433   register_cp_abi (gnu_v3_abi_ops);
 434 }