|
111
|
1 /* Some code common to C++ and ObjC++ front ends.
|
|
145
|
2 Copyright (C) 2004-2020 Free Software Foundation, Inc.
|
|
111
|
3 Contributed by Ziemowit Laski <zlaski@apple.com>
|
|
|
4
|
|
|
5 This file is part of GCC.
|
|
|
6
|
|
|
7 GCC is free software; you can redistribute it and/or modify it under
|
|
|
8 the terms of the GNU General Public License as published by the Free
|
|
|
9 Software Foundation; either version 3, or (at your option) any later
|
|
|
10 version.
|
|
|
11
|
|
|
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
|
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
|
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
|
15 for more details.
|
|
|
16
|
|
|
17 You should have received a copy of the GNU General Public License
|
|
|
18 along with GCC; see the file COPYING3. If not see
|
|
|
19 <http://www.gnu.org/licenses/>. */
|
|
|
20
|
|
|
21 #include "config.h"
|
|
|
22 #include "system.h"
|
|
|
23 #include "coretypes.h"
|
|
|
24 #include "cp-tree.h"
|
|
|
25 #include "cp-objcp-common.h"
|
|
|
26 #include "dwarf2.h"
|
|
145
|
27 #include "stringpool.h"
|
|
111
|
28
|
|
|
29 /* Special routine to get the alias set for C++. */
|
|
|
30
|
|
|
31 alias_set_type
|
|
|
32 cxx_get_alias_set (tree t)
|
|
|
33 {
|
|
|
34 if (IS_FAKE_BASE_TYPE (t))
|
|
|
35 /* The base variant of a type must be in the same alias set as the
|
|
|
36 complete type. */
|
|
|
37 return get_alias_set (TYPE_CONTEXT (t));
|
|
|
38
|
|
|
39 /* Punt on PMFs until we canonicalize functions properly. */
|
|
|
40 if (TYPE_PTRMEMFUNC_P (t)
|
|
131
|
41 || (INDIRECT_TYPE_P (t)
|
|
111
|
42 && TYPE_PTRMEMFUNC_P (TREE_TYPE (t))))
|
|
|
43 return 0;
|
|
|
44
|
|
|
45 return c_common_get_alias_set (t);
|
|
|
46 }
|
|
|
47
|
|
|
48 /* Called from check_global_declaration. */
|
|
|
49
|
|
|
50 bool
|
|
|
51 cxx_warn_unused_global_decl (const_tree decl)
|
|
|
52 {
|
|
|
53 if (TREE_CODE (decl) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (decl))
|
|
|
54 return false;
|
|
|
55 if (DECL_IN_SYSTEM_HEADER (decl))
|
|
|
56 return false;
|
|
|
57
|
|
|
58 return true;
|
|
|
59 }
|
|
|
60
|
|
|
61 /* Langhook for tree_size: determine size of our 'x' and 'c' nodes. */
|
|
|
62 size_t
|
|
|
63 cp_tree_size (enum tree_code code)
|
|
|
64 {
|
|
|
65 gcc_checking_assert (code >= NUM_TREE_CODES);
|
|
|
66 switch (code)
|
|
|
67 {
|
|
|
68 case PTRMEM_CST: return sizeof (ptrmem_cst);
|
|
|
69 case BASELINK: return sizeof (tree_baselink);
|
|
|
70 case TEMPLATE_PARM_INDEX: return sizeof (template_parm_index);
|
|
145
|
71 case DEFERRED_PARSE: return sizeof (tree_deferred_parse);
|
|
111
|
72 case DEFERRED_NOEXCEPT: return sizeof (tree_deferred_noexcept);
|
|
|
73 case OVERLOAD: return sizeof (tree_overload);
|
|
|
74 case STATIC_ASSERT: return sizeof (tree_static_assert);
|
|
|
75 case TYPE_ARGUMENT_PACK:
|
|
|
76 case TYPE_PACK_EXPANSION: return sizeof (tree_type_non_common);
|
|
|
77 case NONTYPE_ARGUMENT_PACK:
|
|
|
78 case EXPR_PACK_EXPANSION: return sizeof (tree_exp);
|
|
|
79 case ARGUMENT_PACK_SELECT: return sizeof (tree_argument_pack_select);
|
|
|
80 case TRAIT_EXPR: return sizeof (tree_trait_expr);
|
|
|
81 case LAMBDA_EXPR: return sizeof (tree_lambda_expr);
|
|
|
82 case TEMPLATE_INFO: return sizeof (tree_template_info);
|
|
|
83 case CONSTRAINT_INFO: return sizeof (tree_constraint_info);
|
|
|
84 case USERDEF_LITERAL: return sizeof (tree_userdef_literal);
|
|
|
85 case TEMPLATE_DECL: return sizeof (tree_template_decl);
|
|
|
86 default:
|
|
|
87 switch (TREE_CODE_CLASS (code))
|
|
|
88 {
|
|
|
89 case tcc_declaration: return sizeof (tree_decl_non_common);
|
|
|
90 case tcc_type: return sizeof (tree_type_non_common);
|
|
|
91 default: gcc_unreachable ();
|
|
|
92 }
|
|
|
93 }
|
|
|
94 /* NOTREACHED */
|
|
|
95 }
|
|
|
96
|
|
|
97 /* Returns true if T is a variably modified type, in the sense of C99.
|
|
|
98 FN is as passed to variably_modified_p.
|
|
|
99 This routine needs only check cases that cannot be handled by the
|
|
|
100 language-independent logic in tree.c. */
|
|
|
101
|
|
|
102 bool
|
|
|
103 cp_var_mod_type_p (tree type, tree fn)
|
|
|
104 {
|
|
|
105 /* If TYPE is a pointer-to-member, it is variably modified if either
|
|
|
106 the class or the member are variably modified. */
|
|
|
107 if (TYPE_PTRMEM_P (type))
|
|
|
108 return (variably_modified_type_p (TYPE_PTRMEM_CLASS_TYPE (type), fn)
|
|
|
109 || variably_modified_type_p (TYPE_PTRMEM_POINTED_TO_TYPE (type),
|
|
|
110 fn));
|
|
|
111
|
|
|
112 /* All other types are not variably modified. */
|
|
|
113 return false;
|
|
|
114 }
|
|
|
115
|
|
|
116 /* This compares two types for equivalence ("compatible" in C-based languages).
|
|
|
117 This routine should only return 1 if it is sure. It should not be used
|
|
|
118 in contexts where erroneously returning 0 causes problems. */
|
|
|
119
|
|
|
120 int
|
|
|
121 cxx_types_compatible_p (tree x, tree y)
|
|
|
122 {
|
|
|
123 return same_type_ignoring_top_level_qualifiers_p (x, y);
|
|
|
124 }
|
|
|
125
|
|
145
|
126 static GTY((cache)) type_tree_cache_map *debug_type_map;
|
|
111
|
127
|
|
|
128 /* Return a type to use in the debug info instead of TYPE, or NULL_TREE to
|
|
|
129 keep TYPE. */
|
|
|
130
|
|
|
131 tree
|
|
|
132 cp_get_debug_type (const_tree type)
|
|
|
133 {
|
|
131
|
134 tree dtype = NULL_TREE;
|
|
111
|
135
|
|
131
|
136 if (TYPE_PTRMEMFUNC_P (type) && !typedef_variant_p (type))
|
|
|
137 dtype = build_offset_type (TYPE_PTRMEMFUNC_OBJECT_TYPE (type),
|
|
|
138 TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (type)));
|
|
111
|
139
|
|
131
|
140 /* We cannot simply return the debug type here because the function uses
|
|
|
141 the type canonicalization hashtable, which is GC-ed, so its behavior
|
|
|
142 depends on the actual collection points. Since we are building these
|
|
|
143 types on the fly for the debug info only, they would not be attached
|
|
|
144 to any GC root and always be swept, so we would make the contents of
|
|
|
145 the debug info depend on the collection points. */
|
|
|
146 if (dtype)
|
|
|
147 {
|
|
|
148 tree ktype = CONST_CAST_TREE (type);
|
|
145
|
149 if (tree *slot = hash_map_safe_get (debug_type_map, ktype))
|
|
131
|
150 return *slot;
|
|
145
|
151 hash_map_safe_put<hm_ggc> (debug_type_map, ktype, dtype);
|
|
111
|
152 }
|
|
|
153
|
|
131
|
154 return dtype;
|
|
111
|
155 }
|
|
|
156
|
|
|
157 /* Return -1 if dwarf ATTR shouldn't be added for DECL, or the attribute
|
|
|
158 value otherwise. */
|
|
|
159 int
|
|
|
160 cp_decl_dwarf_attribute (const_tree decl, int attr)
|
|
|
161 {
|
|
|
162 if (decl == NULL_TREE)
|
|
|
163 return -1;
|
|
|
164
|
|
|
165 switch (attr)
|
|
|
166 {
|
|
|
167 case DW_AT_explicit:
|
|
|
168 if (TREE_CODE (decl) == FUNCTION_DECL
|
|
|
169 && DECL_LANG_SPECIFIC (STRIP_TEMPLATE (decl))
|
|
|
170 && DECL_NONCONVERTING_P (decl))
|
|
|
171 return 1;
|
|
|
172 break;
|
|
|
173
|
|
|
174 case DW_AT_deleted:
|
|
|
175 if (TREE_CODE (decl) == FUNCTION_DECL
|
|
|
176 && DECL_LANG_SPECIFIC (STRIP_TEMPLATE (decl))
|
|
|
177 && DECL_DELETED_FN (decl))
|
|
|
178 return 1;
|
|
|
179 break;
|
|
|
180
|
|
|
181 case DW_AT_defaulted:
|
|
|
182 if (TREE_CODE (decl) == FUNCTION_DECL
|
|
|
183 && DECL_LANG_SPECIFIC (STRIP_TEMPLATE (decl))
|
|
|
184 && DECL_DEFAULTED_FN (decl))
|
|
|
185 {
|
|
|
186 if (DECL_DEFAULTED_IN_CLASS_P (decl))
|
|
|
187 return DW_DEFAULTED_in_class;
|
|
|
188
|
|
|
189 if (DECL_DEFAULTED_OUTSIDE_CLASS_P (decl))
|
|
|
190 return DW_DEFAULTED_out_of_class;
|
|
|
191 }
|
|
|
192 break;
|
|
|
193
|
|
|
194 case DW_AT_const_expr:
|
|
|
195 if (VAR_OR_FUNCTION_DECL_P (decl) && DECL_DECLARED_CONSTEXPR_P (decl))
|
|
|
196 return 1;
|
|
|
197 break;
|
|
|
198
|
|
|
199 case DW_AT_reference:
|
|
|
200 if (TREE_CODE (decl) == FUNCTION_DECL
|
|
|
201 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl)
|
|
|
202 && FUNCTION_REF_QUALIFIED (TREE_TYPE (decl))
|
|
|
203 && !FUNCTION_RVALUE_QUALIFIED (TREE_TYPE (decl)))
|
|
|
204 return 1;
|
|
|
205 break;
|
|
|
206
|
|
|
207 case DW_AT_rvalue_reference:
|
|
|
208 if (TREE_CODE (decl) == FUNCTION_DECL
|
|
|
209 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl)
|
|
|
210 && FUNCTION_REF_QUALIFIED (TREE_TYPE (decl))
|
|
|
211 && FUNCTION_RVALUE_QUALIFIED (TREE_TYPE (decl)))
|
|
|
212 return 1;
|
|
|
213 break;
|
|
|
214
|
|
|
215 case DW_AT_inline:
|
|
|
216 if (VAR_P (decl) && DECL_INLINE_VAR_P (decl))
|
|
|
217 {
|
|
|
218 if (DECL_VAR_DECLARED_INLINE_P (decl))
|
|
|
219 return DW_INL_declared_inlined;
|
|
|
220 else
|
|
|
221 return DW_INL_inlined;
|
|
|
222 }
|
|
|
223 break;
|
|
|
224
|
|
|
225 case DW_AT_export_symbols:
|
|
|
226 if (TREE_CODE (decl) == NAMESPACE_DECL
|
|
|
227 && (DECL_NAMESPACE_INLINE_P (decl)
|
|
|
228 || (DECL_NAME (decl) == NULL_TREE && dwarf_version >= 5)))
|
|
|
229 return 1;
|
|
|
230 break;
|
|
|
231
|
|
|
232 default:
|
|
|
233 break;
|
|
|
234 }
|
|
|
235
|
|
|
236 return -1;
|
|
|
237 }
|
|
|
238
|
|
|
239 /* Return -1 if dwarf ATTR shouldn't be added for TYPE, or the attribute
|
|
|
240 value otherwise. */
|
|
|
241 int
|
|
|
242 cp_type_dwarf_attribute (const_tree type, int attr)
|
|
|
243 {
|
|
|
244 if (type == NULL_TREE)
|
|
|
245 return -1;
|
|
|
246
|
|
|
247 switch (attr)
|
|
|
248 {
|
|
|
249 case DW_AT_reference:
|
|
145
|
250 if (FUNC_OR_METHOD_TYPE_P (type)
|
|
111
|
251 && FUNCTION_REF_QUALIFIED (type)
|
|
|
252 && !FUNCTION_RVALUE_QUALIFIED (type))
|
|
|
253 return 1;
|
|
|
254 break;
|
|
|
255
|
|
|
256 case DW_AT_rvalue_reference:
|
|
145
|
257 if (FUNC_OR_METHOD_TYPE_P (type)
|
|
111
|
258 && FUNCTION_REF_QUALIFIED (type)
|
|
|
259 && FUNCTION_RVALUE_QUALIFIED (type))
|
|
|
260 return 1;
|
|
|
261 break;
|
|
|
262
|
|
|
263 default:
|
|
|
264 break;
|
|
|
265 }
|
|
|
266
|
|
|
267 return -1;
|
|
|
268 }
|
|
|
269
|
|
|
270 /* Return the unit size of TYPE without reusable tail padding. */
|
|
|
271
|
|
|
272 tree
|
|
|
273 cp_unit_size_without_reusable_padding (tree type)
|
|
|
274 {
|
|
|
275 if (CLASS_TYPE_P (type))
|
|
|
276 return CLASSTYPE_SIZE_UNIT (type);
|
|
|
277 return TYPE_SIZE_UNIT (type);
|
|
|
278 }
|
|
|
279
|
|
|
280 /* Stubs to keep c-opts.c happy. */
|
|
|
281 void
|
|
|
282 push_file_scope (void)
|
|
|
283 {
|
|
|
284 }
|
|
|
285
|
|
|
286 void
|
|
|
287 pop_file_scope (void)
|
|
|
288 {
|
|
|
289 }
|
|
|
290
|
|
|
291 /* c-pragma.c needs to query whether a decl has extern "C" linkage. */
|
|
|
292 bool
|
|
|
293 has_c_linkage (const_tree decl)
|
|
|
294 {
|
|
|
295 return DECL_EXTERN_C_P (decl);
|
|
|
296 }
|
|
|
297
|
|
|
298 /* Return true if stmt can fall through. Used by block_may_fallthru
|
|
|
299 default case. */
|
|
|
300
|
|
|
301 bool
|
|
|
302 cxx_block_may_fallthru (const_tree stmt)
|
|
|
303 {
|
|
|
304 switch (TREE_CODE (stmt))
|
|
|
305 {
|
|
|
306 case EXPR_STMT:
|
|
|
307 return block_may_fallthru (EXPR_STMT_EXPR (stmt));
|
|
|
308
|
|
|
309 case THROW_EXPR:
|
|
|
310 return false;
|
|
|
311
|
|
131
|
312 case IF_STMT:
|
|
|
313 if (block_may_fallthru (THEN_CLAUSE (stmt)))
|
|
|
314 return true;
|
|
|
315 return block_may_fallthru (ELSE_CLAUSE (stmt));
|
|
|
316
|
|
|
317 case SWITCH_STMT:
|
|
|
318 return (!SWITCH_STMT_ALL_CASES_P (stmt)
|
|
|
319 || !SWITCH_STMT_NO_BREAK_P (stmt)
|
|
|
320 || block_may_fallthru (SWITCH_STMT_BODY (stmt)));
|
|
|
321
|
|
111
|
322 default:
|
|
|
323 return true;
|
|
|
324 }
|
|
|
325 }
|
|
|
326
|
|
|
327 /* Return the list of decls in the global namespace. */
|
|
|
328
|
|
|
329 tree
|
|
|
330 cp_get_global_decls ()
|
|
|
331 {
|
|
|
332 return NAMESPACE_LEVEL (global_namespace)->names;
|
|
|
333 }
|
|
|
334
|
|
|
335 /* Push DECL into the current scope. */
|
|
|
336
|
|
|
337 tree
|
|
|
338 cp_pushdecl (tree decl)
|
|
|
339 {
|
|
|
340 return pushdecl (decl);
|
|
|
341 }
|
|
|
342
|
|
|
343 /* Get the global value binding of NAME. Called directly from
|
|
|
344 c-common.c, not via a hook. */
|
|
|
345
|
|
|
346 tree
|
|
|
347 identifier_global_value (tree name)
|
|
|
348 {
|
|
|
349 return get_global_binding (name);
|
|
|
350 }
|
|
|
351
|
|
145
|
352 /* Similarly, but return struct/class/union NAME instead. */
|
|
|
353
|
|
|
354 tree
|
|
|
355 identifier_global_tag (tree name)
|
|
|
356 {
|
|
|
357 tree ret = lookup_qualified_name (global_namespace, name, /*prefer_type*/2,
|
|
|
358 /*complain*/false);
|
|
|
359 if (ret == error_mark_node)
|
|
|
360 return NULL_TREE;
|
|
|
361 return ret;
|
|
|
362 }
|
|
|
363
|
|
|
364 /* Returns true if NAME refers to a built-in function or function-like
|
|
|
365 operator. */
|
|
|
366
|
|
|
367 bool
|
|
|
368 names_builtin_p (const char *name)
|
|
|
369 {
|
|
|
370 tree id = get_identifier (name);
|
|
|
371 if (tree binding = get_global_binding (id))
|
|
|
372 {
|
|
|
373 if (TREE_CODE (binding) == FUNCTION_DECL && DECL_IS_BUILTIN (binding))
|
|
|
374 return true;
|
|
|
375
|
|
|
376 /* Handle the case when an overload for a built-in name exists. */
|
|
|
377 if (TREE_CODE (binding) != OVERLOAD)
|
|
|
378 return false;
|
|
|
379
|
|
|
380 for (ovl_iterator it (binding); it; ++it)
|
|
|
381 {
|
|
|
382 tree decl = *it;
|
|
|
383 if (DECL_IS_BUILTIN (decl))
|
|
|
384 return true;
|
|
|
385 }
|
|
|
386 }
|
|
|
387
|
|
|
388 /* Also detect common reserved C++ words that aren't strictly built-in
|
|
|
389 functions. */
|
|
|
390 switch (C_RID_CODE (id))
|
|
|
391 {
|
|
|
392 case RID_ADDRESSOF:
|
|
|
393 case RID_BUILTIN_CONVERTVECTOR:
|
|
|
394 case RID_BUILTIN_HAS_ATTRIBUTE:
|
|
|
395 case RID_BUILTIN_SHUFFLE:
|
|
|
396 case RID_BUILTIN_LAUNDER:
|
|
|
397 case RID_OFFSETOF:
|
|
|
398 case RID_HAS_NOTHROW_ASSIGN:
|
|
|
399 case RID_HAS_NOTHROW_CONSTRUCTOR:
|
|
|
400 case RID_HAS_NOTHROW_COPY:
|
|
|
401 case RID_HAS_TRIVIAL_ASSIGN:
|
|
|
402 case RID_HAS_TRIVIAL_CONSTRUCTOR:
|
|
|
403 case RID_HAS_TRIVIAL_COPY:
|
|
|
404 case RID_HAS_TRIVIAL_DESTRUCTOR:
|
|
|
405 case RID_HAS_UNIQUE_OBJ_REPRESENTATIONS:
|
|
|
406 case RID_HAS_VIRTUAL_DESTRUCTOR:
|
|
|
407 case RID_IS_ABSTRACT:
|
|
|
408 case RID_IS_AGGREGATE:
|
|
|
409 case RID_IS_BASE_OF:
|
|
|
410 case RID_IS_CLASS:
|
|
|
411 case RID_IS_EMPTY:
|
|
|
412 case RID_IS_ENUM:
|
|
|
413 case RID_IS_FINAL:
|
|
|
414 case RID_IS_LITERAL_TYPE:
|
|
|
415 case RID_IS_POD:
|
|
|
416 case RID_IS_POLYMORPHIC:
|
|
|
417 case RID_IS_SAME_AS:
|
|
|
418 case RID_IS_STD_LAYOUT:
|
|
|
419 case RID_IS_TRIVIAL:
|
|
|
420 case RID_IS_TRIVIALLY_ASSIGNABLE:
|
|
|
421 case RID_IS_TRIVIALLY_CONSTRUCTIBLE:
|
|
|
422 case RID_IS_TRIVIALLY_COPYABLE:
|
|
|
423 case RID_IS_UNION:
|
|
|
424 case RID_IS_ASSIGNABLE:
|
|
|
425 case RID_IS_CONSTRUCTIBLE:
|
|
|
426 case RID_UNDERLYING_TYPE:
|
|
|
427 return true;
|
|
|
428 default:
|
|
|
429 break;
|
|
|
430 }
|
|
|
431
|
|
|
432 return false;
|
|
|
433 }
|
|
|
434
|
|
111
|
435 /* Register c++-specific dumps. */
|
|
|
436
|
|
|
437 void
|
|
|
438 cp_register_dumps (gcc::dump_manager *dumps)
|
|
|
439 {
|
|
|
440 class_dump_id = dumps->dump_register
|
|
|
441 (".class", "lang-class", "lang-class", DK_lang, OPTGROUP_NONE, false);
|
|
|
442
|
|
|
443 raw_dump_id = dumps->dump_register
|
|
|
444 (".raw", "lang-raw", "lang-raw", DK_lang, OPTGROUP_NONE, false);
|
|
|
445 }
|
|
|
446
|
|
|
447 void
|
|
|
448 cp_common_init_ts (void)
|
|
|
449 {
|
|
145
|
450 /* With type. */
|
|
|
451 MARK_TS_TYPED (PTRMEM_CST);
|
|
|
452 MARK_TS_TYPED (LAMBDA_EXPR);
|
|
|
453 MARK_TS_TYPED (TYPE_ARGUMENT_PACK);
|
|
111
|
454
|
|
145
|
455 /* Random new trees. */
|
|
|
456 MARK_TS_COMMON (BASELINK);
|
|
|
457 MARK_TS_COMMON (DECLTYPE_TYPE);
|
|
|
458 MARK_TS_COMMON (OVERLOAD);
|
|
111
|
459 MARK_TS_COMMON (TEMPLATE_PARM_INDEX);
|
|
|
460 MARK_TS_COMMON (TYPENAME_TYPE);
|
|
|
461 MARK_TS_COMMON (TYPEOF_TYPE);
|
|
145
|
462 MARK_TS_COMMON (UNBOUND_CLASS_TEMPLATE);
|
|
111
|
463 MARK_TS_COMMON (UNDERLYING_TYPE);
|
|
145
|
464
|
|
|
465 /* New decls. */
|
|
|
466 MARK_TS_DECL_COMMON (TEMPLATE_DECL);
|
|
|
467 MARK_TS_DECL_COMMON (WILDCARD_DECL);
|
|
|
468 MARK_TS_DECL_COMMON (CONCEPT_DECL);
|
|
|
469
|
|
|
470 MARK_TS_DECL_NON_COMMON (USING_DECL);
|
|
|
471
|
|
|
472 /* New Types. */
|
|
|
473 MARK_TS_TYPE_NON_COMMON (BOUND_TEMPLATE_TEMPLATE_PARM);
|
|
|
474 MARK_TS_TYPE_NON_COMMON (TEMPLATE_TEMPLATE_PARM);
|
|
|
475 MARK_TS_TYPE_NON_COMMON (TEMPLATE_TYPE_PARM);
|
|
|
476 MARK_TS_TYPE_NON_COMMON (TYPE_ARGUMENT_PACK);
|
|
|
477 MARK_TS_TYPE_NON_COMMON (TYPE_PACK_EXPANSION);
|
|
|
478
|
|
|
479 /* Statements. */
|
|
|
480 MARK_TS_EXP (BREAK_STMT);
|
|
|
481 MARK_TS_EXP (CLEANUP_STMT);
|
|
|
482 MARK_TS_EXP (CONTINUE_STMT);
|
|
|
483 MARK_TS_EXP (DO_STMT);
|
|
|
484 MARK_TS_EXP (EH_SPEC_BLOCK);
|
|
|
485 MARK_TS_EXP (FOR_STMT);
|
|
|
486 MARK_TS_EXP (HANDLER);
|
|
|
487 MARK_TS_EXP (IF_STMT);
|
|
|
488 MARK_TS_EXP (OMP_DEPOBJ);
|
|
|
489 MARK_TS_EXP (RANGE_FOR_STMT);
|
|
|
490 MARK_TS_EXP (SWITCH_STMT);
|
|
|
491 MARK_TS_EXP (TRY_BLOCK);
|
|
|
492 MARK_TS_EXP (USING_STMT);
|
|
|
493 MARK_TS_EXP (WHILE_STMT);
|
|
111
|
494
|
|
145
|
495 /* Random expressions. */
|
|
|
496 MARK_TS_EXP (ADDRESSOF_EXPR);
|
|
|
497 MARK_TS_EXP (AGGR_INIT_EXPR);
|
|
|
498 MARK_TS_EXP (ALIGNOF_EXPR);
|
|
|
499 MARK_TS_EXP (ARROW_EXPR);
|
|
|
500 MARK_TS_EXP (AT_ENCODE_EXPR);
|
|
|
501 MARK_TS_EXP (CAST_EXPR);
|
|
|
502 MARK_TS_EXP (CONST_CAST_EXPR);
|
|
|
503 MARK_TS_EXP (CTOR_INITIALIZER);
|
|
|
504 MARK_TS_EXP (DELETE_EXPR);
|
|
|
505 MARK_TS_EXP (DOTSTAR_EXPR);
|
|
|
506 MARK_TS_EXP (DYNAMIC_CAST_EXPR);
|
|
|
507 MARK_TS_EXP (EMPTY_CLASS_EXPR);
|
|
|
508 MARK_TS_EXP (EXPR_STMT);
|
|
|
509 MARK_TS_EXP (IMPLICIT_CONV_EXPR);
|
|
|
510 MARK_TS_EXP (MEMBER_REF);
|
|
|
511 MARK_TS_EXP (MODOP_EXPR);
|
|
|
512 MARK_TS_EXP (MUST_NOT_THROW_EXPR);
|
|
|
513 MARK_TS_EXP (NEW_EXPR);
|
|
|
514 MARK_TS_EXP (NOEXCEPT_EXPR);
|
|
|
515 MARK_TS_EXP (NON_DEPENDENT_EXPR);
|
|
|
516 MARK_TS_EXP (OFFSETOF_EXPR);
|
|
|
517 MARK_TS_EXP (OFFSET_REF);
|
|
|
518 MARK_TS_EXP (PSEUDO_DTOR_EXPR);
|
|
|
519 MARK_TS_EXP (REINTERPRET_CAST_EXPR);
|
|
|
520 MARK_TS_EXP (SCOPE_REF);
|
|
|
521 MARK_TS_EXP (STATIC_CAST_EXPR);
|
|
|
522 MARK_TS_EXP (STMT_EXPR);
|
|
|
523 MARK_TS_EXP (TAG_DEFN);
|
|
|
524 MARK_TS_EXP (TEMPLATE_ID_EXPR);
|
|
|
525 MARK_TS_EXP (THROW_EXPR);
|
|
|
526 MARK_TS_EXP (TRAIT_EXPR);
|
|
|
527 MARK_TS_EXP (TYPEID_EXPR);
|
|
|
528 MARK_TS_EXP (TYPE_EXPR);
|
|
|
529 MARK_TS_EXP (UNARY_PLUS_EXPR);
|
|
|
530 MARK_TS_EXP (VEC_DELETE_EXPR);
|
|
|
531 MARK_TS_EXP (VEC_INIT_EXPR);
|
|
|
532 MARK_TS_EXP (VEC_NEW_EXPR);
|
|
|
533 MARK_TS_EXP (SPACESHIP_EXPR);
|
|
|
534
|
|
|
535 /* Fold expressions. */
|
|
|
536 MARK_TS_EXP (BINARY_LEFT_FOLD_EXPR);
|
|
|
537 MARK_TS_EXP (BINARY_RIGHT_FOLD_EXPR);
|
|
|
538 MARK_TS_EXP (EXPR_PACK_EXPANSION);
|
|
|
539 MARK_TS_EXP (NONTYPE_ARGUMENT_PACK);
|
|
|
540 MARK_TS_EXP (UNARY_LEFT_FOLD_EXPR);
|
|
|
541 MARK_TS_EXP (UNARY_RIGHT_FOLD_EXPR);
|
|
|
542
|
|
|
543 /* Constraints. */
|
|
|
544 MARK_TS_EXP (CHECK_CONSTR);
|
|
|
545 MARK_TS_EXP (COMPOUND_REQ);
|
|
|
546 MARK_TS_EXP (CONJ_CONSTR);
|
|
|
547 MARK_TS_EXP (DISJ_CONSTR);
|
|
|
548 MARK_TS_EXP (ATOMIC_CONSTR);
|
|
|
549 MARK_TS_EXP (NESTED_REQ);
|
|
|
550 MARK_TS_EXP (REQUIRES_EXPR);
|
|
|
551 MARK_TS_EXP (SIMPLE_REQ);
|
|
|
552 MARK_TS_EXP (TYPE_REQ);
|
|
|
553
|
|
|
554 MARK_TS_EXP (CO_AWAIT_EXPR);
|
|
|
555 MARK_TS_EXP (CO_YIELD_EXPR);
|
|
|
556 MARK_TS_EXP (CO_RETURN_EXPR);
|
|
|
557
|
|
|
558 c_common_init_ts ();
|
|
111
|
559 }
|
|
|
560
|
|
|
561 #include "gt-cp-cp-objcp-common.h"
|
