gcc/c-family/c-common.h

   1 /* Definitions for c-common.c.
   2    Copyright (C) 1987-2015 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 (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 (tree, int, tree *);
 792 extern void check_function_format (tree, int, tree *);
 793 extern tree handle_format_attribute (tree *, tree, tree, int, bool *);
 794 extern tree handle_format_arg_attribute (tree *, tree, tree, int, bool *);
 795 extern bool attribute_takes_identifier_p (const_tree);
 796 extern bool c_common_handle_option (size_t, const char *, int, int, location_t,
 797                                     const struct cl_option_handlers *);
 798 extern bool default_handle_c_option (size_t, const char *, int);
 799 extern tree c_common_type_for_mode (machine_mode, int);
 800 extern tree c_common_type_for_size (unsigned int, int);
 801 extern tree c_common_fixed_point_type_for_size (unsigned int, unsigned int,
 802                                                 int, int);
 803 extern tree c_common_unsigned_type (tree);
 804 extern tree c_common_signed_type (tree);
 805 extern tree c_common_signed_or_unsigned_type (int, tree);
 806 extern void c_common_init_ts (void);
 807 extern tree c_build_bitfield_integer_type (unsigned HOST_WIDE_INT, int);
 808 extern enum conversion_safety unsafe_conversion_p (location_t, tree, tree,
 809                                                    bool);
 810 extern bool decl_with_nonnull_addr_p (const_tree);
 811 extern tree c_fully_fold (tree, bool, bool *);
 812 extern tree decl_constant_value_for_optimization (tree);
 813 extern tree c_wrap_maybe_const (tree, bool);
 814 extern tree c_save_expr (tree);
 815 extern tree c_common_truthvalue_conversion (location_t, tree);
 816 extern void c_apply_type_quals_to_decl (int, tree);
 817 extern tree c_sizeof_or_alignof_type (location_t, tree, bool, bool, int);
 818 extern tree c_alignof_expr (location_t, tree);
 819 /* Print an error message for invalid operands to arith operation CODE.
 820    NOP_EXPR is used as a special case (see truthvalue_conversion).  */
 821 extern void binary_op_error (location_t, enum tree_code, tree, tree);
 822 extern tree fix_string_type (tree);
 823 extern void constant_expression_warning (tree);
 824 extern void constant_expression_error (tree);
 825 extern bool strict_aliasing_warning (tree, tree, tree);
 826 extern void sizeof_pointer_memaccess_warning (location_t *, tree,
 827                                               vec<tree, va_gc> *, tree *,
 828                                               bool (*) (tree, tree));
 829 extern void warnings_for_convert_and_check (location_t, tree, tree, tree);
 830 extern tree convert_and_check (location_t, tree, tree);
 831 extern void overflow_warning (location_t, tree);
 832 extern bool warn_if_unused_value (const_tree, location_t);
 833 extern void warn_logical_operator (location_t, enum tree_code, tree,
 834                                    enum tree_code, tree, enum tree_code, tree);
 835 extern void warn_logical_not_parentheses (location_t, enum tree_code, tree);
 836 extern void warn_tautological_cmp (location_t, enum tree_code, tree, tree);
 837 extern void check_main_parameter_types (tree decl);
 838 extern bool c_determine_visibility (tree);
 839 extern bool vector_types_compatible_elements_p (tree, tree);
 840 extern void mark_valid_location_for_stdc_pragma (bool);
 841 extern bool valid_location_for_stdc_pragma_p (void);
 842 extern void set_float_const_decimal64 (void);
 843 extern void clear_float_const_decimal64 (void);
 844 extern bool float_const_decimal64_p (void);
 845
 846 extern bool keyword_begins_type_specifier (enum rid);
 847 extern bool keyword_is_storage_class_specifier (enum rid);
 848 extern bool keyword_is_type_qualifier (enum rid);
 849 extern bool keyword_is_decl_specifier (enum rid);
 850 extern bool cxx_fundamental_alignment_p (unsigned);
 851 extern bool pointer_to_zero_sized_aggr_p (tree);
 852
 853 #define c_sizeof(LOC, T)  c_sizeof_or_alignof_type (LOC, T, true, false, 1)
 854 #define c_alignof(LOC, T) c_sizeof_or_alignof_type (LOC, T, false, false, 1)
 855
 856 /* Subroutine of build_binary_op, used for certain operations.  */
 857 extern tree shorten_binary_op (tree result_type, tree op0, tree op1, bool bitwise);
 858
 859 /* Subroutine of build_binary_op, used for comparison operations.
 860    See if the operands have both been converted from subword integer types
 861    and, if so, perhaps change them both back to their original type.  */
 862 extern tree shorten_compare (location_t, tree *, tree *, tree *,
 863                              enum tree_code *);
 864
 865 extern tree pointer_int_sum (location_t, enum tree_code, tree, tree,
 866                              bool = true);
 867
 868 /* Add qualifiers to a type, in the fashion for C.  */
 869 extern tree c_build_qualified_type (tree, int, tree = NULL_TREE, size_t = 0);
 870
 871 /* Build tree nodes and builtin functions common to both C and C++ language
 872    frontends.  */
 873 extern void c_common_nodes_and_builtins (void);
 874
 875 extern void disable_builtin_function (const char *);
 876
 877 extern void set_compound_literal_name (tree decl);
 878
 879 extern tree build_va_arg (location_t, tree, tree);
 880
 881 extern const unsigned int c_family_lang_mask;
 882 extern unsigned int c_common_option_lang_mask (void);
 883 extern void c_common_diagnostics_set_defaults (diagnostic_context *);
 884 extern bool c_common_complain_wrong_lang_p (const struct cl_option *);
 885 extern void c_common_init_options_struct (struct gcc_options *);
 886 extern void c_common_init_options (unsigned int, struct cl_decoded_option *);
 887 extern bool c_common_post_options (const char **);
 888 extern bool c_common_init (void);
 889 extern void c_common_finish (void);
 890 extern void c_common_parse_file (void);
 891 extern FILE *get_dump_info (int, int *);
 892 extern alias_set_type c_common_get_alias_set (tree);
 893 extern void c_register_builtin_type (tree, const char*);
 894 extern bool c_promoting_integer_type_p (const_tree);
 895 extern int self_promoting_args_p (const_tree);
 896 extern tree strip_pointer_operator (tree);
 897 extern tree strip_pointer_or_array_types (tree);
 898 extern HOST_WIDE_INT c_common_to_target_charset (HOST_WIDE_INT);
 899
 900 /* This is the basic parsing function.  */
 901 extern void c_parse_file (void);
 902
 903 extern void c_parse_final_cleanups (void);
 904
 905 extern void warn_for_omitted_condop (location_t, tree);
 906
 907 /* These macros provide convenient access to the various _STMT nodes.  */
 908
 909 /* Nonzero if a given STATEMENT_LIST represents the outermost binding
 910    if a statement expression.  */
 911 #define STATEMENT_LIST_STMT_EXPR(NODE) \
 912   TREE_LANG_FLAG_1 (STATEMENT_LIST_CHECK (NODE))
 913
 914 /* Nonzero if a label has been added to the statement list.  */
 915 #define STATEMENT_LIST_HAS_LABEL(NODE) \
 916   TREE_LANG_FLAG_3 (STATEMENT_LIST_CHECK (NODE))
 917
 918 /* C_MAYBE_CONST_EXPR accessors.  */
 919 #define C_MAYBE_CONST_EXPR_PRE(NODE)                    \
 920   TREE_OPERAND (C_MAYBE_CONST_EXPR_CHECK (NODE), 0)
 921 #define C_MAYBE_CONST_EXPR_EXPR(NODE)                   \
 922   TREE_OPERAND (C_MAYBE_CONST_EXPR_CHECK (NODE), 1)
 923 #define C_MAYBE_CONST_EXPR_INT_OPERANDS(NODE)           \
 924   TREE_LANG_FLAG_0 (C_MAYBE_CONST_EXPR_CHECK (NODE))
 925 #define C_MAYBE_CONST_EXPR_NON_CONST(NODE)              \
 926   TREE_LANG_FLAG_1 (C_MAYBE_CONST_EXPR_CHECK (NODE))
 927 #define EXPR_INT_CONST_OPERANDS(EXPR)                   \
 928   (INTEGRAL_TYPE_P (TREE_TYPE (EXPR))                   \
 929    && (TREE_CODE (EXPR) == INTEGER_CST                  \
 930        || (TREE_CODE (EXPR) == C_MAYBE_CONST_EXPR       \
 931            && C_MAYBE_CONST_EXPR_INT_OPERANDS (EXPR))))
 932
 933 /* In a FIELD_DECL, nonzero if the decl was originally a bitfield.  */
 934 #define DECL_C_BIT_FIELD(NODE) \
 935   (DECL_LANG_FLAG_4 (FIELD_DECL_CHECK (NODE)) == 1)
 936 #define SET_DECL_C_BIT_FIELD(NODE) \
 937   (DECL_LANG_FLAG_4 (FIELD_DECL_CHECK (NODE)) = 1)
 938 #define CLEAR_DECL_C_BIT_FIELD(NODE) \
 939   (DECL_LANG_FLAG_4 (FIELD_DECL_CHECK (NODE)) = 0)
 940
 941 extern tree do_case (location_t, tree, tree);
 942 extern tree build_stmt (location_t, enum tree_code, ...);
 943 extern tree build_real_imag_expr (location_t, enum tree_code, tree);
 944
 945 /* These functions must be defined by each front-end which implements
 946    a variant of the C language.  They are used in c-common.c.  */
 947
 948 extern tree build_unary_op (location_t, enum tree_code, tree, int);
 949 extern tree build_binary_op (location_t, enum tree_code, tree, tree, int);
 950 extern tree perform_integral_promotions (tree);
 951
 952 /* These functions must be defined by each front-end which implements
 953    a variant of the C language.  They are used by port files.  */
 954
 955 extern tree default_conversion (tree);
 956
 957 /* Given two integer or real types, return the type for their sum.
 958    Given two compatible ANSI C types, returns the merged type.  */
 959
 960 extern tree common_type (tree, tree);
 961
 962 extern tree decl_constant_value (tree);
 963
 964 /* Handle increment and decrement of boolean types.  */
 965 extern tree boolean_increment (enum tree_code, tree);
 966
 967 extern int case_compare (splay_tree_key, splay_tree_key);
 968
 969 extern tree c_add_case_label (location_t, splay_tree, tree, tree, tree, tree,
 970                               bool *);
 971
 972 extern void c_do_switch_warnings (splay_tree, location_t, tree, tree, bool,
 973                                   bool);
 974
 975 extern tree build_function_call (location_t, tree, tree);
 976
 977 extern tree build_function_call_vec (location_t, vec<location_t>, tree,
 978                                      vec<tree, va_gc> *, vec<tree, va_gc> *);
 979
 980 extern tree resolve_overloaded_builtin (location_t, tree, vec<tree, va_gc> *);
 981
 982 extern tree finish_label_address_expr (tree, location_t);
 983
 984 /* Same function prototype, but the C and C++ front ends have
 985    different implementations.  Used in c-common.c.  */
 986 extern tree lookup_label (tree);
 987 extern tree lookup_name (tree);
 988 extern bool lvalue_p (const_tree);
 989
 990 extern bool vector_targets_convertible_p (const_tree t1, const_tree t2);
 991 extern bool vector_types_convertible_p (const_tree t1, const_tree t2, bool emit_lax_note);
 992 extern tree c_build_vec_perm_expr (location_t, tree, tree, tree, bool = true);
 993
 994 extern void init_c_lex (void);
 995
 996 extern void c_cpp_builtins (cpp_reader *);
 997 extern void c_cpp_builtins_optimize_pragma (cpp_reader *, tree, tree);
 998 extern bool c_cpp_error (cpp_reader *, int, int, rich_location *,
 999                          const char *, va_list *)
