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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-6.8/] [gdb/] [cp-abi.h] - Blame information for rev 258

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

Line No. Rev Author Line
1 24 jeremybenn
/* Abstraction of various C++ ABI's we support, and the info we need
2
   to get from them.
3
 
4
   Contributed by Daniel Berlin <dberlin@redhat.com>
5
 
6
   Copyright (C) 2001, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
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
#ifndef CP_ABI_H_
24
#define CP_ABI_H_ 1
25
 
26
struct fn_field;
27
struct type;
28
struct value;
29
struct ui_file;
30
struct frame_info;
31
 
32
/* The functions here that attempt to determine what sort of thing a
33
   mangled name refers to may well be revised in the future.  It would
34
   certainly be cleaner to carry this information explicitly in GDB's
35
   data structures than to derive it from the mangled name.  */
36
 
37
 
38
/* Kinds of constructors.  All these values are guaranteed to be
39
   non-zero.  */
40
enum ctor_kinds {
41
 
42
  /* Initialize a complete object, including virtual bases, using
43
     memory provided by caller.  */
44
  complete_object_ctor = 1,
45
 
46
  /* Initialize a base object of some larger object.  */
47
  base_object_ctor,
48
 
49
  /* An allocating complete-object constructor.  */
50
  complete_object_allocating_ctor
51
};
52
 
53
/* Return non-zero iff NAME is the mangled name of a constructor.
54
   Actually, return an `enum ctor_kind' value describing what *kind*
55
   of constructor it is.  */
56
extern enum ctor_kinds is_constructor_name (const char *name);
57
 
58
 
59
/* Kinds of destructors.  All these values are guaranteed to be
60
   non-zero.  */
61
enum dtor_kinds {
62
 
63
  /* A destructor which finalizes the entire object, and then calls
64
     `delete' on its storage.  */
65
  deleting_dtor = 1,
66
 
67
  /* A destructor which finalizes the entire object, but does not call
68
     `delete'.  */
69
  complete_object_dtor,
70
 
71
  /* A destructor which finalizes a subobject of some larger object.  */
72
  base_object_dtor
73
};
74
 
75
/* Return non-zero iff NAME is the mangled name of a destructor.
76
   Actually, return an `enum dtor_kind' value describing what *kind*
77
   of destructor it is.  */
78
extern enum dtor_kinds is_destructor_name (const char *name);
79
 
80
 
81
/* Return non-zero iff NAME is the mangled name of a vtable.  */
82
extern int is_vtable_name (const char *name);
83
 
84
 
85
/* Return non-zero iff NAME is the un-mangled name of an operator,
86
   perhaps scoped within some class.  */
87
extern int is_operator_name (const char *name);
88
 
89
 
90
/* Return an object's virtual function as a value.
91
 
92
   VALUEP is a pointer to a pointer to a value, holding the object
93
   whose virtual function we want to invoke.  If the ABI requires a
94
   virtual function's caller to adjust the `this' pointer by an amount
95
   retrieved from the vtable before invoking the function (i.e., we're
96
   not using "vtable thunks" to do the adjustment automatically), then
97
   this function may set *VALUEP to point to a new object with an
98
   appropriately tweaked address.
99
 
100
   The J'th element of the overload set F is the virtual function of
101
   *VALUEP we want to invoke.
102
 
103
   TYPE is the base type of *VALUEP whose method we're invoking ---
104
   this is the type containing F.  OFFSET is the offset of that base
105
   type within *VALUEP.  */
106
extern struct value *value_virtual_fn_field (struct value **valuep,
107
                                             struct fn_field *f, int j,
108
                                             struct type *type, int offset);
109
 
110
 
111
/* Try to find the run-time type of VALUE, using C++ run-time type
112
   information.  Return the run-time type, or zero if we can't figure
113
   it out.
114
 
115
   If we do find the run-time type:
116
   - Set *FULL to non-zero if VALUE already contains the complete
117
     run-time object, not just some embedded base class of the object.
118
   - Set *TOP and *USING_ENC to indicate where the enclosing object
119
     starts relative to VALUE:
120
     - If *USING_ENC is zero, then *TOP is the offset from the start
121
       of the complete object to the start of the embedded subobject
122
       VALUE represents.  In other words, the enclosing object starts
123
       at VALUE_ADDR (VALUE) + VALUE_OFFSET (VALUE) +
124
       value_embedded_offset (VALUE) + *TOP
125
     - If *USING_ENC is non-zero, then *TOP is the offset from the
126
       address of the complete object to the enclosing object stored
127
       in VALUE.  In other words, the enclosing object starts at
128
       VALUE_ADDR (VALUE) + VALUE_OFFSET (VALUE) + *TOP.
129
     If VALUE's type and enclosing type are the same, then these two
130
     cases are equivalent.
131
 
132
   FULL, TOP, and USING_ENC can each be zero, in which case we don't
133
   provide the corresponding piece of information.  */
