1 /* Interface between GCC C++ FE and GDB
2
3 Copyright (C) 2014-2023 Free Software Foundation, Inc.
4
5 This file is part of GCC.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
19
20 #ifndef GCC_CP_INTERFACE_H
21 #define GCC_CP_INTERFACE_H
22
23 #include "gcc-interface.h"
24
25 /* This header defines the interface to the GCC API. It must be both
26 valid C and valid C++, because it is included by both programs. */
27
28 #ifdef __cplusplus
29 extern "C" {
30 #endif
31
32 /* Forward declaration. */
33
34 struct gcc_cp_context;
35
36 /*
37 * Definitions and declarations for the C++ front end.
38 */
39
40 /* Defined versions of the C++ front-end API. */
41
42 enum gcc_cp_api_version
43 {
44 GCC_CP_FE_VERSION_0 = 0
45 };
46
47 /* Qualifiers. */
48
49 enum gcc_cp_qualifiers
50 {
51 GCC_CP_QUALIFIER_CONST = 1,
52 GCC_CP_QUALIFIER_VOLATILE = 2,
53 GCC_CP_QUALIFIER_RESTRICT = 4
54 };
55
56 /* Ref qualifiers. */
57
58 enum gcc_cp_ref_qualifiers {
59 GCC_CP_REF_QUAL_NONE = 0,
60 GCC_CP_REF_QUAL_LVALUE = 1,
61 GCC_CP_REF_QUAL_RVALUE = 2
62 };
63
64 /* Opaque typedef for unbound class templates. They are used for
65 template arguments, and defaults for template template
66 parameters. */
67
68 typedef unsigned long long gcc_utempl;
69
70 /* Opaque typedef for expressions. They are used for template
71 arguments, defaults for non-type template parameters, and defaults
72 for function arguments. */
73
74 typedef unsigned long long gcc_expr;
75
76 typedef enum
77 { GCC_CP_TPARG_VALUE, GCC_CP_TPARG_CLASS,
78 GCC_CP_TPARG_TEMPL, GCC_CP_TPARG_PACK }
79 gcc_cp_template_arg_kind;
80
81 typedef union
82 { gcc_expr value; gcc_type type; gcc_utempl templ; gcc_type pack; }
83 gcc_cp_template_arg;
84
85 /* An array of template arguments. */
86
87 struct gcc_cp_template_args
88 {
89 /* Number of elements. */
90
91 int n_elements;
92
93 /* kind[i] indicates what kind of template argument type[i] is. */
94
95 char /* gcc_cp_template_arg_kind */ *kinds;
96
97 /* The template arguments. */
98
99 gcc_cp_template_arg *elements;
100 };
101
102 /* An array of (default) function arguments. */
103
104 struct gcc_cp_function_args
105 {
106 /* Number of elements. */
107
108 int n_elements;
109
110 /* The (default) values for each argument. */
111
112 gcc_expr *elements;
113 };
114
115 /* This enumerates the kinds of decls that GDB can create. */
116
117 enum gcc_cp_symbol_kind
118 {
119 /* A function. */
120
121 GCC_CP_SYMBOL_FUNCTION,
122
123 /* A variable. */
124
125 GCC_CP_SYMBOL_VARIABLE,
126
127 /* A typedef, or an alias declaration (including template ones). */
128
129 GCC_CP_SYMBOL_TYPEDEF,
130
131 /* A label. */
132
133 GCC_CP_SYMBOL_LABEL,
134
135 /* A class, forward declared in build_decl (to be later defined in
136 start_class_definition), or, in a template parameter list scope,
137 a declaration of a template class, closing the parameter
138 list. */
139
140 GCC_CP_SYMBOL_CLASS,
141
142 /* A union, forward declared in build_decl (to be later defined in
143 start_class_definition). */
144
145 GCC_CP_SYMBOL_UNION,
146
147 /* An enumeration type being introduced with start_new_enum_type. */
148
149 GCC_CP_SYMBOL_ENUM,
150
151 /* A nonstatic data member being introduced with new_field. */
152
153 GCC_CP_SYMBOL_FIELD,
154
155 /* A base class in a gcc_vbase_array. */
156
157 GCC_CP_SYMBOL_BASECLASS,
158
159 /* A using declaration in new_using_decl. */
160
161 GCC_CP_SYMBOL_USING,
162
163 /* A (lambda) closure class type. In many regards this is just like
164 a regular class, but it's not supposed to have base classes, some
165 of the member functions that are usually implicitly-defined are
166 deleted, and it should have an operator() member function that
167 holds the lambda body. We can't instantiate objects of lambda
168 types from the snippet, but we can interact with them in such
169 ways as passing them to functions that take their types, and
170 calling their body. */
171
172 GCC_CP_SYMBOL_LAMBDA_CLOSURE,
173
174 /* Marker to check that we haven't exceeded GCC_CP_SYMBOL_MASK. */
175 GCC_CP_SYMBOL_END,
176
177 GCC_CP_SYMBOL_MASK = 15,
178
179 /* When defining a class member, at least one of the
180 GCC_CP_ACCESS_MASK bits must be set; when defining a namespace-
181 or union-scoped symbol, none of them must be set. */
182
183 GCC_CP_ACCESS_PRIVATE,
184 GCC_CP_ACCESS_PUBLIC = GCC_CP_ACCESS_PRIVATE << 1,
185 GCC_CP_ACCESS_MASK = (GCC_CP_ACCESS_PUBLIC
186 | GCC_CP_ACCESS_PRIVATE),
187 GCC_CP_ACCESS_PROTECTED = GCC_CP_ACCESS_MASK,
188 GCC_CP_ACCESS_NONE = 0,
189
190 GCC_CP_FLAG_BASE = GCC_CP_ACCESS_PRIVATE << 2,
191
192 /* Flags to be used along with GCC_CP_SYMBOL_FUNCTION: */
193
194 /* This flag should be set for constructors, destructors and
195 operators. */
196 GCC_CP_FLAG_SPECIAL_FUNCTION = GCC_CP_FLAG_BASE,
197
198 /* We intentionally cannot express inline, constexpr, or virtual
199 override for functions. We can't inline or constexpr-replace
200 without a source-level body. The override keyword is only
201 meaningful within the definition of the containing class. */
202
203 /* This indicates a "virtual" member function, explicitly or
204 implicitly (due to a virtual function with the same name and
205 prototype in a base class) declared as such. */
206 GCC_CP_FLAG_VIRTUAL_FUNCTION = GCC_CP_FLAG_BASE << 1,
207
208 /* The following two flags should only be set when the flag above is
209 set. */
210
211 /* This indicates a pure virtual member function, i.e., one that is
212 declared with "= 0", even if a body is provided in the
213 definition. */
214 GCC_CP_FLAG_PURE_VIRTUAL_FUNCTION = GCC_CP_FLAG_BASE << 2,
215
216 /* This indicates a "final" virtual member function. */
217 GCC_CP_FLAG_FINAL_VIRTUAL_FUNCTION = GCC_CP_FLAG_BASE << 3,
218
219 /* This indicates a special member function should have its default
220 implementation. This either means the function declaration
221 contains the "= default" tokens, or that the member function was
222 implicitly generated by the compiler, although the latter use is
223 discouraged: just let the compiler implicitly introduce it.
224
225 A member function defaulted after its first declaration has
226 slightly different ABI implications from one implicitly generated
227 or explicitly defaulted at the declaration (and definition)
228 point. To avoid silent (possibly harmless) violation of the one
229 definition rule, it is recommended that this flag not be used for
230 such functions, and that the address of the definition be
231 supplied instead. */
232 GCC_CP_FLAG_DEFAULTED_FUNCTION = GCC_CP_FLAG_BASE << 4,
233
234 /* This indicates a deleted member function, i.e., one that has been
235 defined as "= delete" at its declaration point, or one that has
236 been implicitly defined as deleted (with or without an explicit
237 "= default" definition).
238
239 This should not be used for implicitly-declared member functions
240 that resolve to deleted definitions, as it may affect the
241 implicit declaration of other member functions. */
242 GCC_CP_FLAG_DELETED_FUNCTION = GCC_CP_FLAG_BASE << 5,
243
244 /* This indicates a constructor or type-conversion operator declared
245 as "explicit". */
246
247 GCC_CP_FLAG_EXPLICIT_FUNCTION = GCC_CP_FLAG_BASE << 6,
248
249 GCC_CP_FLAG_END_FUNCTION,
250 GCC_CP_FLAG_MASK_FUNCTION = (((GCC_CP_FLAG_END_FUNCTION - 1) << 1)
251 - GCC_CP_FLAG_BASE),
252
253 /* Flags to be used along with GCC_CP_SYMBOL_VARIABLE: */
254
255 /* This indicates a variable declared as "constexpr". */
256
257 GCC_CP_FLAG_CONSTEXPR_VARIABLE = GCC_CP_FLAG_BASE,
258
259 /* This indicates a variable declared as "thread_local". ??? What
260 should the ADDRESS be? */
261
262 GCC_CP_FLAG_THREAD_LOCAL_VARIABLE = GCC_CP_FLAG_BASE << 1,
263
264 GCC_CP_FLAG_END_VARIABLE,
265 GCC_CP_FLAG_MASK_VARIABLE = (((GCC_CP_FLAG_END_VARIABLE - 1) << 1)
266 - GCC_CP_FLAG_BASE),
267
268 /* Flags to be used when defining nonstatic data members of classes
269 with new_field. */
270
271 /* Use this when no flags are present. */
272 GCC_CP_FLAG_FIELD_NOFLAG = 0,
273
274 /* This indicates the field is declared as mutable. */
275 GCC_CP_FLAG_FIELD_MUTABLE = GCC_CP_FLAG_BASE,
276
277 GCC_CP_FLAG_END_FIELD,
278 GCC_CP_FLAG_MASK_FIELD = (((GCC_CP_FLAG_END_FIELD - 1) << 1)
279 - GCC_CP_FLAG_BASE),
280
281 /* Flags to be used when defining an enum with
282 start_new_enum_type. */
283
284 /* This indicates an enum type without any flags. */
285 GCC_CP_FLAG_ENUM_NOFLAG = 0,
286
287 /* This indicates a scoped enum type. */
288 GCC_CP_FLAG_ENUM_SCOPED = GCC_CP_FLAG_BASE,
289
290 GCC_CP_FLAG_END_ENUM,
291 GCC_CP_FLAG_MASK_ENUM = (((GCC_CP_FLAG_END_ENUM - 1) << 1)
292 - GCC_CP_FLAG_BASE),
293
294
295 /* Flags to be used when introducing a class or a class template
296 with build_decl. */
297
298 /* This indicates an enum type without any flags. */
299 GCC_CP_FLAG_CLASS_NOFLAG = 0,
300
301 /* This indicates the class is actually a struct. This has no
302 effect whatsoever on access control in this interface, since all
303 class members must have explicit access control bits set, but it
304 may affect error messages. */
305 GCC_CP_FLAG_CLASS_IS_STRUCT = GCC_CP_FLAG_BASE,
306
307 GCC_CP_FLAG_END_CLASS,
308 GCC_CP_FLAG_MASK_CLASS = (((GCC_CP_FLAG_END_CLASS - 1) << 1)
309 - GCC_CP_FLAG_BASE),
310
311
312 /* Flags to be used when introducing a virtual base class in a
313 gcc_vbase_array. */
314
315 /* This indicates an enum type without any flags. */
316 GCC_CP_FLAG_BASECLASS_NOFLAG = 0,
317
318 /* This indicates the class is actually a struct. This has no
319 effect whatsoever on access control in this interface, since all
320 class members must have explicit access control bits set, but it
321 may affect error messages. */
322 GCC_CP_FLAG_BASECLASS_VIRTUAL = GCC_CP_FLAG_BASE,
323
324 GCC_CP_FLAG_END_BASECLASS,
325 GCC_CP_FLAG_MASK_BASECLASS = (((GCC_CP_FLAG_END_BASECLASS - 1) << 1)
326 - GCC_CP_FLAG_BASE),
327
328
329 GCC_CP_FLAG_MASK = (GCC_CP_FLAG_MASK_FUNCTION
330 | GCC_CP_FLAG_MASK_VARIABLE
331 | GCC_CP_FLAG_MASK_FIELD
332 | GCC_CP_FLAG_MASK_ENUM
333 | GCC_CP_FLAG_MASK_CLASS
334 | GCC_CP_FLAG_MASK_BASECLASS
335 )
336 };
337
338
339 /* An array of types used for creating lists of base classes. */
340
341 struct gcc_vbase_array
342 {
343 /* Number of elements. */
344
345 int n_elements;
346
347 /* The base classes. */
348
349 gcc_type *elements;
350
351 /* Flags for each base class. Used to indicate access control and
352 virtualness. */
353
354 enum gcc_cp_symbol_kind *flags;
355 };
356
357
358 /* This enumerates the types of symbols that GCC might request from
359 GDB. */
360
361 enum gcc_cp_oracle_request
362 {
363 /* An identifier in namespace scope -- type, variable, function,
364 namespace, template. All namespace-scoped symbols with the
365 requested name, in any namespace (including the global
366 namespace), should be defined in response to this request. */
367
368 GCC_CP_ORACLE_IDENTIFIER
369 };
370
371 /* The type of the function called by GCC to ask GDB for a symbol's
372 definition. DATUM is an arbitrary value supplied when the oracle
373 function is registered. CONTEXT is the GCC context in which the
374 request is being made. REQUEST specifies what sort of symbol is
375 being requested, and IDENTIFIER is the name of the symbol. */
376
377 typedef void gcc_cp_oracle_function (void *datum,
378 struct gcc_cp_context *context,
379 enum gcc_cp_oracle_request request,
380 const char *identifier);
381
382 /* The type of the function called by GCC to ask GDB for a symbol's
383 address. This should return 0 if the address is not known. */
384
385 typedef gcc_address gcc_cp_symbol_address_function (void *datum,
386 struct gcc_cp_context *ctxt,
387 const char *identifier);
388
389 /* The type of the function called by GCC to ask GDB to enter or leave
390 the user expression scope. */
391
392 typedef void gcc_cp_enter_leave_user_expr_scope_function (void *datum,
393 struct gcc_cp_context
394 *context);
395
396 /* The vtable used by the C front end. */
397
398 struct gcc_cp_fe_vtable
399 {
400 /* The version of the C interface. The value is one of the
401 gcc_cp_api_version constants. */
402
403 unsigned int cp_version;
404
405 /* Set the callbacks for this context.
406
407 The binding oracle is called whenever the C++ parser needs to
408 look up a symbol. This gives the caller a chance to lazily
409 instantiate symbols using other parts of the gcc_cp_fe_interface
410 API. The symbol is looked up without a scope, and the oracle
411 must supply a definition for ALL namespace-scoped definitions
412 bound to the symbol.
413
414 The address oracle is called whenever the C++ parser needs to
415 look up a symbol. This may be called for symbols not provided by
416 the symbol oracle, such as built-in functions where GCC provides
417 the declaration; other internal symbols, such as those related
418 with thunks, rtti, and virtual tables are likely to be queried
419 through this interface too. The identifier is a mangled symbol
420 name.
421
422 DATUM is an arbitrary piece of data that is passed back verbatim
423 to the callbacks in requests. */
424
425 void (*set_callbacks) (struct gcc_cp_context *self,
426 gcc_cp_oracle_function *binding_oracle,
427 gcc_cp_symbol_address_function *address_oracle,
428 gcc_cp_enter_leave_user_expr_scope_function *enter_scope,
429 gcc_cp_enter_leave_user_expr_scope_function *leave_scope,
430 void *datum);
431
432 #define GCC_METHOD0(R, N) \
433 R (*N) (struct gcc_cp_context *);
434 #define GCC_METHOD1(R, N, A) \
435 R (*N) (struct gcc_cp_context *, A);
436 #define GCC_METHOD2(R, N, A, B) \
437 R (*N) (struct gcc_cp_context *, A, B);
438 #define GCC_METHOD3(R, N, A, B, C) \
439 R (*N) (struct gcc_cp_context *, A, B, C);
440 #define GCC_METHOD4(R, N, A, B, C, D) \
441 R (*N) (struct gcc_cp_context *, A, B, C, D);
442 #define GCC_METHOD5(R, N, A, B, C, D, E) \
443 R (*N) (struct gcc_cp_context *, A, B, C, D, E);
444 #define GCC_METHOD7(R, N, A, B, C, D, E, F, G) \
445 R (*N) (struct gcc_cp_context *, A, B, C, D, E, F, G);
446
447 #include "gcc-cp-fe.def"
448
449 #undef GCC_METHOD0
450 #undef GCC_METHOD1
451 #undef GCC_METHOD2
452 #undef GCC_METHOD3
453 #undef GCC_METHOD4
454 #undef GCC_METHOD5
455 #undef GCC_METHOD7
456
457 };
458
459 /* The C front end object. */
460
461 struct gcc_cp_context
462 {
463 /* Base class. */
464
465 struct gcc_base_context base;
466
467 /* Our vtable. This is a separate field because this is simpler
468 than implementing a vtable inheritance scheme in C. */
469
470 const struct gcc_cp_fe_vtable *cp_ops;
471 };
472
473 /* The name of the .so that the compiler builds. We dlopen this
474 later. */
475
476 #define GCC_CP_FE_LIBCC libcc1.so
477
478 /* The compiler exports a single initialization function. This macro
479 holds its name as a symbol. */
480
481 #define GCC_CP_FE_CONTEXT gcc_cp_fe_context
482
483 /* The type of the initialization function. The caller passes in the
484 desired base version and desired C-specific version. If the
485 request can be satisfied, a compatible gcc_context object will be
486 returned. Otherwise, the function returns NULL. */
487
488 typedef struct gcc_cp_context *gcc_cp_fe_context_function
489 (enum gcc_base_api_version,
490 enum gcc_cp_api_version);
491
492 #ifdef __cplusplus
493 }
494 #endif
495
496 #endif /* GCC_CP_INTERFACE_H */