cp-abi.h revision 1.7 
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-2017 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
26struct fn_field;
27struct type;
28struct value;
29struct ui_file;
30struct 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.  */
40enum 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.  */
56extern 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.  */
61enum 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
72     object.  */
73  base_object_dtor
74};
75
76/* Return non-zero iff NAME is the mangled name of a destructor.
77   Actually, return an `enum dtor_kind' value describing what *kind*
78   of destructor it is.  */
79extern enum dtor_kinds is_destructor_name (const char *name);
80
81
82/* Return non-zero iff NAME is the mangled name of a vtable.  */
83extern int is_vtable_name (const char *name);
84
85
86/* Return non-zero iff NAME is the un-mangled name of an operator,
87   perhaps scoped within some class.  */
88extern int is_operator_name (const char *name);
89
90
91/* Return an object's virtual function as a value.
92
93   VALUEP is a pointer to a pointer to a value, holding the object
94   whose virtual function we want to invoke.  If the ABI requires a
95   virtual function's caller to adjust the `this' pointer by an amount
96   retrieved from the vtable before invoking the function (i.e., we're
97   not using "vtable thunks" to do the adjustment automatically), then
98   this function may set *VALUEP to point to a new object with an
99   appropriately tweaked address.
100
101   The J'th element of the overload set F is the virtual function of
102   *VALUEP we want to invoke.
103
104   TYPE is the base type of *VALUEP whose method we're invoking ---
105   this is the type containing F.  OFFSET is the offset of that base
106   type within *VALUEP.  */
107extern struct value *value_virtual_fn_field (struct value **valuep,
108					     struct fn_field *f,
109					     int j,
110					     struct type *type,
111					     int offset);
112
113
114/* Try to find the run-time type of VALUE, using C++ run-time type
115   information.  Return the run-time type, or zero if we can't figure
116   it out.
117
118   If we do find the run-time type:
119   - Set *FULL to non-zero if VALUE already contains the complete
120     run-time object, not just some embedded base class of the object.
121   - Set *TOP and *USING_ENC to indicate where the enclosing object
122     starts relative to VALUE:
123     - If *USING_ENC is zero, then *TOP is the offset from the start
124       of the complete object to the start of the embedded subobject
125       VALUE represents.  In other words, the enclosing object starts
126       at VALUE_ADDR (VALUE) + VALUE_OFFSET (VALUE) +
127       value_embedded_offset (VALUE) + *TOP
128     - If *USING_ENC is non-zero, then *TOP is the offset from the
129       address of the complete object to the enclosing object stored
130       in VALUE.  In other words, the enclosing object starts at
131       VALUE_ADDR (VALUE) + VALUE_OFFSET (VALUE) + *TOP.
132     If VALUE's type and enclosing type are the same, then these two
133     cases are equivalent.
134
135   FULL, TOP, and USING_ENC can each be zero, in which case we don't
136   provide the corresponding piece of information.  */
137extern struct type *value_rtti_type (struct value *value,
138                                     int *full, LONGEST *top,
139				     int *using_enc);
140
141/* Compute the offset of the baseclass which is the INDEXth baseclass
142   of class TYPE, for value at VALADDR (in host) at ADDRESS (in
143   target), offset by EMBEDDED_OFFSET.  VALADDR points to the raw
144   contents of VAL.  The result is the offset of the baseclass value
145   relative to (the address of)(ARG) + OFFSET.  */
146
147extern int baseclass_offset (struct type *type,
148			     int index, const gdb_byte *valaddr,
149			     LONGEST embedded_offset,
150			     CORE_ADDR address,
151			     const struct value *val);
152
153/* Describe the target of a pointer to method.  CONTENTS is the byte
154   pattern representing the pointer to method.  TYPE is the pointer to
155   method type.  STREAM is the stream to print it to.  */
156void cplus_print_method_ptr (const gdb_byte *contents,
157			     struct type *type,
158			     struct ui_file *stream);
159
160/* Return the size of a pointer to member function of type
161   TO_TYPE.  */
162int cplus_method_ptr_size (struct type *to_type);
163
164/* Return the method which should be called by applying METHOD_PTR to
165   *THIS_P, and adjust *THIS_P if necessary.  */
166struct value *cplus_method_ptr_to_value (struct value **this_p,
167					 struct value *method_ptr);
168
169/* Create the byte pattern in CONTENTS representing a pointer of type
170   TYPE to member function at ADDRESS (if IS_VIRTUAL is 0) or with
171   virtual table offset ADDRESS (if IS_VIRTUAL is 1).  This is the
172   opposite of cplus_method_ptr_to_value.  */
173void cplus_make_method_ptr (struct type *type, gdb_byte *CONTENTS,
174			    CORE_ADDR address, int is_virtual);
175
176/* Print the vtable for VALUE, if there is one.  If there is no
177   vtable, print a message, but do not throw.  */
178
179void cplus_print_vtable (struct value *value);
180
181/* Implement 'typeid': find the type info for VALUE, if possible.  If
182   the type info cannot be found, throw an exception.  */
183
184extern struct value *cplus_typeid (struct value *value);
185
186/* Return the type of 'typeid' for the current C++ ABI on the given
187   architecture.  */
188
189extern struct type *cplus_typeid_type (struct gdbarch *gdbarch);
190
191/* Given a value which holds a pointer to a std::type_info, return the
192   type which that type_info represents.  Throw an exception if the
193   type cannot be found.  */
194
195extern struct type *cplus_type_from_type_info (struct value *value);
196
197/* Given a value which holds a pointer to a std::type_info, return the
198   name of the type which that type_info represents.  Throw an
199   exception if the type name cannot be found.  */
200
201extern std::string cplus_typename_from_type_info (struct value *value);
202
203/* Determine if we are currently in a C++ thunk.  If so, get the
204   address of the routine we are thunking to and continue to there
205   instead.  */
206
207CORE_ADDR cplus_skip_trampoline (struct frame_info *frame,
208				 CORE_ADDR stop_pc);
209
210/* Return non-zero if an argument of type TYPE should be passed by
211   reference instead of value.  */
212extern int cp_pass_by_reference (struct type *type);
213
214struct cp_abi_ops
215{
216  const char *shortname;
217  const char *longname;
218  const char *doc;
219
220  /* ABI-specific implementations for the functions declared
221     above.  */
222  enum ctor_kinds (*is_constructor_name) (const char *name);
223  enum dtor_kinds (*is_destructor_name) (const char *name);
224  int (*is_vtable_name) (const char *name);
225  int (*is_operator_name) (const char *name);
226  struct value *(*virtual_fn_field) (struct value **arg1p,
227				     struct fn_field * f,
228				     int j, struct type * type,
229				     int offset);
230  struct type *(*rtti_type) (struct value *v, int *full,
231			     LONGEST *top, int *using_enc);
232  int (*baseclass_offset) (struct type *type, int index,
233			   const bfd_byte *valaddr, LONGEST embedded_offset,
234			   CORE_ADDR address, const struct value *val);
235  void (*print_method_ptr) (const gdb_byte *contents,
236			    struct type *type,
237			    struct ui_file *stream);
238  int (*method_ptr_size) (struct type *);
239  void (*make_method_ptr) (struct type *, gdb_byte *,
240			   CORE_ADDR, int);
241  struct value * (*method_ptr_to_value) (struct value **,
242					 struct value *);
243  void (*print_vtable) (struct value *);
244  struct value *(*get_typeid) (struct value *value);
245  struct type *(*get_typeid_type) (struct gdbarch *gdbarch);
246  struct type *(*get_type_from_type_info) (struct value *value);
247  std::string (*get_typename_from_type_info) (struct value *value);
248  CORE_ADDR (*skip_trampoline) (struct frame_info *, CORE_ADDR);
249  int (*pass_by_reference) (struct type *type);
250};
251
252
253extern int register_cp_abi (struct cp_abi_ops *abi);
254extern void set_cp_abi_as_auto_default (const char *short_name);
255
256#endif
257
258