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