|
111
|
1 /* Interface between GCC C++ FE and GDB -*- c -*-
|
|
|
2
|
|
145
|
3 Copyright (C) 2014-2020 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
|
|
|
21
|
|
|
22 /* Push namespace NAME as the current binding level, to which
|
|
|
23 newly-introduced decls will be bound. An empty string identifies
|
|
|
24 the global namespace, whereas NULL identifies an anonymous
|
|
|
25 namespace. A namespace named NAME is created in the current scope,
|
|
|
26 if needed.
|
|
|
27
|
|
|
28 If the newly-created namespace is to be an inline namespace, see
|
|
|
29 make_namespace_inline. */
|
|
|
30
|
|
|
31 GCC_METHOD1 (int /* bool */, push_namespace,
|
|
|
32 const char *) /* Argument NAME. */
|
|
|
33
|
|
|
34 /* Push TYPE as the current binding level, making its members visible
|
|
|
35 for name lookup. The current scope before the call must be the
|
|
|
36 scope in which the class was declared. This should be used if the
|
|
|
37 definition of a class is already finished, but one wishes to define
|
|
|
38 a nested class, or to enter the scope of one of its member
|
|
|
39 functions. */
|
|
|
40
|
|
|
41 GCC_METHOD1 (int /* bool */, push_class,
|
|
|
42 gcc_type) /* Argument TYPE. */
|
|
|
43
|
|
|
44 /* Push FUNCTION_DECL as the current (empty) binding level (see
|
|
|
45 reactivate_decl). The current enclosing scope before the call must
|
|
|
46 be the scope in which the function was declared. */
|
|
|
47
|
|
|
48 GCC_METHOD1 (int /* bool */, push_function,
|
|
|
49 gcc_decl) /* Argument FUNCTION_DECL. */
|
|
|
50
|
|
|
51 /* Make DECL visible (again?) within SCOPE. When SCOPE is NULL, it
|
|
|
52 means the current scope; if it is not NULL, it must name a function
|
|
|
53 that is currently active, even if not at the top of the binding
|
|
|
54 chain.
|
|
|
55
|
|
|
56 This function can be used to make e.g. a global function or
|
|
|
57 variable visible in a namespace or local scope (overriding another
|
|
|
58 enclosing definition of the same name), but its most common
|
|
|
59 expected use of this primitive, that gives it its name, is to make
|
|
|
60 declarations visible again after reentering a function scope,
|
|
|
61 because when a function is entered with push_function, that does
|
|
|
62 NOT make any of the declarations nested in it visible for name
|
|
|
63 lookup.
|
|
|
64
|
|
|
65 There is a reason/excuse for that: unlike namespaces and classes,
|
|
|
66 G++ doesn't ever have to reenter function scopes, so its name
|
|
|
67 resolution infrastructure is not prepared to do that. But wait,
|
|
|
68 there is also a good use for this apparent limitation: a function
|
|
|
69 may contain multiple scopes (blocks), and the name may be bound to
|
|
|
70 different symbols in each of these scopes. With this interface, as
|
|
|
71 we reenter a function scope, we may choose which symbols to make
|
|
|
72 visible for the code snippet, or, if there could be template
|
|
|
73 functions in local scopes, for unresolved names in nested template
|
|
|
74 class default arguments, or in nested template function signatures.
|
|
|
75
|
|
|
76 As for making a local declaration visible for the code snippet,
|
|
|
77 there are two possibilities: a) introduce it upfront, while
|
|
|
78 entering the scope for the user expression (see the enter_scope
|
|
|
79 callback, called by g++ when encountering the push_user_expression
|
|
|
80 pragma), which might save some scope switching and reactivate_decl
|
|
|
81 (though this can't be helped if some declarations have to be
|
|
|
82 introduced and discarded, because of multiple definitions of the
|
|
|
83 same name in different scopes within a function: they have to be
|
|
|
84 defined in discriminator order); or b) introduce it when its name
|
|
|
85 is looked up, entering the scope, introducing the declaration,
|
|
|
86 leaving the scope, and then reactivating the declaration in its
|
|
|
87 local scope.
|
|
|
88
|
|
|
89 Here's some more detail on how reactivate_decl works. Say there's
|
|
|
90 a function foo whose body looks like this:
|
|
|
91
|
|
|
92 {
|
|
|
93 {
|
|
|
94 // point 1
|
|
|
95 class c {} o __attribute__ ((__used__)); // c , o
|
|
|
96 }
|
|
|
97 struct c {
|
|
|
98 void f() {
|
|
|
99 // point 2
|
|
|
100 }
|
|
|
101 } o __attribute__ ((__used__)); // c_0, o_0
|
|
|
102 {
|
|
|
103 class c {} p __attribute__ ((__used__)); // c_1, p
|
|
|
104 // point 3
|
|
|
105 o.f();
|
|
|
106 }
|
|
|
107 }
|
|
|
108
|
|
|
109 When we are about to define class c at point 1, we enter the
|
|
|
110 function foo scope, and since no symbols are visible at point 1, we
|
|
|
111 proceed to declare class c. We may then define the class right
|
|
|
112 away, or, if we leave the function scope, and we later wish to
|
|
|
113 define it, or to define object o, we can reenter the scope and just
|
|
|
114 use the previously-obtained gcc_decl to define the class, without
|
|
|
115 having to reactivate the declaration.
|
|
|
116
|
|
|
117 Now, if we are to set up the binding context for point 2, we have
|
|
|
118 to define c_0::f, and in order to do so, we have to declare and
|
|
|
119 define c_0. Before we can declare c_0, we MUST at least declare c.
|
|
|
120
|
|
|
121 As a general rule, before we can declare or define any local name
|
|
|
122 with a discriminator, we have to at least declare any other
|
|
|
123 occurrences of the same name in the same enclosing entity with
|
|
|
124 lower or absent discriminator.
|
|
|
125
|
|
|
126 So, we declare c, then we leave the function scope and reenter it
|
|
|
127 so as to declare c_0 (also with name "c", which is why we have to
|
|
|
128 leave and reenter the function scope, otherwise we would get an
|
|
|
129 error because of the duplicate definition; g++ will assign a
|
|
|
130 discriminator because it still remembers there was an earlier
|
|
|
131 declaration of c_0 within the function, it's just no longer in
|
|
|
132 scope), then we can define c_0, including its member function f.
|
|
|
133
|
|
|
134 Likewise, if we wish to define o_0, we have to define o first. If
|
|
|
135 we wish to declare (and maybe then define) c_1, we have to at least
|
|
|
136 declare (c and then) c_0 first.
|
|
|
137
|
|
|
138 Then, as we set up the binding context to compile a code snippet at
|
|
|
139 point 3, we may choose to activate c_1, o_0 and p upfront,
|
|
|
140 declaring and discarding c, c_0 and o, and then reentering the
|
|
|
141 funciton scope to declare c_1, o_0 and p; or we can wait for oracle
|
|
|
142 lookups of c, o or p. If c is looked up, and the debugger resolves
|
|
|
143 c in the scope to c_1, it is expected to enter the function scope
|
|
|
144 from the top level, declare c, leave it, reenter it, declare c_0,
|
|
|
145 leave it, reenter it, declare c_1, leave it, and then reactivate
|
|
|
146 c_1 in the function scope. If c_1 is needed as a complete type,
|
|
|
147 the definition may be given right after the declaration, or the
|
|
|
148 scope will have to be reentered in order to define the class.
|
|
|
149
|
|
|
150 . If the code snippet is at point 2, we don't need to (re)activate
|
|
|
151 any declaration: nothing from any local scope is visible. Just
|
|
|
152 entering the scope of the class containing member function f
|
|
|
153 reactivates the names of its members, including the class name
|
|
|
154 itself. */
|
|
|
155
|
|
|
156 GCC_METHOD2 (int /* bool */, reactivate_decl,
|
|
|
157 gcc_decl, /* Argument DECL. */
|
|
|
158 gcc_decl) /* Argument SCOPE. */
|
|
|
159
|
|
|
160 /* Pop the namespace last entered with push_namespace, or class last
|
|
|
161 entered with push_class, or function last entered with
|
|
|
162 push_function, restoring the binding level in effect before the
|
|
|
163 matching push_* call. */
|
|
|
164
|
|
|
165 GCC_METHOD0 (int /* bool */, pop_binding_level)
|
|
|
166
|
|
|
167 /* Return the NAMESPACE_DECL, TYPE_DECL or FUNCTION_DECL of the
|
|
|
168 binding level that would be popped by pop_scope. */
|
|
|
169
|
|
|
170 GCC_METHOD0 (gcc_decl, get_current_binding_level_decl)
|
|
|
171
|
|
|
172 /* Make the current binding level an inline namespace. It must be a
|
|
|
173 namespace to begin with. It is safe to call this more than once
|
|
|
174 for the same namespace, but after the first call, subsequent ones
|
|
|
175 will not return a success status. */
|
|
|
176
|
|
|
177 GCC_METHOD0 (int /* bool */, make_namespace_inline)
|
|
|
178
|
|
|
179 /* Add USED_NS to the namespaces used by the current binding level.
|
|
|
180 Use get_current_binding_level_decl to obtain USED_NS's
|
|
|
181 gcc_decl. */
|
|
|
182
|
|
|
183 GCC_METHOD1 (int /* bool */, add_using_namespace,
|
|
|
184 gcc_decl) /* Argument USED_NS. */
|
|
|
185
|
|
|
186 /* Introduce a namespace alias declaration, as in:
|
|
|
187
|
|
|
188 namespace foo = [... ::] bar;
|
|
|
189
|
|
|
190 After this call, namespace TARGET will be visible as ALIAS within
|
|
|
191 the current namespace. Get the declaration for TARGET by calling
|
|
|
192 get_current_binding_level_decl after pushing into it. */
|
|
|
193
|
|
|
194 GCC_METHOD2 (int /* bool */, add_namespace_alias,
|
|
|
195 const char *, /* Argument ALIAS. */
|
|
|
196 gcc_decl) /* Argument TARGET. */
|
|
|
197
|
|
|
198 /* Introduce a using declaration, as in:
|
|
|
199
|
|
|
200 using foo::bar;
|
|
|
201
|
|
|
202 The TARGET decl names the qualifying scope (foo:: above) and the
|
|
|
203 identifier (bar), but that does not mean that only TARGET will be
|
|
|
204 brought into the current scope: all bindings of TARGET's identifier
|
|
|
205 in the qualifying scope will be brought in.
|
|
|
206
|
|
|
207 FLAGS should specify GCC_CP_SYMBOL_USING. If the current scope is
|
|
|
208 a class scope, visibility flags must be supplied.
|
|
|
209
|
|
|
210 Even when TARGET is template dependent, we don't need to specify
|
|
|
211 whether or not it is a typename: the supplied declaration (that
|
|
|
212 could be a template-dependent type converted to declaration by
|
|
|
213 get_type_decl) indicates so. */
|
|
|
214
|
|
|
215 GCC_METHOD2 (int /* bool */, add_using_decl,
|
|
|
216 enum gcc_cp_symbol_kind, /* Argument FLAGS. */
|
|
|
217 gcc_decl) /* Argument TARGET. */
|
|
|
218
|
|
|
219 /* Create a new "decl" in GCC, and bind it in the current binding
|
|
|
220 level. A decl is a declaration, basically a kind of symbol.
|
|
|
221
|
|
|
222 NAME is the name of the new symbol. SYM_KIND is the kind of
|
|
|
223 symbol being requested. SYM_TYPE is the new symbol's C++ type;
|
|
|
224 except for labels, where this is not meaningful and should be
|
|
|
225 zero. If SUBSTITUTION_NAME is not NULL, then a reference to this
|
|
|
226 decl in the source will later be substituted with a dereference
|
|
|
227 of a variable of the given name. Otherwise, for symbols having
|
|
|
228 an address (e.g., functions), ADDRESS is the address. FILENAME
|
|
|
229 and LINE_NUMBER refer to the symbol's source location. If this
|
|
|
230 is not known, FILENAME can be NULL and LINE_NUMBER can be 0.
|
|
|
231 This function returns the new decl.
|
|
|
232
|
|
|
233 Use this function to register typedefs, functions and variables to
|
|
|
234 namespace and local binding levels, and typedefs, member functions
|
|
|
235 (static or not), and static data members to class binding levels.
|
|
|
236 Class members must have their access controls specified with
|
|
|
237 GCC_CP_ACCESS_* flags in SYM_KIND.
|
|
|
238
|
|
|
239 Note that, since access controls are disabled, we have no means to
|
|
|
240 express private, protected and public.
|
|
|
241
|
|
|
242 There are various flags that can be set in SYM_KIND to specify
|
|
|
243 additional semantics. Look for GCC_CP_FLAGs in the definition of
|
|
|
244 enum gcc_cp_symbol_kind in gcc-cp-interface.h.
|
|
|
245
|
|
|
246 In order to define member functions, pass GCC_CP_SYMBOL_FUNCTION in
|
|
|
247 SYM_KIND, and a function_type for static member functions or a
|
|
|
248 method type for non-static member functions, including constructors
|
|
|
249 and destructors. Use build_function_type to create a function
|
|
|
250 type; for a method type, start by creating a function type without
|
|
|
251 any compiler-introduced artificial arguments (the implicit this
|
|
|
252 pointer, and the __in_chrg added to constructors and destructors,
|
|
|
253 and __vtt_parm added to the former), and then use build_method_type
|
|
|
254 to create the method type out of the class type and the function
|
|
|
255 type.
|
|
|
256
|
|
|
257 For operator functions, set GCC_CP_FLAG_SPECIAL_FUNCTION in
|
|
|
258 SYM_KIND, in addition to any other applicable flags, and pass as
|
|
|
259 NAME a string starting with the two-character mangling for operator
|
|
|
260 name: "ps" for unary plus, "mL" for multiply and assign, *=; etc.
|
|
|
261 Use "cv" for type converstion operators (the target type portion
|
|
|
262 may be omitted, as it is taken from the return type in SYM_TYPE).
|
|
|
263 For operator"", use "li" followed by the identifier (the mangled
|
|
|
264 name mandates digits specifying the length of the identifier; if
|
|
|
265 present, they determine the end of the identifier, otherwise, the
|
|
|
266 identifier extents to the end of the string, so that "li3_Kme" and
|
|
|
267 "li_Km" are equivalent).
|
|
|
268
|
|
|
269 Constructors and destructors need special care, because for each
|
|
|
270 constructor and destructor there may be multiple clones defined
|
|
|
271 internally by the compiler. With build_decl, you can introduce the
|
|
|
272 base declaration of a constructor or a destructor, setting
|
|
|
273 GCC_CP_FLAG_SPECIAL_FUNCTION the flag and using names starting with
|
|
|
274 capital "C" or "D", respectively, followed by a digit (see below),
|
|
|
275 a blank, or NUL ('\0'). DO NOT supply an ADDRESS or a
|
|
|
276 SUBSTITUTION_NAME to build_decl, it would be meaningless (and
|
|
|
277 rejected) for the base declaration; use define_cdtor_clone to
|
|
|
278 introduce the address of each clone. For constructor templates,
|
|
|
279 declare the template with build_decl, and then, for each
|
|
|
280 specialization, introduce it with
|
|
|
281 build_function_template_specialization, and then define the
|
|
|
282 addresses of each of its clones with define_cdtor_clone.
|
|
|
283
|
|
|
284 NAMEs for GCC_CP_FLAG_SPECIAL_FUNCTION:
|
|
|
285
|
|
|
286 NAME meaning
|
|
|
287 C? constructor base declaration (? may be 1, 2, 4, blank or NUL)
|
|
|
288 D? destructor base declaration (? may be 0, 1, 2, 4, blank or NUL)
|
|
|
289 nw operator new
|
|
|
290 na operator new[]
|
|
|
291 dl operator delete
|
|
|
292 da operator delete[]
|
|
|
293 ps operator + (unary)
|
|
|
294 ng operator - (unary)
|
|
|
295 ad operator & (unary)
|
|
|
296 de operator * (unary)
|
|
|
297 co operator ~
|
|
|
298 pl operator +
|
|
|
299 mi operator -
|
|
|
300 ml operator *
|
|
|
301 dv operator /
|
|
|
302 rm operator %
|
|
|
303 an operator &
|
|
|
304 or operator |
|
|
|
305 eo operator ^
|
|
|
306 aS operator =
|
|
|
307 pL operator +=
|
|
|
308 mI operator -=
|
|
|
309 mL operator *=
|
|
|
310 dV operator /=
|
|
|
311 rM operator %=
|
|
|
312 aN operator &=
|
|
|
313 oR operator |=
|
|
|
314 eO operator ^=
|
|
|
315 ls operator <<
|
|
|
316 rs operator >>
|
|
|
317 lS operator <<=
|
|
|
318 rS operator >>=
|
|
|
319 eq operator ==
|
|
|
320 ne operator !=
|
|
|
321 lt operator <
|
|
|
322 gt operator >
|
|
|
323 le operator <=
|
|
|
324 ge operator >=
|
|
|
325 nt operator !
|
|
|
326 aa operator &&
|
|
|
327 oo operator ||
|
|
|
328 pp operator ++
|
|
|
329 mm operator --
|
|
|
330 cm operator ,
|
|
|
331 pm operator ->*
|
|
|
332 pt operator ->
|
|
|
333 cl operator ()
|
|
|
334 ix operator []
|
|
|
335 qu operator ?
|
|
|
336 cv operator <T> (conversion operator)
|
|
|
337 li<id> operator "" <id>
|
|
|
338
|
|
|
339 FIXME: How about attributes? */
|
|
|
340
|
|
|
341 GCC_METHOD7 (gcc_decl, build_decl,
|
|
|
342 const char *, /* Argument NAME. */
|
|
|
343 enum gcc_cp_symbol_kind, /* Argument SYM_KIND. */
|
|
|
344 gcc_type, /* Argument SYM_TYPE. */
|
|
|
345 const char *, /* Argument SUBSTITUTION_NAME. */
|
|
|
346 gcc_address, /* Argument ADDRESS. */
|
|
|
347 const char *, /* Argument FILENAME. */
|
|
|
348 unsigned int) /* Argument LINE_NUMBER. */
|
|
|
349
|
|
|
350 /* Supply the ADDRESS of one of the multiple clones of constructor or
|
|
|
351 destructor CDTOR. The clone is specified by NAME, using the
|
|
|
352 following name mangling conventions:
|
|
|
353
|
|
|
354 C1 in-charge constructor
|
|
|
355 C2 not-in-charge constructor
|
|
|
356 C4 unified constructor
|
|
|
357 D0 deleting destructor
|
|
|
358 D1 in-charge destructor
|
|
|
359 D2 not-in-charge destructor
|
|
|
360 D4 unified destructor
|
|
|
361
|
|
|
362 The following information is not necessary to use the API.
|
|
|
363
|
|
|
364 C1 initializes an instance of the class (rather than of derived
|
|
|
365 classes), including virtual base classes, whereas C2 initializes a
|
|
|
366 sub-object (of the given class type) of an instance of some derived
|
|
|
367 class (or a full object that doesn't have any virtual base
|
|
|
368 classes).
|
|
|
369
|
|
|
370 D0 and D1 destruct an instance of the class, including virtual base
|
|
|
371 classes, but only the former calls operator delete to release the
|
|
|
372 object's storage at the end; D2 destructs a sub-object (of the
|
|
|
373 given class type) of an instance of a derived class (or a full
|
|
|
374 object that doesn't have any virtual base classes).
|
|
|
375
|
|
|
376 The [CD]4 manglings (and symbol definitions) are non-standard, but
|
|
|
377 GCC uses them in some cases: rather than assuming they are
|
|
|
378 in-charge or not-in-charge, they test the implicit argument that
|
|
|
379 the others ignore to tell how to behave. These are used instead of
|
|
|
380 cloning when we just can't use aliases. */
|
|
|
381
|
|
|
382 GCC_METHOD3 (gcc_decl, define_cdtor_clone,
|
|
|
383 const char *, /* Argument NAME. */
|
|
|
384 gcc_decl, /* Argument CDTOR. */
|
|
|
385 gcc_address) /* Argument ADDRESS. */
|
|
|
386
|
|
|
387 /* Return the type associated with the given declaration. This is
|
|
|
388 most useful to obtain the type associated with a forward-declared
|
|
|
389 class, because it is the gcc_type, rather than the gcc_decl, that
|
|
|
390 has to be used to build other types, but build_decl returns a
|
|
|
391 gcc_decl rather than a gcc_type. This call can in theory be used
|
|
|
392 to obtain the type from any other declaration; it is supposed to
|
|
|
393 return the same type that was supplied when the declaration was
|
|
|
394 created. */
|
|
|
395
|
|
|
396 GCC_METHOD1 (gcc_type, get_decl_type,
|
|
|
397 gcc_decl) /* Argument DECL. */
|
|
|
398
|
|
|
399 /* Return the declaration for a type. */
|
|
|
400
|
|
|
401 GCC_METHOD1 (gcc_decl, get_type_decl,
|
|
|
402 gcc_type) /* Argument TYPE. */
|
|
|
403
|
|
|
404 /* Declare DECL as a friend of the current class scope, if TYPE is
|
|
|
405 NULL, or of TYPE itself otherwise. DECL may be a function or a
|
|
|
406 class, be they template generics, template specializations or not
|
|
|
407 templates. TYPE must be a class type (not a template generic).
|
|
|
408
|
|
|
409 The add_friend call cannot introduce a declaration; even if the
|
|
|
410 friend is first declared as a friend in the source code, the
|
|
|
411 declaration belongs in the enclosing namespace, so it must be
|
|
|
412 introduced in that namespace, and the resulting declaration can
|
|
|
413 then be made a friend.
|
|
|
414
|
|
|
415 DECL cannot, however, be a member of a template class generic,
|
|
|
416 because we have no means to introduce their declarations. This
|
|
|
417 interface has no notion of definitions for template generics. As a
|
|
|
418 consequence, users of this interface must introduce each friend
|
|
|
419 template member specialization separately, i.e., instead of:
|
|
|
420
|
|
|
421 template <typename T> friend struct X<T>::M;
|
|
|
422
|
|
|
423 they must be declared as if they were:
|
|
|
424
|
|
|
425 friend struct X<onetype>::M;
|
|
|
426 friend struct X<anothertype>::M;
|
|
|
427 ... for each specialization of X.
|
|
|
428
|
|
|
429
|
|
|
430 Specializations of a template can have each others' members as
|
|
|
431 friends:
|
|
|
432
|
|
|
433 template <typename T> class foo {
|
|
|
434 int f();
|
|
|
435 template <typename U> friend int foo<U>::f();
|
|
|
436 };
|
|
|
437
|
|
|
438 It wouldn't always be possible to define all specializations of a
|
|
|
439 template class before introducing the friend declarations in their
|
|
|
440 expanded, per-specialization form.
|
|
|
441
|
|
|
442 In order to simplify such friend declarations, and to enable
|
|
|
443 incremental friend declarations as template specializations are
|
|
|
444 introduced, add_friend can be called after the befriending class is
|
|
|
445 fully defined, passing it a non-NULL TYPE argument naming the
|
|
|
446 befriending class type. */
|
|
|
447
|
|
|
448 GCC_METHOD2 (int /* bool */, add_friend,
|
|
|
449 gcc_decl, /* Argument DECL. */
|
|
|
450 gcc_type) /* Argument TYPE. */
|
|
|
451
|
|
|
452 /* Return the type of a pointer to a given base type. */
|
|
|
453
|
|
|
454 GCC_METHOD1 (gcc_type, build_pointer_type,
|
|
|
455 gcc_type) /* Argument BASE_TYPE. */
|
|
|
456
|
|
|
457 /* Return the type of a reference to a given base type. */
|
|
|
458
|
|
|
459 GCC_METHOD2 (gcc_type, build_reference_type,
|
|
|
460 gcc_type, /* Argument BASE_TYPE. */
|
|
|
461 enum gcc_cp_ref_qualifiers) /* Argument RQUALS. */
|
|
|
462
|
|
|
463 /* Create a new pointer-to-member type. MEMBER_TYPE is the data
|
|
|
464 member type, while CLASS_TYPE is the class type containing the data
|
|
|
465 member. For pointers to member functions, MEMBER_TYPE must be a
|
|
|
466 method type, and CLASS_TYPE must be specified even though it might
|
|
|
467 be possible to extract it from the method type. */
|
|
|
468
|
|
|
469 GCC_METHOD2 (gcc_type, build_pointer_to_member_type,
|
|
|
470 gcc_type, /* Argument CLASS_TYPE. */
|
|
|
471 gcc_type) /* Argument MEMBER_TYPE. */
|
|
|
472
|
|
|
473 /* Start a template parameter list scope and enters it, so that
|
|
|
474 subsequent build_type_template_parameter and
|
|
|
475 build_value_template_parameter calls create template parameters in
|
|
|
476 the list. The list is closed by a build_decl call with
|
|
|
477 GCC_CP_SYMBOL_FUNCTION or GCC_CP_SYMBOL_CLASS, that, when the scope
|
|
|
478 is a template parameter list, declares a template function or a
|
|
|
479 template class with the then-closed parameter list. The scope in
|
|
|
480 which the new declaration is to be introduced by build_decl must be
|
|
|
481 entered before calling start_template_decl, and build_decl returns
|
|
|
482 to that scope, from the template parameter list scope, before
|
|
|
483 introducing the declaration. */
|
|
|
484
|
|
|
485 GCC_METHOD0 (int /* bool */, start_template_decl)
|
|
|
486
|
|
|
487 /* Build a typename template-parameter (e.g., the T in template
|
|
|
488 <typename T = X>). Either PACK_P should be nonzero, to indicate an
|
|
|
489 argument pack (the last argument in a variadic template argument
|
|
|
490 list, as in template <typename... T>), or DEFAULT_TYPE may be
|
|
|
491 non-NULL to set the default type argument (e.g. X) for the template
|
|
|
492 parameter. FILENAME and LINE_NUMBER may specify the source
|
|
|
493 location in which the template parameter was declared. */
|
|
|
494
|
|
|
495 GCC_METHOD5 (gcc_type, build_type_template_parameter,
|
|
|
496 const char *, /* Argument ID. */
|
|
|
497 int /* bool */, /* Argument PACK_P. */
|
|
|
498 gcc_type, /* Argument DEFAULT_TYPE. */
|
|
|
499 const char *, /* Argument FILENAME. */
|
|
|
500 unsigned int) /* Argument LINE_NUMBER. */
|
|
|
501
|
|
|
502 /* Build a template template-parameter (e.g., the T in template
|
|
|
503 <template <[...]> class T = X>). DEFAULT_TEMPL may be non-NULL to
|
|
|
504 set the default type-template argument (e.g. X) for the template
|
|
|
505 template parameter. FILENAME and LINE_NUMBER may specify the
|
|
|
506 source location in which the template parameter was declared. */
|
|
|
507
|
|
|
508 GCC_METHOD5 (gcc_utempl, build_template_template_parameter,
|
|
|
509 const char *, /* Argument ID. */
|
|
|
510 int /* bool */, /* Argument PACK_P. */
|
|
|
511 gcc_utempl, /* Argument DEFAULT_TEMPL. */
|
|
|
512 const char *, /* Argument FILENAME. */
|
|
|
513 unsigned int) /* Argument LINE_NUMBER. */
|
|
|
514
|
|
|
515 /* Build a value template-parameter (e.g., the V in template <typename
|
|
|
516 T, T V> or in template <int V = X>). DEFAULT_VALUE may be non-NULL
|
|
|
517 to set the default value argument for the template parameter (e.g.,
|
|
|
518 X). FILENAME and LINE_NUMBER may specify the source location in
|
|
|
519 which the template parameter was declared. */
|
|
|
520
|
|
|
521 GCC_METHOD5 (gcc_decl, build_value_template_parameter,
|
|
|
522 gcc_type, /* Argument TYPE. */
|
|
|
523 const char *, /* Argument ID. */
|
|
|
524 gcc_expr, /* Argument DEFAULT_VALUE. */
|
|
|
525 const char *, /* Argument FILENAME. */
|
|
|
526 unsigned int) /* Argument LINE_NUMBER. */
|
|
|
527
|
|
|
528 /* Build a template-dependent typename (e.g., typename T::bar or
|
|
|
529 typename T::template bart<X>). ENCLOSING_TYPE should be the
|
|
|
530 template-dependent nested name specifier (e.g., T), ID should be
|
|
|
531 the name of the member of the ENCLOSING_TYPE (e.g., bar or bart),
|
|
|
532 and TARGS should be non-NULL and specify the template arguments
|
|
|
533 (e.g. <X>) iff ID is to name a class template.
|
|
|
534
|
|
|
535 In this and other calls, a template-dependent nested name specifier
|
|
|
536 may be a template class parameter (build_type_template_parameter),
|
|
|
537 a specialization (returned by build_dependent_type_template_id) of
|
|
|
538 a template template parameter (returned by
|
|
|
539 build_template_template_parameter) or a member type thereof
|
|
|
540 (returned by build_dependent_typename itself). */
|
|
|
541
|
|
|
542 GCC_METHOD3 (gcc_type, build_dependent_typename,
|
|
|
543 gcc_type, /* Argument ENCLOSING_TYPE. */
|
|
|
544 const char *, /* Argument ID. */
|
|
|
545 const struct gcc_cp_template_args *) /* Argument TARGS. */
|
|
|
546
|
|
|
547 /* Build a template-dependent class template (e.g., T::template bart).
|
|
|
548 ENCLOSING_TYPE should be the template-dependent nested name
|
|
|
549 specifier (e.g., T), ID should be the name of the class template
|
|
|
550 member of the ENCLOSING_TYPE (e.g., bart). */
|
|
|
551
|
|
|
552 GCC_METHOD2 (gcc_utempl, build_dependent_class_template,
|
|
|
553 gcc_type, /* Argument ENCLOSING_TYPE. */
|
|
|
554 const char *) /* Argument ID. */
|
|
|
555
|
|
|
556 /* Build a template-dependent type template-id (e.g., T<A>).
|
|
|
557 TEMPLATE_DECL should be a template template parameter (e.g., the T
|
|
|
558 in template <template <[...]> class T = X>), and TARGS should
|
|
|
559 specify the template arguments (e.g. <A>). */
|
|
|
560
|
|
|
561 GCC_METHOD2 (gcc_type, build_dependent_type_template_id,
|
|
|
562 gcc_utempl, /* Argument TEMPLATE_DECL. */
|
|
|
563 const struct gcc_cp_template_args *) /* Argument TARGS. */
|
|
|
564
|
|
|
565 /* Build a template-dependent expression (e.g., S::val or S::template
|
|
|
566 mtf<X>, or unqualified f or template tf<X>).
|
|
|
567
|
|
|
568 ENCLOSING_SCOPE should be a template-dependent nested name
|
|
|
569 specifier (e.g., T), a resolved namespace or class decl, or NULL
|
|
|
570 for unqualified names; ID should be the name of the member of the
|
|
|
571 ENCLOSING_SCOPE (e.g., val or mtf) or unqualified overloaded
|
|
|
572 function; and TARGS should list template arguments (e.g. <X>) when
|
|
|
573 mtf or tf are to name a template function, or be NULL otherwise.
|
|
|
574
|
|
|
575 Unqualified names and namespace- or class-qualified names can only
|
|
|
576 resolve to overloaded functions, to be used in contexts that
|
|
|
577 involve overload resolution that cannot be resolved because of
|
|
|
578 template-dependent argument or return types, such as call
|
|
|
579 expressions with template-dependent arguments, conversion
|
|
|
580 expressions to function types with template-dependent argument
|
|
|
581 types or the like. Other cases of unqualified or
|
|
|
582 non-template-dependent-qualified names should NOT use this
|
|
|
583 function, and use decl_expr to convert the appropriate function or
|
|
|
584 object declaration to an expression.
|
|
|
585
|
|
|
586 If ID is the name of a special member function, FLAGS should be
|
|
|
587 GCC_CP_SYMBOL_FUNCTION|GCC_CP_FLAG_SPECIAL_FUNCTION, and ID should
|
|
|
588 be one of the encodings for special member functions documented in
|
|
|
589 build_decl. Otherwise, FLAGS should be GCC_CP_SYMBOL_MASK, which
|
|
|
590 suggests the symbol kind is not known (though we know it is not a
|
|
|
591 type).
|
|
|
592
|
|
|
593 If ID denotes a conversion operator, CONV_TYPE should name the
|
|
|
594 target type of the conversion. Otherwise, CONV_TYPE must be
|
|
|
595 NULL. */
|
|
|
596
|
|
|
597 GCC_METHOD5 (gcc_expr, build_dependent_expr,
|
|
|
598 gcc_decl, /* Argument ENCLOSING_SCOPE. */
|
|
|
599 enum gcc_cp_symbol_kind, /* Argument FLAGS. */
|
|
|
600 const char *, /* Argument NAME. */
|
|
|
601 gcc_type, /* Argument CONV_TYPE. */
|
|
|
602 const struct gcc_cp_template_args *) /* Argument TARGS. */
|
|
|
603
|
|
|
604 /* Build a gcc_expr for the value VALUE in type TYPE. */
|
|
|
605
|
|
|
606 GCC_METHOD2 (gcc_expr, build_literal_expr,
|
|
|
607 gcc_type, /* Argument TYPE. */
|
|
|
608 unsigned long) /* Argument VALUE. */
|
|
|
609
|
|
|
610 /* Build a gcc_expr that denotes DECL, the declaration of a variable
|
|
|
611 or function in namespace scope, or of a static member variable or
|
|
|
612 function. Use QUALIFIED_P to build the operand of unary & so as to
|
|
|
613 compute a pointer-to-member, rather than a regular pointer. */
|
|
|
614
|
|
|
615 GCC_METHOD2 (gcc_expr, build_decl_expr,
|
|
|
616 gcc_decl, /* Argument DECL. */
|
|
|
617 int /* bool */) /* Argument QUALIFIED_P. */
|
|
|
618
|
|
|
619 /* Build a gcc_expr that denotes the unary operation UNARY_OP applied
|
|
|
620 to the gcc_expr OPERAND. For non-expr operands, see
|
|
|
621 unary_type_expr. Besides the UNARY_OP encodings used for operator
|
|
|
622 names, we support "pp_" for preincrement, and "mm_" for
|
|
|
623 predecrement, "nx" for noexcept, "tw" for throw, "tr" for rethrow
|
|
|
624 (pass NULL as the operand), "te" for typeid, "sz" for sizeof, "az"
|
|
|
625 for alignof, "dl" for delete, "gsdl" for ::delete, "da" for
|
|
|
626 delete[], "gsda" for ::delete[], "sp" for pack expansion, "sZ" for
|
|
|
627 sizeof...(function argument pack). */
|
|
|
628
|
|
|
629 GCC_METHOD2 (gcc_expr, build_unary_expr,
|
|
|
630 const char *, /* Argument UNARY_OP. */
|
|
|
631 gcc_expr) /* Argument OPERAND. */
|
|
|
632
|
|
|
633 /* Build a gcc_expr that denotes the binary operation BINARY_OP
|
|
|
634 applied to gcc_exprs OPERAND1 and OPERAND2. Besides the BINARY_OP
|
|
|
635 encodings used for operator names, we support "ds" for the operator
|
|
|
636 token ".*" and "dt" for the operator token ".". When using
|
|
|
637 operators that take a name as their second operand ("." and "->")
|
|
|
638 use decl_expr to convert the gcc_decl of the member name to a
|
|
|
639 gcc_expr, if the member name wasn't created with
|
|
|
640 e.g. build_dependent_expr. */
|
|
|
641
|
|
|
642 GCC_METHOD3 (gcc_expr, build_binary_expr,
|
|
|
643 const char *, /* Argument BINARY_OP. */
|
|
|
644 gcc_expr, /* Argument OPERAND1. */
|
|
|
645 gcc_expr) /* Argument OPERAND2. */
|
|
|
646
|
|
|
647 /* Build a gcc_expr that denotes the ternary operation TERNARY_OP
|
|
|
648 applied to gcc_exprs OPERAND1, OPERAND2 and OPERAND3. The only
|
|
|
649 supported TERNARY_OP is "qu", for the "?:" operator. */
|
|
|
650
|
|
|
651 GCC_METHOD4 (gcc_expr, build_ternary_expr,
|
|
|
652 const char *, /* Argument TERNARY_OP. */
|
|
|
653 gcc_expr, /* Argument OPERAND1. */
|
|
|
654 gcc_expr, /* Argument OPERAND2. */
|
|
|
655 gcc_expr) /* Argument OPERAND3. */
|
|
|
656
|
|
|
657 /* Build a gcc_expr that denotes the unary operation UNARY_OP applied
|
|
|
658 to the gcc_type OPERAND. Supported unary operations taking types
|
|
|
659 are "ti" for typeid, "st" for sizeof, "at" for alignof, and "sZ"
|
|
|
660 for sizeof...(template argument pack). */
|
|
|
661
|
|
|
662 GCC_METHOD2 (gcc_expr, build_unary_type_expr,
|
|
|
663 const char *, /* Argument UNARY_OP. */
|
|
|
664 gcc_type) /* Argument OPERAND. */
|
|
|
665
|
|
|
666 /* Build a gcc_expr that denotes the binary operation BINARY_OP
|
|
|
667 applied to gcc_type OPERAND1 and gcc_expr OPERAND2. Use this for
|
|
|
668 all kinds of (single-argument) type casts ("dc", "sc", "cc", "rc"
|
|
|
669 for dynamic, static, const and reinterpret casts, respectively;
|
|
|
670 "cv" for functional or C-style casts). */
|
|
|
671
|
|
|
672 GCC_METHOD3 (gcc_expr, build_cast_expr,
|
|
|
673 const char *, /* Argument BINARY_OP. */
|
|
|
674 gcc_type, /* Argument OPERAND1. */
|
|
|
675 gcc_expr) /* Argument OPERAND2. */
|
|
|
676
|
|
|
677 /* Build a gcc_expr that denotes the conversion of an expression list
|
|
|
678 VALUES to TYPE, with ("tl") or without ("cv") braces, or a braced
|
|
|
679 initializer list of unspecified type (e.g., a component of another
|
|
|
680 braced initializer list; pass "il" for CONV_OP, and NULL for
|
|
|
681 TYPE). */
|
|
|
682
|
|
|
683 GCC_METHOD3 (gcc_expr, build_expression_list_expr,
|
|
|
684 const char *, /* Argument CONV_OP. */
|
|
|
685 gcc_type, /* Argument TYPE. */
|
|
|
686 const struct gcc_cp_function_args *) /* Argument VALUES. */
|
|
|
687
|
|
|
688 /* Build a gcc_expr that denotes a new ("nw") or new[] ("na")
|
|
|
689 expression of TYPE, with or without a GLOBAL_NS qualifier (prefix
|
|
|
690 the NEW_OP with "gs"), with or without PLACEMENT, with or without
|
|
|
691 INITIALIZER. If it's not a placement new, PLACEMENT must be NULL
|
|
|
692 (rather than a zero-length placement arg list). If there's no
|
|
|
693 specified initializer, INITIALIZER must be NULL; a zero-length arg
|
|
|
694 list stands for a default initializer. */
|
|
|
695
|
|
|
696 GCC_METHOD4 (gcc_expr, build_new_expr,
|
|
|
697 const char *, /* Argument NEW_OP. */
|
|
|
698 const struct gcc_cp_function_args *, /* Argument PLACEMENT. */
|
|
|
699 gcc_type, /* Argument TYPE. */
|
|
|
700 const struct gcc_cp_function_args *) /* Argument INITIALIZER. */
|
|
|
701
|
|
|
702 /* Return a call expression that calls CALLABLE with arguments ARGS.
|
|
|
703 CALLABLE may be a function, a callable object, a pointer to
|
|
|
704 function, an unresolved expression, an unresolved overload set, an
|
|
|
705 object expression combined with a member function overload set or a
|
|
|
706 pointer-to-member. If QUALIFIED_P, CALLABLE will be interpreted as
|
|
|
707 a qualified name, preventing virtual function dispatch. */
|
|
|
708
|
|
|
709 GCC_METHOD3 (gcc_expr, build_call_expr,
|
|
|
710 gcc_expr, /* Argument CALLABLE. */
|
|
|
711 int /* bool */, /* Argument QUALIFIED_P. */
|
|
|
712 const struct gcc_cp_function_args *) /* Argument ARGS. */
|
|
|
713
|
|
|
714 /* Return the type of the gcc_expr OPERAND.
|
|
|
715 Use this for decltype.
|
|
|
716 For decltype (auto), pass a NULL OPERAND.
|
|
|
717
|
|
|
718 Note: for template-dependent expressions, the result is NULL,
|
|
|
719 because the type is only computed when template argument
|
|
|
720 substitution is performed. */
|
|
|
721
|
|
|
722 GCC_METHOD1 (gcc_type, get_expr_type,
|
|
|
723 gcc_expr) /* Argument OPERAND. */
|
|
|
724
|
|
|
725 /* Introduce a specialization of a template function.
|
|
|
726
|
|
|
727 TEMPLATE_DECL is the template function, and TARGS are the arguments
|
|
|
728 for the specialization. ADDRESS is the address of the
|
|
|
729 specialization. FILENAME and LINE_NUMBER specify the source
|
|
|
730 location associated with the template function specialization. */
|
|
|
731
|
|
|
732 GCC_METHOD5 (gcc_decl, build_function_template_specialization,
|
|
|
733 gcc_decl, /* Argument TEMPLATE_DECL. */
|
|
|
734 const struct gcc_cp_template_args *, /* Argument TARGS. */
|
|
|
735 gcc_address, /* Argument ADDRESS. */
|
|
|
736 const char *, /* Argument FILENAME. */
|
|
|
737 unsigned int) /* Argument LINE_NUMBER. */
|
|
|
738
|
|
|
739 /* Specialize a template class as an incomplete type. A definition
|
|
|
740 can be supplied later, with start_class_type.
|
|
|
741
|
|
|
742 TEMPLATE_DECL is the template class, and TARGS are the arguments
|
|
|
743 for the specialization. FILENAME and LINE_NUMBER specify the
|
|
|
744 source location associated with the template class
|
|
|
745 specialization. */
|
|
|
746
|
|
|
747 GCC_METHOD4 (gcc_decl, build_class_template_specialization,
|
|
|
748 gcc_decl, /* Argument TEMPLATE_DECL. */
|
|
|
749 const struct gcc_cp_template_args *, /* Argument TARGS. */
|
|
|
750 const char *, /* Argument FILENAME. */
|
|
|
751 unsigned int) /* Argument LINE_NUMBER. */
|
|
|
752
|
|
|
753 /* Start defining a 'class', 'struct' or 'union' type, entering its
|
|
|
754 own binding level. Initially it has no fields.
|
|
|
755
|
|
|
756 TYPEDECL is the forward-declaration of the type, returned by
|
|
|
757 build_decl. BASE_CLASSES indicate the base classes of class NAME.
|
|
|
758 FILENAME and LINE_NUMBER specify the source location associated
|
|
|
759 with the class definition, should they be different from those of
|
|
|
760 the forward declaration. */
|
|
|
761
|
|
|
762 GCC_METHOD4 (gcc_type, start_class_type,
|
|
|
763 gcc_decl, /* Argument TYPEDECL. */
|
|
|
764 const struct gcc_vbase_array *,/* Argument BASE_CLASSES. */
|
|
|
765 const char *, /* Argument FILENAME. */
|
|
|
766 unsigned int) /* Argument LINE_NUMBER. */
|
|
|
767
|
|
|
768 /* Create a new closure class type, record it as the
|
|
|
769 DISCRIMINATOR-numbered closure type in the current scope (or
|
|
|
770 associated with EXTRA_SCOPE, if non-NULL), and enter the closure
|
|
|
771 type's own binding level. This primitive would sort of combine
|
|
|
772 build_decl and start_class_type, if they could be used to introduce
|
|
|
773 a closure type. Initially it has no fields.
|
|
|
774
|
|
|
775 FILENAME and LINE_NUMBER specify the source location associated
|
|
|
776 with the class. EXTRA_SCOPE, if non-NULL, must be a PARM_DECL of
|
|
|
777 the current function, or a FIELD_DECL of the current class. If it
|
|
|
778 is NULL, the current scope must be a function. */
|
|
|
779
|
|
|
780 GCC_METHOD5 (gcc_type, start_closure_class_type,
|
|
|
781 int, /* Argument DISCRIMINATOR. */
|
|
|
782 gcc_decl, /* Argument EXTRA_SCOPE. */
|
|
|
783 enum gcc_cp_symbol_kind, /* Argument FLAGS. */
|
|
|
784 const char *, /* Argument FILENAME. */
|
|
|
785 unsigned int) /* Argument LINE_NUMBER. */
|
|
|
786
|
|
|
787 /* Add a non-static data member to the most-recently-started
|
|
|
788 unfinished struct or union type. FIELD_NAME is the field's name.
|
|
|
789 FIELD_TYPE is the type of the field. BITSIZE and BITPOS indicate
|
|
|
790 where in the struct the field occurs. */
|
|
|
791
|
|
|
792 GCC_METHOD5 (gcc_decl, build_field,
|
|
|
793 const char *, /* Argument FIELD_NAME. */
|
|
|
794 gcc_type, /* Argument FIELD_TYPE. */
|
|
|
795 enum gcc_cp_symbol_kind, /* Argument FIELD_FLAGS. */
|
|
|
796 unsigned long, /* Argument BITSIZE. */
|
|
|
797 unsigned long) /* Argument BITPOS. */
|
|
|
798
|
|
|
799 /* After all the fields have been added to a struct, class or union,
|
|
|
800 the struct or union type must be "finished". This does some final
|
|
|
801 cleanups in GCC, and pops to the binding level that was in effect
|
|
|
802 before the matching start_class_type or
|
|
|
803 start_closure_class_type. */
|
|
|
804
|
|
|
805 GCC_METHOD1 (int /* bool */, finish_class_type,
|
|
|
806 unsigned long) /* Argument SIZE_IN_BYTES. */
|
|
|
807
|
|
|
808 /* Create a new 'enum' type, and record it in the current binding
|
|
|
809 level. The new type initially has no associated constants.
|
|
|
810
|
|
|
811 NAME is the enum name. FILENAME and LINE_NUMBER specify its source
|
|
|
812 location. */
|
|
|
813
|
|
|
814 GCC_METHOD5 (gcc_type, start_enum_type,
|
|
|
815 const char *, /* Argument NAME. */
|
|
|
816 gcc_type, /* Argument UNDERLYING_INT_TYPE. */
|
|
|
817 enum gcc_cp_symbol_kind, /* Argument FLAGS. */
|
|
|
818 const char *, /* Argument FILENAME. */
|
|
|
819 unsigned int) /* Argument LINE_NUMBER. */
|
|
|
820
|
|
|
821 /* Add a new constant to an enum type. NAME is the constant's name
|
|
|
822 and VALUE is its value. Returns a gcc_decl for the constant. */
|
|
|
823
|
|
|
824 GCC_METHOD3 (gcc_decl, build_enum_constant,
|
|
|
825 gcc_type, /* Argument ENUM_TYPE. */
|
|
|
826 const char *, /* Argument NAME. */
|
|
|
827 unsigned long) /* Argument VALUE. */
|
|
|
828
|
|
|
829 /* After all the constants have been added to an enum, the type must
|
|
|
830 be "finished". This does some final cleanups in GCC. */
|
|
|
831
|
|
|
832 GCC_METHOD1 (int /* bool */, finish_enum_type,
|
|
|
833 gcc_type) /* Argument ENUM_TYPE. */
|
|
|
834
|
|
|
835 /* Create a new function type. RETURN_TYPE is the type returned by
|
|
|
836 the function, and ARGUMENT_TYPES is a vector, of length NARGS, of
|
|
|
837 the argument types. IS_VARARGS is true if the function is
|
|
|
838 varargs. */
|
|
|
839
|
|
|
840 GCC_METHOD3 (gcc_type, build_function_type,
|
|
|
841 gcc_type, /* Argument RETURN_TYPE. */
|
|
|
842 const struct gcc_type_array *,/* Argument ARGUMENT_TYPES. */
|
|
|
843 int /* bool */) /* Argument IS_VARARGS. */
|
|
|
844
|
|
|
845 /* Create a variant of a function type with an exception
|
|
|
846 specification. FUNCTION_TYPE is a function or method type.
|
|
|
847 EXCEPT_TYPES is an array with the list of exception types. Zero as
|
|
|
848 the array length implies throw() AKA noexcept(true); NULL as the
|
|
|
849 pointer to gcc_type_array implies noexcept(false), which is almost
|
|
|
850 equivalent (but distinguishable by the compiler) to an unspecified
|
|
|
851 exception list. */
|
|
|
852
|
|
|
853 GCC_METHOD2 (gcc_type, build_exception_spec_variant,
|
|
|
854 gcc_type, /* Argument FUNCTION_TYPE. */
|
|
|
855 const struct gcc_type_array *)/* Argument EXCEPT_TYPES. */
|
|
|
856
|
|
|
857 /* Create a new non-static member function type. FUNC_TYPE is the
|
|
|
858 method prototype, without the implicit THIS pointer, added as a
|
|
|
859 pointer to the QUALS-qualified CLASS_TYPE. If CLASS_TYPE is NULL,
|
|
|
860 this creates a cv-qualified (member) function type not associated
|
|
|
861 with any specific class, as needed to support "typedef void f(int)
|
|
|
862 const;", which can later be used to declare member functions and
|
|
|
863 pointers to member functions. */
|
|
|
864
|
|
|
865 GCC_METHOD4 (gcc_type, build_method_type,
|
|
|
866 gcc_type, /* Argument CLASS_TYPE. */
|
|
|
867 gcc_type, /* Argument FUNC_TYPE. */
|
|
|
868 enum gcc_cp_qualifiers, /* Argument QUALS. */
|
|
|
869 enum gcc_cp_ref_qualifiers) /* Argument RQUALS. */
|
|
|
870
|
|
|
871 /* Return a declaration for the (INDEX - 1)th argument of
|
|
|
872 FUNCTION_DECL, i.e., for the first argument, use zero as the index.
|
|
|
873 If FUNCTION_DECL is a non-static member function, use -1 to get the
|
|
|
874 implicit THIS parameter. */
|
|
|
875
|
|
|
876 GCC_METHOD2 (gcc_decl, get_function_parameter_decl,
|
|
|
877 gcc_decl, /* Argument FUNCTION_DECL. */
|
|
|
878 int) /* Argument INDEX. */
|
|
|
879
|
|
|
880 /* Return a lambda expr that constructs an instance of CLOSURE_TYPE.
|
|
|
881 Only lambda exprs without any captures can be correctly created
|
|
|
882 through these mechanisms; that's all we need to support lambdas
|
|
|
883 expressions in default parameters, the only kind that may have to
|
|
|
884 be introduced through this interface. */
|
|
|
885
|
|
|
886 GCC_METHOD1 (gcc_expr, build_lambda_expr,
|
|
|
887 gcc_type) /* Argument CLOSURE_TYPE. */
|
|
|
888
|
|
|
889 /* Return an integer type with the given properties. If BUILTIN_NAME
|
|
|
890 is non-NULL, it must name a builtin integral type with the given
|
|
|
891 signedness and size, and that is the type that will be returned. */
|
|
|
892
|
|
|
893 GCC_METHOD3 (gcc_type, get_int_type,
|
|
|
894 int /* bool */, /* Argument IS_UNSIGNED. */
|
|
|
895 unsigned long, /* Argument SIZE_IN_BYTES. */
|
|
|
896 const char *) /* Argument BUILTIN_NAME. */
|
|
|
897
|
|
|
898 /* Return the 'char' type, a distinct type from both 'signed char' and
|
|
|
899 'unsigned char' returned by int_type. */
|
|
|
900
|
|
|
901 GCC_METHOD0 (gcc_type, get_char_type)
|
|
|
902
|
|
|
903 /* Return a floating point type with the given properties. If BUILTIN_NAME
|
|
|
904 is non-NULL, it must name a builtin integral type with the given
|
|
|
905 signedness and size, and that is the type that will be returned. */
|
|
|
906
|
|
|
907 GCC_METHOD2 (gcc_type, get_float_type,
|
|
|
908 unsigned long, /* Argument SIZE_IN_BYTES. */
|
|
|
909 const char *) /* Argument BUILTIN_NAME. */
|
|
|
910
|
|
|
911 /* Return the 'void' type. */
|
|
|
912
|
|
|
913 GCC_METHOD0 (gcc_type, get_void_type)
|
|
|
914
|
|
|
915 /* Return the 'bool' type. */
|
|
|
916
|
|
|
917 GCC_METHOD0 (gcc_type, get_bool_type)
|
|
|
918
|
|
|
919 /* Return the std::nullptr_t type. */
|
|
|
920
|
|
|
921 GCC_METHOD0 (gcc_type, get_nullptr_type)
|
|
|
922
|
|
|
923 /* Return the nullptr constant. */
|
|
|
924
|
|
|
925 GCC_METHOD0 (gcc_expr, get_nullptr_constant)
|
|
|
926
|
|
|
927 /* Create a new array type. If NUM_ELEMENTS is -1, then the array
|
|
|
928 is assumed to have an unknown length. */
|
|
|
929
|
|
|
930 GCC_METHOD2 (gcc_type, build_array_type,
|
|
|
931 gcc_type, /* Argument ELEMENT_TYPE. */
|
|
|
932 int) /* Argument NUM_ELEMENTS. */
|
|
|
933
|
|
|
934 /* Create a new array type. NUM_ELEMENTS is a template-dependent
|
|
|
935 expression. */
|
|
|
936
|
|
|
937 GCC_METHOD2 (gcc_type, build_dependent_array_type,
|
|
|
938 gcc_type, /* Argument ELEMENT_TYPE. */
|
|
|
939 gcc_expr) /* Argument NUM_ELEMENTS. */
|
|
|
940
|
|
|
941 /* Create a new variably-sized array type. UPPER_BOUND_NAME is the
|
|
|
942 name of a local variable that holds the upper bound of the array;
|
|
|
943 it is one less than the array size. */
|
|
|
944
|
|
|
945 GCC_METHOD2 (gcc_type, build_vla_array_type,
|
|
|
946 gcc_type, /* Argument ELEMENT_TYPE. */
|
|
|
947 const char *) /* Argument UPPER_BOUND_NAME. */
|
|
|
948
|
|
|
949 /* Return a qualified variant of a given base type. QUALIFIERS says
|
|
|
950 which qualifiers to use; it is composed of or'd together
|
|
|
951 constants from 'enum gcc_cp_qualifiers'. */
|
|
|
952
|
|
|
953 GCC_METHOD2 (gcc_type, build_qualified_type,
|
|
|
954 gcc_type, /* Argument UNQUALIFIED_TYPE. */
|
|
|
955 enum gcc_cp_qualifiers) /* Argument QUALIFIERS. */
|
|
|
956
|
|
|
957 /* Build a complex type given its element type. */
|
|
|
958
|
|
|
959 GCC_METHOD1 (gcc_type, build_complex_type,
|
|
|
960 gcc_type) /* Argument ELEMENT_TYPE. */
|
|
|
961
|
|
|
962 /* Build a vector type given its element type and number of
|
|
|
963 elements. */
|
|
|
964
|
|
|
965 GCC_METHOD2 (gcc_type, build_vector_type,
|
|
|
966 gcc_type, /* Argument ELEMENT_TYPE. */
|
|
|
967 int) /* Argument NUM_ELEMENTS. */
|
|
|
968
|
|
|
969 /* Build a constant. NAME is the constant's name and VALUE is its
|
|
|
970 value. FILENAME and LINE_NUMBER refer to the type's source
|
|
|
971 location. If this is not known, FILENAME can be NULL and
|
|
|
972 LINE_NUMBER can be 0. */
|
|
|
973
|
|
|
974 GCC_METHOD5 (int /* bool */, build_constant,
|
|
|
975 gcc_type, /* Argument TYPE. */
|
|
|
976 const char *, /* Argument NAME. */
|
|
|
977 unsigned long, /* Argument VALUE. */
|
|
|
978 const char *, /* Argument FILENAME. */
|
|
|
979 unsigned int) /* Argument LINE_NUMBER. */
|
|
|
980
|
|
|
981 /* Emit an error and return an error type object. */
|
|
|
982
|
|
|
983 GCC_METHOD1 (gcc_type, error,
|
|
|
984 const char *) /* Argument MESSAGE. */
|
|
|
985
|
|
|
986 /* Declare a static_assert with the given CONDITION and ERRORMSG at
|
|
|
987 FILENAME:LINE_NUMBER. */
|
|
|
988
|
|
|
989 GCC_METHOD4 (int /* bool */, add_static_assert,
|
|
|
990 gcc_expr, /* Argument CONDITION. */
|
|
|
991 const char *, /* Argument ERRORMSG. */
|
|
|
992 const char *, /* Argument FILENAME. */
|
|
|
993 unsigned int) /* Argument LINE_NUMBER. */
|
|
|
994
|
|
|
995 #if 0
|
|
|
996
|
|
|
997 /* FIXME: We don't want to expose the internal implementation detail
|
|
|
998 that default parms are stored in function types, and it's not clear
|
|
|
999 how this or other approaches would interact with the type sharing
|
|
|
1000 of e.g. ctor clones, so we're leaving this out, since default args
|
|
|
1001 are not even present in debug information anyway. Besides, the set
|
|
|
1002 of default args for a function may grow within its scope, and vary
|
|
|
1003 independently in other scopes. */
|
|
|
1004
|
|
|
1005 /* Create a modified version of a function type that has default
|
|
|
1006 values for some of its arguments. The returned type should ONLY be
|
|
|
1007 used to define functions or methods, never to declare parameters,
|
|
|
1008 variables, types or the like.
|
|
|
1009
|
|
|
1010 DEFAULTS must have at most as many N_ELEMENTS as there are
|
|
|
1011 arguments without default values in FUNCTION_TYPE. Say, if
|
|
|
1012 FUNCTION_TYPE has an argument list such as (T1, T2, T3, T4 = V0)
|
|
|
1013 and DEFAULTS has 2 elements (V1, V2), the returned type will have
|
|
|
1014 the following argument list: (T1, T2 = V1, T3 = V2, T4 = V0).
|
|
|
1015
|
|
|
1016 Any NULL expressions in DEFAULTS will be marked as deferred, and
|
|
|
1017 they should be filled in with set_deferred_function_default_args. */
|
|
|
1018
|
|
|
1019 GCC_METHOD2 (gcc_type, add_function_default_args,
|
|
|
1020 gcc_type, /* Argument FUNCTION_TYPE. */
|
|
|
1021 const struct gcc_cp_function_args *) /* Argument DEFAULTS. */
|
|
|
1022
|
|
|
1023 /* Fill in the first deferred default args in FUNCTION_DECL with the
|
|
|
1024 expressions given in DEFAULTS. This can be used when the
|
|
|
1025 declaration of a parameter is needed to create a default
|
|
|
1026 expression, such as taking the size of an earlier parameter, or
|
|
|
1027 building a lambda expression in the parameter's context. */
|
|
|
1028
|
|
|
1029 GCC_METHOD2 (int /* bool */, set_deferred_function_default_args,
|
|
|
1030 gcc_decl, /* Argument FUNCTION_DECL. */
|
|
|
1031 const struct gcc_cp_function_args *) /* Argument DEFAULTS. */
|
|
|
1032
|
|
|
1033 #endif
|
|
|
1034
|
|
|
1035
|
|
|
1036 /* When you add entry points, add them at the end, so that the new API
|
|
|
1037 version remains compatible with the old version.
|
|
|
1038
|
|
|
1039 The following conventions have been observed as to naming entry points:
|
|
|
1040
|
|
|
1041 - build_* creates (and maybe records) something and returns it;
|
|
|
1042 - add_* creates and records something, but doesn't return it;
|
|
|
1043 - get_* obtains something without creating it;
|
|
|
1044 - start_* marks the beginning of a compound (type, list, ...);
|
|
|
1045 - finish_* completes the compound when needed.
|
|
|
1046
|
|
|
1047 Entry points that return an int (bool) and don't have a return value
|
|
|
1048 specification return nonzero (true) on success and zero (false) on
|
|
|
1049 failure. This is in line with libcc1's conventions of returning a
|
|
|
1050 zero-initialized value in case of e.g. a transport error. */
|
