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