sdcc/support/cpp/gcc/c-family/c-common.h

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