gcc/c-family/c-common.h

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