gcc/c-family/c-common.h

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