OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-7.1/] [gdb/] [gnu-v2-abi.c] - Blame information for rev 853

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 227 jeremybenn
/* Abstraction of GNU v2 abi.
2
 
3
   Copyright (C) 2001, 2002, 2003, 2005, 2007, 2008, 2009, 2010
4
   Free Software Foundation, Inc.
5
 
6
   Contributed by Daniel Berlin <dberlin@redhat.com>
7
 
8
   This file is part of GDB.
9
 
10
   This program is free software; you can redistribute it and/or modify
11
   it under the terms of the GNU General Public License as published by
12
   the Free Software Foundation; either version 3 of the License, or
13
   (at your option) any later version.
14
 
15
   This program is distributed in the hope that it will be useful,
16
   but WITHOUT ANY WARRANTY; without even the implied warranty of
17
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18
   GNU General Public License for more details.
19
 
20
   You should have received a copy of the GNU General Public License
21
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
22
 
23
#include "defs.h"
24
#include "gdb_string.h"
25
#include "symtab.h"
26
#include "gdbtypes.h"
27
#include "value.h"
28
#include "demangle.h"
29
#include "cp-abi.h"
30
#include "cp-support.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
 
38
static enum dtor_kinds
39
gnuv2_is_destructor_name (const char *name)
40
{
41
  if ((name[0] == '_' && is_cplus_marker (name[1]) && name[2] == '_')
42
      || strncmp (name, "__dt__", 6) == 0)
43
    return complete_object_dtor;
44
  else
45
    return 0;
46
}
47
 
48
static enum ctor_kinds
49
gnuv2_is_constructor_name (const char *name)
50
{
51
  if ((name[0] == '_' && name[1] == '_'
52
       && (isdigit (name[2]) || strchr ("Qt", name[2])))
53
      || strncmp (name, "__ct__", 6) == 0)
54
    return complete_object_ctor;
55
  else
56
    return 0;
57
}
58
 
59
static int
60
gnuv2_is_vtable_name (const char *name)
61
{
62
  return (((name)[0] == '_'
63
           && (((name)[1] == 'V' && (name)[2] == 'T')
64
               || ((name)[1] == 'v' && (name)[2] == 't'))
65
           && is_cplus_marker ((name)[3])) ||
66
          ((name)[0] == '_' && (name)[1] == '_'
67
           && (name)[2] == 'v' && (name)[3] == 't' && (name)[4] == '_'));
68
}
69
 
70
static int
71
gnuv2_is_operator_name (const char *name)
72
{
73
  return strncmp (name, "operator", 8) == 0;
74
}
75
 
76
 
77
/* Return a virtual function as a value.
78
   ARG1 is the object which provides the virtual function
79
   table pointer.  *ARG1P is side-effected in calling this function.
80
   F is the list of member functions which contains the desired virtual
81
   function.
82
   J is an index into F which provides the desired virtual function.
83
 
84
   TYPE is the type in which F is located.  */
85
static struct value *
86
gnuv2_virtual_fn_field (struct value **arg1p, struct fn_field * f, int j,
87
                        struct type * type, int offset)
