gdb/gnu-v2-abi.c

   1 /* Abstraction of GNU v2 abi.
   2
   3    Copyright (C) 2001-2003, 2005, 2007-2012 Free Software Foundation,
   4    Inc.
   5
   6    Contributed by Daniel Berlin <dberlin@redhat.com>
   7
   8    This file is part of GDB.
   9
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 3 of the License, or
  13    (at your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  22
  23 #include "defs.h"
  24 #include "gdb_string.h"
  25 #include "symtab.h"
  26 #include "gdbtypes.h"
  27 #include "value.h"
  28 #include "demangle.h"
  29 #include "gdb-demangle.h"
  30 #include "cp-abi.h"
  31 #include "cp-support.h"
  32 #include "exceptions.h"
  33
  34 #include <ctype.h>
  35
  36 struct cp_abi_ops gnu_v2_abi_ops;
  37
  38 static int vb_match (struct type *, int, struct type *);
  39
  40 static enum dtor_kinds
  41 gnuv2_is_destructor_name (const char *name)
  42 {
  43   if ((name[0] == '_' && is_cplus_marker (name[1]) && name[2] == '_')
  44       || strncmp (name, "__dt__", 6) == 0)
  45     return complete_object_dtor;
  46   else
  47     return 0;
  48 }
  49
  50 static enum ctor_kinds
  51 gnuv2_is_constructor_name (const char *name)
  52 {
  53   if ((name[0] == '_' && name[1] == '_'
  54        && (isdigit (name[2]) || strchr ("Qt", name[2])))
  55       || strncmp (name, "__ct__", 6) == 0)
  56     return complete_object_ctor;
  57   else
  58     return 0;
  59 }
  60
  61 static int
  62 gnuv2_is_vtable_name (const char *name)
  63 {
  64   return (((name)[0] == '_'
  65            && (((name)[1] == 'V' && (name)[2] == 'T')
  66                || ((name)[1] == 'v' && (name)[2] == 't'))
  67            && is_cplus_marker ((name)[3])) ||
  68           ((name)[0] == '_' && (name)[1] == '_'
  69            && (name)[2] == 'v' && (name)[3] == 't' && (name)[4] == '_'));
  70 }
  71
  72 static int
  73 gnuv2_is_operator_name (const char *name)
  74 {
  75   return strncmp (name, "operator", 8) == 0;
  76 }
  77
  78 \f
  79 /* Return a virtual function as a value.
  80    ARG1 is the object which provides the virtual function
  81    table pointer.  *ARG1P is side-effected in calling this function.
  82    F is the list of member functions which contains the desired virtual
  83    function.
  84    J is an index into F which provides the desired virtual function.
  85
  86    TYPE is the type in which F is located.  */
  87 static struct value *
  88 gnuv2_virtual_fn_field (struct value **arg1p, struct fn_field * f, int j,
  89                         struct type * type, int offset)
  90 {
  91   struct value *arg1 = *arg1p;
  92   struct type *type1 = check_typedef (value_type (arg1));
  93   struct type *entry_type;
  94   /* First, get the virtual function table pointer.  That comes
  95      with a strange type, so cast it to type `pointer to long' (which
  96      should serve just fine as a function type).  Then, index into
  97      the table, and convert final value to appropriate function type.  */
  98   struct value *entry;
  99   struct value *vfn;
 100   struct value *vtbl;
 101   LONGEST vi = (LONGEST) TYPE_FN_FIELD_VOFFSET (f, j);
 102   struct type *fcontext = TYPE_FN_FIELD_FCONTEXT (f, j);
 103   struct type *context;
 104   struct type *context_vptr_basetype;
 105   int context_vptr_fieldno;
 106
 107   if (fcontext == NULL)
 108     /* We don't have an fcontext (e.g. the program was compiled with
 109        g++ version 1).  Try to get the vtbl from the TYPE_VPTR_BASETYPE.
 110        This won't work right for multiple inheritance, but at least we
 111        should do as well as GDB 3.x did.  */
 112     fcontext = TYPE_VPTR_BASETYPE (type);
 113   context = lookup_pointer_type (fcontext);
 114   /* Now context is a pointer to the basetype containing the vtbl.  */
 115   if (TYPE_TARGET_TYPE (context) != type1)
 116     {
 117       struct value *tmp = value_cast (context, value_addr (arg1));
 118
 119       arg1 = value_ind (tmp);
 120       type1 = check_typedef (value_type (arg1));
 121     }
 122
 123   context = type1;
 124   /* Now context is the basetype containing the vtbl.  */
 125
 126   /* This type may have been defined before its virtual function table
 127      was.  If so, fill in the virtual function table entry for the
 128      type now.  */
 129   context_vptr_fieldno = get_vptr_fieldno (context, &context_vptr_basetype);
 130   /* FIXME: What to do if vptr_fieldno is still -1?  */
 131
 132   /* The virtual function table is now an array of structures
 133      which have the form { int16 offset, delta; void *pfn; }.  */
 134   vtbl = value_primitive_field (arg1, 0, context_vptr_fieldno,
 135                                 context_vptr_basetype);
 136
 137   /* With older versions of g++, the vtbl field pointed to an array
 138      of structures.  Nowadays it points directly to the structure.  */
 139   if (TYPE_CODE (value_type (vtbl)) == TYPE_CODE_PTR
 140       && TYPE_CODE (TYPE_TARGET_TYPE (value_type (vtbl))) == TYPE_CODE_ARRAY)
 141     {
 142       /* Handle the case where the vtbl field points to an
 143          array of structures.  */
 144       vtbl = value_ind (vtbl);
 145
 146       /* Index into the virtual function table.  This is hard-coded because
 147          looking up a field is not cheap, and it may be important to save
 148          time, e.g. if the user has set a conditional breakpoint calling
 149          a virtual function.  */
 150       entry = value_subscript (vtbl, vi);
 151     }
 152   else
 153     {
 154       /* Handle the case where the vtbl field points directly to a
 155          structure.  */
 156       vtbl = value_ptradd (vtbl, vi);
 157       entry = value_ind (vtbl);
 158     }
 159
 160   entry_type = check_typedef (value_type (entry));
 161
 162   if (TYPE_CODE (entry_type) == TYPE_CODE_STRUCT)
 163     {
 164       /* Move the `this' pointer according to the virtual function table.  */
 165       set_value_offset (arg1, value_offset (arg1)
 166                         + value_as_long (value_field (entry, 0)));
 167
 168       if (!value_lazy (arg1))
 169         {
 170           set_value_lazy (arg1, 1);
 171           value_fetch_lazy (arg1);
 172         }
 173
 174       vfn = value_field (entry, 2);
 175     }
 176   else if (TYPE_CODE (entry_type) == TYPE_CODE_PTR)
 177     vfn = entry;
 178   else
 179     error (_("I'm confused:  virtual function table has bad type"));
 180   /* Reinstantiate the function pointer with the correct type.  */
 181   deprecated_set_value_type (vfn,
 182                              lookup_pointer_type (TYPE_FN_FIELD_TYPE (f, j)));
 183
 184   *arg1p = arg1;
 185   return vfn;
 186 }
 187
 188
 189 static struct type *
 190 gnuv2_value_rtti_type (struct value *v, int *full, int *top, int *using_enc)
 191 {
 192   struct type *known_type;
 193   struct type *rtti_type;
 194   CORE_ADDR vtbl;
 195   struct minimal_symbol *minsym;
 196   char *demangled_name, *p;
 197   struct type *btype;
 198   struct type *known_type_vptr_basetype;
 199   int known_type_vptr_fieldno;
 200
 201   if (full)
 202     *full = 0;
 203   if (top)
 204     *top = -1;
 205   if (using_enc)
 206     *using_enc = 0;
 207
 208   /* Get declared type.  */
 209   known_type = value_type (v);
 210   CHECK_TYPEDEF (known_type);
 211   /* RTTI works only or class objects.  */
 212   if (TYPE_CODE (known_type) != TYPE_CODE_CLASS)
 213     return NULL;
 214
 215   /* Plan on this changing in the future as i get around to setting
 216      the vtables properly for G++ compiled stuff.  Also, I'll be using
 217      the type info functions, which are always right.  Deal with it
 218      until then.  */
 219
 220   /* Try to get the vptr basetype, fieldno.  */
 221   known_type_vptr_fieldno = get_vptr_fieldno (known_type,
 222                                               &known_type_vptr_basetype);
 223
 224   /* If we can't find it, give up.  */
 225   if (known_type_vptr_fieldno < 0)
 226     return NULL;
 227
 228   /* Make sure our basetype and known type match, otherwise, cast
 229      so we can get at the vtable properly.  */
 230   btype = known_type_vptr_basetype;
 231   CHECK_TYPEDEF (btype);
 232   if (btype != known_type )
 233     {
 234       v = value_cast (btype, v);
 235       if (using_enc)
 236         *using_enc=1;
 237     }
 238   /* We can't use value_ind here, because it would want to use RTTI, and
 239      we'd waste a bunch of time figuring out we already know the type.
 240      Besides, we don't care about the type, just the actual pointer.  */
 241   if (value_address (value_field (v, known_type_vptr_fieldno)) == 0)
 242     return NULL;
 243
 244   vtbl = value_as_address (value_field (v, known_type_vptr_fieldno));
 245
 246   /* Try to find a symbol that is the vtable.  */
 247   minsym=lookup_minimal_symbol_by_pc(vtbl);
 248   if (minsym==NULL
 249       || (demangled_name=SYMBOL_LINKAGE_NAME (minsym))==NULL
 250       || !is_vtable_name (demangled_name))
 251     return NULL;
 252
 253   /* If we just skip the prefix, we get screwed by namespaces.  */
 254   demangled_name=cplus_demangle(demangled_name,DMGL_PARAMS|DMGL_ANSI);
 255   p = strchr (demangled_name, ' ');
 256   if (p)
 257     *p = '\0';
 258
 259   /* Lookup the type for the name.  */
 260   /* FIXME: chastain/2003-11-26: block=NULL is bogus.  See pr gdb/1465.  */
 261   rtti_type = cp_lookup_rtti_type (demangled_name, NULL);
 262   if (rtti_type == NULL)
 263     return NULL;
 264
 265   if (TYPE_N_BASECLASSES(rtti_type) > 1 &&  full && (*full) != 1)
 266     {
 267       if (top)
 268         *top = TYPE_BASECLASS_BITPOS (rtti_type,
 269                                       TYPE_VPTR_FIELDNO(rtti_type)) / 8;
 270       if (top && ((*top) >0))
 271         {
 272           if (TYPE_LENGTH(rtti_type) > TYPE_LENGTH(known_type))
 273             {
 274               if (full)
 275                 *full=0;
 276             }
 277           else
 278             {
 279               if (full)
 280                 *full=1;
 281             }
 282         }
 283     }
 284   else
 285     {
 286       if (full)
 287         *full=1;
 288     }
 289
 290   return rtti_type;
 291 }
 292
 293 /* Return true if the INDEXth field of TYPE is a virtual baseclass
 294    pointer which is for the base class whose type is BASECLASS.  */
 295
 296 static int
 297 vb_match (struct type *type, int index, struct type *basetype)
 298 {
 299   struct type *fieldtype;
 300   char *name = TYPE_FIELD_NAME (type, index);
 301   char *field_class_name = NULL;
 302
 303   if (*name != '_')
 304     return 0;
 305   /* gcc 2.4 uses _vb$.  */
 306   if (name[1] == 'v' && name[2] == 'b' && is_cplus_marker (name[3]))
 307     field_class_name = name + 4;
 308   /* gcc 2.5 will use __vb_.  */
 309   if (name[1] == '_' && name[2] == 'v' && name[3] == 'b' && name[4] == '_')
 310     field_class_name = name + 5;
 311
 312   if (field_class_name == NULL)
 313     /* This field is not a virtual base class pointer.  */
 314     return 0;
 315
 316   /* It's a virtual baseclass pointer, now we just need to find out whether
 317      it is for this baseclass.  */
 318   fieldtype = TYPE_FIELD_TYPE (type, index);
 319   if (fieldtype == NULL
 320       || TYPE_CODE (fieldtype) != TYPE_CODE_PTR)
 321     /* "Can't happen".  */
 322     return 0;
 323
 324   /* What we check for is that either the types are equal (needed for
 325      nameless types) or have the same name.  This is ugly, and a more
 326      elegant solution should be devised (which would probably just push
 327      the ugliness into symbol reading unless we change the stabs format).  */
 328   if (TYPE_TARGET_TYPE (fieldtype) == basetype)
 329     return 1;
 330
 331   if (TYPE_NAME (basetype) != NULL
 332       && TYPE_NAME (TYPE_TARGET_TYPE (fieldtype)) != NULL
 333       && strcmp (TYPE_NAME (basetype),
 334                  TYPE_NAME (TYPE_TARGET_TYPE (fieldtype))) == 0)
 335     return 1;
 336   return 0;
 337 }
 338
 339 /* Compute the offset of the baseclass which is the INDEXth baseclass
 340    of class TYPE, for value at VALADDR (in host) at ADDRESS (in
 341    target).  The result is the offset of the baseclass value relative
 342    to (the address of)(ARG) + OFFSET.  */
 343
 344 static int
 345 gnuv2_baseclass_offset (struct type *type, int index,
 346                         const bfd_byte *valaddr, int embedded_offset,
 347                         CORE_ADDR address, const struct value *val)
 348 {
 349   struct type *basetype = TYPE_BASECLASS (type, index);
 350
 351   if (BASETYPE_VIA_VIRTUAL (type, index))
 352     {
 353       /* Must hunt for the pointer to this virtual baseclass.  */
 354       int i, len = TYPE_NFIELDS (type);
 355       int n_baseclasses = TYPE_N_BASECLASSES (type);
 356
 357       /* First look for the virtual baseclass pointer
 358          in the fields.  */
 359       for (i = n_baseclasses; i < len; i++)
 360         {
 361           if (vb_match (type, i, basetype))
 362             {
 363               struct type *field_type;
 364               int field_offset;
 365               int field_length;
 366               CORE_ADDR addr;
 367
 368               field_type = check_typedef (TYPE_FIELD_TYPE (type, i));
 369               field_offset = TYPE_FIELD_BITPOS (type, i) / 8;
 370               field_length = TYPE_LENGTH (field_type);
 371
 372               if (!value_bytes_available (val, embedded_offset + field_offset,
 373                                           field_length))
 374                 throw_error (NOT_AVAILABLE_ERROR,
 375                              _("Virtual baseclass pointer is not available"));
 376
 377               addr = unpack_pointer (field_type,
 378                                      valaddr + embedded_offset + field_offset);
 379
 380               return addr - (LONGEST) address + embedded_offset;
 381             }
 382         }
 383       /* Not in the fields, so try looking through the baseclasses.  */
 384       for (i = index + 1; i < n_baseclasses; i++)
 385         {
 386           /* Don't go through baseclass_offset, as that wraps
 387              exceptions, thus, inner exceptions would be wrapped more
 388              than once.  */
 389           int boffset =
 390             gnuv2_baseclass_offset (type, i, valaddr,
 391                                     embedded_offset, address, val);
 392
 393           if (boffset)
 394             return boffset;
 395         }
 396
 397       error (_("Baseclass offset not found"));
 398     }
 399
 400   /* Baseclass is easily computed.  */
 401   return TYPE_BASECLASS_BITPOS (type, index) / 8;
 402 }
 403
 404 static void
 405 init_gnuv2_ops (void)
 406 {
 407   gnu_v2_abi_ops.shortname = "gnu-v2";
 408   gnu_v2_abi_ops.longname = "GNU G++ Version 2 ABI";
 409   gnu_v2_abi_ops.doc = "G++ Version 2 ABI";
 410   gnu_v2_abi_ops.is_destructor_name = gnuv2_is_destructor_name;
 411   gnu_v2_abi_ops.is_constructor_name = gnuv2_is_constructor_name;
 412   gnu_v2_abi_ops.is_vtable_name = gnuv2_is_vtable_name;
 413   gnu_v2_abi_ops.is_operator_name = gnuv2_is_operator_name;
 414   gnu_v2_abi_ops.virtual_fn_field = gnuv2_virtual_fn_field;
 415   gnu_v2_abi_ops.rtti_type = gnuv2_value_rtti_type;
 416   gnu_v2_abi_ops.baseclass_offset = gnuv2_baseclass_offset;
 417 }
 418
 419 extern initialize_file_ftype _initialize_gnu_v2_abi; /* -Wmissing-prototypes */
 420
 421 void
 422 _initialize_gnu_v2_abi (void)
 423 {
 424   init_gnuv2_ops ();
 425   register_cp_abi (&gnu_v2_abi_ops);
 426   set_cp_abi_as_auto_default (gnu_v2_abi_ops.shortname);
 427 }