134
extern struct type *value_rtti_type (struct value *value,
135
                                     int *full, int *top, int *using_enc);
136
 
137
/* Compute the offset of the baseclass which is
138
   the INDEXth baseclass of class TYPE,
139
   for value at VALADDR (in host) at ADDRESS (in target).
140
   The result is the offset of the baseclass value relative
141
   to (the address of)(ARG) + OFFSET.
142
 
143
   -1 is returned on error. */
144
 
145
extern int baseclass_offset (struct type *type, int index,
146
                             const bfd_byte *valaddr, CORE_ADDR address);
147
 
148
/* Describe the target of a pointer to method.  CONTENTS is the byte
149
   pattern representing the pointer to method.  TYPE is the pointer to
150
   method type.  STREAM is the stream to print it to.  */
151
void cplus_print_method_ptr (const gdb_byte *contents, struct type *type,
152
                             struct ui_file *stream);
153
 
154
/* Return the size of a pointer to member function for the current
155
   architecture.  */
156
int cplus_method_ptr_size (void);
157
 
158
/* Return the method which should be called by applying METHOD_PTR
159
   to *THIS_P, and adjust *THIS_P if necessary.  */
160
struct value *cplus_method_ptr_to_value (struct value **this_p,
161
                                         struct value *method_ptr);
162
 
163
/* Create the byte pattern in CONTENTS representing a pointer to
164
   member function at ADDRESS (if IS_VIRTUAL is 0) or with virtual
165
   table offset ADDRESS (if IS_VIRTUAL is 1).  This is the opposite
166
   of cplus_method_ptr_to_value.  */
167
void cplus_make_method_ptr (gdb_byte *CONTENTS, CORE_ADDR address,
168
                            int is_virtual);
169
 
170
/* Determine if we are currently in a C++ thunk.  If so, get the address
171
   of the routine we are thunking to and continue to there instead.  */
172
 
173
CORE_ADDR cplus_skip_trampoline (struct frame_info *frame, CORE_ADDR stop_pc);
174
 
175
/* Return non-zero if an argument of type TYPE should be passed by reference
176
   instead of value.  */
177
extern int cp_pass_by_reference (struct type *type);
178
 
179
struct cp_abi_ops
180
{
181
  const char *shortname;
182
  const char *longname;
183
  const char *doc;
184
 
185
  /* ABI-specific implementations for the functions declared above.  */
186
  enum ctor_kinds (*is_constructor_name) (const char *name);
187
  enum dtor_kinds (*is_destructor_name) (const char *name);
188
  int (*is_vtable_name) (const char *name);
189
  int (*is_operator_name) (const char *name);
190
  struct value *(*virtual_fn_field) (struct value **arg1p, struct fn_field * f,
191
                                     int j, struct type * type, int offset);
192
  struct type *(*rtti_type) (struct value *v, int *full, int *top,
193
                             int *using_enc);
194
  int (*baseclass_offset) (struct type *type, int index,
195
                           const bfd_byte *valaddr, CORE_ADDR address);
196
  void (*print_method_ptr) (const gdb_byte *contents, struct type *type,
197
                            struct ui_file *stream);
198
  int (*method_ptr_size) (void);
199
  void (*make_method_ptr) (gdb_byte *, CORE_ADDR, int);
200
  struct value * (*method_ptr_to_value) (struct value **, struct value *);
201
  CORE_ADDR (*skip_trampoline) (struct frame_info *, CORE_ADDR);
202
  int (*pass_by_reference) (struct type *type);
203
};
204
 
205
 
206
extern int register_cp_abi (struct cp_abi_ops *abi);
207
extern void set_cp_abi_as_auto_default (const char *short_name);
208
 
209
#endif
210
 

powered by: WebSVN 2.1.0

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