88
{
89
  struct value *arg1 = *arg1p;
90
  struct type *type1 = check_typedef (value_type (arg1));
91
  struct type *entry_type;
92
  /* First, get the virtual function table pointer.  That comes
93
     with a strange type, so cast it to type `pointer to long' (which
94
     should serve just fine as a function type).  Then, index into
95
     the table, and convert final value to appropriate function type.  */
96
  struct value *entry;
97
  struct value *vfn;
98
  struct value *vtbl;
99
  LONGEST vi = (LONGEST) TYPE_FN_FIELD_VOFFSET (f, j);
100
  struct type *fcontext = TYPE_FN_FIELD_FCONTEXT (f, j);
101
  struct type *context;
102
  struct type *context_vptr_basetype;
103
  int context_vptr_fieldno;
104
 
105
  if (fcontext == NULL)
106
    /* We don't have an fcontext (e.g. the program was compiled with
107
       g++ version 1).  Try to get the vtbl from the TYPE_VPTR_BASETYPE.
108
       This won't work right for multiple inheritance, but at least we
109
       should do as well as GDB 3.x did.  */
110
    fcontext = TYPE_VPTR_BASETYPE (type);
111
  context = lookup_pointer_type (fcontext);
112
  /* Now context is a pointer to the basetype containing the vtbl.  */
113
  if (TYPE_TARGET_TYPE (context) != type1)
114
    {
115
      struct value *tmp = value_cast (context, value_addr (arg1));
116
      arg1 = value_ind (tmp);
117
      type1 = check_typedef (value_type (arg1));
118
    }
119
 
120
  context = type1;
121
  /* Now context is the basetype containing the vtbl.  */
122
 
123
  /* This type may have been defined before its virtual function table
124
     was.  If so, fill in the virtual function table entry for the
125
     type now.  */
126
  context_vptr_fieldno = get_vptr_fieldno (context, &context_vptr_basetype);
127
  /* FIXME: What to do if vptr_fieldno is still -1?  */
128
 
129
  /* The virtual function table is now an array of structures
130
     which have the form { int16 offset, delta; void *pfn; }.  */
131
  vtbl = value_primitive_field (arg1, 0, context_vptr_fieldno,
132
                                context_vptr_basetype);
133
 
134
  /* With older versions of g++, the vtbl field pointed to an array
135
     of structures.  Nowadays it points directly to the structure. */
136
  if (TYPE_CODE (value_type (vtbl)) == TYPE_CODE_PTR
137
      && TYPE_CODE (TYPE_TARGET_TYPE (value_type (vtbl))) == TYPE_CODE_ARRAY)
138
    {
139
      /* Handle the case where the vtbl field points to an
140
         array of structures. */
141
      vtbl = value_ind (vtbl);
142
 
143
      /* Index into the virtual function table.  This is hard-coded because
144
         looking up a field is not cheap, and it may be important to save
145
         time, e.g. if the user has set a conditional breakpoint calling
146
         a virtual function.  */
147
      entry = value_subscript (vtbl, vi);
148
    }
149
  else
150
    {
151
      /* Handle the case where the vtbl field points directly to a 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) + value_as_long (value_field (entry, 0)));
162
 
163
      if (!value_lazy (arg1))
164
        {
165
          set_value_lazy (arg1, 1);
166
          value_fetch_lazy (arg1);
167
        }
168
 
169
      vfn = value_field (entry, 2);
170
    }
171
  else if (TYPE_CODE (entry_type) == 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
  deprecated_set_value_type (vfn, 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, int *top, int *using_enc)
185
{
186
  struct type *known_type;
187
  struct type *rtti_type;
188
  CORE_ADDR coreptr;
189
  struct value *vp;
190
  long top_offset = 0;
191
  char rtti_type_name[256];
192
  CORE_ADDR vtbl;
193
  struct minimal_symbol *minsym;
194
  struct symbol *sym;
195
  char *demangled_name, *p;
196
  struct type *btype;
197
  struct type *known_type_vptr_basetype;
198
  int known_type_vptr_fieldno;
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
  /* Try to get the vptr basetype, fieldno.  */
220
  known_type_vptr_fieldno = get_vptr_fieldno (known_type,
221
                                              &known_type_vptr_basetype);
222
 
223
  /* If we can't find it, give up.  */
224
  if (known_type_vptr_fieldno < 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 = 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
  /*
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, known_type_vptr_fieldno)) == 0)
244
    return NULL;
245
 
246
  vtbl = value_as_address (value_field (v, known_type_vptr_fieldno));
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_LINKAGE_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
  p = strchr (demangled_name, ' ');
258
  if (p)
259
    *p = '\0';
260
 
261
  /* Lookup the type for the name */
262
  /* FIXME: chastain/2003-11-26: block=NULL is bogus.  See pr gdb/1465. */
263
  rtti_type = cp_lookup_rtti_type (demangled_name, NULL);
264
  if (rtti_type == NULL)
265
    return NULL;
266
 
267
  if (TYPE_N_BASECLASSES(rtti_type) > 1 &&  full && (*full) != 1)
268
    {
269
      if (top)
270
        *top=TYPE_BASECLASS_BITPOS(rtti_type,TYPE_VPTR_FIELDNO(rtti_type))/8;
271
      if (top && ((*top) >0))
272
        {
273
          if (TYPE_LENGTH(rtti_type) > TYPE_LENGTH(known_type))
274
            {
275
              if (full)
276
                *full=0;
277
            }
278
          else
279
            {
280
              if (full)
281
                *full=1;
282
            }
283
        }
284
    }
285
  else
286
    {
287
      if (full)
288
        *full=1;
289
    }
290
 
291
  return rtti_type;
292
}
293
 
294
/* Return true if the INDEXth field of TYPE is a virtual baseclass
295
   pointer which is for the base class whose type is BASECLASS.  */
296
 
297
static int
298
vb_match (struct type *type, int index, struct type *basetype)
299
{
300
  struct type *fieldtype;
301
  char *name = TYPE_FIELD_NAME (type, index);
302
  char *field_class_name = NULL;
303
 
304
  if (*name != '_')
305
    return 0;
306
  /* gcc 2.4 uses _vb$.  */
307
  if (name[1] == 'v' && name[2] == 'b' && is_cplus_marker (name[3]))
308
    field_class_name = name + 4;
309
  /* gcc 2.5 will use __vb_.  */
310
  if (name[1] == '_' && name[2] == 'v' && name[3] == 'b' && name[4] == '_')
311
    field_class_name = name + 5;
312
 
313
  if (field_class_name == NULL)
314
    /* This field is not a virtual base class pointer.  */
315
    return 0;
316
 
317
  /* It's a virtual baseclass pointer, now we just need to find out whether
318
     it is for this baseclass.  */
319
  fieldtype = TYPE_FIELD_TYPE (type, index);
320
  if (fieldtype == NULL
321
      || TYPE_CODE (fieldtype) != TYPE_CODE_PTR)
322
    /* "Can't happen".  */
323
    return 0;
324
 
325
  /* What we check for is that either the types are equal (needed for
326
     nameless types) or have the same name.  This is ugly, and a more
327
     elegant solution should be devised (which would probably just push
328
     the ugliness into symbol reading unless we change the stabs format).  */
329
  if (TYPE_TARGET_TYPE (fieldtype) == basetype)
330
    return 1;
331
 
332
  if (TYPE_NAME (basetype) != NULL
333
      && TYPE_NAME (TYPE_TARGET_TYPE (fieldtype)) != NULL
334
      && strcmp (TYPE_NAME (basetype),
335
                 TYPE_NAME (TYPE_TARGET_TYPE (fieldtype))) == 0)
336
    return 1;
337
  return 0;
338
}
339
 
340
/* Compute the offset of the baseclass which is
341
   the INDEXth baseclass of class TYPE,
342
   for value at VALADDR (in host) at ADDRESS (in target).
343
   The result is the offset of the baseclass value relative
344
   to (the address of)(ARG) + OFFSET.
345
 
346
   -1 is returned on error. */
347
 
348
static int
349
gnuv2_baseclass_offset (struct type *type, int index,
350
                        const bfd_byte *valaddr, CORE_ADDR address)
351
{
352
  struct type *basetype = TYPE_BASECLASS (type, index);
353
 
354
  if (BASETYPE_VIA_VIRTUAL (type, index))
355
    {
356
      /* Must hunt for the pointer to this virtual baseclass.  */
357
      int i, len = TYPE_NFIELDS (type);
358
      int n_baseclasses = TYPE_N_BASECLASSES (type);
359
 
360
      /* First look for the virtual baseclass pointer
361
         in the fields.  */
362
      for (i = n_baseclasses; i < len; i++)
363
        {
364
          if (vb_match (type, i, basetype))
365
            {
366
              CORE_ADDR addr
367
              = unpack_pointer (TYPE_FIELD_TYPE (type, i),
368
                                valaddr + (TYPE_FIELD_BITPOS (type, i) / 8));
369
 
370
              return addr - (LONGEST) address;
371
            }
372
        }
373
      /* Not in the fields, so try looking through the baseclasses.  */
374
      for (i = index + 1; i < n_baseclasses; i++)
375
        {
376
          int boffset =
377
          baseclass_offset (type, i, valaddr, address);
378
          if (boffset)
379
            return boffset;
380
        }
381
      /* Not found.  */
382
      return -1;
383
    }
384
 
385
  /* Baseclass is easily computed.  */
386
  return TYPE_BASECLASS_BITPOS (type, index) / 8;
387
}
388
 
389
static void
390
init_gnuv2_ops (void)
391
{
392
  gnu_v2_abi_ops.shortname = "gnu-v2";
393
  gnu_v2_abi_ops.longname = "GNU G++ Version 2 ABI";
394
  gnu_v2_abi_ops.doc = "G++ Version 2 ABI";
395
  gnu_v2_abi_ops.is_destructor_name = gnuv2_is_destructor_name;
396
  gnu_v2_abi_ops.is_constructor_name = gnuv2_is_constructor_name;
397
  gnu_v2_abi_ops.is_vtable_name = gnuv2_is_vtable_name;
398
  gnu_v2_abi_ops.is_operator_name = gnuv2_is_operator_name;
399
  gnu_v2_abi_ops.virtual_fn_field = gnuv2_virtual_fn_field;
400
  gnu_v2_abi_ops.rtti_type = gnuv2_value_rtti_type;
401
  gnu_v2_abi_ops.baseclass_offset = gnuv2_baseclass_offset;
402
}
403
 
404
extern initialize_file_ftype _initialize_gnu_v2_abi; /* -Wmissing-prototypes */
405
 
406
void
407
_initialize_gnu_v2_abi (void)
408
{
409
  init_gnuv2_ops ();
410
  register_cp_abi (&gnu_v2_abi_ops);
411
  set_cp_abi_as_auto_default (gnu_v2_abi_ops.shortname);
412
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.