gcc/c-family/c-common.h

   1 /* Definitions for c-common.c.
   2    Copyright (C) 1987-2016 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
  29 /* In order for the format checking to accept the C frontend
  30    diagnostic framework extensions, you must include this file before
  31    diagnostic-core.h, not after.  The C front end formats are a subset of those
  32    for C++, so they are the appropriate set to use in common code;
  33    cp-tree.h overrides this for C++.  */
  34 #if defined(GCC_DIAGNOSTIC_CORE_H)
  35 #error \
  36 In order for the format checking to accept the C front end diagnostic \
  37 framework extensions, you must include this file before diagnostic-core.h \
  38 never after.
  39 #endif
  40 #ifndef GCC_DIAG_STYLE
  41 #define GCC_DIAG_STYLE __gcc_cdiag__
  42 #endif
  43 #include "diagnostic-core.h"
  44
  45 /* Usage of TREE_LANG_FLAG_?:
  46    0: IDENTIFIER_MARKED (used by search routines).
  47       C_MAYBE_CONST_EXPR_INT_OPERANDS (in C_MAYBE_CONST_EXPR, for C)
  48    1: C_DECLARED_LABEL_FLAG (in LABEL_DECL)
  49       STATEMENT_LIST_STMT_EXPR (in STATEMENT_LIST)
  50       C_MAYBE_CONST_EXPR_NON_CONST (in C_MAYBE_CONST_EXPR, for C)
  51    2: unused
  52    3: STATEMENT_LIST_HAS_LABEL (in STATEMENT_LIST)
  53    4: unused
  54 */
  55
  56 /* Reserved identifiers.  This is the union of all the keywords for C,
  57    C++, and Objective-C.  All the type modifiers have to be in one
  58    block at the beginning, because they are used as mask bits.  There
  59    are 28 type modifiers; if we add many more we will have to redesign
  60    the mask mechanism.  */
  61
  62 enum rid
  63 {
  64   /* Modifiers: */
  65   /* C, in empirical order of frequency.  */
  66   RID_STATIC = 0,
  67   RID_UNSIGNED, RID_LONG,    RID_CONST, RID_EXTERN,
  68   RID_REGISTER, RID_TYPEDEF, RID_SHORT, RID_INLINE,
  69   RID_VOLATILE, RID_SIGNED,  RID_AUTO,  RID_RESTRICT,
  70   RID_NORETURN, RID_ATOMIC,
  71
  72   /* C extensions */
  73   RID_COMPLEX, RID_THREAD, RID_SAT,
  74
  75   /* C++ */
  76   RID_FRIEND, RID_VIRTUAL, RID_EXPLICIT, RID_EXPORT, RID_MUTABLE,
  77
  78   /* ObjC ("PQ" reserved words - they do not appear after a '@' and
  79      are keywords only in specific contexts)  */
  80   RID_IN, RID_OUT, RID_INOUT, RID_BYCOPY, RID_BYREF, RID_ONEWAY,
  81
  82   /* ObjC ("PATTR" reserved words - they do not appear after a '@'
  83      and are keywords only as property attributes)  */
  84   RID_GETTER, RID_SETTER,
  85   RID_READONLY, RID_READWRITE,
  86   RID_ASSIGN, RID_RETAIN, RID_COPY,
  87   RID_NONATOMIC,
  88
  89   /* C (reserved and imaginary types not implemented, so any use is a
  90      syntax error) */
  91   RID_IMAGINARY,
  92
  93   /* C */
  94   RID_INT,     RID_CHAR,   RID_FLOAT,    RID_DOUBLE, RID_VOID,
  95   RID_ENUM,    RID_STRUCT, RID_UNION,    RID_IF,     RID_ELSE,
  96   RID_WHILE,   RID_DO,     RID_FOR,      RID_SWITCH, RID_CASE,
  97   RID_DEFAULT, RID_BREAK,  RID_CONTINUE, RID_RETURN, RID_GOTO,
  98   RID_SIZEOF,
  99
 100   /* C extensions */
 101   RID_ASM,       RID_TYPEOF,   RID_ALIGNOF,  RID_ATTRIBUTE,  RID_VA_ARG,
 102   RID_EXTENSION, RID_IMAGPART, RID_REALPART, RID_LABEL,      RID_CHOOSE_EXPR,
 103   RID_TYPES_COMPATIBLE_P,      RID_BUILTIN_COMPLEX,          RID_BUILTIN_SHUFFLE,
 104   RID_DFLOAT32, RID_DFLOAT64, RID_DFLOAT128,
 105   RID_FRACT, RID_ACCUM, RID_AUTO_TYPE, RID_BUILTIN_CALL_WITH_STATIC_CHAIN,
 106
 107   /* C11 */
 108   RID_ALIGNAS, RID_GENERIC,
 109
 110   /* This means to warn that this is a C++ keyword, and then treat it
 111      as a normal identifier.  */
 112   RID_CXX_COMPAT_WARN,
 113
 114   /* GNU transactional memory extension */
 115   RID_TRANSACTION_ATOMIC, RID_TRANSACTION_RELAXED, RID_TRANSACTION_CANCEL,
 116
 117   /* Too many ways of getting the name of a function as a string */
 118   RID_FUNCTION_NAME, RID_PRETTY_FUNCTION_NAME, RID_C99_FUNCTION_NAME,
 119
 120   /* C++ (some of these are keywords in Objective-C as well, but only
 121      if they appear after a '@') */
 122   RID_BOOL,     RID_WCHAR,    RID_CLASS,
 123   RID_PUBLIC,   RID_PRIVATE,  RID_PROTECTED,
 124   RID_TEMPLATE, RID_NULL,     RID_CATCH,
 125   RID_DELETE,   RID_FALSE,    RID_NAMESPACE,
 126   RID_NEW,      RID_OFFSETOF, RID_OPERATOR,
 127   RID_THIS,     RID_THROW,    RID_TRUE,
 128   RID_TRY,      RID_TYPENAME, RID_TYPEID,
 129   RID_USING,    RID_CHAR16,   RID_CHAR32,
 130
 131   /* casts */
 132   RID_CONSTCAST, RID_DYNCAST, RID_REINTCAST, RID_STATCAST,
 133
 134   /* C++ extensions */
 135   RID_BASES,                   RID_DIRECT_BASES,
 136   RID_HAS_NOTHROW_ASSIGN,      RID_HAS_NOTHROW_CONSTRUCTOR,
 137   RID_HAS_NOTHROW_COPY,        RID_HAS_TRIVIAL_ASSIGN,
 138   RID_HAS_TRIVIAL_CONSTRUCTOR, RID_HAS_TRIVIAL_COPY,
 139   RID_HAS_TRIVIAL_DESTRUCTOR,  RID_HAS_VIRTUAL_DESTRUCTOR,
 140   RID_IS_ABSTRACT,             RID_IS_BASE_OF,
 141   RID_IS_CLASS,
 142   RID_IS_EMPTY,                RID_IS_ENUM,
 143   RID_IS_FINAL,                RID_IS_LITERAL_TYPE,
 144   RID_IS_POD,                  RID_IS_POLYMORPHIC,
 145   RID_IS_SAME_AS,
 146   RID_IS_STD_LAYOUT,           RID_IS_TRIVIAL,
 147   RID_IS_TRIVIALLY_ASSIGNABLE, RID_IS_TRIVIALLY_CONSTRUCTIBLE,
 148   RID_IS_TRIVIALLY_COPYABLE,
 149   RID_IS_UNION,                RID_UNDERLYING_TYPE,
 150
 151   /* C++11 */
 152   RID_CONSTEXPR, RID_DECLTYPE, RID_NOEXCEPT, RID_NULLPTR, RID_STATIC_ASSERT,
 153
 154   /* C++ concepts */
 155   RID_CONCEPT, RID_REQUIRES,
 156
 157   /* C++ transactional memory.  */
 158   RID_ATOMIC_NOEXCEPT, RID_ATOMIC_CANCEL, RID_SYNCHRONIZED,
 159
 160   /* Cilk Plus keywords.  */
 161   RID_CILK_SPAWN, RID_CILK_SYNC, RID_CILK_FOR,
 162
 163   /* Objective-C ("AT" reserved words - they are only keywords when
 164      they follow '@')  */
 165   RID_AT_ENCODE,   RID_AT_END,
 166   RID_AT_CLASS,    RID_AT_ALIAS,     RID_AT_DEFS,
 167   RID_AT_PRIVATE,  RID_AT_PROTECTED, RID_AT_PUBLIC,  RID_AT_PACKAGE,
 168   RID_AT_PROTOCOL, RID_AT_SELECTOR,
 169   RID_AT_THROW,    RID_AT_TRY,       RID_AT_CATCH,
 170   RID_AT_FINALLY,  RID_AT_SYNCHRONIZED,
 171   RID_AT_OPTIONAL, RID_AT_REQUIRED, RID_AT_PROPERTY,
 172   RID_AT_SYNTHESIZE, RID_AT_DYNAMIC,
 173   RID_AT_INTERFACE,
 174   RID_AT_IMPLEMENTATION,
 175
 176   /* Named address support, mapping the keyword to a particular named address
 177      number.  Named address space 0 is reserved for the generic address.  If
 178      there are more than 254 named addresses, the addr_space_t type will need
 179      to be grown from an unsigned char to unsigned short.  */
 180   RID_ADDR_SPACE_0,             /* generic address */
 181   RID_ADDR_SPACE_1,
 182   RID_ADDR_SPACE_2,
 183   RID_ADDR_SPACE_3,
 184   RID_ADDR_SPACE_4,
 185   RID_ADDR_SPACE_5,
 186   RID_ADDR_SPACE_6,
 187   RID_ADDR_SPACE_7,
 188   RID_ADDR_SPACE_8,
 189   RID_ADDR_SPACE_9,
 190   RID_ADDR_SPACE_10,
 191   RID_ADDR_SPACE_11,
 192   RID_ADDR_SPACE_12,
 193   RID_ADDR_SPACE_13,
 194   RID_ADDR_SPACE_14,
 195   RID_ADDR_SPACE_15,
 196
 197   RID_FIRST_ADDR_SPACE = RID_ADDR_SPACE_0,
 198   RID_LAST_ADDR_SPACE = RID_ADDR_SPACE_15,
 199
 200   /* __intN keywords.  The _N_M here doesn't correspond to the intN
 201      in the keyword; use the bitsize in int_n_t_data_t[M] for that.
 202      For example, if int_n_t_data_t[0].bitsize is 13, then RID_INT_N_0
 203      is for __int13.  */
 204
 205   /* Note that the range to use is RID_FIRST_INT_N through
 206      RID_FIRST_INT_N + NUM_INT_N_ENTS - 1 and c-parser.c has a list of
 207      all RID_INT_N_* in a case statement.  */
 208
 209   RID_INT_N_0,
 210   RID_INT_N_1,
 211   RID_INT_N_2,
 212   RID_INT_N_3,
 213
 214   RID_FIRST_INT_N = RID_INT_N_0,
 215   RID_LAST_INT_N = RID_INT_N_3,
 216
 217   RID_MAX,
 218
 219   RID_FIRST_MODIFIER = RID_STATIC,
 220   RID_LAST_MODIFIER = RID_ONEWAY,
 221
 222   RID_FIRST_CXX11 = RID_CONSTEXPR,
 223   RID_LAST_CXX11 = RID_STATIC_ASSERT,
 224   RID_FIRST_AT = RID_AT_ENCODE,
 225   RID_LAST_AT = RID_AT_IMPLEMENTATION,
 226   RID_FIRST_PQ = RID_IN,
 227   RID_LAST_PQ = RID_ONEWAY,
 228   RID_FIRST_PATTR = RID_GETTER,
 229   RID_LAST_PATTR = RID_NONATOMIC
 230 };
 231
 232 #define OBJC_IS_AT_KEYWORD(rid) \
 233   ((unsigned int) (rid) >= (unsigned int) RID_FIRST_AT && \
 234    (unsigned int) (rid) <= (unsigned int) RID_LAST_AT)
 235
 236 #define OBJC_IS_PQ_KEYWORD(rid) \
 237   ((unsigned int) (rid) >= (unsigned int) RID_FIRST_PQ && \
 238    (unsigned int) (rid) <= (unsigned int) RID_LAST_PQ)
 239
 240 #define OBJC_IS_PATTR_KEYWORD(rid) \
 241   ((unsigned int) (rid) >= (unsigned int) RID_FIRST_PATTR && \
 242    (unsigned int) (rid) <= (unsigned int) RID_LAST_PATTR)
 243
 244 /* OBJC_IS_CXX_KEYWORD recognizes the 'CXX_OBJC' keywords (such as
 245    'class') which are shared in a subtle way between Objective-C and
 246    C++.  When the lexer is lexing in Objective-C/Objective-C++, if it
 247    finds '@' followed by one of these identifiers (eg, '@class'), it
 248    recognizes the whole as an Objective-C keyword.  If the identifier
 249    is found elsewhere, it follows the rules of the C/C++ language.
 250  */
 251 #define OBJC_IS_CXX_KEYWORD(rid) \
 252   (rid == RID_CLASS || rid == RID_SYNCHRONIZED                  \
 253    || rid == RID_PUBLIC || rid == RID_PROTECTED || rid == RID_PRIVATE   \
 254    || rid == RID_TRY || rid == RID_THROW || rid == RID_CATCH)
 255
 256 /* The elements of `ridpointers' are identifier nodes for the reserved
 257    type names and storage classes.  It is indexed by a RID_... value.  */
 258 extern GTY ((length ("(int) RID_MAX"))) tree *ridpointers;
 259
 260 /* Standard named or nameless data types of the C compiler.  */
 261
 262 enum c_tree_index
 263 {
 264     CTI_CHAR16_TYPE,
 265     CTI_CHAR32_TYPE,
 266     CTI_WCHAR_TYPE,
 267     CTI_UNDERLYING_WCHAR_TYPE,
 268     CTI_WINT_TYPE,
 269     CTI_SIGNED_SIZE_TYPE, /* For format checking only.  */
 270     CTI_UNSIGNED_PTRDIFF_TYPE, /* For format checking only.  */
 271     CTI_INTMAX_TYPE,
 272     CTI_UINTMAX_TYPE,
 273     CTI_WIDEST_INT_LIT_TYPE,
 274     CTI_WIDEST_UINT_LIT_TYPE,
 275
 276     /* Types for <stdint.h>, that may not be defined on all
 277        targets.  */
 278     CTI_SIG_ATOMIC_TYPE,
 279     CTI_INT8_TYPE,
 280     CTI_INT16_TYPE,
 281     CTI_INT32_TYPE,
 282     CTI_INT64_TYPE,
 283     CTI_UINT8_TYPE,
 284     CTI_UINT16_TYPE,
 285     CTI_UINT32_TYPE,
 286     CTI_UINT64_TYPE,
 287     CTI_INT_LEAST8_TYPE,
 288     CTI_INT_LEAST16_TYPE,
 289     CTI_INT_LEAST32_TYPE,
 290     CTI_INT_LEAST64_TYPE,
 291     CTI_UINT_LEAST8_TYPE,
 292     CTI_UINT_LEAST16_TYPE,
 293     CTI_UINT_LEAST32_TYPE,
 294     CTI_UINT_LEAST64_TYPE,
 295     CTI_INT_FAST8_TYPE,
 296     CTI_INT_FAST16_TYPE,
 297     CTI_INT_FAST32_TYPE,
 298     CTI_INT_FAST64_TYPE,
 299     CTI_UINT_FAST8_TYPE,
 300     CTI_UINT_FAST16_TYPE,
 301     CTI_UINT_FAST32_TYPE,
 302     CTI_UINT_FAST64_TYPE,
 303     CTI_INTPTR_TYPE,
 304     CTI_UINTPTR_TYPE,
 305
 306     CTI_CHAR_ARRAY_TYPE,
 307     CTI_CHAR16_ARRAY_TYPE,
 308     CTI_CHAR32_ARRAY_TYPE,
 309     CTI_WCHAR_ARRAY_TYPE,
 310     CTI_STRING_TYPE,
 311     CTI_CONST_STRING_TYPE,
 312
 313     /* Type for boolean expressions (bool in C++, int in C).  */
 314     CTI_TRUTHVALUE_TYPE,
 315     CTI_TRUTHVALUE_TRUE,
 316     CTI_TRUTHVALUE_FALSE,
 317
 318     CTI_DEFAULT_FUNCTION_TYPE,
 319
 320     /* These are not types, but we have to look them up all the time.  */
 321     CTI_FUNCTION_NAME_DECL,
 322     CTI_PRETTY_FUNCTION_NAME_DECL,
 323     CTI_C99_FUNCTION_NAME_DECL,
 324     CTI_SAVED_FUNCTION_NAME_DECLS,
 325
 326     CTI_NULL,
 327
 328     CTI_MAX
 329 };
 330
 331 #define C_CPP_HASHNODE(id) \
 332   (&(((struct c_common_identifier *) (id))->node))
 333 #define C_RID_CODE(id) \
 334   ((enum rid) (((struct c_common_identifier *) (id))->node.rid_code))
 335 #define C_SET_RID_CODE(id, code) \
 336   (((struct c_common_identifier *) (id))->node.rid_code = (unsigned char) code)
 337
 338 /* Identifier part common to the C front ends.  Inherits from
 339    tree_identifier, despite appearances.  */
 340 struct GTY(()) c_common_identifier {
 341   struct tree_common common;
 342   struct cpp_hashnode node;
 343 };
 344
 345 /* An entry in the reserved keyword table.  */
 346
 347 struct c_common_resword
 348 {
 349   const char *const word;
 350   ENUM_BITFIELD(rid) const rid : 16;
 351   const unsigned int disable   : 16;
 352 };
 353
 354 /* Mode used to build pointers (VOIDmode means ptr_mode).  */
 355
 356 extern machine_mode c_default_pointer_mode;
 357
 358 /* Extra cpp_ttype values for C++.  */
 359
 360 /* A token type for template-ids.  If a template-id is processed while
 361    parsing tentatively, it is replaced with a CPP_TEMPLATE_ID token;
 362    the value of the CPP_TEMPLATE_ID is whatever was returned by
 363    cp_parser_template_id.  */
 364 #define CPP_TEMPLATE_ID ((enum cpp_ttype) (CPP_KEYWORD + 1))
 365
 366 /* A token type for nested-name-specifiers.  If a
 367    nested-name-specifier is processed while parsing tentatively, it is
 368    replaced with a CPP_NESTED_NAME_SPECIFIER token; the value of the
 369    CPP_NESTED_NAME_SPECIFIER is whatever was returned by
 370    cp_parser_nested_name_specifier_opt.  */
 371 #define CPP_NESTED_NAME_SPECIFIER ((enum cpp_ttype) (CPP_TEMPLATE_ID + 1))
 372
 373 /* A token type for pre-parsed C++0x decltype.  */
 374 #define CPP_DECLTYPE ((enum cpp_ttype) (CPP_NESTED_NAME_SPECIFIER + 1))
 375
 376 /* A token type for pre-parsed primary-expression (lambda- or statement-).  */
 377 #define CPP_PREPARSED_EXPR ((enum cpp_ttype) (CPP_DECLTYPE + 1))
 378
 379 /* The number of token types, including C++-specific ones.  */
 380 #define N_CP_TTYPES ((int) (CPP_PREPARSED_EXPR + 1))
 381
 382 /* Disable mask.  Keywords are disabled if (reswords[i].disable &
 383    mask) is _true_.  Thus for keywords which are present in all
 384    languages the disable field is zero.  */
 385
 386 #define D_CONLY         0x001   /* C only (not in C++).  */
 387 #define D_CXXONLY       0x002   /* C++ only (not in C).  */
 388 #define D_C99           0x004   /* In C, C99 only.  */
 389 #define D_CXX11         0x008   /* In C++, C++11 only.  */
 390 #define D_EXT           0x010   /* GCC extension.  */
 391 #define D_EXT89         0x020   /* GCC extension incorporated in C99.  */
 392 #define D_ASM           0x040   /* Disabled by -fno-asm.  */
 393 #define D_OBJC          0x080   /* In Objective C and neither C nor C++.  */
 394 #define D_CXX_OBJC      0x100   /* In Objective C, and C++, but not C.  */
 395 #define D_CXXWARN       0x200   /* In C warn with -Wcxx-compat.  */
 396 #define D_CXX_CONCEPTS  0x400   /* In C++, only with concepts. */
 397 #define D_TRANSMEM      0X800   /* C++ transactional memory TS.  */
 398
 399 #define D_CXX_CONCEPTS_FLAGS D_CXXONLY | D_CXX_CONCEPTS
 400
 401 /* The reserved keyword table.  */
 402 extern const struct c_common_resword c_common_reswords[];
 403
 404 /* The number of items in the reserved keyword table.  */
 405 extern const unsigned int num_c_common_reswords;
 406
 407 #define char16_type_node                c_global_trees[CTI_CHAR16_TYPE]
 408 #define char32_type_node                c_global_trees[CTI_CHAR32_TYPE]
 409 #define wchar_type_node                 c_global_trees[CTI_WCHAR_TYPE]
 410 #define underlying_wchar_type_node      c_global_trees[CTI_UNDERLYING_WCHAR_TYPE]
 411 #define wint_type_node                  c_global_trees[CTI_WINT_TYPE]
 412 #define signed_size_type_node           c_global_trees[CTI_SIGNED_SIZE_TYPE]
 413 #define unsigned_ptrdiff_type_node      c_global_trees[CTI_UNSIGNED_PTRDIFF_TYPE]
 414 #define intmax_type_node                c_global_trees[CTI_INTMAX_TYPE]
 415 #define uintmax_type_node               c_global_trees[CTI_UINTMAX_TYPE]
 416 #define widest_integer_literal_type_node c_global_trees[CTI_WIDEST_INT_LIT_TYPE]
 417 #define widest_unsigned_literal_type_node c_global_trees[CTI_WIDEST_UINT_LIT_TYPE]
 418
 419 #define sig_atomic_type_node            c_global_trees[CTI_SIG_ATOMIC_TYPE]
 420 #define int8_type_node                  c_global_trees[CTI_INT8_TYPE]
 421 #define int16_type_node                 c_global_trees[CTI_INT16_TYPE]
 422 #define int32_type_node                 c_global_trees[CTI_INT32_TYPE]
 423 #define int64_type_node                 c_global_trees[CTI_INT64_TYPE]
 424 #define uint8_type_node                 c_global_trees[CTI_UINT8_TYPE]
 425 #define c_uint16_type_node              c_global_trees[CTI_UINT16_TYPE]
 426 #define c_uint32_type_node              c_global_trees[CTI_UINT32_TYPE]
 427 #define c_uint64_type_node              c_global_trees[CTI_UINT64_TYPE]
 428 #define int_least8_type_node            c_global_trees[CTI_INT_LEAST8_TYPE]
 429 #define int_least16_type_node           c_global_trees[CTI_INT_LEAST16_TYPE]
 430 #define int_least32_type_node           c_global_trees[CTI_INT_LEAST32_TYPE]
 431 #define int_least64_type_node           c_global_trees[CTI_INT_LEAST64_TYPE]
 432 #define uint_least8_type_node           c_global_trees[CTI_UINT_LEAST8_TYPE]
 433 #define uint_least16_type_node          c_global_trees[CTI_UINT_LEAST16_TYPE]
 434 #define uint_least32_type_node          c_global_trees[CTI_UINT_LEAST32_TYPE]
 435 #define uint_least64_type_node          c_global_trees[CTI_UINT_LEAST64_TYPE]
 436 #define int_fast8_type_node             c_global_trees[CTI_INT_FAST8_TYPE]
 437 #define int_fast16_type_node            c_global_trees[CTI_INT_FAST16_TYPE]
 438 #define int_fast32_type_node            c_global_trees[CTI_INT_FAST32_TYPE]
 439 #define int_fast64_type_node            c_global_trees[CTI_INT_FAST64_TYPE]
 440 #define uint_fast8_type_node            c_global_trees[CTI_UINT_FAST8_TYPE]
 441 #define uint_fast16_type_node           c_global_trees[CTI_UINT_FAST16_TYPE]
 442 #define uint_fast32_type_node           c_global_trees[CTI_UINT_FAST32_TYPE]
 443 #define uint_fast64_type_node           c_global_trees[CTI_UINT_FAST64_TYPE]
 444 #define intptr_type_node                c_global_trees[CTI_INTPTR_TYPE]
 445 #define uintptr_type_node               c_global_trees[CTI_UINTPTR_TYPE]
 446
 447 #define truthvalue_type_node            c_global_trees[CTI_TRUTHVALUE_TYPE]
 448 #define truthvalue_true_node            c_global_trees[CTI_TRUTHVALUE_TRUE]
 449 #define truthvalue_false_node           c_global_trees[CTI_TRUTHVALUE_FALSE]
 450
 451 #define char_array_type_node            c_global_trees[CTI_CHAR_ARRAY_TYPE]
 452 #define char16_array_type_node          c_global_trees[CTI_CHAR16_ARRAY_TYPE]
 453 #define char32_array_type_node          c_global_trees[CTI_CHAR32_ARRAY_TYPE]
 454 #define wchar_array_type_node           c_global_trees[CTI_WCHAR_ARRAY_TYPE]
 455 #define string_type_node                c_global_trees[CTI_STRING_TYPE]
 456 #define const_string_type_node          c_global_trees[CTI_CONST_STRING_TYPE]
 457
 458 #define default_function_type           c_global_trees[CTI_DEFAULT_FUNCTION_TYPE]
 459
 460 #define function_name_decl_node         c_global_trees[CTI_FUNCTION_NAME_DECL]
 461 #define pretty_function_name_decl_node  c_global_trees[CTI_PRETTY_FUNCTION_NAME_DECL]
 462 #define c99_function_name_decl_node             c_global_trees[CTI_C99_FUNCTION_NAME_DECL]
 463 #define saved_function_name_decls       c_global_trees[CTI_SAVED_FUNCTION_NAME_DECLS]
 464
 465 /* The node for C++ `__null'.  */
 466 #define null_node                       c_global_trees[CTI_NULL]
 467
 468 extern GTY(()) tree c_global_trees[CTI_MAX];
 469
 470 /* In a RECORD_TYPE, a sorted array of the fields of the type, not a
 471    tree for size reasons.  */
 472 struct GTY(()) sorted_fields_type {
 473   int len;
 474   tree GTY((length ("%h.len"))) elts[1];
 475 };
 476
 477 /* Mark which labels are explicitly declared.
 478    These may be shadowed, and may be referenced from nested functions.  */
 479 #define C_DECLARED_LABEL_FLAG(label) TREE_LANG_FLAG_1 (label)
 480
 481 enum c_language_kind
 482 {
 483   clk_c         = 0,            /* C90, C94, C99 or C11 */
 484   clk_objc      = 1,            /* clk_c with ObjC features.  */
 485   clk_cxx       = 2,            /* ANSI/ISO C++ */
 486   clk_objcxx    = 3             /* clk_cxx with ObjC features.  */
 487 };
 488
 489 /* To test for a specific language use c_language, defined by each
 490    front end.  For "ObjC features" or "not C++" use the macros.  */
 491 extern c_language_kind c_language;
 492
 493 #define c_dialect_cxx()         ((c_language & clk_cxx) != 0)
 494 #define c_dialect_objc()        ((c_language & clk_objc) != 0)
 495
 496 /* The various name of operator that appears in error messages. */
 497 enum ref_operator {
 498   /* NULL */
 499   RO_NULL,
 500   /* array indexing */
 501   RO_ARRAY_INDEXING,
 502   /* unary * */
 503   RO_UNARY_STAR,
 504   /* -> */
 505   RO_ARROW,
 506   /* implicit conversion */
 507   RO_IMPLICIT_CONVERSION,
 508   /* ->* */
 509   RO_ARROW_STAR
 510 };
 511
 512 /* Information about a statement tree.  */
 513
 514 struct GTY(()) stmt_tree_s {
 515   /* A stack of statement lists being collected.  */
 516   vec<tree, va_gc> *x_cur_stmt_list;
 517
 518   /* In C++, Nonzero if we should treat statements as full
 519      expressions.  In particular, this variable is non-zero if at the
 520      end of a statement we should destroy any temporaries created
 521      during that statement.  Similarly, if, at the end of a block, we
 522      should destroy any local variables in this block.  Normally, this
 523      variable is nonzero, since those are the normal semantics of
 524      C++.
 525
 526      This flag has no effect in C.  */
 527   int stmts_are_full_exprs_p;
 528 };
 529
 530 typedef struct stmt_tree_s *stmt_tree;
 531
 532 /* Global state pertinent to the current function.  Some C dialects
 533    extend this structure with additional fields.  */
 534
 535 struct GTY(()) c_language_function {
 536   /* While we are parsing the function, this contains information
 537      about the statement-tree that we are building.  */
 538   struct stmt_tree_s x_stmt_tree;
 539
 540   /* Vector of locally defined typedefs, for
 541      -Wunused-local-typedefs.  */
 542   vec<tree, va_gc> *local_typedefs;
 543 };
 544
 545 #define stmt_list_stack (current_stmt_tree ()->x_cur_stmt_list)
 546
 547 /* When building a statement-tree, this is the current statement list
 548    being collected.  */
 549 #define cur_stmt_list   (stmt_list_stack->last ())
 550
 551 #define building_stmt_list_p() (stmt_list_stack && !stmt_list_stack->is_empty())
 552
 553 /* Language-specific hooks.  */
 554
 555 /* If non-NULL, this function is called after a precompile header file
 556    is loaded.  */
 557 extern void (*lang_post_pch_load) (void);
 558
 559 extern void push_file_scope (void);
 560 extern void pop_file_scope (void);
 561 extern stmt_tree current_stmt_tree (void);
 562 extern tree push_stmt_list (void);
 563 extern tree pop_stmt_list (tree);
 564 extern tree add_stmt (tree);
 565 extern void push_cleanup (tree, tree, bool);
 566 extern tree pushdecl_top_level (tree);
 567 extern tree pushdecl (tree);
 568 extern tree build_modify_expr (location_t, tree, tree, enum tree_code,
 569                                location_t, tree, tree);
 570 extern tree build_array_notation_expr (location_t, tree, tree, enum tree_code,
 571                                        location_t, tree, tree);
 572 extern tree build_array_notation_ref (location_t, tree, tree, tree, tree, tree);
 573 extern tree build_indirect_ref (location_t, tree, ref_operator);
 574
 575 extern int field_decl_cmp (const void *, const void *);
 576 extern void resort_sorted_fields (void *, void *, gt_pointer_operator,
 577                                   void *);
 578 extern bool has_c_linkage (const_tree decl);
 579 extern bool c_decl_implicit (const_tree);
 580 \f
 581 /* Switches common to the C front ends.  */
 582
 583 /* Nonzero means don't output line number information.  */
 584
 585 extern char flag_no_line_commands;
 586
 587 /* Nonzero causes -E output not to be done, but directives such as
 588    #define that have side effects are still obeyed.  */
 589
 590 extern char flag_no_output;
 591
 592 /* Nonzero means dump macros in some fashion; contains the 'D', 'M',
 593    'N' or 'U' of the command line switch.  */
 594
 595 extern char flag_dump_macros;
 596
 597 /* Nonzero means pass #include lines through to the output.  */
 598
 599 extern char flag_dump_includes;
 600
 601 /* Nonzero means process PCH files while preprocessing.  */
 602
 603 extern bool flag_pch_preprocess;
 604
 605 /* The file name to which we should write a precompiled header, or
 606    NULL if no header will be written in this compile.  */
 607
 608 extern const char *pch_file;
 609
 610 /* Nonzero if an ISO standard was selected.  It rejects macros in the
 611    user's namespace.  */
 612
 613 extern int flag_iso;
 614
 615 /* C/ObjC language option variables.  */
 616
 617
 618 /* Nonzero means allow type mismatches in conditional expressions;
 619    just make their values `void'.  */
 620
 621 extern int flag_cond_mismatch;
 622
 623 /* Nonzero means enable C89 Amendment 1 features.  */
 624
 625 extern int flag_isoc94;
 626
 627 /* Nonzero means use the ISO C99 (or C11) dialect of C.  */
 628
 629 extern int flag_isoc99;
 630
 631 /* Nonzero means use the ISO C11 dialect of C.  */
 632
 633 extern int flag_isoc11;
 634
 635 /* Nonzero means that we have builtin functions, and main is an int.  */
 636
 637 extern int flag_hosted;
 638
 639 /* ObjC language option variables.  */
 640
 641
 642 /* Tells the compiler that this is a special run.  Do not perform any
 643    compiling, instead we are to test some platform dependent features
 644    and output a C header file with appropriate definitions.  */
 645
 646 extern int print_struct_values;
 647
 648 /* Tells the compiler what is the constant string class for ObjC.  */
 649
 650 extern const char *constant_string_class_name;
 651
 652
 653 /* C++ language option variables.  */
 654
 655 /* The reference version of the ABI for -Wabi.  */
 656
 657 extern int warn_abi_version;
 658
 659 /* Return TRUE if one of {flag_abi_version,flag_abi_compat_version} is
 660    less than N and the other is at least N.  */
 661 #define abi_compat_version_crosses(N)           \
 662   (abi_version_at_least(N)                      \
 663    != (flag_abi_compat_version == 0             \
 664        || flag_abi_compat_version >= (N)))
 665
 666 /* Return TRUE if one of {flag_abi_version,warn_abi_version} is
 667    less than N and the other is at least N, for use by -Wabi.  */
 668 #define abi_version_crosses(N)                  \
 669   (abi_version_at_least(N)                      \
 670    != (warn_abi_version == 0                    \
 671        || warn_abi_version >= (N)))
 672
 673 /* Nonzero means generate separate instantiation control files and
 674    juggle them at link time.  */
 675
 676 extern int flag_use_repository;
 677
 678 /* The supported C++ dialects.  */
 679
 680 enum cxx_dialect {
 681   cxx_unset,
 682   /* C++98 with TC1  */
 683   cxx98,
 684   cxx03 = cxx98,
 685   /* C++11  */
 686   cxx0x,
 687   cxx11 = cxx0x,
 688   /* C++14 */
 689   cxx14,
 690   /* C++1z (C++17?) */
 691   cxx1z
 692 };
 693
 694 /* The C++ dialect being used. C++98 is the default.  */
 695 extern enum cxx_dialect cxx_dialect;
 696
 697 /* Maximum template instantiation depth.  This limit is rather
 698    arbitrary, but it exists to limit the time it takes to notice
 699    excessively recursive template instantiations.  */
 700
 701 extern int max_tinst_depth;
 702
 703 /* Nonzero means that we should not issue warnings about problems that
 704    occur when the code is executed, because the code being processed
 705    is not expected to be executed.  This is set during parsing.  This
 706    is used for cases like sizeof() and "0 ? a : b".  This is a count,
 707    not a bool, because unexecuted expressions can nest.  */
 708
 709 extern int c_inhibit_evaluation_warnings;
 710
 711 /* Whether lexing has been completed, so subsequent preprocessor
 712    errors should use the compiler's input_location.  */
 713
 714 extern bool done_lexing;
 715
 716 /* C types are partitioned into three subsets: object, function, and
 717    incomplete types.  */
 718 #define C_TYPE_OBJECT_P(type) \
 719   (TREE_CODE (type) != FUNCTION_TYPE && TYPE_SIZE (type))
 720
 721 #define C_TYPE_INCOMPLETE_P(type) \
 722   (TREE_CODE (type) != FUNCTION_TYPE && TYPE_SIZE (type) == 0)
 723
 724 #define C_TYPE_FUNCTION_P(type) \
 725   (TREE_CODE (type) == FUNCTION_TYPE)
 726
 727 /* For convenience we define a single macro to identify the class of
 728    object or incomplete types.  */
 729 #define C_TYPE_OBJECT_OR_INCOMPLETE_P(type) \
 730   (!C_TYPE_FUNCTION_P (type))
 731
 732 struct visibility_flags
 733 {
 734   unsigned inpragma : 1;        /* True when in #pragma GCC visibility.  */
 735   unsigned inlines_hidden : 1;  /* True when -finlineshidden in effect.  */
 736 };
 737
 738 /* These enumerators are possible types of unsafe conversions.  */
 739 enum conversion_safety {
 740   /* The conversion is safe.  */
 741   SAFE_CONVERSION = 0,
 742   /* Another type of conversion with problems.  */
 743   UNSAFE_OTHER,
 744   /* Conversion between signed and unsigned integers
 745      which are all warned about immediately, so this is unused.  */
 746   UNSAFE_SIGN,
 747   /* Conversions that reduce the precision of reals including conversions
 748      from reals to integers.  */
 749   UNSAFE_REAL,
 750   /* Conversions from complex to reals or integers, that discard imaginary
 751      component.  */
 752   UNSAFE_IMAGINARY
 753 };
 754
 755 /* Global visibility options.  */
 756 extern struct visibility_flags visibility_options;
 757
 758 /* Attribute table common to the C front ends.  */
 759 extern const struct attribute_spec c_common_attribute_table[];
 760 extern const struct attribute_spec c_common_format_attribute_table[];
 761
 762 /* Pointer to function to lazily generate the VAR_DECL for __FUNCTION__ etc.
 763    ID is the identifier to use, NAME is the string.
 764    TYPE_DEP indicates whether it depends on type of the function or not
 765    (i.e. __PRETTY_FUNCTION__).  */
 766
 767 extern tree (*make_fname_decl) (location_t, tree, int);
 768
 769 /* In c-decl.c and cp/tree.c.  FIXME.  */
 770 extern void c_register_addr_space (const char *str, addr_space_t as);
 771
 772 /* In c-common.c.  */
 773 extern bool in_late_binary_op;
 774 extern const char *c_addr_space_name (addr_space_t as);
 775 extern tree identifier_global_value (tree);
 776 extern tree c_linkage_bindings (tree);
 777 extern void record_builtin_type (enum rid, const char *, tree);
 778 extern tree build_void_list_node (void);
 779 extern void start_fname_decls (void);
 780 extern void finish_fname_decls (void);
 781 extern const char *fname_as_string (int);
 782 extern tree fname_decl (location_t, unsigned, tree);
 783
 784 extern int check_user_alignment (const_tree, bool);
 785 extern void check_function_arguments (location_t loc, const_tree, int, tree *);
 786 extern void check_function_arguments_recurse (void (*)
 787                                               (void *, tree,
 788                                                unsigned HOST_WIDE_INT),
 789                                               void *, tree,
 790                                               unsigned HOST_WIDE_INT);
 791 extern bool check_builtin_function_arguments (location_t, vec<location_t>,
 792                                               tree, int, tree *);
 793 extern void check_function_format (tree, int, tree *);
 794 extern tree handle_unused_attribute (tree *, tree, tree, int, bool *);
 795 extern tree handle_format_attribute (tree *, tree, tree, int, bool *);
 796 extern tree handle_format_arg_attribute (tree *, tree, tree, int, bool *);
 797 extern bool attribute_takes_identifier_p (const_tree);
 798 extern bool c_common_handle_option (size_t, const char *, int, int, location_t,
 799                                     const struct cl_option_handlers *);
 800 extern bool default_handle_c_option (size_t, const char *, int);
 801 extern tree c_common_type_for_mode (machine_mode, int);
 802 extern tree c_common_type_for_size (unsigned int, int);
 803 extern tree c_common_fixed_point_type_for_size (unsigned int, unsigned int,
 804                                                 int, int);
 805 extern tree c_common_unsigned_type (tree);
 806 extern tree c_common_signed_type (tree);
 807 extern tree c_common_signed_or_unsigned_type (int, tree);
 808 extern void c_common_init_ts (void);
 809 extern tree c_build_bitfield_integer_type (unsigned HOST_WIDE_INT, int);
 810 extern enum conversion_safety unsafe_conversion_p (location_t, tree, tree,
 811                                                    bool);
 812 extern bool decl_with_nonnull_addr_p (const_tree);
 813 extern tree c_fully_fold (tree, bool, bool *);
 814 extern tree c_wrap_maybe_const (tree, bool);
 815 extern tree c_save_expr (tree);
 816 extern tree c_common_truthvalue_conversion (location_t, tree);
 817 extern void c_apply_type_quals_to_decl (int, tree);
 818 extern tree c_sizeof_or_alignof_type (location_t, tree, bool, bool, int);
 819 extern tree c_alignof_expr (location_t, tree);
 820 /* Print an error message for invalid operands to arith operation CODE.
 821    NOP_EXPR is used as a special case (see truthvalue_conversion).  */
 822 extern void binary_op_error (rich_location *, enum tree_code, tree, tree);
 823 extern tree fix_string_type (tree);
 824 extern void constant_expression_warning (tree);
 825 extern void constant_expression_error (tree);
 826 extern bool strict_aliasing_warning (tree, tree, tree);
 827 extern void sizeof_pointer_memaccess_warning (location_t *, tree,
 828                                               vec<tree, va_gc> *, tree *,
 829                                               bool (*) (tree, tree));
 830 extern void warnings_for_convert_and_check (location_t, tree, tree, tree);
 831 extern tree convert_and_check (location_t, tree, tree);
 832 extern void overflow_warning (location_t, tree);
 833 extern bool warn_if_unused_value (const_tree, location_t);
 834 extern void warn_logical_operator (location_t, enum tree_code, tree,
 835                                    enum tree_code, tree, enum tree_code, tree);
 836 extern void warn_logical_not_parentheses (location_t, enum tree_code, tree);
 837 extern void warn_tautological_cmp (location_t, enum tree_code, tree, tree);
 838 extern void check_main_parameter_types (tree decl);
 839 extern bool c_determine_visibility (tree);
 840 extern bool vector_types_compatible_elements_p (tree, tree);
 841 extern void mark_valid_location_for_stdc_pragma (bool);
 842 extern bool valid_location_for_stdc_pragma_p (void);
 843 extern void set_float_const_decimal64 (void);
 844 extern void clear_float_const_decimal64 (void);
 845 extern bool float_const_decimal64_p (void);
 846
 847 extern bool keyword_begins_type_specifier (enum rid);
 848 extern bool keyword_is_storage_class_specifier (enum rid);
 849 extern bool keyword_is_type_qualifier (enum rid);
 850 extern bool keyword_is_decl_specifier (enum rid);
 851 extern bool cxx_fundamental_alignment_p (unsigned);
 852 extern bool pointer_to_zero_sized_aggr_p (tree);
 853 extern bool diagnose_mismatched_attributes (tree, tree);
 854
 855 #define c_sizeof(LOC, T)  c_sizeof_or_alignof_type (LOC, T, true, false, 1)
 856 #define c_alignof(LOC, T) c_sizeof_or_alignof_type (LOC, T, false, false, 1)
 857
 858 /* Subroutine of build_binary_op, used for certain operations.  */
 859 extern tree shorten_binary_op (tree result_type, tree op0, tree op1, bool bitwise);
 860
 861 /* Subroutine of build_binary_op, used for comparison operations.
 862    See if the operands have both been converted from subword integer types
 863    and, if so, perhaps change them both back to their original type.  */
 864 extern tree shorten_compare (location_t, tree *, tree *, tree *,
 865                              enum tree_code *);
 866
 867 extern tree pointer_int_sum (location_t, enum tree_code, tree, tree,
 868                              bool = true);
 869
 870 /* Add qualifiers to a type, in the fashion for C.  */
 871 extern tree c_build_qualified_type (tree, int, tree = NULL_TREE, size_t = 0);
 872
 873 /* Build tree nodes and builtin functions common to both C and C++ language
 874    frontends.  */
 875 extern void c_common_nodes_and_builtins (void);
 876
 877 extern void disable_builtin_function (const char *);
 878
 879 extern void set_compound_literal_name (tree decl);
 880
 881 extern tree build_va_arg (location_t, tree, tree);
 882
 883 extern const unsigned int c_family_lang_mask;
 884 extern unsigned int c_common_option_lang_mask (void);
 885 extern void c_common_diagnostics_set_defaults (diagnostic_context *);
 886 extern bool c_common_complain_wrong_lang_p (const struct cl_option *);
 887 extern void c_common_init_options_struct (struct gcc_options *);
 888 extern void c_common_init_options (unsigned int, struct cl_decoded_option *);
 889 extern bool c_common_post_options (const char **);
 890 extern bool c_common_init (void);
 891 extern void c_common_finish (void);
 892 extern void c_common_parse_file (void);
 893 extern FILE *get_dump_info (int, int *);
 894 extern alias_set_type c_common_get_alias_set (tree);
 895 extern void c_register_builtin_type (tree, const char*);
 896 extern bool c_promoting_integer_type_p (const_tree);
 897 extern int self_promoting_args_p (const_tree);
 898 extern tree strip_pointer_operator (tree);
 899 extern tree strip_pointer_or_array_types (tree);
 900 extern HOST_WIDE_INT c_common_to_target_charset (HOST_WIDE_INT);
 901
 902 /* This is the basic parsing function.  */
 903 extern void c_parse_file (void);
 904
 905 extern void c_parse_final_cleanups (void);
 906
 907 extern void warn_for_omitted_condop (location_t, tree);
 908 extern void warn_for_memset (location_t, tree, tree, int);
 909
 910 /* These macros provide convenient access to the various _STMT nodes.  */
 911
 912 /* Nonzero if a given STATEMENT_LIST represents the outermost binding
 913    if a statement expression.  */
 914 #define STATEMENT_LIST_STMT_EXPR(NODE) \
 915   TREE_LANG_FLAG_1 (STATEMENT_LIST_CHECK (NODE))
 916
 917 /* Nonzero if a label has been added to the statement list.  */
 918 #define STATEMENT_LIST_HAS_LABEL(NODE) \
 919   TREE_LANG_FLAG_3 (STATEMENT_LIST_CHECK (NODE))
 920
 921 /* C_MAYBE_CONST_EXPR accessors.  */
 922 #define C_MAYBE_CONST_EXPR_PRE(NODE)                    \
 923   TREE_OPERAND (C_MAYBE_CONST_EXPR_CHECK (NODE), 0)
 924 #define C_MAYBE_CONST_EXPR_EXPR(NODE)                   \
 925   TREE_OPERAND (C_MAYBE_CONST_EXPR_CHECK (NODE), 1)
 926 #define C_MAYBE_CONST_EXPR_INT_OPERANDS(NODE)           \
 927   TREE_LANG_FLAG_0 (C_MAYBE_CONST_EXPR_CHECK (NODE))
 928 #define C_MAYBE_CONST_EXPR_NON_CONST(NODE)              \
 929   TREE_LANG_FLAG_1 (C_MAYBE_CONST_EXPR_CHECK (NODE))
 930 #define EXPR_INT_CONST_OPERANDS(EXPR)                   \
 931   (INTEGRAL_TYPE_P (TREE_TYPE (EXPR))                   \
 932    && (TREE_CODE (EXPR) == INTEGER_CST                  \
 933        || (TREE_CODE (EXPR) == C_MAYBE_CONST_EXPR       \
 934            && C_MAYBE_CONST_EXPR_INT_OPERANDS (EXPR))))
 935
 936 /* In a FIELD_DECL, nonzero if the decl was originally a bitfield.  */
 937 #define DECL_C_BIT_FIELD(NODE) \
 938   (DECL_LANG_FLAG_4 (FIELD_DECL_CHECK (NODE)) == 1)
 939 #define SET_DECL_C_BIT_FIELD(NODE) \
 940   (DECL_LANG_FLAG_4 (FIELD_DECL_CHECK (NODE)) = 1)
 941 #define CLEAR_DECL_C_BIT_FIELD(NODE) \
 942   (DECL_LANG_FLAG_4 (FIELD_DECL_CHECK (NODE)) = 0)
 943
 944 extern tree do_case (location_t, tree, tree);
 945 extern tree build_stmt (location_t, enum tree_code, ...);
 946 extern tree build_real_imag_expr (location_t, enum tree_code, tree);
 947
 948 /* These functions must be defined by each front-end which implements
 949    a variant of the C language.  They are used in c-common.c.  */
 950
 951 extern tree build_unary_op (location_t, enum tree_code, tree, int);
 952 extern tree build_binary_op (location_t, enum tree_code, tree, tree, int);
 953 extern tree perform_integral_promotions (tree);
 954
 955 /* These functions must be defined by each front-end which implements
 956    a variant of the C language.  They are used by port files.  */
 957
 958 extern tree default_conversion (tree);
 959
 960 /* Given two integer or real types, return the type for their sum.
 961    Given two compatible ANSI C types, returns the merged type.  */
 962
 963 extern tree common_type (tree, tree);
 964
 965 extern tree decl_constant_value (tree);
 966
 967 /* Handle increment and decrement of boolean types.  */
 968 extern tree boolean_increment (enum tree_code, tree);
 969
 970 extern int case_compare (splay_tree_key, splay_tree_key);
 971
 972 extern tree c_add_case_label (location_t, splay_tree, tree, tree, tree, tree,
 973                               bool *);
 974
 975 extern void c_do_switch_warnings (splay_tree, location_t, tree, tree, bool,
 976                                   bool);
 977
 978 extern tree build_function_call (location_t, tree, tree);
 979
 980 extern tree build_function_call_vec (location_t, vec<location_t>, tree,
 981                                      vec<tree, va_gc> *, vec<tree, va_gc> *);
 982
 983 extern tree resolve_overloaded_builtin (location_t, tree, vec<tree, va_gc> *);
 984
 985 extern tree finish_label_address_expr (tree, location_t);
 986
 987 /* Same function prototype, but the C and C++ front ends have
 988    different implementations.  Used in c-common.c.  */
 989 extern tree lookup_label (tree);
 990 extern tree lookup_name (tree);
 991 extern bool lvalue_p (const_tree);
 992
 993 enum lookup_name_fuzzy_kind {
 994   /* Names of types.  */
 995   FUZZY_LOOKUP_TYPENAME,
 996
 997   /* Any name.  */
 998   FUZZY_LOOKUP_NAME
 999 };
