gdb/gnu-v2-abi.c

   1 /* Abstraction of GNU v2 abi.
   2
   3    Copyright (C) 2001-2013 Free Software Foundation, Inc.
   4
   5    Contributed by Daniel Berlin <dberlin@redhat.com>
   6
   7    This file is part of GDB.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  21
  22 #include "defs.h"
  23 #include "gdb_string.h"
  24 #include "symtab.h"
  25 #include "gdbtypes.h"
  26 #include "value.h"
  27 #include "demangle.h"
  28 #include "gdb-demangle.h"
  29 #include "cp-abi.h"
  30 #include "cp-support.h"
  31 #include "exceptions.h"
  32
  33 #include <ctype.h>
  34
  35 struct cp_abi_ops gnu_v2_abi_ops;
  36
  37 static int vb_match (struct type *, int, struct type *);
  38
  39 static enum dtor_kinds
  40 gnuv2_is_destructor_name (const char *name)
  41 {
  42   if ((name[0] == '_' && is_cplus_marker (name[1]) && name[2] == '_')
  43       || strncmp (name, "__dt__", 6) == 0)
  44     return complete_object_dtor;
  45   else
  46     return 0;
  47 }
  48
  49 static enum ctor_kinds
  50 gnuv2_is_constructor_name (const char *name)
  51 {
  52   if ((name[0] == '_' && name[1] == '_'
  53        && (isdigit (name[2]) || strchr ("Qt", name[2])))
  54       || strncmp (name, "__ct__", 6) == 0)
  55     return complete_object_ctor;
  56   else
  57     return 0;
  58 }
  59
  60 static int
  61 gnuv2_is_vtable_name (const char *name)
  62 {
  63   return (((name)[0] == '_'
  64            && (((name)[1] == 'V' && (name)[2] == 'T')
  65                || ((name)[1] == 'v' && (name)[2] == 't'))
  66            && is_cplus_marker ((name)[3])) ||
  67           ((name)[0] == '_' && (name)[1] == '_'
  68            && (name)[2] == 'v' && (name)[3] == 't' && (name)[4] == '_'));
  69 }
  70
  71 static int
  72 gnuv2_is_operator_name (const char *name)
  73 {
  74   return strncmp (name, "operator", 8) == 0;
  75 }
  76
  77 \f
  78 /* Return a virtual function as a value.
  79    ARG1 is the object which provides the virtual function
  80    table pointer.  *ARG1P is side-effected in calling this function.
  81    F is the list of member functions which contains the desired virtual
  82    function.
  83    J is an index into F which provides the desired virtual function.
  84
  85    TYPE is the type in which F is located.  */
  86 static struct value *
  87 gnuv2_virtual_fn_field (struct value **arg1p, struct fn_field * f, int j,
  88                         struct type * type, int offset)
  89 {
  90   struct value *arg1 = *arg1p;
  91   struct type *type1 = check_typedef (value_type (arg1));
  92   struct type *entry_type;
  93   /* First, get the virtual function table pointer.  That comes
  94      with a strange type, so cast it to type `pointer to long' (which
  95      should serve just fine as a function type).  Then, index into
  96      the table, and convert final value to appropriate function type.  */
  97   struct value *entry;
  98   struct value *vfn;
  99   struct value *vtbl;
 100   LONGEST vi = (LONGEST) TYPE_FN_FIELD_VOFFSET (f, j);
 101   struct type *fcontext = TYPE_FN_FIELD_FCONTEXT (f, j);
 102   struct type *context;
 103   struct type *context_vptr_basetype;
 104   int context_vptr_fieldno;
 105
 106   if (fcontext == NULL)
 107     /* We don't have an fcontext (e.g. the program was compiled with
 108        g++ version 1).  Try to get the vtbl from the TYPE_VPTR_BASETYPE.
 109        This won't work right for multiple inheritance, but at least we
 110        should do as well as GDB 3.x did.  */
 111     fcontext = TYPE_VPTR_BASETYPE (type);
 112   context = lookup_pointer_type (fcontext);
 113   /* Now context is a pointer to the basetype containing the vtbl.  */
 114   if (TYPE_TARGET_TYPE (context) != type1)
 115     {
 116       struct value *tmp = value_cast (context, value_addr (arg1));
 117
 118       arg1 = value_ind (tmp);
 119       type1 = check_typedef (value_type (arg1));
 120     }
 121
 122   context = type1;
 123   /* Now context is the basetype containing the vtbl.  */
 124
 125   /* This type may have been defined before its virtual function table
 126      was.  If so, fill in the virtual function table entry for the
 127      type now.  */
 128   context_vptr_fieldno = get_vptr_fieldno (context, &context_vptr_basetype);
 129   /* FIXME: What to do if vptr_fieldno is still -1?  */
 130
 131   /* The virtual function table is now an array of structures
 132      which have the form { int16 offset, delta; void *pfn; }.  */
 133   vtbl = value_primitive_field (arg1, 0, context_vptr_fieldno,
 134                                 context_vptr_basetype);
 135
 136   /* With older versions of g++, the vtbl field pointed to an array
 137      of structures.  Nowadays it points directly to the structure.  */
 138   if (TYPE_CODE (value_type (vtbl)) == TYPE_CODE_PTR
 139       && TYPE_CODE (TYPE_TARGET_TYPE (value_type (vtbl))) == TYPE_CODE_ARRAY)
 140     {
 141       /* Handle the case where the vtbl field points to an
 142          array of structures.  */
 143       vtbl = value_ind (vtbl);
 144
 145       /* Index into the virtual function table.  This is hard-coded because
 146          looking up a field is not cheap, and it may be important to save
 147          time, e.g. if the user has set a conditional breakpoint calling
 148          a virtual function.  */
 149       entry = value_subscript (vtbl, vi);
 150     }
 151   else
 152     {
 153       /* Handle the case where the vtbl field points directly to a
 154          structure.  */
 155       vtbl = value_ptradd (vtbl, vi);
 156       entry = value_ind (vtbl);
 157     }
 158
 159   entry_type = check_typedef (value_type (entry));
 160
 161   if (TYPE_CODE (entry_type) == TYPE_CODE_STRUCT)
 162     {
 163       /* Move the `this' pointer according to the virtual function table.  */
 164       set_value_offset (arg1, value_offset (arg1)
 165                         + value_as_long (value_field (entry, 0)));
 166
 167       if (!value_lazy (arg1))
 168         {
 169           set_value_lazy (arg1, 1);
 170           value_fetch_lazy (arg1);
 171         }
 172
 173       vfn = value_field (entry, 2);
 174     }
 175   else if (TYPE_CODE (entry_type) == TYPE_CODE_PTR)
 176     vfn = entry;
 177   else
 178     error (_("I'm confused:  virtual function table has bad type"));
 179   /* Reinstantiate the function pointer with the correct type.  */
 180   deprecated_set_value_type (vfn,
 181                              lookup_pointer_type (TYPE_FN_FIELD_TYPE (f, j)));
 182
 183   *arg1p = arg1;
 184   return vfn;
 185 }
 186
 187
 188 static struct type *
 189 gnuv2_value_rtti_type (struct value *v, int *full, int *top, int *using_enc)
 190 {
 191   struct type *known_type;
 192   struct type *rtti_type;
 193   CORE_ADDR vtbl;
 194   struct minimal_symbol *minsym;
 195   char *demangled_name, *p;
 196   const char *linkage_name;
 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       || (linkage_name=SYMBOL_LINKAGE_NAME (minsym))==NULL
 250       || !is_vtable_name (linkage_name))
 251     return NULL;
 252
 253   /* If we just skip the prefix, we get screwed by namespaces.  */
 254   demangled_name=cplus_demangle(linkage_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   const char *name = TYPE_FIELD_NAME (type, index);
 301   const 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 }