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