1000 extern tree lookup_name_fuzzy (tree, enum lookup_name_fuzzy_kind);
1001
1002 extern bool vector_targets_convertible_p (const_tree t1, const_tree t2);
1003 extern bool vector_types_convertible_p (const_tree t1, const_tree t2, bool emit_lax_note);
1004 extern tree c_build_vec_perm_expr (location_t, tree, tree, tree, bool = true);
1005
1006 extern void init_c_lex (void);
1007
1008 extern void c_cpp_builtins (cpp_reader *);
1009 extern void c_cpp_builtins_optimize_pragma (cpp_reader *, tree, tree);
1010 extern bool c_cpp_error (cpp_reader *, int, int, rich_location *,
1011                          const char *, va_list *)
1012      ATTRIBUTE_GCC_DIAG(5,0);
1013 extern int c_common_has_attribute (cpp_reader *);
1014
1015 extern bool parse_optimize_options (tree, bool);
1016
1017 /* Positive if an implicit `extern "C"' scope has just been entered;
1018    negative if such a scope has just been exited.  */
1019 extern GTY(()) int pending_lang_change;
1020
1021 /* Information recorded about each file examined during compilation.  */
1022
1023 struct c_fileinfo
1024 {
1025   int time;     /* Time spent in the file.  */
1026
1027   /* Flags used only by C++.
1028      INTERFACE_ONLY nonzero means that we are in an "interface" section
1029      of the compiler.  INTERFACE_UNKNOWN nonzero means we cannot trust
1030      the value of INTERFACE_ONLY.  If INTERFACE_UNKNOWN is zero and
1031      INTERFACE_ONLY is zero, it means that we are responsible for
1032      exporting definitions that others might need.  */
1033   short interface_only;
1034   short interface_unknown;
1035 };
1036
1037 struct c_fileinfo *get_fileinfo (const char *);
1038 extern void dump_time_statistics (void);
1039
1040 extern bool c_dump_tree (void *, tree);
1041
1042 extern void verify_sequence_points (tree);
1043
1044 extern tree fold_offsetof_1 (tree, tree_code ctx = ERROR_MARK);
1045 extern tree fold_offsetof (tree);
1046
1047 /* Places where an lvalue, or modifiable lvalue, may be required.
1048    Used to select diagnostic messages in lvalue_error and
1049    readonly_error.  */
1050 enum lvalue_use {
1051   lv_assign,
1052   lv_increment,
1053   lv_decrement,
1054   lv_addressof,
1055   lv_asm
1056 };
1057
1058 extern void readonly_error (location_t, tree, enum lvalue_use);
1059 extern void lvalue_error (location_t, enum lvalue_use);
1060 extern void invalid_indirection_error (location_t, tree, ref_operator);
1061
1062 extern int complete_array_type (tree *, tree, bool);
1063
1064 extern tree builtin_type_for_size (int, bool);
1065
1066 extern void c_common_mark_addressable_vec (tree);
1067
1068 extern void warn_array_subscript_with_type_char (location_t, tree);
1069 extern void warn_about_parentheses (location_t,
1070                                     enum tree_code,
1071                                     enum tree_code, tree,
1072                                     enum tree_code, tree);
1073 extern void warn_for_unused_label (tree label);
1074 extern void warn_for_div_by_zero (location_t, tree divisor);
1075 extern void warn_for_sign_compare (location_t,
1076                                    tree orig_op0, tree orig_op1,
1077                                    tree op0, tree op1,
1078                                    tree result_type,
1079                                    enum tree_code resultcode);
1080 extern void do_warn_unused_parameter (tree);
1081 extern void do_warn_double_promotion (tree, tree, tree, const char *,
1082                                       location_t);
1083 extern void set_underlying_type (tree);
1084 extern void record_types_used_by_current_var_decl (tree);
1085 extern void record_locally_defined_typedef (tree);
1086 extern void maybe_record_typedef_use (tree);
1087 extern void maybe_warn_unused_local_typedefs (void);
1088 extern void maybe_warn_bool_compare (location_t, enum tree_code, tree, tree);
1089 extern bool maybe_warn_shift_overflow (location_t, tree, tree);
1090 extern vec<tree, va_gc> *make_tree_vector (void);
1091 extern void release_tree_vector (vec<tree, va_gc> *);
1092 extern vec<tree, va_gc> *make_tree_vector_single (tree);
1093 extern vec<tree, va_gc> *make_tree_vector_from_list (tree);
1094 extern vec<tree, va_gc> *make_tree_vector_copy (const vec<tree, va_gc> *);
1095
1096 /* Used for communication between c_common_type_for_mode and
1097    c_register_builtin_type.  */
1098 extern GTY(()) tree registered_builtin_types;
1099
1100 /* Read SOURCE_DATE_EPOCH from environment to have a deterministic
1101    timestamp to replace embedded current dates to get reproducible
1102    results.  Returns -1 if SOURCE_DATE_EPOCH is not defined.  */
1103 extern time_t cb_get_source_date_epoch (cpp_reader *pfile);
1104
1105 /* The value (as a unix timestamp) corresponds to date
1106    "Dec 31 9999 23:59:59 UTC", which is the latest date that __DATE__ and
1107    __TIME__ can store.  */
1108 #define MAX_SOURCE_DATE_EPOCH HOST_WIDE_INT_C (253402300799)
1109
1110 /* In c-gimplify.c  */
1111 extern void c_genericize (tree);
1112 extern int c_gimplify_expr (tree *, gimple_seq *, gimple_seq *);
1113 extern tree c_build_bind_expr (location_t, tree, tree);
1114
1115 /* In c-lex.c.  */
1116 extern enum cpp_ttype
1117 conflict_marker_get_final_tok_kind (enum cpp_ttype tok1_kind);
1118
1119 /* In c-pch.c  */
1120 extern void pch_init (void);
1121 extern void pch_cpp_save_state (void);
1122 extern int c_common_valid_pch (cpp_reader *pfile, const char *name, int fd);
1123 extern void c_common_read_pch (cpp_reader *pfile, const char *name, int fd,
1124                                const char *orig);
1125 extern void c_common_write_pch (void);
1126 extern void c_common_no_more_pch (void);
1127 extern void c_common_pch_pragma (cpp_reader *pfile, const char *);
1128
1129 /* In *-checksum.c */
1130 extern const unsigned char executable_checksum[16];
1131
1132 /* In c-cppbuiltin.c  */
1133 extern void builtin_define_std (const char *macro);
1134 extern void builtin_define_with_value (const char *, const char *, int);
1135 extern void builtin_define_with_int_value (const char *, HOST_WIDE_INT);
1136 extern void builtin_define_type_sizeof (const char *, tree);
1137 extern void c_stddef_cpp_builtins (void);
1138 extern void fe_file_change (const line_map_ordinary *);
1139 extern void c_parse_error (const char *, enum cpp_ttype, tree, unsigned char);
1140
1141 /* In c-ppoutput.c  */
1142 extern void init_pp_output (FILE *);
1143 extern void preprocess_file (cpp_reader *);
1144 extern void pp_file_change (const line_map_ordinary *);
1145 extern void pp_dir_change (cpp_reader *, const char *);
1146 extern bool check_missing_format_attribute (tree, tree);
1147
1148 /* In c-omp.c  */
1149 struct omp_clause_mask
1150 {
1151   inline omp_clause_mask ();
1152   inline omp_clause_mask (uint64_t l);
1153   inline omp_clause_mask (uint64_t l, uint64_t h);
1154   inline omp_clause_mask &operator &= (omp_clause_mask);
1155   inline omp_clause_mask &operator |= (omp_clause_mask);
1156   inline omp_clause_mask operator ~ () const;
1157   inline omp_clause_mask operator & (omp_clause_mask) const;
1158   inline omp_clause_mask operator | (omp_clause_mask) const;
1159   inline omp_clause_mask operator >> (int);
1160   inline omp_clause_mask operator << (int);
1161   inline bool operator == (omp_clause_mask) const;
1162   inline bool operator != (omp_clause_mask) const;
1163   uint64_t low, high;
1164 };
1165
1166 inline
1167 omp_clause_mask::omp_clause_mask ()
1168 {
1169 }
1170
1171 inline
1172 omp_clause_mask::omp_clause_mask (uint64_t l)
1173 : low (l), high (0)
1174 {
1175 }
1176
1177 inline
1178 omp_clause_mask::omp_clause_mask (uint64_t l, uint64_t h)
1179 : low (l), high (h)
1180 {
1181 }
1182
1183 inline omp_clause_mask &
1184 omp_clause_mask::operator &= (omp_clause_mask b)
1185 {
1186   low &= b.low;
1187   high &= b.high;
1188   return *this;
1189 }
1190
1191 inline omp_clause_mask &
1192 omp_clause_mask::operator |= (omp_clause_mask b)
1193 {
1194   low |= b.low;
1195   high |= b.high;
1196   return *this;
1197 }
1198
1199 inline omp_clause_mask
1200 omp_clause_mask::operator ~ () const
1201 {
1202   omp_clause_mask ret (~low, ~high);
1203   return ret;
1204 }
1205
1206 inline omp_clause_mask
1207 omp_clause_mask::operator | (omp_clause_mask b) const
1208 {
1209   omp_clause_mask ret (low | b.low, high | b.high);
1210   return ret;
1211 }
1212
1213 inline omp_clause_mask
1214 omp_clause_mask::operator & (omp_clause_mask b) const
1215 {
1216   omp_clause_mask ret (low & b.low, high & b.high);
1217   return ret;
1218 }
1219
1220 inline omp_clause_mask
1221 omp_clause_mask::operator << (int amount)
1222 {
1223   omp_clause_mask ret;
1224   if (amount >= 64)
1225     {
1226       ret.low = 0;
1227       ret.high = low << (amount - 64);
1228     }
1229   else if (amount == 0)
1230     ret = *this;
1231   else
1232     {
1233       ret.low = low << amount;
1234       ret.high = (low >> (64 - amount)) | (high << amount);
1235     }
1236   return ret;
1237 }
1238
1239 inline omp_clause_mask
1240 omp_clause_mask::operator >> (int amount)
1241 {
1242   omp_clause_mask ret;
1243   if (amount >= 64)
1244     {
1245       ret.low = high >> (amount - 64);
1246       ret.high = 0;
1247     }
1248   else if (amount == 0)
1249     ret = *this;
1250   else
1251     {
1252       ret.low = (high << (64 - amount)) | (low >> amount);
1253       ret.high = high >> amount;
1254     }
1255   return ret;
1256 }
1257
1258 inline bool
1259 omp_clause_mask::operator == (omp_clause_mask b) const
1260 {
1261   return low == b.low && high == b.high;
1262 }
1263
1264 inline bool
1265 omp_clause_mask::operator != (omp_clause_mask b) const
1266 {
1267   return low != b.low || high != b.high;
1268 }
1269
1270 #define OMP_CLAUSE_MASK_1 omp_clause_mask (1)
1271
1272 enum c_omp_clause_split
1273 {
1274   C_OMP_CLAUSE_SPLIT_TARGET = 0,
1275   C_OMP_CLAUSE_SPLIT_TEAMS,
1276   C_OMP_CLAUSE_SPLIT_DISTRIBUTE,
1277   C_OMP_CLAUSE_SPLIT_PARALLEL,
1278   C_OMP_CLAUSE_SPLIT_FOR,
1279   C_OMP_CLAUSE_SPLIT_SIMD,
1280   C_OMP_CLAUSE_SPLIT_COUNT,
1281   C_OMP_CLAUSE_SPLIT_SECTIONS = C_OMP_CLAUSE_SPLIT_FOR,
1282   C_OMP_CLAUSE_SPLIT_TASKLOOP = C_OMP_CLAUSE_SPLIT_FOR
1283 };
1284
1285 enum c_omp_region_type
1286 {
1287   C_ORT_OMP                     = 1 << 0,
1288   C_ORT_CILK                    = 1 << 1,
1289   C_ORT_ACC                     = 1 << 2,
1290   C_ORT_DECLARE_SIMD            = 1 << 3,
1291   C_ORT_OMP_DECLARE_SIMD        = C_ORT_OMP | C_ORT_DECLARE_SIMD
1292 };
1293
1294 extern tree c_finish_omp_master (location_t, tree);
1295 extern tree c_finish_omp_taskgroup (location_t, tree);
1296 extern tree c_finish_omp_critical (location_t, tree, tree, tree);
1297 extern tree c_finish_omp_ordered (location_t, tree, tree);
1298 extern void c_finish_omp_barrier (location_t);
1299 extern tree c_finish_omp_atomic (location_t, enum tree_code, enum tree_code,
1300                                  tree, tree, tree, tree, tree, bool, bool,
1301                                  bool = false);
1302 extern void c_finish_omp_flush (location_t);
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);
1307 extern bool c_omp_check_loop_iv (tree, tree, walk_tree_lh);
1308 extern bool c_omp_check_loop_iv_exprs (location_t, tree, tree, tree, tree,
1309                                        walk_tree_lh);
1310 extern tree c_finish_oacc_wait (location_t, tree, tree);
1311 extern tree c_oacc_split_loop_clauses (tree, tree *, bool);
1312 extern void c_omp_split_clauses (location_t, enum tree_code, omp_clause_mask,
1313                                  tree, tree *);
1314 extern tree c_omp_declare_simd_clauses_to_numbers (tree, tree);
1315 extern void c_omp_declare_simd_clauses_to_decls (tree, tree);
1316 extern enum omp_clause_default_kind c_omp_predetermined_sharing (tree);
1317
1318 /* Return next tree in the chain for chain_next walking of tree nodes.  */
1319 static inline tree
1320 c_tree_chain_next (tree t)
1321 {
1322   /* TREE_CHAIN of a type is TYPE_STUB_DECL, which is different
1323      kind of object, never a long chain of nodes.  Prefer
1324      TYPE_NEXT_VARIANT for types.  */
1325   if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_TYPE_COMMON))
1326     return TYPE_NEXT_VARIANT (t);
1327   /* Otherwise, if there is TREE_CHAIN, return it.  */
1328   if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_COMMON))
1329     return TREE_CHAIN (t);
1330   return NULL;
1331 }
1332
1333 /* Mask used by tm_stmt_attr.  */
1334 #define TM_STMT_ATTR_OUTER      2
1335 #define TM_STMT_ATTR_ATOMIC     4
1336 #define TM_STMT_ATTR_RELAXED    8
1337
1338 extern int parse_tm_stmt_attr (tree, int);
1339
1340 /* Mask used by tm_attr_to_mask and tm_mask_to_attr.  Note that these
1341    are ordered specifically such that more restrictive attributes are
1342    at lower bit positions.  This fact is known by the C++ tm attribute
1343    inheritance code such that least bit extraction (mask & -mask) results
1344    in the most restrictive attribute.  */
1345 #define TM_ATTR_SAFE                    1
1346 #define TM_ATTR_CALLABLE                2
1347 #define TM_ATTR_PURE                    4
1348 #define TM_ATTR_IRREVOCABLE             8
1349 #define TM_ATTR_MAY_CANCEL_OUTER        16
1350
1351 extern int tm_attr_to_mask (tree);
1352 extern tree tm_mask_to_attr (int);
1353 extern tree find_tm_attribute (tree);
1354
1355 /* A suffix-identifier value doublet that represents user-defined literals
1356    for C++-0x.  */
1357 enum overflow_type {
1358   OT_UNDERFLOW = -1,
1359   OT_NONE,
1360   OT_OVERFLOW
1361 };
1362
1363 struct GTY(()) tree_userdef_literal {
1364   struct tree_base base;
1365   tree suffix_id;
1366   tree value;
1367   tree num_string;
1368   enum overflow_type overflow;
1369 };
1370
1371 #define USERDEF_LITERAL_SUFFIX_ID(NODE) \
1372   (((struct tree_userdef_literal *)USERDEF_LITERAL_CHECK (NODE))->suffix_id)
1373
1374 #define USERDEF_LITERAL_VALUE(NODE) \
1375   (((struct tree_userdef_literal *)USERDEF_LITERAL_CHECK (NODE))->value)
1376
1377 #define USERDEF_LITERAL_OVERFLOW(NODE) \
1378   (((struct tree_userdef_literal *)USERDEF_LITERAL_CHECK (NODE))->overflow)
1379
1380 #define USERDEF_LITERAL_NUM_STRING(NODE) \
1381   (((struct tree_userdef_literal *)USERDEF_LITERAL_CHECK (NODE))->num_string)
1382
1383 #define USERDEF_LITERAL_TYPE(NODE) \
1384   (TREE_TYPE (USERDEF_LITERAL_VALUE (NODE)))
1385
1386 extern tree build_userdef_literal (tree suffix_id, tree value,
1387                                    enum overflow_type overflow,
1388                                    tree num_string);
1389
1390 extern bool convert_vector_to_array_for_subscript (location_t, tree *, tree);
1391
1392 /* Possibe cases of scalar_to_vector conversion.  */
1393 enum stv_conv {
1394   stv_error,        /* Error occurred.  */
1395   stv_nothing,      /* Nothing happened.  */
1396   stv_firstarg,     /* First argument must be expanded.  */
1397   stv_secondarg     /* Second argument must be expanded.  */
1398 };
1399
1400 extern enum stv_conv scalar_to_vector (location_t loc, enum tree_code code,
1401                                        tree op0, tree op1, bool);
1402
1403 /* In c-cilkplus.c  */
1404 extern tree c_validate_cilk_plus_loop (tree *, int *, void *);
1405 extern bool c_check_cilk_loop (location_t, tree);
1406
1407 /* These #defines allow users to access different operands of the
1408    array notation tree.  */
1409
1410 #define ARRAY_NOTATION_CHECK(NODE) TREE_CHECK (NODE, ARRAY_NOTATION_REF)
1411 #define ARRAY_NOTATION_ARRAY(NODE) \
1412   TREE_OPERAND (ARRAY_NOTATION_CHECK (NODE), 0)
1413 #define ARRAY_NOTATION_START(NODE) \
1414   TREE_OPERAND (ARRAY_NOTATION_CHECK (NODE), 1)
1415 #define ARRAY_NOTATION_LENGTH(NODE) \
1416   TREE_OPERAND (ARRAY_NOTATION_CHECK (NODE), 2)
1417 #define ARRAY_NOTATION_STRIDE(NODE) \
1418   TREE_OPERAND (ARRAY_NOTATION_CHECK (NODE), 3)
1419
1420 /* This structure holds all the scalar values and its appropriate variable
1421    replacment.  It is mainly used by the function that pulls all the invariant
1422    parts that should be executed only once, which comes with array notation
1423    expressions.  */
1424 struct inv_list
1425 {
1426   vec<tree, va_gc> *list_values;
1427   vec<tree, va_gc> *replacement;
1428   vec<enum tree_code, va_gc> *additional_tcodes;
1429 };
1430
1431 /* This structure holds all the important components that can be extracted
1432    from an ARRAY_NOTATION_REF expression.  It is used to pass array notation
1433    information between the functions that are responsible for expansion.  */
1434 typedef struct cilkplus_an_parts
1435 {
1436   tree value;
1437   tree start;
1438   tree length;
1439   tree stride;
1440   bool is_vector;
1441 } an_parts;
1442
1443 /* This structure holds the components necessary to create the loop around
1444    the ARRAY_REF that is created using the ARRAY_NOTATION information.  */
1445
1446 typedef struct cilkplus_an_loop_parts
1447 {
1448   tree var;         /* Loop induction variable.  */
1449   tree incr;        /* Loop increment/decrement expression.  */
1450   tree cmp;         /* Loop condition.  */
1451   tree ind_init;    /* Initialization of the loop induction variable.  */
1452 } an_loop_parts;
1453
1454 /* In array-notation-common.c.  */
1455 extern HOST_WIDE_INT extract_sec_implicit_index_arg (location_t, tree);
1456 extern bool is_sec_implicit_index_fn (tree);
1457 extern void array_notation_init_builtins (void);
1458 extern struct c_expr fix_array_notation_expr (location_t, enum tree_code,
1459                                               struct c_expr);
1460 extern bool contains_array_notation_expr (tree);
1461 extern tree expand_array_notation_exprs (tree);
1462 extern tree fix_conditional_array_notations (tree);
1463 extern tree find_correct_array_notation_type (tree);
1464 extern bool length_mismatch_in_expr_p (location_t, vec<vec<an_parts> >);
1465 extern enum built_in_function is_cilkplus_reduce_builtin (tree);
1466 extern bool find_rank (location_t, tree, tree, bool, size_t *);
1467 extern void extract_array_notation_exprs (tree, bool, vec<tree, va_gc> **);
1468 extern void replace_array_notations (tree *, bool, vec<tree, va_gc> *,
1469                                      vec<tree, va_gc> *);
1470 extern tree find_inv_trees (tree *, int *, void *);
1471 extern tree replace_inv_trees (tree *, int *, void *);
1472 extern tree find_correct_array_notation_type (tree op);
1473 extern void cilkplus_extract_an_triplets (vec<tree, va_gc> *, size_t, size_t,
1474                                           vec<vec<an_parts> > *);
1475 extern vec <tree, va_gc> *fix_sec_implicit_args
1476   (location_t, vec <tree, va_gc> *, vec<an_loop_parts>, size_t, tree);
1477 extern bool is_cilkplus_vector_p (tree);
1478
1479 /* In cilk.c.  */
1480 extern tree insert_cilk_frame (tree);
1481 extern void cilk_init_builtins (void);
1482 extern int gimplify_cilk_spawn (tree *);
1483 extern void cilk_gimplify_call_params_in_spawned_fn (tree *, gimple_seq *);
1484 extern void cilk_install_body_with_frame_cleanup (tree, tree, void *);
1485 extern bool cilk_detect_spawn_and_unwrap (tree *);
1486 extern bool cilk_set_spawn_marker (location_t, tree);
1487 extern tree build_cilk_sync (void);
1488 extern tree build_cilk_spawn (location_t, tree);
1489 extern tree make_cilk_frame (tree);
1490 extern tree create_cilk_function_exit (tree, bool, bool);
1491 extern tree cilk_install_body_pedigree_operations (tree);
1492 extern void cilk_outline (tree, tree *, void *);
1493 extern bool contains_cilk_spawn_stmt (tree);
1494 extern tree cilk_for_number_of_iterations (tree);
1495 extern bool check_no_cilk (tree, const char *, const char *,
1496                            location_t loc = UNKNOWN_LOCATION);
1497 extern bool reject_gcc_builtin (const_tree, location_t = UNKNOWN_LOCATION);
1498 extern void warn_duplicated_cond_add_or_warn (location_t, tree, vec<tree> **);
1499 extern bool valid_array_size_p (location_t, tree, tree);
1500
1501 extern bool cilk_ignorable_spawn_rhs_op (tree);
1502 extern bool cilk_recognize_spawn (tree, tree *);
1503
1504 #endif /* ! GCC_C_COMMON_H */