gdb/gnu-v2-abi.c

   1 /* Abstraction of GNU v2 abi.
   2    Contributed by Daniel Berlin <[email protected]>
   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
   9    it under the terms of the GNU General Public License as published
  10    by
  11    the Free Software Foundation; either version 2 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, write to the Free Software
  21    Foundation, Inc., 59 Temple Place - Suite 330,
  22    Boston, MA 02111-1307, USA.  */
  23
  24 #include "defs.h"
  25 #include "gdb_string.h"
  26 #include "symtab.h"
  27 #include "gdbtypes.h"
  28 #include "value.h"
  29 #include "demangle.h"
  30 #include "cp-abi.h"
  31
  32 #include <ctype.h>
  33
  34 struct cp_abi_ops gnu_v2_abi_ops;
  35
  36 static int vb_match (struct type *, int, struct type *);
  37 int gnuv2_baseclass_offset (struct type *type, int index, char *valaddr,
  38                             CORE_ADDR address);
  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
  94
  95   struct type *entry_type;
  96   /* First, get the virtual function table pointer.  That comes
  97      with a strange type, so cast it to type `pointer to long' (which
  98      should serve just fine as a function type).  Then, index into
  99      the table, and convert final value to appropriate function type.  */
 100   struct value *entry;
 101   struct value *vfn;
 102   struct value *vtbl;
 103   struct value *vi = value_from_longest (builtin_type_int,
 104                                      (LONGEST) TYPE_FN_FIELD_VOFFSET (f, j));
 105   struct type *fcontext = TYPE_FN_FIELD_FCONTEXT (f, j);
 106   struct type *context;
 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       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   if (TYPE_VPTR_FIELDNO (context) < 0)
 129     fill_in_vptr_fieldno (context);
 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, TYPE_VPTR_FIELDNO (context),
 134                                 TYPE_VPTR_BASETYPE (context));
 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 structure. */
 154       vtbl = value_add (vtbl, vi);
 155       entry = value_ind (vtbl);
 156     }
 157
 158   entry_type = check_typedef (VALUE_TYPE (entry));
 159
 160   if (TYPE_CODE (entry_type) == TYPE_CODE_STRUCT)
 161     {
 162       /* Move the `this' pointer according to the virtual function table. */
 163       VALUE_OFFSET (arg1) += value_as_long (value_field (entry, 0));
 164
 165       if (!VALUE_LAZY (arg1))
 166         {
 167           VALUE_LAZY (arg1) = 1;
 168           value_fetch_lazy (arg1);
 169         }
 170
 171       vfn = value_field (entry, 2);
 172     }
 173   else if (TYPE_CODE (entry_type) == TYPE_CODE_PTR)
 174     vfn = entry;
 175   else
 176     error ("I'm confused:  virtual function table has bad type");
 177   /* Reinstantiate the function pointer with the correct type.  */
 178   VALUE_TYPE (vfn) = lookup_pointer_type (TYPE_FN_FIELD_TYPE (f, j));
 179
 180   *arg1p = arg1;
 181   return vfn;
 182 }
 183
 184
 185 struct type *
 186 gnuv2_value_rtti_type (struct value *v, int *full, int *top, int *using_enc)
 187 {
 188   struct type *known_type;
 189   struct type *rtti_type;
 190   CORE_ADDR coreptr;
 191   struct value *vp;
 192   int using_enclosing = 0;
 193   long top_offset = 0;
 194   char rtti_type_name[256];
 195   CORE_ADDR vtbl;
 196   struct minimal_symbol *minsym;
 197   struct symbol *sym;
 198   char *demangled_name;
 199   struct type *btype;
 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   /* If the type has no vptr fieldno, try to get it filled in */
 221   if (TYPE_VPTR_FIELDNO(known_type) < 0)
 222     fill_in_vptr_fieldno(known_type);
 223
 224   /* If we still can't find one, give up */
 225   if (TYPE_VPTR_FIELDNO(known_type) < 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   */
 231   btype = TYPE_VPTR_BASETYPE (known_type);
 232   CHECK_TYPEDEF (btype);
 233   if (btype != known_type )
 234     {
 235       v = value_cast (btype, v);
 236       if (using_enc)
 237         *using_enc=1;
 238     }
 239   /*
 240     We can't use value_ind here, because it would want to use RTTI, and
 241     we'd waste a bunch of time figuring out we already know the type.
 242     Besides, we don't care about the type, just the actual pointer
 243   */
 244   if (VALUE_ADDRESS (value_field (v, TYPE_VPTR_FIELDNO (known_type))) == 0)
 245     return NULL;
 246
 247   /*
 248     If we are enclosed by something that isn't us, adjust the
 249     address properly and set using_enclosing.
 250   */
 251   if (VALUE_ENCLOSING_TYPE(v) != VALUE_TYPE(v))
 252     {
 253       struct value *tempval;
 254       int bitpos = TYPE_BASECLASS_BITPOS (known_type,
 255                                           TYPE_VPTR_FIELDNO (known_type));
 256       tempval=value_field (v, TYPE_VPTR_FIELDNO(known_type));
 257       VALUE_ADDRESS(tempval) += bitpos / 8;
 258       vtbl=value_as_address (tempval);
 259       using_enclosing=1;
 260     }
 261   else
 262     {
 263       vtbl=value_as_address(value_field(v,TYPE_VPTR_FIELDNO(known_type)));
 264       using_enclosing=0;
 265     }
 266
 267   /* Try to find a symbol that is the vtable */
 268   minsym=lookup_minimal_symbol_by_pc(vtbl);
 269   if (minsym==NULL
 270       || (demangled_name=SYMBOL_NAME(minsym))==NULL
 271       || !is_vtable_name (demangled_name))
 272     return NULL;
 273
 274   /* If we just skip the prefix, we get screwed by namespaces */
 275   demangled_name=cplus_demangle(demangled_name,DMGL_PARAMS|DMGL_ANSI);
 276   *(strchr(demangled_name,' '))=0;
 277
 278   /* Lookup the type for the name */
 279   rtti_type=lookup_typename(demangled_name, (struct block *)0,1);
 280
 281   if (rtti_type==NULL)
 282     return NULL;
 283
 284   if (TYPE_N_BASECLASSES(rtti_type) > 1 &&  full && (*full) != 1)
 285     {
 286       if (top)
 287         *top=TYPE_BASECLASS_BITPOS(rtti_type,TYPE_VPTR_FIELDNO(rtti_type))/8;
 288       if (top && ((*top) >0))
 289         {
 290           if (TYPE_LENGTH(rtti_type) > TYPE_LENGTH(known_type))
 291             {
 292               if (full)
 293                 *full=0;
 294             }
 295           else
 296             {
 297               if (full)
 298                 *full=1;
 299             }
 300         }
 301     }
 302   else
 303     {
 304       if (full)
 305         *full=1;
 306     }
 307   if (using_enc)
 308     *using_enc=using_enclosing;
 309
 310   return rtti_type;
 311 }
 312
 313 /* Return true if the INDEXth field of TYPE is a virtual baseclass
 314    pointer which is for the base class whose type is BASECLASS.  */
 315
 316 static int
 317 vb_match (struct type *type, int index, struct type *basetype)
 318 {
 319   struct type *fieldtype;
 320   char *name = TYPE_FIELD_NAME (type, index);
 321   char *field_class_name = NULL;
 322
 323   if (*name != '_')
 324     return 0;
 325   /* gcc 2.4 uses _vb$.  */
 326   if (name[1] == 'v' && name[2] == 'b' && is_cplus_marker (name[3]))
 327     field_class_name = name + 4;
 328   /* gcc 2.5 will use __vb_.  */
 329   if (name[1] == '_' && name[2] == 'v' && name[3] == 'b' && name[4] == '_')
 330     field_class_name = name + 5;
 331
 332   if (field_class_name == NULL)
 333     /* This field is not a virtual base class pointer.  */
 334     return 0;
 335
 336   /* It's a virtual baseclass pointer, now we just need to find out whether
 337      it is for this baseclass.  */
 338   fieldtype = TYPE_FIELD_TYPE (type, index);
 339   if (fieldtype == NULL
 340       || TYPE_CODE (fieldtype) != TYPE_CODE_PTR)
 341     /* "Can't happen".  */
 342     return 0;
 343
 344   /* What we check for is that either the types are equal (needed for
 345      nameless types) or have the same name.  This is ugly, and a more
 346      elegant solution should be devised (which would probably just push
 347      the ugliness into symbol reading unless we change the stabs format).  */
 348   if (TYPE_TARGET_TYPE (fieldtype) == basetype)
 349     return 1;
 350
 351   if (TYPE_NAME (basetype) != NULL
 352       && TYPE_NAME (TYPE_TARGET_TYPE (fieldtype)) != NULL
 353       && STREQ (TYPE_NAME (basetype),
 354                 TYPE_NAME (TYPE_TARGET_TYPE (fieldtype))))
 355     return 1;
 356   return 0;
 357 }
 358
 359 /* Compute the offset of the baseclass which is
 360    the INDEXth baseclass of class TYPE,
 361    for value at VALADDR (in host) at ADDRESS (in target).
 362    The result is the offset of the baseclass value relative
 363    to (the address of)(ARG) + OFFSET.
 364
 365    -1 is returned on error. */
 366
 367 int
 368 gnuv2_baseclass_offset (struct type *type, int index, char *valaddr,
 369                   CORE_ADDR address)
 370 {
 371   struct type *basetype = TYPE_BASECLASS (type, index);
 372
 373   if (BASETYPE_VIA_VIRTUAL (type, index))
 374     {
 375       /* Must hunt for the pointer to this virtual baseclass.  */
 376       register int i, len = TYPE_NFIELDS (type);
 377       register int n_baseclasses = TYPE_N_BASECLASSES (type);
 378
 379       /* First look for the virtual baseclass pointer
 380          in the fields.  */
 381       for (i = n_baseclasses; i < len; i++)
 382         {
 383           if (vb_match (type, i, basetype))
 384             {
 385               CORE_ADDR addr
 386               = unpack_pointer (TYPE_FIELD_TYPE (type, i),
 387                                 valaddr + (TYPE_FIELD_BITPOS (type, i) / 8));
 388
 389               return addr - (LONGEST) address;
 390             }
 391         }
 392       /* Not in the fields, so try looking through the baseclasses.  */
 393       for (i = index + 1; i < n_baseclasses; i++)
 394         {
 395           int boffset =
 396           baseclass_offset (type, i, valaddr, address);
 397           if (boffset)
 398             return boffset;
 399         }
 400       /* Not found.  */
 401       return -1;
 402     }
 403
 404   /* Baseclass is easily computed.  */
 405   return TYPE_BASECLASS_BITPOS (type, index) / 8;
 406 }
 407
 408 static void
 409 init_gnuv2_ops (void)
 410 {
 411   gnu_v2_abi_ops.shortname = "gnu-v2";
 412   gnu_v2_abi_ops.longname = "GNU G++ Version 2 ABI";
 413   gnu_v2_abi_ops.doc = "G++ Version 2 ABI";
 414   gnu_v2_abi_ops.is_destructor_name = gnuv2_is_destructor_name;
 415   gnu_v2_abi_ops.is_constructor_name = gnuv2_is_constructor_name;
 416   gnu_v2_abi_ops.is_vtable_name = gnuv2_is_vtable_name;
 417   gnu_v2_abi_ops.is_operator_name = gnuv2_is_operator_name;
 418   gnu_v2_abi_ops.virtual_fn_field = gnuv2_virtual_fn_field;
 419   gnu_v2_abi_ops.rtti_type = gnuv2_value_rtti_type;
 420   gnu_v2_abi_ops.baseclass_offset = gnuv2_baseclass_offset;
 421 }
 422
 423 void
 424 _initialize_gnu_v2_abi (void)
 425 {
 426   init_gnuv2_ops ();
 427   register_cp_abi (gnu_v2_abi_ops);
 428   switch_to_cp_abi ("gnu-v2");
 429 }