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   long top_offset = 0;
 193   char rtti_type_name[256];
 194   CORE_ADDR vtbl;
 195   struct minimal_symbol *minsym;
 196   struct symbol *sym;
 197   char *demangled_name;
 198   struct type *btype;
 199
 200   if (full)
 201     *full = 0;
 202   if (top)
 203     *top = -1;
 204   if (using_enc)
 205     *using_enc = 0;
 206
 207   /* Get declared type */
 208   known_type = VALUE_TYPE (v);
 209   CHECK_TYPEDEF (known_type);
 210   /* RTTI works only or class objects */
 211   if (TYPE_CODE (known_type) != TYPE_CODE_CLASS)
 212     return NULL;
 213
 214   /* Plan on this changing in the future as i get around to setting
 215      the vtables properly for G++ compiled stuff.  Also, I'll be using
 216      the type info functions, which are always right.  Deal with it
 217      until then.  */
 218
 219   /* If the type has no vptr fieldno, try to get it filled in */
 220   if (TYPE_VPTR_FIELDNO(known_type) < 0)
 221     fill_in_vptr_fieldno(known_type);
 222
 223   /* If we still can't find one, give up */
 224   if (TYPE_VPTR_FIELDNO(known_type) < 0)
 225     return NULL;
 226
 227   /* Make sure our basetype and known type match, otherwise, cast
 228      so we can get at the vtable properly.
 229   */
 230   btype = TYPE_VPTR_BASETYPE (known_type);
 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   /*
 239     We can't use value_ind here, because it would want to use RTTI, and
 240     we'd waste a bunch of time figuring out we already know the type.
 241     Besides, we don't care about the type, just the actual pointer
 242   */
 243   if (VALUE_ADDRESS (value_field (v, TYPE_VPTR_FIELDNO (known_type))) == 0)
 244     return NULL;
 245
 246   vtbl=value_as_address(value_field(v,TYPE_VPTR_FIELDNO(known_type)));
 247
 248   /* Try to find a symbol that is the vtable */
 249   minsym=lookup_minimal_symbol_by_pc(vtbl);
 250   if (minsym==NULL
 251       || (demangled_name=SYMBOL_NAME(minsym))==NULL
 252       || !is_vtable_name (demangled_name))
 253     return NULL;
 254
 255   /* If we just skip the prefix, we get screwed by namespaces */
 256   demangled_name=cplus_demangle(demangled_name,DMGL_PARAMS|DMGL_ANSI);
 257   *(strchr(demangled_name,' '))=0;
 258
 259   /* Lookup the type for the name */
 260   rtti_type=lookup_typename(demangled_name, (struct block *)0,1);
 261
 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,TYPE_VPTR_FIELDNO(rtti_type))/8;
 269       if (top && ((*top) >0))
 270         {
 271           if (TYPE_LENGTH(rtti_type) > TYPE_LENGTH(known_type))
 272             {
 273               if (full)
 274                 *full=0;
 275             }
 276           else
 277             {
 278               if (full)
 279                 *full=1;
 280             }
 281         }
 282     }
 283   else
 284     {
 285       if (full)
 286         *full=1;
 287     }
 288
 289   return rtti_type;
 290 }
 291
 292 /* Return true if the INDEXth field of TYPE is a virtual baseclass
 293    pointer which is for the base class whose type is BASECLASS.  */
 294
 295 static int
 296 vb_match (struct type *type, int index, struct type *basetype)
 297 {
 298   struct type *fieldtype;
 299   char *name = TYPE_FIELD_NAME (type, index);
 300   char *field_class_name = NULL;
 301
 302   if (*name != '_')
 303     return 0;
 304   /* gcc 2.4 uses _vb$.  */
 305   if (name[1] == 'v' && name[2] == 'b' && is_cplus_marker (name[3]))
 306     field_class_name = name + 4;
 307   /* gcc 2.5 will use __vb_.  */
 308   if (name[1] == '_' && name[2] == 'v' && name[3] == 'b' && name[4] == '_')
 309     field_class_name = name + 5;
 310
 311   if (field_class_name == NULL)
 312     /* This field is not a virtual base class pointer.  */
 313     return 0;
 314
 315   /* It's a virtual baseclass pointer, now we just need to find out whether
 316      it is for this baseclass.  */
 317   fieldtype = TYPE_FIELD_TYPE (type, index);
 318   if (fieldtype == NULL
 319       || TYPE_CODE (fieldtype) != TYPE_CODE_PTR)
 320     /* "Can't happen".  */
 321     return 0;
 322
 323   /* What we check for is that either the types are equal (needed for
 324      nameless types) or have the same name.  This is ugly, and a more
 325      elegant solution should be devised (which would probably just push
 326      the ugliness into symbol reading unless we change the stabs format).  */
 327   if (TYPE_TARGET_TYPE (fieldtype) == basetype)
 328     return 1;
 329
 330   if (TYPE_NAME (basetype) != NULL
 331       && TYPE_NAME (TYPE_TARGET_TYPE (fieldtype)) != NULL
 332       && STREQ (TYPE_NAME (basetype),
 333                 TYPE_NAME (TYPE_TARGET_TYPE (fieldtype))))
 334     return 1;
 335   return 0;
 336 }
 337
 338 /* Compute the offset of the baseclass which is
 339    the INDEXth baseclass of class TYPE,
 340    for value at VALADDR (in host) at ADDRESS (in target).
 341    The result is the offset of the baseclass value relative
 342    to (the address of)(ARG) + OFFSET.
 343
 344    -1 is returned on error. */
 345
 346 int
 347 gnuv2_baseclass_offset (struct type *type, int index, char *valaddr,
 348                   CORE_ADDR address)
 349 {
 350   struct type *basetype = TYPE_BASECLASS (type, index);
 351
 352   if (BASETYPE_VIA_VIRTUAL (type, index))
 353     {
 354       /* Must hunt for the pointer to this virtual baseclass.  */
 355       register int i, len = TYPE_NFIELDS (type);
 356       register int n_baseclasses = TYPE_N_BASECLASSES (type);
 357
 358       /* First look for the virtual baseclass pointer
 359          in the fields.  */
 360       for (i = n_baseclasses; i < len; i++)
 361         {
 362           if (vb_match (type, i, basetype))
 363             {
 364               CORE_ADDR addr
 365               = unpack_pointer (TYPE_FIELD_TYPE (type, i),
 366                                 valaddr + (TYPE_FIELD_BITPOS (type, i) / 8));
 367
 368               return addr - (LONGEST) address;
 369             }
 370         }
 371       /* Not in the fields, so try looking through the baseclasses.  */
 372       for (i = index + 1; i < n_baseclasses; i++)
 373         {
 374           int boffset =
 375           baseclass_offset (type, i, valaddr, address);
 376           if (boffset)
 377             return boffset;
 378         }
 379       /* Not found.  */
 380       return -1;
 381     }
 382
 383   /* Baseclass is easily computed.  */
 384   return TYPE_BASECLASS_BITPOS (type, index) / 8;
 385 }
 386
 387 static void
 388 init_gnuv2_ops (void)
 389 {
 390   gnu_v2_abi_ops.shortname = "gnu-v2";
 391   gnu_v2_abi_ops.longname = "GNU G++ Version 2 ABI";
 392   gnu_v2_abi_ops.doc = "G++ Version 2 ABI";
 393   gnu_v2_abi_ops.is_destructor_name = gnuv2_is_destructor_name;
 394   gnu_v2_abi_ops.is_constructor_name = gnuv2_is_constructor_name;
 395   gnu_v2_abi_ops.is_vtable_name = gnuv2_is_vtable_name;
 396   gnu_v2_abi_ops.is_operator_name = gnuv2_is_operator_name;
 397   gnu_v2_abi_ops.virtual_fn_field = gnuv2_virtual_fn_field;
 398   gnu_v2_abi_ops.rtti_type = gnuv2_value_rtti_type;
 399   gnu_v2_abi_ops.baseclass_offset = gnuv2_baseclass_offset;
 400 }
 401
 402 void
 403 _initialize_gnu_v2_abi (void)
 404 {
 405   init_gnuv2_ops ();
 406   register_cp_abi (gnu_v2_abi_ops);
 407   switch_to_cp_abi ("gnu-v2");
 408 }