gdb/gnu-v2-abi.c

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