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     {
 245       warning ("can't find linker symbol for virtual table for `%s' value",
 246                TYPE_NAME (value_type));
 247       if (vtable_symbol_name)
 248         warning ("  found `%s' instead", vtable_symbol_name);
 249       return NULL;
 250     }
 251   class_name = vtable_symbol_name + 11;
 252
 253   /* Try to look up the class name as a type name.  */
 254   class_symbol = lookup_symbol (class_name, 0, STRUCT_NAMESPACE, 0, 0);
 255   if (! class_symbol)
 256     {
 257       warning ("can't find class named `%s', as given by C++ RTTI", class_name);
 258       return NULL;
 259     }
 260
 261   /* Make sure the type symbol is sane.  (An earlier version of this
 262      code would find constructor functions, who have the same name as
 263      the class.)  */
 264   if (SYMBOL_CLASS (class_symbol) != LOC_TYPEDEF
 265       || TYPE_CODE (SYMBOL_TYPE (class_symbol)) != TYPE_CODE_CLASS)
 266     {
 267       warning ("C++ RTTI gives a class name of `%s', but that isn't a type name",
 268                class_name);
 269       return NULL;
 270     }
 271
 272   /* This is the object's run-time type!  */
 273   run_time_type = SYMBOL_TYPE (class_symbol);
 274
 275   /* Get the offset from VALUE to the top of the complete object.
 276      NOTE: this is the reverse of the meaning of *TOP_P.  */
 277   offset_to_top
 278     = value_as_long (value_field (vtable, vtable_field_offset_to_top));
 279
 280   if (full_p)
 281     *full_p = (- offset_to_top == VALUE_EMBEDDED_OFFSET (value)
 282                && (TYPE_LENGTH (VALUE_ENCLOSING_TYPE (value))
 283                    >= TYPE_LENGTH (run_time_type)));
 284   if (top_p)
 285     *top_p = - offset_to_top;
 286
 287   return run_time_type;
 288 }
 289
 290
 291 static struct value *
 292 gnuv3_virtual_fn_field (struct value **value_p,
 293                         struct fn_field *f, int j,
 294                         struct type *type, int offset)
 295 {
 296   struct type *vtable_type = gdbarch_data (vtable_type_gdbarch_data);
 297   struct value *value = *value_p;
 298   struct type *value_type = check_typedef (VALUE_TYPE (value));
 299   struct type *vfn_base;
 300   CORE_ADDR vtable_address;
 301   struct value *vtable;
 302   struct value *vfn;
 303
 304   /* Some simple sanity checks.  */
 305   if (TYPE_CODE (value_type) != TYPE_CODE_CLASS)
 306     error ("Only classes can have virtual functions.");
 307
 308   /* Find the base class that defines this virtual function.  */
 309   vfn_base = TYPE_FN_FIELD_FCONTEXT (f, j);
 310   if (! vfn_base)
 311     /* In programs compiled with G++ version 1, the debug info doesn't
 312        say which base class defined the virtual function.  We'll guess
 313        it's the same base class that has our vtable; this is wrong for
 314        multiple inheritance, but it's better than nothing.  */
 315     vfn_base = TYPE_VPTR_BASETYPE (type);
 316
 317   /* This type may have been defined before its virtual function table
 318      was.  If so, fill in the virtual function table entry for the
 319      type now.  */
 320   if (TYPE_VPTR_FIELDNO (vfn_base) < 0)
 321     fill_in_vptr_fieldno (vfn_base);
 322
 323   /* Now that we know which base class is defining our virtual
 324      function, cast our value to that baseclass.  This takes care of
 325      any necessary `this' adjustments.  */
 326   if (vfn_base != value_type)
 327     value = value_cast (vfn_base, value);
 328
 329   /* Now value is an object of the appropriate base type.  Fetch its
 330      virtual table.  */
 331   /* It might be possible to do this cast at the same time as the above.
 332      Does multiple inheritance affect this?
 333      Can this even trigger, or is TYPE_VPTR_BASETYPE idempotent?
 334   */
 335   if (TYPE_VPTR_BASETYPE (vfn_base) != vfn_base)
 336     value = value_cast (TYPE_VPTR_BASETYPE (vfn_base), value);
 337   vtable_address
 338     = value_as_address (value_field (value, TYPE_VPTR_FIELDNO (vfn_base)));
 339
 340   vtable = value_at_lazy (vtable_type,
 341                           vtable_address - vtable_address_point_offset (),
 342                           VALUE_BFD_SECTION (value));
 343
 344   /* Fetch the appropriate function pointer from the vtable.  */
 345   vfn = value_subscript (value_field (vtable, vtable_field_virtual_functions),
 346                          value_from_longest (builtin_type_int,
 347                                              TYPE_FN_FIELD_VOFFSET (f, j)));
 348
 349   /* Cast the function pointer to the appropriate type.  */
 350   vfn = value_cast (lookup_pointer_type (TYPE_FN_FIELD_TYPE (f, j)),
 351                     vfn);
 352
 353   /* Is (type)value always numerically the same as (vfn_base)value?
 354      If so we can spare this cast and use one of the ones above.  */
 355   *value_p = value_addr (value_cast (type, *value_p));
 356
 357   return vfn;
 358 }
 359
 360 /* Compute the offset of the baseclass which is
 361    the INDEXth baseclass of class TYPE,
 362    for value at VALADDR (in host) at ADDRESS (in target).
 363    The result is the offset of the baseclass value relative
 364    to (the address of)(ARG) + OFFSET.
 365
 366    -1 is returned on error. */
 367 int
 368 gnuv3_baseclass_offset (struct type *type, int index, char *valaddr,
 369                         CORE_ADDR address)
 370 {
 371   struct type *vtable_type = gdbarch_data (vtable_type_gdbarch_data);
 372   struct type *basetype = TYPE_BASECLASS (type, index);
 373   struct value *full_object, *vbase_object, *orig_object;
 374   struct value *vtable, *orig_typeinfo, *orig_base_info;
 375   struct type *orig_type, *vbasetype;
 376   struct value *offset_val, *vbase_array;
 377   CORE_ADDR vtable_address;
 378   long int cur_base_offset, base_offset;
 379   int to_top;
 380   int baseclasses, i;
 381
 382   /* If it isn't a virtual base, this is easy.  The offset is in the
 383      type definition.  */
 384   if (!BASETYPE_VIA_VIRTUAL (type, index))
 385     return TYPE_BASECLASS_BITPOS (type, index) / 8;
 386
 387   /* To access a virtual base, we need to use the vbase offset stored in
 388      our vtable.  Recent GCC versions provide this information.  If it isn't
 389      available, we could get what we needed from RTTI, or from drawing the
 390      complete inheritance graph based on the debug info.  Neither is
 391      worthwhile.  */
 392   cur_base_offset = TYPE_BASECLASS_BITPOS (type, index) / 8;
 393   if (cur_base_offset >= - vtable_address_point_offset ())
 394     error ("Expected a negative vbase offset (old compiler?)");
 395
 396   cur_base_offset = cur_base_offset + vtable_address_point_offset ();
 397   if ((- cur_base_offset) % TYPE_LENGTH (builtin_type_void_data_ptr) != 0)
 398     error ("Misaligned vbase offset.");
 399   cur_base_offset = cur_base_offset
 400     / ((int) TYPE_LENGTH (builtin_type_void_data_ptr));
 401
 402   /* We're now looking for the cur_base_offset'th entry (negative index)
 403      in the vcall_and_vbase_offsets array.  */
 404
 405   orig_object = value_at_lazy (type, address, NULL);
 406   vbasetype = TYPE_VPTR_BASETYPE (VALUE_TYPE (orig_object));
 407   vbase_object = value_cast (vbasetype, orig_object);
 408
 409   vtable_address
 410     = value_as_address (value_field (vbase_object,
 411                                      TYPE_VPTR_FIELDNO (vbasetype)));
 412   vtable = value_at_lazy (vtable_type,
 413                           vtable_address - vtable_address_point_offset (),
 414                           NULL);
 415   offset_val = value_from_longest(builtin_type_int, cur_base_offset);
 416   vbase_array = value_field (vtable, vtable_field_vcall_and_vbase_offsets);
 417   base_offset = value_as_long (value_subscript (vbase_array, offset_val));
 418   return base_offset;
 419 }
 420
 421 static void
 422 init_gnuv3_ops (void)
 423 {
 424   vtable_type_gdbarch_data = register_gdbarch_data (build_gdb_vtable_type, 0);
 425
 426   gnu_v3_abi_ops.shortname = "gnu-v3";
 427   gnu_v3_abi_ops.longname = "GNU G++ Version 3 ABI";
 428   gnu_v3_abi_ops.doc = "G++ Version 3 ABI";
 429   gnu_v3_abi_ops.is_destructor_name = is_gnu_v3_mangled_dtor;
 430   gnu_v3_abi_ops.is_constructor_name = is_gnu_v3_mangled_ctor;
 431   gnu_v3_abi_ops.is_vtable_name = gnuv3_is_vtable_name;
 432   gnu_v3_abi_ops.is_operator_name = gnuv3_is_operator_name;
 433   gnu_v3_abi_ops.rtti_type = gnuv3_rtti_type;
 434   gnu_v3_abi_ops.virtual_fn_field = gnuv3_virtual_fn_field;
 435   gnu_v3_abi_ops.baseclass_offset = gnuv3_baseclass_offset;
 436 }
 437
 438
 439 void
 440 _initialize_gnu_v3_abi (void)
 441 {
 442   init_gnuv3_ops ();
 443
 444   register_cp_abi (gnu_v3_abi_ops);
 445 }