|
111
|
1 /* Interface between GCC C++ FE and GDB
|
|
|
2
|
|
131
|
3 Copyright (C) 2014-2018 Free Software Foundation, Inc.
|
|
111
|
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 */
|
