gcc/c-family/c-common.h

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