1/* Definitions for c-common.cc.
2 Copyright (C) 1987-2025 Free Software Foundation, Inc.
3
4This file is part of GCC.
5
6GCC is free software; you can redistribute it and/or modify it under
7the terms of the GNU General Public License as published by the Free
8Software Foundation; either version 3, or (at your option) any later
9version.
10
11GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12WARRANTY; without even the implied warranty of MERCHANTABILITY or
13FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14for more details.
15
16You should have received a copy of the GNU General Public License
17along with GCC; see the file COPYING3. If not see
18<http://www.gnu.org/licenses/>. */
19
20#ifndef GCC_C_COMMON_H
21#define GCC_C_COMMON_H
22
23#include "splay-tree.h"
24#include "cpplib.h"
25#include "alias.h"
26#include "tree.h"
27#include "fold-const.h"
28#include "wide-int-bitmask.h"
29
30/* In order for the format checking to accept the C frontend
31 diagnostic framework extensions, you must include this file before
32 diagnostic-core.h, not after. The C front end formats are a subset of those
33 for C++, so they are the appropriate set to use in common code;
34 cp-tree.h overrides this for C++. */
35#if defined(GCC_DIAGNOSTIC_CORE_H)
36#error \
37In order for the format checking to accept the C front end diagnostic \
38framework extensions, you must include this file before diagnostic-core.h \
39never after.
40#endif
41#ifndef GCC_DIAG_STYLE
42#define GCC_DIAG_STYLE __gcc_cdiag__
43#endif
44#include "diagnostic-core.h"
45
46/* Usage of TREE_LANG_FLAG_?:
47 0: IDENTIFIER_MARKED (used by search routines).
48 C_MAYBE_CONST_EXPR_INT_OPERANDS (in C_MAYBE_CONST_EXPR, for C)
49 1: C_DECLARED_LABEL_FLAG (in LABEL_DECL)
50 STATEMENT_LIST_STMT_EXPR (in STATEMENT_LIST)
51 C_MAYBE_CONST_EXPR_NON_CONST (in C_MAYBE_CONST_EXPR, for C)
52 2: unused
53 3: STATEMENT_LIST_HAS_LABEL (in STATEMENT_LIST)
54 4: unused
55*/
56
57/* Reserved identifiers. This is the union of all the keywords for C,
58 C++, and Objective-C. All the type modifiers have to be in one
59 block at the beginning, because they are used as mask bits. There
60 are 28 type modifiers; if we add many more we will have to redesign
61 the mask mechanism. */
62
63enum rid
64{
65 /* Modifiers: */
66 /* C, in empirical order of frequency. */
67 RID_STATIC = 0,
68 RID_UNSIGNED, RID_LONG, RID_CONST, RID_EXTERN,
69 RID_REGISTER, RID_TYPEDEF, RID_SHORT, RID_INLINE,
70 RID_VOLATILE, RID_SIGNED, RID_AUTO, RID_RESTRICT,
71 RID_NORETURN, RID_ATOMIC,
72
73 /* C extensions */
74 RID_COMPLEX, RID_THREAD, RID_SAT,
75
76 /* C++ */
77 RID_FRIEND, RID_VIRTUAL, RID_EXPLICIT, RID_EXPORT, RID_MUTABLE,
78
79 /* ObjC ("PQ" reserved words - they do not appear after a '@' and
80 are keywords only in specific contexts) */
81 RID_IN, RID_OUT, RID_INOUT, RID_BYCOPY, RID_BYREF, RID_ONEWAY,
82
83 /* ObjC ("PATTR" reserved words - they do not appear after a '@'
84 and are keywords only as property attributes) */
85 RID_GETTER, RID_SETTER,
86 RID_READONLY, RID_READWRITE,
87 RID_ASSIGN, RID_RETAIN, RID_COPY,
88 RID_PROPATOMIC, RID_NONATOMIC,
89
90 /* ObjC nullability support keywords that also can appear in the
91 property attribute context. These values should remain contiguous
92 with the other property attributes. */
93 RID_NULL_UNSPECIFIED, RID_NULLABLE, RID_NONNULL, RID_NULL_RESETTABLE,
94
95 /* C (reserved and imaginary types not implemented, so any use is a
96 syntax error) */
97 RID_IMAGINARY,
98
99 /* C */
100 RID_INT, RID_CHAR, RID_FLOAT, RID_DOUBLE, RID_VOID,
101 RID_ENUM, RID_STRUCT, RID_UNION, RID_IF, RID_ELSE,
102 RID_WHILE, RID_DO, RID_FOR, RID_SWITCH, RID_CASE,
103 RID_DEFAULT, RID_BREAK, RID_CONTINUE, RID_RETURN, RID_GOTO,
104 RID_SIZEOF, RID_BITINT,
105
106 /* C extensions */
107 RID_ASM, RID_TYPEOF, RID_TYPEOF_UNQUAL, RID_ALIGNOF, RID_ATTRIBUTE,
108 RID_COUNTOF,
109 RID_C23_VA_START, RID_VA_ARG,
110 RID_EXTENSION, RID_IMAGPART, RID_REALPART, RID_LABEL, RID_CHOOSE_EXPR,
111 RID_TYPES_COMPATIBLE_P, RID_BUILTIN_COMPLEX, RID_BUILTIN_SHUFFLE,
112 RID_BUILTIN_SHUFFLEVECTOR, RID_BUILTIN_CONVERTVECTOR, RID_BUILTIN_TGMATH,
113 RID_BUILTIN_HAS_ATTRIBUTE, RID_BUILTIN_ASSOC_BARRIER, RID_BUILTIN_STDC,
114 RID_BUILTIN_COUNTED_BY_REF,
115 RID_DFLOAT32, RID_DFLOAT64, RID_DFLOAT128, RID_DFLOAT64X,
116
117 /* TS 18661-3 keywords, in the same sequence as the TI_* values. */
118 RID_FLOAT16,
119 RID_FLOATN_NX_FIRST = RID_FLOAT16,
120 RID_FLOAT32,
121 RID_FLOAT64,
122 RID_FLOAT128,
123 RID_FLOAT32X,
124 RID_FLOAT64X,
125 RID_FLOAT128X,
126#define CASE_RID_FLOATN_NX \
127 case RID_FLOAT16: case RID_FLOAT32: case RID_FLOAT64: case RID_FLOAT128: \
128 case RID_FLOAT32X: case RID_FLOAT64X: case RID_FLOAT128X
129
130 RID_FRACT, RID_ACCUM, RID_AUTO_TYPE, RID_BUILTIN_CALL_WITH_STATIC_CHAIN,
131
132 /* "__GIMPLE", for the GIMPLE-parsing extension to the C frontend. */
133 RID_GIMPLE,
134
135 /* "__PHI", for parsing PHI function in GIMPLE FE. */
136 RID_PHI,
137
138 /* "__RTL", for the RTL-parsing extension to the C frontend. */
139 RID_RTL,
140
141 /* C11 */
142 RID_ALIGNAS, RID_GENERIC,
143
144 /* This means to warn that this is a C++ keyword, and then treat it
145 as a normal identifier. */
146 RID_CXX_COMPAT_WARN,
147
148 /* GNU transactional memory extension */
149 RID_TRANSACTION_ATOMIC, RID_TRANSACTION_RELAXED, RID_TRANSACTION_CANCEL,
150
151 /* Too many ways of getting the name of a function as a string */
152 RID_FUNCTION_NAME, RID_PRETTY_FUNCTION_NAME, RID_C99_FUNCTION_NAME,
153
154 /* C++ (some of these are keywords in Objective-C as well, but only
155 if they appear after a '@') */
156 RID_BOOL, RID_WCHAR, RID_CLASS,
157 RID_PUBLIC, RID_PRIVATE, RID_PROTECTED,
158 RID_TEMPLATE, RID_NULL, RID_CATCH,
159 RID_DELETE, RID_FALSE, RID_NAMESPACE,
160 RID_NEW, RID_OFFSETOF, RID_OPERATOR,
161 RID_THIS, RID_THROW, RID_TRUE,
162 RID_TRY, RID_TYPENAME, RID_TYPEID,
163 RID_USING, RID_CHAR16, RID_CHAR32,
164
165 /* casts */
166 RID_CONSTCAST, RID_DYNCAST, RID_REINTCAST, RID_STATCAST,
167
168 /* C++ extensions */
169 RID_ADDRESSOF,
170 RID_BUILTIN_LAUNDER,
171 RID_BUILTIN_BIT_CAST,
172 RID_BUILTIN_OPERATOR_NEW, RID_BUILTIN_OPERATOR_DELETE,
173
174 /* C++11 */
175 RID_CONSTEXPR, RID_DECLTYPE, RID_NOEXCEPT, RID_NULLPTR, RID_STATIC_ASSERT,
176
177 /* C++20 */
178 RID_CONSTINIT, RID_CONSTEVAL,
179
180 /* char8_t */
181 RID_CHAR8,
182
183 /* C++ concepts */
184 RID_CONCEPT, RID_REQUIRES,
185
186 /* C++ modules. */
187 RID__MODULE, RID__IMPORT, RID__EXPORT, /* Internal tokens. */
188
189 /* C++ coroutines */
190 RID_CO_AWAIT, RID_CO_YIELD, RID_CO_RETURN,
191
192 /* C++ transactional memory. */
193 RID_ATOMIC_NOEXCEPT, RID_ATOMIC_CANCEL, RID_SYNCHRONIZED,
194
195 /* Objective-C ("AT" reserved words - they are only keywords when
196 they follow '@') */
197 RID_AT_ENCODE, RID_AT_END,
198 RID_AT_CLASS, RID_AT_ALIAS, RID_AT_DEFS,
199 RID_AT_PRIVATE, RID_AT_PROTECTED, RID_AT_PUBLIC, RID_AT_PACKAGE,
200 RID_AT_PROTOCOL, RID_AT_SELECTOR,
201 RID_AT_THROW, RID_AT_TRY, RID_AT_CATCH,
202 RID_AT_FINALLY, RID_AT_SYNCHRONIZED,
203 RID_AT_OPTIONAL, RID_AT_REQUIRED, RID_AT_PROPERTY,
204 RID_AT_SYNTHESIZE, RID_AT_DYNAMIC,
205 RID_AT_INTERFACE,
206 RID_AT_IMPLEMENTATION,
207
208 /* OpenMP */
209 RID_OMP_ALL_MEMORY,
210
211 /* Named address support, mapping the keyword to a particular named address
212 number. Named address space 0 is reserved for the generic address. If
213 there are more than 254 named addresses, the addr_space_t type will need
214 to be grown from an unsigned char to unsigned short. */
215 RID_ADDR_SPACE_0, /* generic address */
216 RID_ADDR_SPACE_1,
217 RID_ADDR_SPACE_2,
218 RID_ADDR_SPACE_3,
219 RID_ADDR_SPACE_4,
220 RID_ADDR_SPACE_5,
221 RID_ADDR_SPACE_6,
222 RID_ADDR_SPACE_7,
223 RID_ADDR_SPACE_8,
224 RID_ADDR_SPACE_9,
225 RID_ADDR_SPACE_10,
226 RID_ADDR_SPACE_11,
227 RID_ADDR_SPACE_12,
228 RID_ADDR_SPACE_13,
229 RID_ADDR_SPACE_14,
230 RID_ADDR_SPACE_15,
231
232 RID_FIRST_ADDR_SPACE = RID_ADDR_SPACE_0,
233 RID_LAST_ADDR_SPACE = RID_ADDR_SPACE_15,
234
235 /* __intN keywords. The _N_M here doesn't correspond to the intN
236 in the keyword; use the bitsize in int_n_t_data_t[M] for that.
237 For example, if int_n_t_data_t[0].bitsize is 13, then RID_INT_N_0
238 is for __int13. */
239
240 /* Note that the range to use is RID_FIRST_INT_N through
241 RID_FIRST_INT_N + NUM_INT_N_ENTS - 1 and c-parser.cc has a list of
242 all RID_INT_N_* in a case statement. */
243
244 RID_INT_N_0,
245 RID_INT_N_1,
246 RID_INT_N_2,
247 RID_INT_N_3,
248
249 RID_FIRST_INT_N = RID_INT_N_0,
250 RID_LAST_INT_N = RID_INT_N_3,
251
252 RID_MAX,
253
254 RID_FIRST_MODIFIER = RID_STATIC,
255 RID_LAST_MODIFIER = RID_ONEWAY,
256
257 RID_FIRST_CXX11 = RID_CONSTEXPR,
258 RID_LAST_CXX11 = RID_STATIC_ASSERT,
259 RID_FIRST_CXX20 = RID_CONSTINIT,
260 RID_LAST_CXX20 = RID_CO_RETURN,
261 RID_FIRST_AT = RID_AT_ENCODE,
262 RID_LAST_AT = RID_AT_IMPLEMENTATION,
263 RID_FIRST_PQ = RID_IN,
264 RID_LAST_PQ = RID_ONEWAY,
265 RID_FIRST_PATTR = RID_GETTER,
266 RID_LAST_PATTR = RID_NULL_RESETTABLE
267};
268
269#define OBJC_IS_AT_KEYWORD(rid) \
270 ((unsigned int) (rid) >= (unsigned int) RID_FIRST_AT && \
271 (unsigned int) (rid) <= (unsigned int) RID_LAST_AT)
272
273#define OBJC_IS_PQ_KEYWORD(rid) \
274 ((unsigned int) (rid) >= (unsigned int) RID_FIRST_PQ && \
275 (unsigned int) (rid) <= (unsigned int) RID_LAST_PQ)
276
277/* Keywords permitted in an @property attribute context. */
278#define OBJC_IS_PATTR_KEYWORD(rid) \
279 ((((unsigned int) (rid) >= (unsigned int) RID_FIRST_PATTR && \
280 (unsigned int) (rid) <= (unsigned int) RID_LAST_PATTR)) \
281 || rid == RID_CLASS)
282
283/* OBJC_IS_CXX_KEYWORD recognizes the 'CXX_OBJC' keywords (such as
284 'class') which are shared in a subtle way between Objective-C and
285 C++. When the lexer is lexing in Objective-C/Objective-C++, if it
286 finds '@' followed by one of these identifiers (eg, '@class'), it
287 recognizes the whole as an Objective-C keyword. If the identifier
288 is found elsewhere, it follows the rules of the C/C++ language.
289 */
290#define OBJC_IS_CXX_KEYWORD(rid) \
291 (rid == RID_CLASS || rid == RID_SYNCHRONIZED \
292 || rid == RID_PUBLIC || rid == RID_PROTECTED || rid == RID_PRIVATE \
293 || rid == RID_TRY || rid == RID_THROW || rid == RID_CATCH)
294
295/* The elements of `ridpointers' are identifier nodes for the reserved
296 type names and storage classes. It is indexed by a RID_... value. */
297extern GTY ((length ("(int) RID_MAX"))) tree *ridpointers;
298
299/* Standard named or nameless data types of the C compiler. */
300
301enum c_tree_index
302{
303 CTI_CHAR8_TYPE,
304 CTI_CHAR16_TYPE,
305 CTI_CHAR32_TYPE,
306 CTI_WCHAR_TYPE,
307 CTI_UNDERLYING_WCHAR_TYPE,
308 CTI_WINT_TYPE,
309 CTI_SIGNED_SIZE_TYPE, /* For format checking only. */
310 CTI_UNSIGNED_PTRDIFF_TYPE, /* For format checking only. */
311 CTI_INTMAX_TYPE,
312 CTI_UINTMAX_TYPE,
313 CTI_WIDEST_INT_LIT_TYPE,
314 CTI_WIDEST_UINT_LIT_TYPE,
315
316 /* Types for <stdint.h>, that may not be defined on all
317 targets. */
318 CTI_SIG_ATOMIC_TYPE,
319 CTI_INT8_TYPE,
320 CTI_INT16_TYPE,
321 CTI_INT32_TYPE,
322 CTI_INT64_TYPE,
323 CTI_UINT8_TYPE,
324 CTI_UINT16_TYPE,
325 CTI_UINT32_TYPE,
326 CTI_UINT64_TYPE,
327 CTI_INT_LEAST8_TYPE,
328 CTI_INT_LEAST16_TYPE,
329 CTI_INT_LEAST32_TYPE,
330 CTI_INT_LEAST64_TYPE,
331 CTI_UINT_LEAST8_TYPE,
332 CTI_UINT_LEAST16_TYPE,
333 CTI_UINT_LEAST32_TYPE,
334 CTI_UINT_LEAST64_TYPE,
335 CTI_INT_FAST8_TYPE,
336 CTI_INT_FAST16_TYPE,
337 CTI_INT_FAST32_TYPE,
338 CTI_INT_FAST64_TYPE,
339 CTI_UINT_FAST8_TYPE,
340 CTI_UINT_FAST16_TYPE,
341 CTI_UINT_FAST32_TYPE,
342 CTI_UINT_FAST64_TYPE,
343 CTI_INTPTR_TYPE,
344 CTI_UINTPTR_TYPE,
345
346 CTI_CHAR_ARRAY_TYPE,
347 CTI_CHAR8_ARRAY_TYPE,
348 CTI_CHAR16_ARRAY_TYPE,
349 CTI_CHAR32_ARRAY_TYPE,
350 CTI_WCHAR_ARRAY_TYPE,
351 CTI_STRING_TYPE,
352 CTI_CONST_STRING_TYPE,
353
354 /* Type for boolean expressions (bool in C++, int in C). */
355 CTI_TRUTHVALUE_TYPE,
356 CTI_TRUTHVALUE_TRUE,
357 CTI_TRUTHVALUE_FALSE,
358
359 CTI_DEFAULT_FUNCTION_TYPE,
360
361 CTI_NULL,
362 CTI_NULLPTR,
363 CTI_NULLPTR_TYPE,
364
365 /* These are not types, but we have to look them up all the time. */
366 CTI_FUNCTION_NAME_DECL,
367 CTI_PRETTY_FUNCTION_NAME_DECL,
368 CTI_C99_FUNCTION_NAME_DECL,
369
370 CTI_MODULE_HWM,
371 /* Below here entities change during compilation. */
372
373 CTI_SAVED_FUNCTION_NAME_DECLS,
374
375 CTI_MAX
376};
377
378#define C_CPP_HASHNODE(id) \
379 (&(((struct c_common_identifier *) (id))->node))
380#define C_RID_CODE(id) \
381 ((enum rid) (((struct c_common_identifier *) (id))->node.rid_code))
382#define C_SET_RID_CODE(id, code) \
383 (((struct c_common_identifier *) (id))->node.rid_code = (unsigned char) code)
384
385/* Identifier part common to the C front ends. Inherits from
386 tree_identifier, despite appearances. */
387struct GTY(()) c_common_identifier {
388 struct tree_common common;
389 struct cpp_hashnode node;
390};
391
392/* An entry in the reserved keyword table. */
393
394struct c_common_resword
395{
396 const char *const word;
397 ENUM_BITFIELD(rid) const rid : 16;
398 const unsigned int disable : 32;
399};
400
401/* Mode used to build pointers (VOIDmode means ptr_mode). */
402
403extern machine_mode c_default_pointer_mode;
404
405/* Extra cpp_ttype values for C++. */
406
407/* A token type for template-ids. If a template-id is processed while
408 parsing tentatively, it is replaced with a CPP_TEMPLATE_ID token;
409 the value of the CPP_TEMPLATE_ID is whatever was returned by
410 cp_parser_template_id. */
411#define CPP_TEMPLATE_ID ((enum cpp_ttype) (CPP_KEYWORD + 1))
412
413/* A token type for nested-name-specifiers. If a
414 nested-name-specifier is processed while parsing tentatively, it is
415 replaced with a CPP_NESTED_NAME_SPECIFIER token; the value of the
416 CPP_NESTED_NAME_SPECIFIER is whatever was returned by
417 cp_parser_nested_name_specifier_opt. */
418#define CPP_NESTED_NAME_SPECIFIER ((enum cpp_ttype) (CPP_TEMPLATE_ID + 1))
419
420/* A token type for pre-parsed C++0x decltype. */
421#define CPP_DECLTYPE ((enum cpp_ttype) (CPP_NESTED_NAME_SPECIFIER + 1))
422
423/* A token type for pre-parsed primary-expression (lambda- or statement-). */
424#define CPP_PREPARSED_EXPR ((enum cpp_ttype) (CPP_DECLTYPE + 1))
425
426/* The number of token types, including C++-specific ones. */
427#define N_CP_TTYPES ((int) (CPP_PREPARSED_EXPR + 1))
428
429/* Disable mask. Keywords are disabled if (reswords[i].disable &
430 mask) is _true_. Thus for keywords which are present in all
431 languages the disable field is zero. */
432
433#define D_CONLY 0x0001 /* C only (not in C++). */
434#define D_CXXONLY 0x0002 /* C++ only (not in C). */
435#define D_C99 0x0004 /* In C, C99 only. */
436#define D_C23 0x0008 /* In C, C23 only. */
437#define D_CXX11 0x0010 /* In C++, C++11 only. */
438#define D_EXT 0x0020 /* GCC extension. */
439#define D_EXT89 0x0040 /* GCC extension incorporated in C99. */
440#define D_EXT11 0x0080 /* GCC extension incorporated in C23. */
441#define D_ASM 0x0100 /* Disabled by -fno-asm. */
442#define D_OBJC 0x0200 /* In Objective C and neither C nor C++. */
443#define D_CXX_OBJC 0x0400 /* In Objective C, and C++, but not C. */
444#define D_CXXWARN 0x0800 /* In C warn with -Wcxx-compat. */
445#define D_CXX_CONCEPTS 0x1000 /* In C++, only with concepts. */
446#define D_TRANSMEM 0x2000 /* C++ transactional memory TS. */
447#define D_CXX_CHAR8_T 0x4000 /* In C++, only with -fchar8_t. */
448#define D_CXX20 0x8000 /* In C++, C++20 only. */
449#define D_CXX_COROUTINES 0x10000 /* In C++, only with coroutines. */
450#define D_CXX_MODULES 0x20000 /* In C++, only with modules. */
451
452#define D_CXX_CONCEPTS_FLAGS D_CXXONLY | D_CXX_CONCEPTS
453#define D_CXX_CHAR8_T_FLAGS D_CXXONLY | D_CXX_CHAR8_T
454#define D_CXX_MODULES_FLAGS (D_CXXONLY | D_CXX_MODULES)
455#define D_CXX_COROUTINES_FLAGS (D_CXXONLY | D_CXX_COROUTINES)
456
457/* The reserved keyword table. */
458extern const struct c_common_resword c_common_reswords[];
459
460/* The number of items in the reserved keyword table. */
461extern const unsigned int num_c_common_reswords;
462
463#define char8_type_node c_global_trees[CTI_CHAR8_TYPE]
464#define char16_type_node c_global_trees[CTI_CHAR16_TYPE]
465#define char32_type_node c_global_trees[CTI_CHAR32_TYPE]
466#define wchar_type_node c_global_trees[CTI_WCHAR_TYPE]
467#define underlying_wchar_type_node c_global_trees[CTI_UNDERLYING_WCHAR_TYPE]
468#define wint_type_node c_global_trees[CTI_WINT_TYPE]
469#define signed_size_type_node c_global_trees[CTI_SIGNED_SIZE_TYPE]
470#define unsigned_ptrdiff_type_node c_global_trees[CTI_UNSIGNED_PTRDIFF_TYPE]
471#define intmax_type_node c_global_trees[CTI_INTMAX_TYPE]
472#define uintmax_type_node c_global_trees[CTI_UINTMAX_TYPE]
473#define widest_integer_literal_type_node c_global_trees[CTI_WIDEST_INT_LIT_TYPE]
474#define widest_unsigned_literal_type_node c_global_trees[CTI_WIDEST_UINT_LIT_TYPE]
475
476#define sig_atomic_type_node c_global_trees[CTI_SIG_ATOMIC_TYPE]
477#define int8_type_node c_global_trees[CTI_INT8_TYPE]
478#define int16_type_node c_global_trees[CTI_INT16_TYPE]
479#define int32_type_node c_global_trees[CTI_INT32_TYPE]
480#define int64_type_node c_global_trees[CTI_INT64_TYPE]
481#define uint8_type_node c_global_trees[CTI_UINT8_TYPE]
482#define c_uint16_type_node c_global_trees[CTI_UINT16_TYPE]
483#define c_uint32_type_node c_global_trees[CTI_UINT32_TYPE]
484#define c_uint64_type_node c_global_trees[CTI_UINT64_TYPE]
485#define int_least8_type_node c_global_trees[CTI_INT_LEAST8_TYPE]
486#define int_least16_type_node c_global_trees[CTI_INT_LEAST16_TYPE]
487#define int_least32_type_node c_global_trees[CTI_INT_LEAST32_TYPE]
488#define int_least64_type_node c_global_trees[CTI_INT_LEAST64_TYPE]
489#define uint_least8_type_node c_global_trees[CTI_UINT_LEAST8_TYPE]
490#define uint_least16_type_node c_global_trees[CTI_UINT_LEAST16_TYPE]
491#define uint_least32_type_node c_global_trees[CTI_UINT_LEAST32_TYPE]
492#define uint_least64_type_node c_global_trees[CTI_UINT_LEAST64_TYPE]
493#define int_fast8_type_node c_global_trees[CTI_INT_FAST8_TYPE]
494#define int_fast16_type_node c_global_trees[CTI_INT_FAST16_TYPE]
495#define int_fast32_type_node c_global_trees[CTI_INT_FAST32_TYPE]
496#define int_fast64_type_node c_global_trees[CTI_INT_FAST64_TYPE]
497#define uint_fast8_type_node c_global_trees[CTI_UINT_FAST8_TYPE]
498#define uint_fast16_type_node c_global_trees[CTI_UINT_FAST16_TYPE]
499#define uint_fast32_type_node c_global_trees[CTI_UINT_FAST32_TYPE]
500#define uint_fast64_type_node c_global_trees[CTI_UINT_FAST64_TYPE]
501#define intptr_type_node c_global_trees[CTI_INTPTR_TYPE]
502#define uintptr_type_node c_global_trees[CTI_UINTPTR_TYPE]
503
504#define truthvalue_type_node c_global_trees[CTI_TRUTHVALUE_TYPE]
505#define truthvalue_true_node c_global_trees[CTI_TRUTHVALUE_TRUE]
506#define truthvalue_false_node c_global_trees[CTI_TRUTHVALUE_FALSE]
507
508#define char_array_type_node c_global_trees[CTI_CHAR_ARRAY_TYPE]
509#define char8_array_type_node c_global_trees[CTI_CHAR8_ARRAY_TYPE]
510#define char16_array_type_node c_global_trees[CTI_CHAR16_ARRAY_TYPE]
511#define char32_array_type_node c_global_trees[CTI_CHAR32_ARRAY_TYPE]
512#define wchar_array_type_node c_global_trees[CTI_WCHAR_ARRAY_TYPE]
513#define string_type_node c_global_trees[CTI_STRING_TYPE]
514#define const_string_type_node c_global_trees[CTI_CONST_STRING_TYPE]
515
516#define default_function_type c_global_trees[CTI_DEFAULT_FUNCTION_TYPE]
517
518#define function_name_decl_node c_global_trees[CTI_FUNCTION_NAME_DECL]
519#define pretty_function_name_decl_node c_global_trees[CTI_PRETTY_FUNCTION_NAME_DECL]
520#define c99_function_name_decl_node c_global_trees[CTI_C99_FUNCTION_NAME_DECL]
521#define saved_function_name_decls c_global_trees[CTI_SAVED_FUNCTION_NAME_DECLS]
522
523/* The node for C++ `__null'. */
524#define null_node c_global_trees[CTI_NULL]
525/* The nodes for `nullptr'. */
526#define nullptr_node c_global_trees[CTI_NULLPTR]
527#define nullptr_type_node c_global_trees[CTI_NULLPTR_TYPE]
528
529extern GTY(()) tree c_global_trees[CTI_MAX];
530
531/* Mark which labels are explicitly declared.
532 These may be shadowed, and may be referenced from nested functions. */
533#define C_DECLARED_LABEL_FLAG(label) TREE_LANG_FLAG_1 (label)
534
535enum c_language_kind
536{
537 clk_c = 0, /* C without ObjC features. */
538 clk_objc = 1, /* clk_c with ObjC features. */
539 clk_cxx = 2, /* ANSI/ISO C++ */
540 clk_objcxx = 3 /* clk_cxx with ObjC features. */
541};
542
543/* To test for a specific language use c_language, defined by each
544 front end. For "ObjC features" or "not C++" use the macros. */
545extern c_language_kind c_language;
546
547#define c_dialect_cxx() ((c_language & clk_cxx) != 0)
548#define c_dialect_objc() ((c_language & clk_objc) != 0)
549
550/* The various name of operator that appears in error messages. */
551enum ref_operator {
552 /* NULL */
553 RO_NULL,
554 /* array indexing */
555 RO_ARRAY_INDEXING,
556 /* unary * */
557 RO_UNARY_STAR,
558 /* -> */
559 RO_ARROW,
560 /* implicit conversion */
561 RO_IMPLICIT_CONVERSION,
562 /* ->* */
563 RO_ARROW_STAR
564};
565
566/* Information about a statement tree. */
567
568struct GTY(()) stmt_tree_s {
569 /* A stack of statement lists being collected. */
570 vec<tree, va_gc> *x_cur_stmt_list;
571
572 /* In C++, Nonzero if we should treat statements as full
573 expressions. In particular, this variable is non-zero if at the
574 end of a statement we should destroy any temporaries created
575 during that statement. Similarly, if, at the end of a block, we
576 should destroy any local variables in this block. Normally, this
577 variable is nonzero, since those are the normal semantics of
578 C++.
579
580 This flag has no effect in C. */
581 int stmts_are_full_exprs_p;
582};
583
584typedef struct stmt_tree_s *stmt_tree;
585
586/* Global state pertinent to the current function. Some C dialects
587 extend this structure with additional fields. */
588
589struct GTY(()) c_language_function {
590 /* While we are parsing the function, this contains information
591 about the statement-tree that we are building. */
592 struct stmt_tree_s x_stmt_tree;
593
594 /* Vector of locally defined typedefs, for
595 -Wunused-local-typedefs. */
596 vec<tree, va_gc> *local_typedefs;
597};
598
599#define stmt_list_stack (current_stmt_tree ()->x_cur_stmt_list)
600
601/* When building a statement-tree, this is the current statement list
602 being collected. */
603#define cur_stmt_list (stmt_list_stack->last ())
604
605#define building_stmt_list_p() (stmt_list_stack && !stmt_list_stack->is_empty())
606
607/* Language-specific hooks. */
608
609/* If non-NULL, this function is called after a precompile header file
610 is loaded. */
611extern void (*lang_post_pch_load) (void);
612
613extern void push_file_scope (void);
614extern void pop_file_scope (void);
615extern stmt_tree current_stmt_tree (void);
616extern tree push_stmt_list (void);
617extern tree pop_stmt_list (tree);
618extern tree add_stmt (tree);
619extern void push_cleanup (tree, tree, bool);
620
621extern tree build_modify_expr (location_t, tree, tree, enum tree_code,
622 location_t, tree, tree);
623extern tree build_indirect_ref (location_t, tree, ref_operator);
624
625extern bool has_c_linkage (const_tree decl);
626extern bool c_decl_implicit (const_tree);
627
628/* Switches common to the C front ends. */
629
630/* Nonzero means don't output line number information. */
631
632extern char flag_no_line_commands;
633
634/* Nonzero causes -E output not to be done, but directives such as
635 #define that have side effects are still obeyed. */
636
637extern char flag_no_output;
638
639/* Nonzero means dump macros in some fashion; contains the 'D', 'M',
640 'N' or 'U' of the command line switch. */
641
642extern char flag_dump_macros;
643
644/* Nonzero means pass #include lines through to the output. */
645
646extern char flag_dump_includes;
647
648/* Nonzero means process PCH files while preprocessing. */
649
650extern bool flag_pch_preprocess;
651
652/* The file name to which we should write a precompiled header, or
653 NULL if no header will be written in this compile. */
654
655extern const char *pch_file;
656
657/* Nonzero if an ISO standard was selected. It rejects macros in the
658 user's namespace. */
659
660extern int flag_iso;
661
662/* C/ObjC language option variables. */
663
664
665/* Nonzero means allow type mismatches in conditional expressions;
666 just make their values `void'. */
667
668extern int flag_cond_mismatch;
669
670/* Nonzero means enable C89 Amendment 1 features. */
671
672extern int flag_isoc94;
673
674/* Nonzero means use the ISO C99 (or later) dialect of C. */
675
676extern int flag_isoc99;
677
678/* Nonzero means use the ISO C11 (or later) dialect of C. */
679
680extern int flag_isoc11;
681
682/* Nonzero means use the ISO C23 (or later) dialect of C. */
683
684extern int flag_isoc23;
685
686/* Nonzero means use the ISO C2Y (or later) dialect of C. */
687
688extern int flag_isoc2y;
689
690/* Nonzero means that we have builtin functions, and main is an int. */
691
692extern int flag_hosted;
693
694/* ObjC language option variables. */
695
696
697/* Tells the compiler that this is a special run. Do not perform any
698 compiling, instead we are to test some platform dependent features
699 and output a C header file with appropriate definitions. */
700
701extern int print_struct_values;
702
703/* Tells the compiler what is the constant string class for ObjC. */
704
705extern const char *constant_string_class_name;
706
707
708/* C++ language option variables. */
709
710/* The reference version of the ABI for -Wabi. */
711
712extern int warn_abi_version;
713
714/* Return TRUE if one of {flag_abi_version,flag_abi_compat_version} is
715 less than N and the other is at least N. */
716#define abi_compat_version_crosses(N) \
717 (abi_version_at_least(N) \
718 != (flag_abi_compat_version == 0 \
719 || flag_abi_compat_version >= (N)))
720
721/* Return TRUE if one of {flag_abi_version,warn_abi_version} is
722 less than N and the other is at least N, for use by -Wabi. */
723#define abi_version_crosses(N) \
724 (abi_version_at_least(N) \
725 != (warn_abi_version == 0 \
726 || warn_abi_version >= (N)))
727
728/* The supported C++ dialects. */
729
730enum cxx_dialect {
731 cxx_unset,
732 /* C++98 with TC1 */
733 cxx98,
734 cxx03 = cxx98,
735 /* C++11 */
736 cxx0x,
737 cxx11 = cxx0x,
738 /* C++14 */
739 cxx14,
740 /* C++17 */
741 cxx17,
742 /* C++20 */
743 cxx20,
744 /* C++23 */
745 cxx23,
746 /* C++26 */
747 cxx26
748};
749
750/* The C++ dialect being used. C++98 is the default. */
751extern enum cxx_dialect cxx_dialect;
752
753/* Maximum template instantiation depth. This limit is rather
754 arbitrary, but it exists to limit the time it takes to notice
755 excessively recursive template instantiations. */
756
757extern int max_tinst_depth;
758
759/* Nonzero means that we should not issue warnings about problems that
760 occur when the code is executed, because the code being processed
761 is not expected to be executed. This is set during parsing. This
762 is used for cases like sizeof() and "0 ? a : b". This is a count,
763 not a bool, because unexecuted expressions can nest. */
764
765extern int c_inhibit_evaluation_warnings;
766
767/* Depending on which phase of processing we are in, we may need
768 to prefer input_location to libcpp's locations. (Specifically,
769 after the C++ lexer is done lexing tokens, but prior to calling
770 cpp_finish (), we need to do so. */
771
772extern bool override_libcpp_locations;
773
774/* C types are partitioned into three subsets: object, function, and
775 incomplete types. */
776#define C_TYPE_OBJECT_P(type) \
777 (TREE_CODE (type) != FUNCTION_TYPE && TYPE_SIZE (type))
778
779#define C_TYPE_INCOMPLETE_P(type) \
780 (TREE_CODE (type) != FUNCTION_TYPE && TYPE_SIZE (type) == 0)
781
782#define C_TYPE_FUNCTION_P(type) \
783 (TREE_CODE (type) == FUNCTION_TYPE)
784
785/* For convenience we define a single macro to identify the class of
786 object or incomplete types. */
787#define C_TYPE_OBJECT_OR_INCOMPLETE_P(type) \
788 (!C_TYPE_FUNCTION_P (type))
789
790/* Return true if TYPE is a vector type that should be subject to the GNU
791 vector extensions (as opposed to a vector type that is used only for
792 the purposes of defining target-specific built-in functions). */
793
794inline bool
795gnu_vector_type_p (const_tree type)
796{
797 return VECTOR_TYPE_P (type) && !TYPE_INDIVISIBLE_P (type);
798}
799
800struct visibility_flags
801{
802 unsigned inpragma : 1; /* True when in #pragma GCC visibility. */
803 unsigned inlines_hidden : 1; /* True when -finlineshidden in effect. */
804};
805
806/* These enumerators are possible types of unsafe conversions. */
807enum conversion_safety {
808 /* The conversion is safe. */
809 SAFE_CONVERSION = 0,
810 /* Another type of conversion with problems. */
811 UNSAFE_OTHER,
812 /* Conversion between signed and unsigned integers. */
813 UNSAFE_SIGN,
814 /* Conversions that reduce the precision of reals including conversions
815 from reals to integers. */
816 UNSAFE_REAL,
817 /* Conversions from complex to reals or integers, that discard imaginary
818 component. */
819 UNSAFE_IMAGINARY
820};
821
822/* Global visibility options. */
823extern struct visibility_flags visibility_options;
824
825/* Attribute table common to the C front ends. */
826extern const struct scoped_attribute_specs c_common_gnu_attribute_table;
827extern const struct scoped_attribute_specs c_common_clang_attribute_table;
828extern const struct scoped_attribute_specs c_common_format_attribute_table;
829
830/* Pointer to function to lazily generate the VAR_DECL for __FUNCTION__ etc.
831 ID is the identifier to use, NAME is the string.
832 TYPE_DEP indicates whether it depends on type of the function or not
833 (i.e. __PRETTY_FUNCTION__). */
834
835extern tree (*make_fname_decl) (location_t, tree, int);
836
837/* In c-decl.cc and cp/tree.cc. FIXME. */
838extern void c_register_addr_space (const char *str, addr_space_t as);
839
840/* In c-common.cc. */
841extern bool in_late_binary_op;
842extern const char *c_addr_space_name (addr_space_t as);
843extern tree identifier_global_value (tree);
844extern tree identifier_global_tag (tree);
845extern int names_builtin_p (const char *);
846extern tree c_linkage_bindings (tree);
847extern void record_builtin_type (enum rid, const char *, tree);
848extern void start_fname_decls (void);
849extern void finish_fname_decls (void);
850extern const char *fname_as_string (int);
851extern tree fname_decl (location_t, unsigned, tree);
852
853extern int check_user_alignment (const_tree, bool, bool);
854extern bool check_function_arguments (location_t loc, const_tree, const_tree,
855 int, tree *, vec<location_t> *,
856 bool (*comp_types) (tree, tree));
857extern void check_function_arguments_recurse (void (*)
858 (void *, tree,
859 unsigned HOST_WIDE_INT),
860 void *, tree,
861 unsigned HOST_WIDE_INT,
862 opt_code);
863extern bool check_builtin_function_arguments (location_t, vec<location_t>, tree,
864 tree, int, tree *, bool = true);
865extern void check_function_format (const_tree, tree, int, tree *,
866 vec<location_t> *,
867 bool (*comp_types) (tree, tree));
868extern bool attribute_fallthrough_p (tree);
869extern tree handle_format_attribute (tree *, tree, tree, int, bool *);
870extern tree handle_format_arg_attribute (tree *, tree, tree, int, bool *);
871extern tree handle_unsequenced_attribute (tree *, tree, tree, int, bool *);
872extern tree handle_reproducible_attribute (tree *, tree, tree, int, bool *);
873extern bool c_common_handle_option (size_t, const char *, HOST_WIDE_INT, int,
874 location_t,
875 const struct cl_option_handlers *);
876extern bool default_handle_c_option (size_t, const char *, int);
877extern tree c_common_type_for_mode (machine_mode, int);
878extern tree c_common_type_for_size (unsigned int, int);
879extern tree c_common_fixed_point_type_for_size (unsigned int, unsigned int,
880 int, int);
881extern tree c_common_unsigned_type (tree);
882extern tree c_common_signed_type (tree);
883extern tree c_common_signed_or_unsigned_type (int, tree);
884extern void c_common_init_ts (void);
885extern tree c_build_bitfield_integer_type (unsigned HOST_WIDE_INT, int);
886extern enum conversion_safety unsafe_conversion_p (tree, tree, tree, bool);
887extern bool decl_with_nonnull_addr_p (const_tree);
888extern tree c_fully_fold (tree, bool, bool *, bool = false);
889extern tree c_wrap_maybe_const (tree, bool);
890extern tree c_common_truthvalue_conversion (location_t, tree);
891extern void c_apply_type_quals_to_decl (int, tree);
892extern tree c_sizeof_or_alignof_type (location_t, tree, bool, bool, int);
893extern tree c_alignof_expr (location_t, tree);
894extern tree c_countof_type (location_t, tree);
895/* Print an error message for invalid operands to arith operation CODE.
896 NOP_EXPR is used as a special case (see truthvalue_conversion). */
897extern void binary_op_error (rich_location *, enum tree_code, tree, tree);
898extern tree fix_string_type (tree);
899extern tree convert_and_check (location_t, tree, tree, bool = false);
900extern bool c_determine_visibility (tree);
901extern bool vector_types_compatible_elements_p (tree, tree);
902extern void mark_valid_location_for_stdc_pragma (bool);
903extern bool valid_location_for_stdc_pragma_p (void);
904extern void set_float_const_decimal64 (void);
905extern void clear_float_const_decimal64 (void);
906extern bool float_const_decimal64_p (void);
907
908extern bool keyword_begins_type_specifier (enum rid);
909extern bool keyword_is_storage_class_specifier (enum rid);
910extern bool keyword_is_type_qualifier (enum rid);
911extern bool keyword_is_decl_specifier (enum rid);
912extern unsigned max_align_t_align (void);
913extern bool cxx_fundamental_alignment_p (unsigned);
914extern bool pointer_to_zero_sized_aggr_p (tree);
915extern bool bool_promoted_to_int_p (tree);
916extern tree fold_for_warn (tree);
917extern tree c_common_get_narrower (tree, int *);
918extern bool get_attribute_operand (tree, unsigned HOST_WIDE_INT *);
919extern void c_common_finalize_early_debug (void);
920extern bool c_flexible_array_member_type_p (const_tree);
921extern unsigned int c_strict_flex_array_level_of (tree);
922extern bool c_option_is_from_cpp_diagnostics (int);
923extern tree c_hardbool_type_attr_1 (tree, tree *, tree *);
924
925/* Used by convert_and_check; in front ends. */
926extern tree convert_init (tree, tree);
927
928#define c_sizeof(LOC, T) c_sizeof_or_alignof_type (LOC, T, true, false, 1)
929#define c_alignof(LOC, T) c_sizeof_or_alignof_type (LOC, T, false, false, 1)
930
931/* Subroutine of build_binary_op, used for certain operations. */
932extern tree shorten_binary_op (tree result_type, tree op0, tree op1, bool bitwise);
933
934/* Return true if division or modulo op0 / op1 or op0 % op1 may be shortened.
935 We can shorten only if we can guarantee that op0 is not signed integral
936 minimum or op1 is not -1, because e.g. (long long) INT_MIN / -1 is
937 well defined INT_MAX + 1LL if long long is wider than int, but INT_MIN / -1
938 is UB. */
939inline bool
940may_shorten_divmod (tree op0, tree op1)
941{
942 tree type0 = TREE_TYPE (op0);
943 if (TYPE_UNSIGNED (type0))
944 return true;
945 /* A cast from narrower unsigned won't be signed integral minimum,
946 but cast from same or wider precision unsigned could be. */
947 if (TREE_CODE (op0) == NOP_EXPR
948 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (op0, 0)))
949 && TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0, 0)))
950 && (TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op0, 0)))
951 < TYPE_PRECISION (type0)))
952 return true;
953 if (TREE_CODE (op1) == INTEGER_CST && !integer_all_onesp (op1))
954 return true;
955 return false;
956}
957
958/* Subroutine of build_binary_op, used for comparison operations.
959 See if the operands have both been converted from subword integer types
960 and, if so, perhaps change them both back to their original type. */
961extern tree shorten_compare (location_t, tree *, tree *, tree *,
962 enum tree_code *);
963
964extern tree pointer_int_sum (location_t, enum tree_code, tree, tree,
965 bool = true);
966
967/* Add qualifiers to a type, in the fashion for C. */
968extern tree c_build_qualified_type (tree, int, tree = NULL_TREE, size_t = 0);
969
970/* Build tree nodes and builtin functions common to both C and C++ language
971 frontends. */
972extern void c_common_nodes_and_builtins (void);
973
974extern void disable_builtin_function (const char *);
975
976extern void set_compound_literal_name (tree decl);
977
978extern tree build_va_arg (location_t, tree, tree);
979
980extern const unsigned int c_family_lang_mask;
981extern unsigned int c_common_option_lang_mask (void);
982extern void c_common_diagnostics_set_defaults (diagnostic_context *);
983extern bool c_common_complain_wrong_lang_p (const struct cl_option *);
984extern void c_common_init_options_struct (struct gcc_options *);
985extern void c_common_init_options (unsigned int, struct cl_decoded_option *);
986extern bool c_common_post_options (const char **);
987extern bool c_common_init (void);
988extern void c_common_finish (void);
989extern void c_common_parse_file (void);
990extern alias_set_type c_common_get_alias_set (tree);
991extern void c_register_builtin_type (tree, const char*);
992extern bool c_promoting_integer_type_p (const_tree);
993extern bool self_promoting_args_p (const_tree);
994extern tree strip_pointer_operator (tree);
995extern tree strip_pointer_or_array_types (tree);
996extern HOST_WIDE_INT c_common_to_target_charset (HOST_WIDE_INT);
997
998/* This is the basic parsing function. */
999extern void c_parse_file (void);
1000
1001extern void c_parse_final_cleanups (void);
1002
1003/* This initializes for preprocess-only mode. */
1004extern void c_init_preprocess (void);
1005
1006/* These macros provide convenient access to the various _STMT nodes. */
1007
1008/* Nonzero if a given STATEMENT_LIST represents the outermost binding
1009 if a statement expression. */
1010#define STATEMENT_LIST_STMT_EXPR(NODE) \
1011 TREE_LANG_FLAG_1 (STATEMENT_LIST_CHECK (NODE))
1012
1013/* Nonzero if a label has been added to the statement list. */
1014#define STATEMENT_LIST_HAS_LABEL(NODE) \
1015 TREE_LANG_FLAG_3 (STATEMENT_LIST_CHECK (NODE))
1016
1017/* C_MAYBE_CONST_EXPR accessors. */
1018#define C_MAYBE_CONST_EXPR_PRE(NODE) \
1019 TREE_OPERAND (C_MAYBE_CONST_EXPR_CHECK (NODE), 0)
1020#define C_MAYBE_CONST_EXPR_EXPR(NODE) \
1021 TREE_OPERAND (C_MAYBE_CONST_EXPR_CHECK (NODE), 1)
1022#define C_MAYBE_CONST_EXPR_INT_OPERANDS(NODE) \
1023 TREE_LANG_FLAG_0 (C_MAYBE_CONST_EXPR_CHECK (NODE))
1024#define C_MAYBE_CONST_EXPR_NON_CONST(NODE) \
1025 TREE_LANG_FLAG_1 (C_MAYBE_CONST_EXPR_CHECK (NODE))
1026#define EXPR_INT_CONST_OPERANDS(EXPR) \
1027 (INTEGRAL_TYPE_P (TREE_TYPE (EXPR)) \
1028 && (TREE_CODE (EXPR) == INTEGER_CST \
1029 || (TREE_CODE (EXPR) == C_MAYBE_CONST_EXPR \
1030 && C_MAYBE_CONST_EXPR_INT_OPERANDS (EXPR))))
1031
1032/* In a FIELD_DECL, nonzero if the decl was originally a bitfield. */
1033#define DECL_C_BIT_FIELD(NODE) \
1034 (DECL_LANG_FLAG_4 (FIELD_DECL_CHECK (NODE)) == 1)
1035#define SET_DECL_C_BIT_FIELD(NODE) \
1036 (DECL_LANG_FLAG_4 (FIELD_DECL_CHECK (NODE)) = 1)
1037#define CLEAR_DECL_C_BIT_FIELD(NODE) \
1038 (DECL_LANG_FLAG_4 (FIELD_DECL_CHECK (NODE)) = 0)
1039
1040/* True if the decl was an unnamed bitfield. */
1041#define DECL_UNNAMED_BIT_FIELD(NODE) \
1042 (DECL_C_BIT_FIELD (NODE) && !DECL_NAME (NODE))
1043
1044/* True iff TYPE is cv decltype(nullptr). */
1045#define NULLPTR_TYPE_P(TYPE) (TREE_CODE (TYPE) == NULLPTR_TYPE)
1046
1047/* Returns the underlying type of the given enumeration type. The
1048 underlying type is determined in different ways, depending on the
1049 properties of the enum:
1050
1051 - In C++0x or C23, the underlying type can be explicitly specified, e.g.,
1052
1053 enum E1 : char { ... } // underlying type is char
1054
1055 - In a C++0x scoped enumeration, the underlying type is int
1056 unless otherwises specified:
1057
1058 enum class E2 { ... } // underlying type is int
1059
1060 - Otherwise, the underlying type is determined based on the
1061 values of the enumerators. In this case, the
1062 ENUM_UNDERLYING_TYPE will not be set until after the definition
1063 of the enumeration is completed by finish_enum. */
1064#define ENUM_UNDERLYING_TYPE(TYPE) \
1065 TREE_TYPE (ENUMERAL_TYPE_CHECK (TYPE))
1066
1067/* Determines whether an ENUMERAL_TYPE has an explicit
1068 underlying type. */
1069#define ENUM_FIXED_UNDERLYING_TYPE_P(NODE) (TYPE_LANG_FLAG_5 (NODE))
1070
1071extern tree do_case (location_t, tree, tree, tree);
1072extern tree build_stmt (location_t, enum tree_code, ...);
1073extern tree build_real_imag_expr (location_t, enum tree_code, tree);
1074
1075/* These functions must be defined by each front-end which implements
1076 a variant of the C language. They are used in c-common.cc. */
1077
1078extern tree build_unary_op (location_t, enum tree_code, tree, bool);
1079extern tree build_binary_op (location_t, enum tree_code, tree, tree, bool);
1080extern tree perform_integral_promotions (tree);
1081
1082/* These functions must be defined by each front-end which implements
1083 a variant of the C language. They are used by port files. */
1084
1085extern tree default_conversion (tree);
1086
1087/* Given two integer or real types, return the type for their sum.
1088 Given two compatible ANSI C types, returns the merged type. */
1089
1090extern tree common_type (tree, tree);
1091
1092extern tree decl_constant_value (tree);
1093
1094/* Handle increment and decrement of boolean types. */
1095extern tree boolean_increment (enum tree_code, tree);
1096
1097extern int case_compare (splay_tree_key, splay_tree_key);
1098
1099extern tree c_add_case_label (location_t, splay_tree, tree, tree, tree,
1100 tree = NULL_TREE);
1101extern bool c_switch_covers_all_cases_p (splay_tree, tree);
1102extern bool c_block_may_fallthru (const_tree);
1103
1104extern tree build_function_call (location_t, tree, tree);
1105
1106extern tree build_function_call_vec (location_t, vec<location_t>, tree,
1107 vec<tree, va_gc> *, vec<tree, va_gc> *,
1108 tree = NULL_TREE);
1109
1110extern tree resolve_overloaded_builtin (location_t, tree, vec<tree, va_gc> *,
1111 bool = true);
1112
1113extern tree finish_label_address_expr (tree, location_t);
1114
1115/* Same function prototype, but the C and C++ front ends have
1116 different implementations. Used in c-common.cc. */
1117extern tree lookup_label (tree);
1118extern tree lookup_name (tree);
1119extern bool lvalue_p (const_tree);
1120extern int maybe_adjust_arg_pos_for_attribute (const_tree);
1121extern bool instantiation_dependent_expression_p (tree);
1122
1123extern bool vector_targets_convertible_p (const_tree t1, const_tree t2);
1124extern bool vector_types_convertible_p (const_tree t1, const_tree t2, bool emit_lax_note);
1125extern tree c_build_vec_perm_expr (location_t, tree, tree, tree, bool = true);
1126extern tree c_build_shufflevector (location_t, tree, tree,
1127 const vec<tree> &, bool = true);
1128extern tree c_build_vec_convert (location_t, tree, location_t, tree, bool = true);
1129
1130extern void init_c_lex (void);
1131
1132extern void c_cpp_builtins (cpp_reader *);
1133extern void c_cpp_builtins_optimize_pragma (cpp_reader *, tree, tree);
1134extern bool c_cpp_diagnostic (cpp_reader *, enum cpp_diagnostic_level,
1135 enum cpp_warning_reason, rich_location *,
1136 const char *, va_list *)
1137 ATTRIBUTE_GCC_DIAG(5,0);
1138extern int c_common_has_attribute (cpp_reader *, bool);
1139extern int c_common_has_builtin (cpp_reader *);
1140extern int c_common_has_feature (cpp_reader *, bool);
1141
1142/* Implemented by each front end in *-lang.cc. */
1143extern void c_family_register_lang_features ();
1144
1145/* Implemented in c-family/c-common.cc. */
1146extern void c_common_register_feature (const char *, bool);
1147extern bool has_feature_p (const char *, bool);
1148
1149extern bool parse_optimize_options (tree, bool);
1150
1151/* Positive if an implicit `extern "C"' scope has just been entered;
1152 negative if such a scope has just been exited. */
1153extern GTY(()) int pending_lang_change;
1154
1155/* Information recorded about each file examined during compilation. */
1156
1157struct c_fileinfo
1158{
1159 int time; /* Time spent in the file. */
1160
1161 /* Flags used only by C++.
1162 INTERFACE_ONLY nonzero means that we are in an "interface" section
1163 of the compiler. INTERFACE_UNKNOWN nonzero means we cannot trust
1164 the value of INTERFACE_ONLY. If INTERFACE_UNKNOWN is zero and
1165 INTERFACE_ONLY is zero, it means that we are responsible for
1166 exporting definitions that others might need. */
1167 short interface_only;
1168 short interface_unknown;
1169};
1170
1171struct c_fileinfo *get_fileinfo (const char *);
1172extern void dump_time_statistics (void);
1173
1174extern bool c_dump_tree (void *, tree);
1175
1176extern void verify_sequence_points (tree);
1177
1178extern tree fold_offsetof (tree, tree = size_type_node,
1179 tree_code ctx = ERROR_MARK);
1180
1181extern int complete_array_type (tree *, tree, bool);
1182extern void complete_flexible_array_elts (tree);
1183
1184extern tree builtin_type_for_size (int, bool);
1185
1186extern void c_common_mark_addressable_vec (tree);
1187
1188extern void set_underlying_type (tree);
1189extern bool user_facing_original_type_p (const_tree);
1190extern void record_types_used_by_current_var_decl (tree);
1191extern vec<tree, va_gc> *make_tree_vector (void);
1192extern void release_tree_vector (vec<tree, va_gc> *);
1193extern vec<tree, va_gc> *make_tree_vector_single (tree);
1194extern vec<tree, va_gc> *make_tree_vector_from_list (tree);
1195extern vec<tree, va_gc> *append_ctor_to_tree_vector (vec<tree, va_gc> *,
1196 tree);
1197extern vec<tree, va_gc> *make_tree_vector_from_ctor (tree);
1198extern vec<tree, va_gc> *make_tree_vector_copy (const vec<tree, va_gc> *);
1199
1200/* Used for communication between c_common_type_for_mode and
1201 c_register_builtin_type. */
1202extern GTY(()) tree registered_builtin_types;
1203
1204/* Read SOURCE_DATE_EPOCH from environment to have a deterministic
1205 timestamp to replace embedded current dates to get reproducible
1206 results. Returns -1 if SOURCE_DATE_EPOCH is not defined. */
1207extern time_t cb_get_source_date_epoch (cpp_reader *pfile);
1208
1209/* The value (as a unix timestamp) corresponds to date
1210 "Dec 31 9999 23:59:59 UTC", which is the latest date that __DATE__ and
1211 __TIME__ can store. */
1212#define MAX_SOURCE_DATE_EPOCH HOST_WIDE_INT_C (253402300799)
1213
1214/* Callback for libcpp for offering spelling suggestions for misspelled
1215 directives. */
1216extern const char *cb_get_suggestion (cpp_reader *, const char *,
1217 const char *const *);
1218
1219extern GTY(()) string_concat_db *g_string_concat_db;
1220
1221class substring_loc;
1222extern const char *c_get_substring_location (const substring_loc &substr_loc,
1223 location_t *out_loc);
1224
1225/* In c-gimplify.cc. */
1226typedef hash_map<tree, tree_pair,
1227 simple_hashmap_traits<tree_decl_hash,
1228 tree_pair>> bc_hash_map_t;
1229typedef struct bc_state
1230{
1231 tree bc_label[2];
1232 bc_hash_map_t *bc_hash_map;
1233} bc_state_t;
1234extern void save_bc_state (bc_state_t *);
1235extern void restore_bc_state (bc_state_t *);
1236extern tree c_genericize_control_stmt (tree *, int *, void *,
1237 walk_tree_fn, walk_tree_lh);
1238extern void c_genericize (tree);
1239extern int c_gimplify_expr (tree *, gimple_seq *, gimple_seq *);
1240extern tree c_build_bind_expr (location_t, tree, tree);
1241
1242/* In c-lex.cc. */
1243extern enum cpp_ttype
1244conflict_marker_get_final_tok_kind (enum cpp_ttype tok1_kind);
1245
1246/* In c-pch.cc */
1247extern void pch_init (void);
1248extern void pch_cpp_save_state (void);
1249extern int c_common_valid_pch (cpp_reader *pfile, const char *name, int fd);
1250extern void c_common_read_pch (cpp_reader *pfile, const char *name, int fd,
1251 const char *orig);
1252extern void c_common_write_pch (void);
1253extern void c_common_no_more_pch (void);
1254extern void c_common_pch_pragma (cpp_reader *pfile, const char *);
1255
1256/* In *-checksum.c */
1257extern const unsigned char executable_checksum[16];
1258
1259/* In c-cppbuiltin.cc */
1260extern void builtin_define_std (const char *macro);
1261extern void builtin_define_with_value (const char *, const char *, int);
1262extern void builtin_define_with_int_value (const char *, HOST_WIDE_INT);
1263extern void builtin_define_type_sizeof (const char *, tree);
1264extern void c_stddef_cpp_builtins (void);
1265extern void fe_file_change (const line_map_ordinary *);
1266extern void c_parse_error (const char *, enum cpp_ttype, tree, unsigned char,
1267 rich_location *richloc);
1268extern diagnostic_option_id get_option_for_builtin_define (const char *macro_name);
1269
1270/* In c-ppoutput.cc */
1271extern void init_pp_output (FILE *);
1272extern void preprocess_file (cpp_reader *);
1273extern void pp_file_change (const line_map_ordinary *);
1274extern void pp_dir_change (cpp_reader *, const char *);
1275extern bool check_missing_format_attribute (tree, tree);
1276extern void c_pp_stream_token (cpp_reader *, const cpp_token *, location_t loc);
1277
1278/* In c-omp.cc */
1279typedef wide_int_bitmask omp_clause_mask;
1280
1281#define OMP_CLAUSE_MASK_1 omp_clause_mask (1)
1282
1283enum c_omp_clause_split
1284{
1285 C_OMP_CLAUSE_SPLIT_TARGET = 0,
1286 C_OMP_CLAUSE_SPLIT_TEAMS,
1287 C_OMP_CLAUSE_SPLIT_DISTRIBUTE,
1288 C_OMP_CLAUSE_SPLIT_PARALLEL,
1289 C_OMP_CLAUSE_SPLIT_FOR,
1290 C_OMP_CLAUSE_SPLIT_SIMD,
1291 C_OMP_CLAUSE_SPLIT_COUNT,
1292 C_OMP_CLAUSE_SPLIT_SECTIONS = C_OMP_CLAUSE_SPLIT_FOR,
1293 C_OMP_CLAUSE_SPLIT_TASKLOOP = C_OMP_CLAUSE_SPLIT_FOR,
1294 C_OMP_CLAUSE_SPLIT_LOOP = C_OMP_CLAUSE_SPLIT_FOR,
1295 C_OMP_CLAUSE_SPLIT_MASKED = C_OMP_CLAUSE_SPLIT_DISTRIBUTE
1296};
1297
1298enum c_omp_region_type
1299{
1300 C_ORT_OMP = 1 << 0,
1301 C_ORT_ACC = 1 << 1,
1302 C_ORT_DECLARE_SIMD = 1 << 2,
1303 C_ORT_TARGET = 1 << 3,
1304 C_ORT_EXIT_DATA = 1 << 4,
1305 C_ORT_INTEROP = 1 << 5,
1306 C_ORT_DECLARE_MAPPER = 1 << 6,
1307 C_ORT_OMP_DECLARE_SIMD = C_ORT_OMP | C_ORT_DECLARE_SIMD,
1308 C_ORT_OMP_TARGET = C_ORT_OMP | C_ORT_TARGET,
1309 C_ORT_OMP_EXIT_DATA = C_ORT_OMP | C_ORT_EXIT_DATA,
1310 C_ORT_OMP_INTEROP = C_ORT_OMP | C_ORT_INTEROP,
1311 C_ORT_OMP_DECLARE_MAPPER = C_ORT_OMP | C_ORT_DECLARE_MAPPER,
1312 C_ORT_ACC_TARGET = C_ORT_ACC | C_ORT_TARGET
1313};
1314
1315extern tree c_finish_omp_master (location_t, tree);
1316extern tree c_finish_omp_masked (location_t, tree, tree);
1317extern tree c_finish_omp_taskgroup (location_t, tree, tree);
1318extern tree c_finish_omp_critical (location_t, tree, tree, tree);
1319extern tree c_finish_omp_ordered (location_t, tree, tree);
1320extern void c_finish_omp_barrier (location_t);
1321extern tree c_finish_omp_atomic (location_t, enum tree_code, enum tree_code,
1322 tree, tree, tree, tree, tree, tree, bool,
1323 enum omp_memory_order, bool, bool = false);
1324extern bool c_omp_interop_t_p (tree);
1325extern bool c_omp_depend_t_p (tree);
1326extern void c_finish_omp_depobj (location_t, tree, enum omp_clause_depend_kind,
1327 tree);
1328extern void c_finish_omp_flush (location_t, int);
1329extern void c_finish_omp_taskwait (location_t);
1330extern void c_finish_omp_taskyield (location_t);
1331extern tree c_finish_omp_for (location_t, enum tree_code, tree, tree, tree,
1332 tree, tree, tree, tree, bool);
1333extern int c_omp_find_generated_loop (tree &, int, walk_tree_lh);
1334extern bool c_omp_check_loop_iv (tree, tree, walk_tree_lh);
1335extern bool c_omp_check_loop_iv_exprs (location_t, enum tree_code, tree, int,
1336 tree, tree, tree, walk_tree_lh);
1337extern bool c_omp_check_loop_binding_exprs (tree, vec<tree> *);
1338extern tree c_finish_oacc_wait (location_t, tree, tree);
1339extern tree c_oacc_split_loop_clauses (tree, tree *, bool);
1340extern void c_omp_split_clauses (location_t, enum tree_code, omp_clause_mask,
1341 tree, tree *);
1342extern tree c_omp_declare_simd_clauses_to_numbers (tree, tree);
1343extern void c_omp_declare_simd_clauses_to_decls (tree, tree);
1344extern bool c_omp_predefined_variable (tree);
1345extern enum omp_clause_default_kind c_omp_predetermined_sharing (tree);
1346extern enum omp_clause_defaultmap_kind c_omp_predetermined_mapping (tree);
1347extern tree c_omp_check_context_selector (location_t, tree);
1348extern void c_omp_mark_declare_variant (location_t, tree, tree);
1349extern void c_omp_adjust_map_clauses (tree, bool);
1350template<typename T> struct omp_mapper_list;
1351extern void c_omp_find_nested_mappers (struct omp_mapper_list<tree> *, tree);
1352extern tree c_omp_instantiate_mappers (tree);
1353
1354namespace omp_addr_tokenizer { struct omp_addr_token; }
1355typedef omp_addr_tokenizer::omp_addr_token omp_addr_token;
1356
1357class c_omp_address_inspector
1358{
1359 location_t loc;
1360 tree root_term;
1361 bool indirections;
1362 int map_supported;
1363
1364protected:
1365 tree orig;
1366
1367public:
1368 c_omp_address_inspector (location_t loc, tree t)
1369 : loc (loc), root_term (NULL_TREE), indirections (false),
1370 map_supported (-1), orig (t)
1371 {
1372 }
1373
1374 ~c_omp_address_inspector ()
1375 {
1376 }
1377
1378 virtual bool processing_template_decl_p ()
1379 {
1380 return false;
1381 }
1382
1383 virtual void emit_unmappable_type_notes (tree)
1384 {
1385 }
1386
1387 virtual tree convert_from_reference (tree)
1388 {
1389 gcc_unreachable ();
1390 }
1391
1392 virtual tree build_array_ref (location_t loc, tree arr, tree idx)
1393 {
1394 tree eltype = TREE_TYPE (TREE_TYPE (arr));
1395 return build4_loc (loc, code: ARRAY_REF, type: eltype, arg0: arr, arg1: idx, NULL_TREE,
1396 NULL_TREE);
1397 }
1398
1399 virtual bool check_clause (tree);
1400 tree get_root_term (bool);
1401
1402 tree unconverted_ref_origin ();
1403 bool component_access_p ();
1404
1405 bool map_supported_p ();
1406
1407 tree get_origin (tree);
1408 tree maybe_unconvert_ref (tree);
1409
1410 bool maybe_zero_length_array_section (tree);
1411
1412 tree expand_array_base (tree, vec<omp_addr_token *> &, tree, unsigned *,
1413 c_omp_region_type);
1414 tree expand_component_selector (tree, vec<omp_addr_token *> &, tree,
1415 unsigned *, c_omp_region_type);
1416 tree expand_map_clause (tree, tree, vec<omp_addr_token *> &,
1417 c_omp_region_type);
1418};
1419
1420enum c_omp_directive_kind {
1421 C_OMP_DIR_STANDALONE,
1422 C_OMP_DIR_CONSTRUCT,
1423 C_OMP_DIR_DECLARATIVE,
1424 C_OMP_DIR_UTILITY,
1425 C_OMP_DIR_INFORMATIONAL,
1426 C_OMP_DIR_META
1427};
1428
1429struct c_omp_directive {
1430 const char *first, *second, *third;
1431 unsigned int id;
1432 enum c_omp_directive_kind kind;
1433 bool simd;
1434};
1435
1436extern const struct c_omp_directive c_omp_directives[];
1437extern const struct c_omp_directive *c_omp_categorize_directive (const char *,
1438 const char *,
1439 const char *);
1440extern tree c_omp_expand_variant_construct (vec<struct omp_variant> &);
1441
1442/* Return next tree in the chain for chain_next walking of tree nodes. */
1443inline tree
1444c_tree_chain_next (tree t)
1445{
1446 /* TREE_CHAIN of a type is TYPE_STUB_DECL, which is different
1447 kind of object, never a long chain of nodes. Prefer
1448 TYPE_NEXT_VARIANT for types. */
1449 if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_TYPE_COMMON))
1450 return TYPE_NEXT_VARIANT (t);
1451 /* Otherwise, if there is TREE_CHAIN, return it. */
1452 if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_COMMON))
1453 return TREE_CHAIN (t);
1454 return NULL;
1455}
1456
1457/* Return the hardbool attribute associated with TYPE, if there is one, provided
1458 that TYPE looks like an enumeral type that might have been set up by
1459 handle_hardbool_attribute. Return NULL otherwise.
1460
1461 If FALSE_VALUE or TRUE_VALUE are non-NULL and TYPE is a hardened boolean
1462 type, store the corresponding representation values. */
1463static inline tree
1464c_hardbool_type_attr (tree type,
1465 tree *false_value = NULL, tree *true_value = NULL)
1466{
1467 if (TREE_CODE (type) != ENUMERAL_TYPE
1468 || TYPE_LANG_SPECIFIC (type))
1469 return NULL_TREE;
1470
1471 return c_hardbool_type_attr_1 (type, false_value, true_value);
1472}
1473
1474/* Mask used by tm_stmt_attr. */
1475#define TM_STMT_ATTR_OUTER 2
1476#define TM_STMT_ATTR_ATOMIC 4
1477#define TM_STMT_ATTR_RELAXED 8
1478
1479/* Mask used by tm_attr_to_mask and tm_mask_to_attr. Note that these
1480 are ordered specifically such that more restrictive attributes are
1481 at lower bit positions. This fact is known by the C++ tm attribute
1482 inheritance code such that least bit extraction (mask & -mask) results
1483 in the most restrictive attribute. */
1484#define TM_ATTR_SAFE 1
1485#define TM_ATTR_CALLABLE 2
1486#define TM_ATTR_PURE 4
1487#define TM_ATTR_IRREVOCABLE 8
1488#define TM_ATTR_MAY_CANCEL_OUTER 16
1489
1490/* A suffix-identifier value doublet that represents user-defined literals
1491 for C++-0x. */
1492enum overflow_type {
1493 OT_UNDERFLOW = -1,
1494 OT_NONE,
1495 OT_OVERFLOW
1496};
1497
1498struct GTY(()) tree_userdef_literal {
1499 struct tree_base base;
1500 tree suffix_id;
1501 tree value;
1502 tree num_string;
1503 enum overflow_type overflow;
1504};
1505
1506#define USERDEF_LITERAL_SUFFIX_ID(NODE) \
1507 (((struct tree_userdef_literal *)USERDEF_LITERAL_CHECK (NODE))->suffix_id)
1508
1509#define USERDEF_LITERAL_VALUE(NODE) \
1510 (((struct tree_userdef_literal *)USERDEF_LITERAL_CHECK (NODE))->value)
1511
1512#define USERDEF_LITERAL_OVERFLOW(NODE) \
1513 (((struct tree_userdef_literal *)USERDEF_LITERAL_CHECK (NODE))->overflow)
1514
1515#define USERDEF_LITERAL_NUM_STRING(NODE) \
1516 (((struct tree_userdef_literal *)USERDEF_LITERAL_CHECK (NODE))->num_string)
1517
1518#define USERDEF_LITERAL_TYPE(NODE) \
1519 (TREE_TYPE (USERDEF_LITERAL_VALUE (NODE)))
1520
1521extern tree build_userdef_literal (tree suffix_id, tree value,
1522 enum overflow_type overflow,
1523 tree num_string);
1524
1525
1526/* WHILE_STMT accessors. These give access to the condition of the
1527 while statement, the body, and name of the while statement, and
1528 condition preparation statements and number of its nested cleanups,
1529 respectively. */
1530#define WHILE_COND(NODE) TREE_OPERAND (WHILE_STMT_CHECK (NODE), 0)
1531#define WHILE_BODY(NODE) TREE_OPERAND (WHILE_STMT_CHECK (NODE), 1)
1532#define WHILE_NAME(NODE) TREE_OPERAND (WHILE_STMT_CHECK (NODE), 2)
1533#define WHILE_COND_PREP(NODE) TREE_OPERAND (WHILE_STMT_CHECK (NODE), 3)
1534#define WHILE_COND_CLEANUP(NODE) TREE_OPERAND (WHILE_STMT_CHECK (NODE), 4)
1535
1536/* DO_STMT accessors. These give access to the condition of the do
1537 statement, the body and name of the do statement, respectively. */
1538#define DO_COND(NODE) TREE_OPERAND (DO_STMT_CHECK (NODE), 0)
1539#define DO_BODY(NODE) TREE_OPERAND (DO_STMT_CHECK (NODE), 1)
1540#define DO_NAME(NODE) TREE_OPERAND (DO_STMT_CHECK (NODE), 2)
1541
1542/* FOR_STMT accessors. These give access to the init statement,
1543 condition, update expression, body and name of the for statement,
1544 and condition preparation statements and number of its nested cleanups,
1545 respectively. */
1546#define FOR_INIT_STMT(NODE) TREE_OPERAND (FOR_STMT_CHECK (NODE), 0)
1547#define FOR_COND(NODE) TREE_OPERAND (FOR_STMT_CHECK (NODE), 1)
1548#define FOR_EXPR(NODE) TREE_OPERAND (FOR_STMT_CHECK (NODE), 2)
1549#define FOR_BODY(NODE) TREE_OPERAND (FOR_STMT_CHECK (NODE), 3)
1550#define FOR_SCOPE(NODE) TREE_OPERAND (FOR_STMT_CHECK (NODE), 4)
1551#define FOR_NAME(NODE) TREE_OPERAND (FOR_STMT_CHECK (NODE), 5)
1552#define FOR_COND_PREP(NODE) TREE_OPERAND (FOR_STMT_CHECK (NODE), 6)
1553#define FOR_COND_CLEANUP(NODE) TREE_OPERAND (FOR_STMT_CHECK (NODE), 7)
1554
1555/* BREAK_STMT accessors. */
1556#define BREAK_NAME(NODE) TREE_OPERAND (BREAK_STMT_CHECK (NODE), 0)
1557
1558/* CONTINUE_STMT accessors. */
1559#define CONTINUE_NAME(NODE) TREE_OPERAND (CONTINUE_STMT_CHECK (NODE), 0)
1560
1561#define SWITCH_STMT_COND(NODE) TREE_OPERAND (SWITCH_STMT_CHECK (NODE), 0)
1562#define SWITCH_STMT_BODY(NODE) TREE_OPERAND (SWITCH_STMT_CHECK (NODE), 1)
1563#define SWITCH_STMT_TYPE(NODE) TREE_OPERAND (SWITCH_STMT_CHECK (NODE), 2)
1564#define SWITCH_STMT_SCOPE(NODE) TREE_OPERAND (SWITCH_STMT_CHECK (NODE), 3)
1565#define SWITCH_STMT_NAME(NODE) TREE_OPERAND (SWITCH_STMT_CHECK (NODE), 4)
1566/* True if there are case labels for all possible values of switch cond, either
1567 because there is a default: case label or because the case label ranges cover
1568 all values. */
1569#define SWITCH_STMT_ALL_CASES_P(NODE) \
1570 TREE_LANG_FLAG_0 (SWITCH_STMT_CHECK (NODE))
1571/* True if the body of a switch stmt contains no BREAK_STMTs. */
1572#define SWITCH_STMT_NO_BREAK_P(NODE) \
1573 TREE_LANG_FLAG_2 (SWITCH_STMT_CHECK (NODE))
1574
1575
1576/* Nonzero if NODE is the target for genericization of 'break' stmts. */
1577#define LABEL_DECL_BREAK(NODE) \
1578 DECL_LANG_FLAG_0 (LABEL_DECL_CHECK (NODE))
1579
1580/* Nonzero if NODE is the target for genericization of 'continue' stmts. */
1581#define LABEL_DECL_CONTINUE(NODE) \
1582 DECL_LANG_FLAG_1 (LABEL_DECL_CHECK (NODE))
1583
1584extern bool convert_vector_to_array_for_subscript (location_t, tree *, tree);
1585
1586/* Possibe cases of scalar_to_vector conversion. */
1587enum stv_conv {
1588 stv_error, /* Error occurred. */
1589 stv_nothing, /* Nothing happened. */
1590 stv_firstarg, /* First argument must be expanded. */
1591 stv_secondarg /* Second argument must be expanded. */
1592};
1593
1594extern enum stv_conv scalar_to_vector (location_t loc, enum tree_code code,
1595 tree op0, tree op1, bool);
1596
1597extern tree find_inv_trees (tree *, int *, void *);
1598extern tree replace_inv_trees (tree *, int *, void *);
1599
1600extern bool reject_gcc_builtin (const_tree, location_t = UNKNOWN_LOCATION);
1601extern bool valid_array_size_p (location_t, const_tree, tree, bool = true);
1602extern void invalid_array_size_error (location_t, cst_size_error,
1603 const_tree, const_tree);
1604
1605/* In c-warn.cc. */
1606extern void constant_expression_warning (tree);
1607extern void constant_expression_error (tree);
1608extern void overflow_warning (location_t, tree, tree = NULL_TREE);
1609extern void warn_logical_operator (location_t, enum tree_code, tree,
1610 enum tree_code, tree, enum tree_code, tree);
1611extern void warn_tautological_cmp (const op_location_t &, enum tree_code,
1612 tree, tree);
1613extern void warn_logical_not_parentheses (location_t, enum tree_code, tree,
1614 tree);
1615extern bool warn_if_unused_value (const_tree, location_t, bool = false);
1616extern bool strict_aliasing_warning (location_t, tree, tree);
1617extern void sizeof_pointer_memaccess_warning (location_t *, tree,
1618 vec<tree, va_gc> *, tree *,
1619 bool (*) (tree, tree));
1620extern void check_main_parameter_types (tree decl);
1621extern void warnings_for_convert_and_check (location_t, tree, tree, tree);
1622extern void c_do_switch_warnings (splay_tree, location_t, tree, tree, bool);
1623extern void warn_for_omitted_condop (location_t, tree);
1624extern bool warn_for_restrict (unsigned, tree *, unsigned);
1625extern void warn_for_address_of_packed_member (tree, tree);
1626extern void warn_parm_array_mismatch (location_t, tree, tree);
1627extern void maybe_warn_sizeof_array_div (location_t, tree, tree, tree, tree);
1628extern void do_warn_array_compare (location_t, tree_code, tree, tree);
1629
1630/* Places where an lvalue, or modifiable lvalue, may be required.
1631 Used to select diagnostic messages in lvalue_error and
1632 readonly_error. */
1633enum lvalue_use {
1634 lv_assign,
1635 lv_increment,
1636 lv_decrement,
1637 lv_addressof,
1638 lv_asm
1639};
1640
1641extern void lvalue_error (location_t, enum lvalue_use);
1642extern void invalid_indirection_error (location_t, tree, ref_operator);
1643extern void readonly_error (location_t, tree, enum lvalue_use);
1644extern void warn_array_subscript_with_type_char (location_t, tree);
1645extern void warn_about_parentheses (location_t,
1646 enum tree_code,
1647 enum tree_code, tree,
1648 enum tree_code, tree);
1649extern void warn_for_unused_label (tree label);
1650extern void warn_for_div_by_zero (location_t, tree divisor);
1651extern void warn_for_memset (location_t, tree, tree, int);
1652extern void warn_for_calloc (location_t *, tree, vec<tree, va_gc> *,
1653 tree *, tree);
1654extern void warn_for_alloc_size (location_t, tree, tree, tree);
1655extern void warn_for_sign_compare (location_t,
1656 tree orig_op0, tree orig_op1,
1657 tree op0, tree op1,
1658 tree result_type,
1659 enum tree_code resultcode);
1660extern void do_warn_double_promotion (tree, tree, tree, const char *,
1661 location_t);
1662extern void do_warn_unused_parameter (tree);
1663extern void record_locally_defined_typedef (tree);
1664extern void maybe_record_typedef_use (tree);
1665extern void maybe_warn_unused_local_typedefs (void);
1666extern void maybe_warn_bool_compare (location_t, enum tree_code, tree, tree);
1667extern bool maybe_warn_shift_overflow (location_t, tree, tree);
1668extern void warn_duplicated_cond_add_or_warn (location_t, tree, vec<tree> **);
1669extern bool diagnose_mismatched_attributes (tree, tree);
1670extern tree do_warn_duplicated_branches_r (tree *, int *, void *);
1671extern void warn_for_multistatement_macros (location_t, location_t,
1672 location_t, enum rid);
1673
1674extern void check_for_xor_used_as_pow (location_t lhs_loc, tree lhs_val,
1675 location_t operator_loc,
1676 location_t rhs_loc, tree rhs_val);
1677
1678/* In c-attribs.cc. */
1679extern bool attribute_takes_identifier_p (const_tree);
1680extern tree handle_deprecated_attribute (tree *, tree, tree, int, bool *);
1681extern tree handle_unused_attribute (tree *, tree, tree, int, bool *);
1682extern tree handle_fallthrough_attribute (tree *, tree, tree, int, bool *);
1683extern int parse_tm_stmt_attr (tree, int);
1684extern int tm_attr_to_mask (tree);
1685extern tree tm_mask_to_attr (int);
1686extern tree find_tm_attribute (tree);
1687extern const struct attribute_spec::exclusions attr_aligned_exclusions[];
1688extern const struct attribute_spec::exclusions attr_cold_hot_exclusions[];
1689extern const struct attribute_spec::exclusions attr_noreturn_exclusions[];
1690extern tree handle_aligned_attribute (tree *, tree, tree, int, bool *);
1691extern tree handle_noreturn_attribute (tree *, tree, tree, int, bool *);
1692extern tree handle_musttail_attribute (tree *, tree, tree, int, bool *);
1693extern bool has_attribute (location_t, tree, tree, tree (*)(tree));
1694extern tree build_attr_access_from_parms (tree, bool);
1695extern void set_musttail_on_return (tree, location_t, bool);
1696
1697/* In c-format.cc. */
1698extern bool valid_format_string_type_p (tree);
1699
1700/* A bitmap of flags to positional_argument. */
1701enum posargflags {
1702 /* Consider positional attribute argument value zero valid. */
1703 POSARG_ZERO = 1,
1704 /* Consider positional attribute argument value valid if it refers
1705 to the ellipsis (i.e., beyond the last typed argument). */
1706 POSARG_ELLIPSIS = 2
1707};
1708
1709extern tree positional_argument (const_tree, const_tree, tree &, tree_code,
1710 int = 0, int = posargflags ());
1711
1712extern enum flt_eval_method
1713excess_precision_mode_join (enum flt_eval_method, enum flt_eval_method);
1714
1715extern int c_flt_eval_method (bool ts18661_p);
1716extern void add_no_sanitize_value (tree node, unsigned int flags);
1717
1718extern void maybe_add_include_fixit (rich_location *, const char *, bool);
1719extern void maybe_suggest_missing_token_insertion (rich_location *richloc,
1720 enum cpp_ttype token_type,
1721 location_t prev_token_loc);
1722extern void maybe_emit_indirection_note (location_t loc,
1723 tree expr, tree expected_type);
1724extern bool compatible_types_for_indirection_note_p (tree type1, tree type2);
1725
1726extern tree braced_lists_to_strings (tree, tree);
1727
1728#if CHECKING_P
1729namespace selftest {
1730 /* Declarations for specific families of tests within c-family,
1731 by source file, in alphabetical order. */
1732 extern void c_diagnostic_cc_tests (void);
1733 extern void c_format_cc_tests (void);
1734 extern void c_indentation_cc_tests (void);
1735 extern void c_opt_problem_cc_tests (void);
1736 extern void c_pretty_print_cc_tests (void);
1737 extern void c_spellcheck_cc_tests (void);
1738
1739 /* The entrypoint for running all of the above tests. */
1740 extern void c_family_tests (void);
1741} // namespace selftest
1742#endif /* #if CHECKING_P */
1743
1744#endif /* ! GCC_C_COMMON_H */
1745

Provided by KDAB

Privacy Policy
Learn to use CMake with our Intro Training
Find out more

source code of gcc/c-family/c-common.h