1000      ATTRIBUTE_GCC_DIAG(5,0);
1001 extern int c_common_has_attribute (cpp_reader *);
1002
1003 extern bool parse_optimize_options (tree, bool);
1004
1005 /* Positive if an implicit `extern "C"' scope has just been entered;
1006    negative if such a scope has just been exited.  */
1007 extern GTY(()) int pending_lang_change;
1008
1009 /* Information recorded about each file examined during compilation.  */
1010
1011 struct c_fileinfo
1012 {
1013   int time;     /* Time spent in the file.  */
1014
1015   /* Flags used only by C++.
1016      INTERFACE_ONLY nonzero means that we are in an "interface" section
1017      of the compiler.  INTERFACE_UNKNOWN nonzero means we cannot trust
1018      the value of INTERFACE_ONLY.  If INTERFACE_UNKNOWN is zero and
1019      INTERFACE_ONLY is zero, it means that we are responsible for
1020      exporting definitions that others might need.  */
1021   short interface_only;
1022   short interface_unknown;
1023 };
1024
1025 struct c_fileinfo *get_fileinfo (const char *);
1026 extern void dump_time_statistics (void);
1027
1028 extern bool c_dump_tree (void *, tree);
1029
1030 extern void verify_sequence_points (tree);
1031
1032 extern tree fold_offsetof_1 (tree, tree_code ctx = ERROR_MARK);
1033 extern tree fold_offsetof (tree);
1034
1035 /* Places where an lvalue, or modifiable lvalue, may be required.
1036    Used to select diagnostic messages in lvalue_error and
1037    readonly_error.  */
1038 enum lvalue_use {
1039   lv_assign,
1040   lv_increment,
1041   lv_decrement,
1042   lv_addressof,
1043   lv_asm
1044 };
1045
1046 extern void readonly_error (location_t, tree, enum lvalue_use);
1047 extern void lvalue_error (location_t, enum lvalue_use);
1048 extern void invalid_indirection_error (location_t, tree, ref_operator);
1049
1050 extern int complete_array_type (tree *, tree, bool);
1051
1052 extern tree builtin_type_for_size (int, bool);
1053
1054 extern void c_common_mark_addressable_vec (tree);
1055
1056 extern void warn_array_subscript_with_type_char (location_t, tree);
1057 extern void warn_about_parentheses (location_t,
1058                                     enum tree_code,
1059                                     enum tree_code, tree,
1060                                     enum tree_code, tree);
1061 extern void warn_for_unused_label (tree label);
1062 extern void warn_for_div_by_zero (location_t, tree divisor);
1063 extern void warn_for_sign_compare (location_t,
1064                                    tree orig_op0, tree orig_op1,
1065                                    tree op0, tree op1,
1066                                    tree result_type,
1067                                    enum tree_code resultcode);
1068 extern void do_warn_unused_parameter (tree);
1069 extern void do_warn_double_promotion (tree, tree, tree, const char *,
1070                                       location_t);
1071 extern void set_underlying_type (tree);
1072 extern void record_types_used_by_current_var_decl (tree);
1073 extern void record_locally_defined_typedef (tree);
1074 extern void maybe_record_typedef_use (tree);
1075 extern void maybe_warn_unused_local_typedefs (void);
1076 extern void maybe_warn_bool_compare (location_t, enum tree_code, tree, tree);
1077 extern bool maybe_warn_shift_overflow (location_t, tree, tree);
1078 extern vec<tree, va_gc> *make_tree_vector (void);
1079 extern void release_tree_vector (vec<tree, va_gc> *);
1080 extern vec<tree, va_gc> *make_tree_vector_single (tree);
1081 extern vec<tree, va_gc> *make_tree_vector_from_list (tree);
1082 extern vec<tree, va_gc> *make_tree_vector_copy (const vec<tree, va_gc> *);
1083
1084 /* Used for communication between c_common_type_for_mode and
1085    c_register_builtin_type.  */
1086 extern GTY(()) tree registered_builtin_types;
1087
1088 /* In c-gimplify.c  */
1089 extern void c_genericize (tree);
1090 extern int c_gimplify_expr (tree *, gimple_seq *, gimple_seq *);
1091 extern tree c_build_bind_expr (location_t, tree, tree);
1092
1093 /* In c-pch.c  */
1094 extern void pch_init (void);
1095 extern void pch_cpp_save_state (void);
1096 extern int c_common_valid_pch (cpp_reader *pfile, const char *name, int fd);
1097 extern void c_common_read_pch (cpp_reader *pfile, const char *name, int fd,
1098                                const char *orig);
1099 extern void c_common_write_pch (void);
1100 extern void c_common_no_more_pch (void);
1101 extern void c_common_pch_pragma (cpp_reader *pfile, const char *);
1102
1103 /* In *-checksum.c */
1104 extern const unsigned char executable_checksum[16];
1105
1106 /* In c-cppbuiltin.c  */
1107 extern void builtin_define_std (const char *macro);
1108 extern void builtin_define_with_value (const char *, const char *, int);
1109 extern void builtin_define_with_int_value (const char *, HOST_WIDE_INT);
1110 extern void builtin_define_type_sizeof (const char *, tree);
1111 extern void c_stddef_cpp_builtins (void);
1112 extern void fe_file_change (const line_map_ordinary *);
1113 extern void c_parse_error (const char *, enum cpp_ttype, tree, unsigned char);
1114
1115 /* In c-ppoutput.c  */
1116 extern void init_pp_output (FILE *);
1117 extern void preprocess_file (cpp_reader *);
1118 extern void pp_file_change (const line_map_ordinary *);
1119 extern void pp_dir_change (cpp_reader *, const char *);
1120 extern bool check_missing_format_attribute (tree, tree);
1121
1122 /* In c-omp.c  */
1123 struct omp_clause_mask
1124 {
1125   inline omp_clause_mask ();
1126   inline omp_clause_mask (uint64_t l);
1127   inline omp_clause_mask (uint64_t l, uint64_t h);
1128   inline omp_clause_mask &operator &= (omp_clause_mask);
1129   inline omp_clause_mask &operator |= (omp_clause_mask);
1130   inline omp_clause_mask operator ~ () const;
1131   inline omp_clause_mask operator & (omp_clause_mask) const;
1132   inline omp_clause_mask operator | (omp_clause_mask) const;
1133   inline omp_clause_mask operator >> (int);
1134   inline omp_clause_mask operator << (int);
1135   inline bool operator == (omp_clause_mask) const;
1136   inline bool operator != (omp_clause_mask) const;
1137   uint64_t low, high;
1138 };
1139
1140 inline
1141 omp_clause_mask::omp_clause_mask ()
1142 {
1143 }
1144
1145 inline
1146 omp_clause_mask::omp_clause_mask (uint64_t l)
1147 : low (l), high (0)
1148 {
1149 }
1150
1151 inline
1152 omp_clause_mask::omp_clause_mask (uint64_t l, uint64_t h)
1153 : low (l), high (h)
1154 {
1155 }
1156
1157 inline omp_clause_mask &
1158 omp_clause_mask::operator &= (omp_clause_mask b)
1159 {
1160   low &= b.low;
1161   high &= b.high;
1162   return *this;
1163 }
1164
1165 inline omp_clause_mask &
1166 omp_clause_mask::operator |= (omp_clause_mask b)
1167 {
1168   low |= b.low;
1169   high |= b.high;
1170   return *this;
1171 }
1172
1173 inline omp_clause_mask
1174 omp_clause_mask::operator ~ () const
1175 {
1176   omp_clause_mask ret (~low, ~high);
1177   return ret;
1178 }
1179
1180 inline omp_clause_mask
1181 omp_clause_mask::operator | (omp_clause_mask b) const
1182 {
1183   omp_clause_mask ret (low | b.low, high | b.high);
1184   return ret;
1185 }
1186
1187 inline omp_clause_mask
1188 omp_clause_mask::operator & (omp_clause_mask b) const
1189 {
1190   omp_clause_mask ret (low & b.low, high & b.high);
1191   return ret;
1192 }
1193
1194 inline omp_clause_mask
1195 omp_clause_mask::operator << (int amount)
1196 {
1197   omp_clause_mask ret;
1198   if (amount >= 64)
1199     {
1200       ret.low = 0;
1201       ret.high = low << (amount - 64);
1202     }
1203   else if (amount == 0)
1204     ret = *this;
1205   else
1206     {
1207       ret.low = low << amount;
1208       ret.high = (low >> (64 - amount)) | (high << amount);
1209     }
1210   return ret;
1211 }
1212
1213 inline omp_clause_mask
1214 omp_clause_mask::operator >> (int amount)
1215 {
1216   omp_clause_mask ret;
1217   if (amount >= 64)
1218     {
1219       ret.low = high >> (amount - 64);
1220       ret.high = 0;
1221     }
1222   else if (amount == 0)
1223     ret = *this;
1224   else
1225     {
1226       ret.low = (high << (64 - amount)) | (low >> amount);
1227       ret.high = high >> amount;
1228     }
1229   return ret;
1230 }
1231
1232 inline bool
1233 omp_clause_mask::operator == (omp_clause_mask b) const
1234 {
1235   return low == b.low && high == b.high;
1236 }
1237
1238 inline bool
1239 omp_clause_mask::operator != (omp_clause_mask b) const
1240 {
1241   return low != b.low || high != b.high;
1242 }
1243
1244 #define OMP_CLAUSE_MASK_1 omp_clause_mask (1)
1245
1246 enum c_omp_clause_split
1247 {
1248   C_OMP_CLAUSE_SPLIT_TARGET = 0,
1249   C_OMP_CLAUSE_SPLIT_TEAMS,
1250   C_OMP_CLAUSE_SPLIT_DISTRIBUTE,
1251   C_OMP_CLAUSE_SPLIT_PARALLEL,
1252   C_OMP_CLAUSE_SPLIT_FOR,
1253   C_OMP_CLAUSE_SPLIT_SIMD,
1254   C_OMP_CLAUSE_SPLIT_COUNT,
1255   C_OMP_CLAUSE_SPLIT_SECTIONS = C_OMP_CLAUSE_SPLIT_FOR,
1256   C_OMP_CLAUSE_SPLIT_TASKLOOP = C_OMP_CLAUSE_SPLIT_FOR
1257 };
1258
1259 extern tree c_finish_omp_master (location_t, tree);
1260 extern tree c_finish_omp_taskgroup (location_t, tree);
1261 extern tree c_finish_omp_critical (location_t, tree, tree, tree);
1262 extern tree c_finish_omp_ordered (location_t, tree, tree);
1263 extern void c_finish_omp_barrier (location_t);
1264 extern tree c_finish_omp_atomic (location_t, enum tree_code, enum tree_code,
1265                                  tree, tree, tree, tree, tree, bool, bool,
1266                                  bool = false);
1267 extern void c_finish_omp_flush (location_t);
1268 extern void c_finish_omp_taskwait (location_t);
1269 extern void c_finish_omp_taskyield (location_t);
1270 extern tree c_finish_omp_for (location_t, enum tree_code, tree, tree, tree,
1271                               tree, tree, tree, tree);
1272 extern bool c_omp_check_loop_iv (tree, tree, walk_tree_lh);
1273 extern bool c_omp_check_loop_iv_exprs (location_t, tree, tree, tree, tree,
1274                                        walk_tree_lh);
1275 extern tree c_finish_oacc_wait (location_t, tree, tree);
1276 extern tree c_oacc_split_loop_clauses (tree, tree *);
1277 extern void c_omp_split_clauses (location_t, enum tree_code, omp_clause_mask,
1278                                  tree, tree *);
1279 extern tree c_omp_declare_simd_clauses_to_numbers (tree, tree);
1280 extern void c_omp_declare_simd_clauses_to_decls (tree, tree);
1281 extern enum omp_clause_default_kind c_omp_predetermined_sharing (tree);
1282
1283 /* Return next tree in the chain for chain_next walking of tree nodes.  */
1284 static inline tree
1285 c_tree_chain_next (tree t)
1286 {
1287   /* TREE_CHAIN of a type is TYPE_STUB_DECL, which is different
1288      kind of object, never a long chain of nodes.  Prefer
1289      TYPE_NEXT_VARIANT for types.  */
1290   if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_TYPE_COMMON))
1291     return TYPE_NEXT_VARIANT (t);
1292   /* Otherwise, if there is TREE_CHAIN, return it.  */
1293   if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_COMMON))
1294     return TREE_CHAIN (t);
1295   return NULL;
1296 }
1297
1298 /* Mask used by tm_stmt_attr.  */
1299 #define TM_STMT_ATTR_OUTER      2
1300 #define TM_STMT_ATTR_ATOMIC     4
1301 #define TM_STMT_ATTR_RELAXED    8
1302
1303 extern int parse_tm_stmt_attr (tree, int);
1304
1305 /* Mask used by tm_attr_to_mask and tm_mask_to_attr.  Note that these
1306    are ordered specifically such that more restrictive attributes are
1307    at lower bit positions.  This fact is known by the C++ tm attribute
1308    inheritance code such that least bit extraction (mask & -mask) results
1309    in the most restrictive attribute.  */
1310 #define TM_ATTR_SAFE                    1
1311 #define TM_ATTR_CALLABLE                2
1312 #define TM_ATTR_PURE                    4
1313 #define TM_ATTR_IRREVOCABLE             8
1314 #define TM_ATTR_MAY_CANCEL_OUTER        16
1315
1316 extern int tm_attr_to_mask (tree);
1317 extern tree tm_mask_to_attr (int);
1318 extern tree find_tm_attribute (tree);
1319
1320 /* A suffix-identifier value doublet that represents user-defined literals
1321    for C++-0x.  */
1322 enum overflow_type {
1323   OT_UNDERFLOW = -1,
1324   OT_NONE,
1325   OT_OVERFLOW
1326 };
1327
1328 struct GTY(()) tree_userdef_literal {
1329   struct tree_base base;
1330   tree suffix_id;
1331   tree value;
1332   tree num_string;
1333   enum overflow_type overflow;
1334 };
1335
1336 #define USERDEF_LITERAL_SUFFIX_ID(NODE) \
1337   (((struct tree_userdef_literal *)USERDEF_LITERAL_CHECK (NODE))->suffix_id)
1338
1339 #define USERDEF_LITERAL_VALUE(NODE) \
1340   (((struct tree_userdef_literal *)USERDEF_LITERAL_CHECK (NODE))->value)
1341
1342 #define USERDEF_LITERAL_OVERFLOW(NODE) \
1343   (((struct tree_userdef_literal *)USERDEF_LITERAL_CHECK (NODE))->overflow)
1344
1345 #define USERDEF_LITERAL_NUM_STRING(NODE) \
1346   (((struct tree_userdef_literal *)USERDEF_LITERAL_CHECK (NODE))->num_string)
1347
1348 #define USERDEF_LITERAL_TYPE(NODE) \
1349   (TREE_TYPE (USERDEF_LITERAL_VALUE (NODE)))
1350
1351 extern tree build_userdef_literal (tree suffix_id, tree value,
1352                                    enum overflow_type overflow,
1353                                    tree num_string);
1354
1355 extern bool convert_vector_to_pointer_for_subscript (location_t, tree *, tree);
1356
1357 /* Possibe cases of scalar_to_vector conversion.  */
1358 enum stv_conv {
1359   stv_error,        /* Error occurred.  */
1360   stv_nothing,      /* Nothing happened.  */
1361   stv_firstarg,     /* First argument must be expanded.  */
1362   stv_secondarg     /* Second argument must be expanded.  */
1363 };
1364
1365 extern enum stv_conv scalar_to_vector (location_t loc, enum tree_code code,
1366                                        tree op0, tree op1, bool);
1367
1368 /* In c-cilkplus.c  */
1369 extern tree c_finish_cilk_clauses (tree);
1370 extern tree c_validate_cilk_plus_loop (tree *, int *, void *);
1371 extern bool c_check_cilk_loop (location_t, tree);
1372
1373 /* These #defines allow users to access different operands of the
1374    array notation tree.  */
1375
1376 #define ARRAY_NOTATION_CHECK(NODE) TREE_CHECK (NODE, ARRAY_NOTATION_REF)
1377 #define ARRAY_NOTATION_ARRAY(NODE) \
1378   TREE_OPERAND (ARRAY_NOTATION_CHECK (NODE), 0)
1379 #define ARRAY_NOTATION_START(NODE) \
1380   TREE_OPERAND (ARRAY_NOTATION_CHECK (NODE), 1)
1381 #define ARRAY_NOTATION_LENGTH(NODE) \
1382   TREE_OPERAND (ARRAY_NOTATION_CHECK (NODE), 2)
1383 #define ARRAY_NOTATION_STRIDE(NODE) \
1384   TREE_OPERAND (ARRAY_NOTATION_CHECK (NODE), 3)
1385
1386 /* This structure holds all the scalar values and its appropriate variable
1387    replacment.  It is mainly used by the function that pulls all the invariant
1388    parts that should be executed only once, which comes with array notation
1389    expressions.  */
1390 struct inv_list
1391 {
1392   vec<tree, va_gc> *list_values;
1393   vec<tree, va_gc> *replacement;
1394   vec<enum tree_code, va_gc> *additional_tcodes;
1395 };
1396
1397 /* This structure holds all the important components that can be extracted
1398    from an ARRAY_NOTATION_REF expression.  It is used to pass array notation
1399    information between the functions that are responsible for expansion.  */
1400 typedef struct cilkplus_an_parts
1401 {
1402   tree value;
1403   tree start;
1404   tree length;
1405   tree stride;
1406   bool is_vector;
1407 } an_parts;
1408
1409 /* This structure holds the components necessary to create the loop around
1410    the ARRAY_REF that is created using the ARRAY_NOTATION information.  */
1411
1412 typedef struct cilkplus_an_loop_parts
1413 {
1414   tree var;         /* Loop induction variable.  */
1415   tree incr;        /* Loop increment/decrement expression.  */
1416   tree cmp;         /* Loop condition.  */
1417   tree ind_init;    /* Initialization of the loop induction variable.  */
1418 } an_loop_parts;
1419
1420 /* In array-notation-common.c.  */
1421 extern HOST_WIDE_INT extract_sec_implicit_index_arg (location_t, tree);
1422 extern bool is_sec_implicit_index_fn (tree);
1423 extern void array_notation_init_builtins (void);
1424 extern struct c_expr fix_array_notation_expr (location_t, enum tree_code,
1425                                               struct c_expr);
1426 extern bool contains_array_notation_expr (tree);
1427 extern tree expand_array_notation_exprs (tree);
1428 extern tree fix_conditional_array_notations (tree);
1429 extern tree find_correct_array_notation_type (tree);
1430 extern bool length_mismatch_in_expr_p (location_t, vec<vec<an_parts> >);
1431 extern enum built_in_function is_cilkplus_reduce_builtin (tree);
1432 extern bool find_rank (location_t, tree, tree, bool, size_t *);
1433 extern void extract_array_notation_exprs (tree, bool, vec<tree, va_gc> **);
1434 extern void replace_array_notations (tree *, bool, vec<tree, va_gc> *,
1435                                      vec<tree, va_gc> *);
1436 extern tree find_inv_trees (tree *, int *, void *);
1437 extern tree replace_inv_trees (tree *, int *, void *);
1438 extern tree find_correct_array_notation_type (tree op);
1439 extern void cilkplus_extract_an_triplets (vec<tree, va_gc> *, size_t, size_t,
1440                                           vec<vec<an_parts> > *);
1441 extern vec <tree, va_gc> *fix_sec_implicit_args
1442   (location_t, vec <tree, va_gc> *, vec<an_loop_parts>, size_t, tree);
1443 extern bool is_cilkplus_vector_p (tree);
1444
1445 /* In cilk.c.  */
1446 extern tree insert_cilk_frame (tree);
1447 extern void cilk_init_builtins (void);
1448 extern int gimplify_cilk_spawn (tree *);
1449 extern void cilk_gimplify_call_params_in_spawned_fn (tree *, gimple_seq *,
1450                                                      gimple_seq *);
1451 extern void cilk_install_body_with_frame_cleanup (tree, tree, void *);
1452 extern bool cilk_detect_spawn_and_unwrap (tree *);
1453 extern bool cilk_set_spawn_marker (location_t, tree);
1454 extern tree build_cilk_sync (void);
1455 extern tree build_cilk_spawn (location_t, tree);
1456 extern tree make_cilk_frame (tree);
1457 extern tree create_cilk_function_exit (tree, bool, bool);
1458 extern tree cilk_install_body_pedigree_operations (tree);
1459 extern void cilk_outline (tree, tree *, void *);
1460 extern bool contains_cilk_spawn_stmt (tree);
1461 extern tree cilk_for_number_of_iterations (tree);
1462 extern bool check_no_cilk (tree, const char *, const char *,
1463                            location_t loc = UNKNOWN_LOCATION);
1464 extern bool reject_gcc_builtin (const_tree, location_t = UNKNOWN_LOCATION);
1465 extern void warn_duplicated_cond_add_or_warn (location_t, tree, vec<tree> **);
1466 extern bool valid_array_size_p (location_t, tree, tree);
1467
1468 #endif /* ! GCC_C_COMMON_H */