Subversion Repositories openrisc

/* Definitions for c-common.c.

   Copyright (C) 1987, 1993, 1994, 1995, 1997, 1998,

   1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010, 2011

   Free Software Foundation, Inc.

This file is part of GCC.

GCC is free software; you can redistribute it and/or modify it under

the terms of the GNU General Public License as published by the Free

Software Foundation; either version 3, or (at your option) any later

version.

GCC is distributed in the hope that it will be useful, but WITHOUT ANY

WARRANTY; without even the implied warranty of MERCHANTABILITY or

FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

for more details.

You should have received a copy of the GNU General Public License

along with GCC; see the file COPYING3.  If not see

<http://www.gnu.org/licenses/>.  */

#ifndef GCC_C_COMMON_H

#define GCC_C_COMMON_H

#include "splay-tree.h"

#include "cpplib.h"

#include "ggc.h"

/* In order for the format checking to accept the C frontend

   diagnostic framework extensions, you must include this file before

   diagnostic-core.h, not after.  The C front end formats are a subset of those

   for C++, so they are the appropriate set to use in common code;

   cp-tree.h overrides this for C++.  */

#if defined(GCC_DIAGNOSTIC_CORE_H)

#error \

In order for the format checking to accept the C front end diagnostic \

framework extensions, you must include this file before diagnostic-core.h \

never after.

#endif

#ifndef GCC_DIAG_STYLE

#define GCC_DIAG_STYLE __gcc_cdiag__

#endif

#include "diagnostic-core.h"

/* Usage of TREE_LANG_FLAG_?:

   0: IDENTIFIER_MARKED (used by search routines).

      DECL_PRETTY_FUNCTION_P (in VAR_DECL)

      C_MAYBE_CONST_EXPR_INT_OPERANDS (in C_MAYBE_CONST_EXPR, for C)

   1: C_DECLARED_LABEL_FLAG (in LABEL_DECL)

      STATEMENT_LIST_STMT_EXPR (in STATEMENT_LIST)

      C_MAYBE_CONST_EXPR_NON_CONST (in C_MAYBE_CONST_EXPR, for C)

   2: unused

   3: STATEMENT_LIST_HAS_LABEL (in STATEMENT_LIST)

   4: unused

*/

/* Reserved identifiers.  This is the union of all the keywords for C,

   C++, and Objective-C.  All the type modifiers have to be in one

   block at the beginning, because they are used as mask bits.  There

   are 28 type modifiers; if we add many more we will have to redesign

   the mask mechanism.  */

enum rid

{

  /* Modifiers: */

  /* C, in empirical order of frequency.  */

  RID_STATIC = 0,

  RID_UNSIGNED, RID_LONG,    RID_CONST, RID_EXTERN,

  RID_REGISTER, RID_TYPEDEF, RID_SHORT, RID_INLINE,

  RID_VOLATILE, RID_SIGNED,  RID_AUTO,  RID_RESTRICT,

  RID_NORETURN,

  /* C extensions */

  RID_COMPLEX, RID_THREAD, RID_SAT,

  /* C++ */

  RID_FRIEND, RID_VIRTUAL, RID_EXPLICIT, RID_EXPORT, RID_MUTABLE,

  /* ObjC ("PQ" reserved words - they do not appear after a '@' and

     are keywords only in specific contexts)  */

  RID_IN, RID_OUT, RID_INOUT, RID_BYCOPY, RID_BYREF, RID_ONEWAY,

  /* ObjC ("PATTR" reserved words - they do not appear after a '@'

     and are keywords only as property attributes)  */

  RID_GETTER, RID_SETTER,

  RID_READONLY, RID_READWRITE,

  RID_ASSIGN, RID_RETAIN, RID_COPY,

  RID_NONATOMIC,

  /* C (reserved and imaginary types not implemented, so any use is a

     syntax error) */

  RID_IMAGINARY,

  /* C */

  RID_INT,     RID_CHAR,   RID_FLOAT,    RID_DOUBLE, RID_VOID,

  RID_INT128,

  RID_ENUM,    RID_STRUCT, RID_UNION,    RID_IF,     RID_ELSE,

  RID_WHILE,   RID_DO,     RID_FOR,      RID_SWITCH, RID_CASE,

  RID_DEFAULT, RID_BREAK,  RID_CONTINUE, RID_RETURN, RID_GOTO,

  RID_SIZEOF,

  /* C extensions */

  RID_ASM,       RID_TYPEOF,   RID_ALIGNOF,  RID_ATTRIBUTE,  RID_VA_ARG,

  RID_EXTENSION, RID_IMAGPART, RID_REALPART, RID_LABEL,      RID_CHOOSE_EXPR,

  RID_TYPES_COMPATIBLE_P,      RID_BUILTIN_COMPLEX,          RID_BUILTIN_SHUFFLE,

  RID_DFLOAT32, RID_DFLOAT64, RID_DFLOAT128,

  RID_FRACT, RID_ACCUM,

  /* C11 */

  RID_ALIGNAS,

  /* This means to warn that this is a C++ keyword, and then treat it

     as a normal identifier.  */

  RID_CXX_COMPAT_WARN,

  /* GNU transactional memory extension */

  RID_TRANSACTION_ATOMIC, RID_TRANSACTION_RELAXED, RID_TRANSACTION_CANCEL,

  /* Too many ways of getting the name of a function as a string */

  RID_FUNCTION_NAME, RID_PRETTY_FUNCTION_NAME, RID_C99_FUNCTION_NAME,

  /* C++ (some of these are keywords in Objective-C as well, but only

     if they appear after a '@') */

  RID_BOOL,     RID_WCHAR,    RID_CLASS,

  RID_PUBLIC,   RID_PRIVATE,  RID_PROTECTED,

  RID_TEMPLATE, RID_NULL,     RID_CATCH,

  RID_DELETE,   RID_FALSE,    RID_NAMESPACE,

  RID_NEW,      RID_OFFSETOF, RID_OPERATOR,

  RID_THIS,     RID_THROW,    RID_TRUE,

  RID_TRY,      RID_TYPENAME, RID_TYPEID,

  RID_USING,    RID_CHAR16,   RID_CHAR32,

  /* casts */

  RID_CONSTCAST, RID_DYNCAST, RID_REINTCAST, RID_STATCAST,

  /* C++ extensions */

  RID_BASES,                   RID_DIRECT_BASES,

  RID_HAS_NOTHROW_ASSIGN,      RID_HAS_NOTHROW_CONSTRUCTOR,

  RID_HAS_NOTHROW_COPY,        RID_HAS_TRIVIAL_ASSIGN,

  RID_HAS_TRIVIAL_CONSTRUCTOR, RID_HAS_TRIVIAL_COPY,

  RID_HAS_TRIVIAL_DESTRUCTOR,  RID_HAS_VIRTUAL_DESTRUCTOR,

  RID_IS_ABSTRACT,             RID_IS_BASE_OF,

  RID_IS_CLASS,                RID_IS_CONVERTIBLE_TO,

  RID_IS_EMPTY,                RID_IS_ENUM,

  RID_IS_FINAL,                RID_IS_LITERAL_TYPE,

  RID_IS_POD,                  RID_IS_POLYMORPHIC,

  RID_IS_STD_LAYOUT,           RID_IS_TRIVIAL,

  RID_IS_UNION,                RID_UNDERLYING_TYPE,

  /* C++11 */

  RID_CONSTEXPR, RID_DECLTYPE, RID_NOEXCEPT, RID_NULLPTR, RID_STATIC_ASSERT,

  /* Objective-C ("AT" reserved words - they are only keywords when

     they follow '@')  */

  RID_AT_ENCODE,   RID_AT_END,

  RID_AT_CLASS,    RID_AT_ALIAS,     RID_AT_DEFS,

  RID_AT_PRIVATE,  RID_AT_PROTECTED, RID_AT_PUBLIC,  RID_AT_PACKAGE,

  RID_AT_PROTOCOL, RID_AT_SELECTOR,

  RID_AT_THROW,    RID_AT_TRY,       RID_AT_CATCH,

  RID_AT_FINALLY,  RID_AT_SYNCHRONIZED,

  RID_AT_OPTIONAL, RID_AT_REQUIRED, RID_AT_PROPERTY,

  RID_AT_SYNTHESIZE, RID_AT_DYNAMIC,

  RID_AT_INTERFACE,

  RID_AT_IMPLEMENTATION,

  /* Named address support, mapping the keyword to a particular named address

     number.  Named address space 0 is reserved for the generic address.  If

     there are more than 254 named addresses, the addr_space_t type will need

     to be grown from an unsigned char to unsigned short.  */

  RID_ADDR_SPACE_0,             /* generic address */

  RID_ADDR_SPACE_1,

  RID_ADDR_SPACE_2,

  RID_ADDR_SPACE_3,

  RID_ADDR_SPACE_4,

  RID_ADDR_SPACE_5,

  RID_ADDR_SPACE_6,

  RID_ADDR_SPACE_7,

  RID_ADDR_SPACE_8,

  RID_ADDR_SPACE_9,

  RID_ADDR_SPACE_10,

  RID_ADDR_SPACE_11,

  RID_ADDR_SPACE_12,

  RID_ADDR_SPACE_13,

  RID_ADDR_SPACE_14,

  RID_ADDR_SPACE_15,

  RID_FIRST_ADDR_SPACE = RID_ADDR_SPACE_0,

  RID_LAST_ADDR_SPACE = RID_ADDR_SPACE_15,

  RID_MAX,

  RID_FIRST_MODIFIER = RID_STATIC,

  RID_LAST_MODIFIER = RID_ONEWAY,

  RID_FIRST_CXX0X = RID_CONSTEXPR,

  RID_LAST_CXX0X = RID_STATIC_ASSERT,

  RID_FIRST_AT = RID_AT_ENCODE,

  RID_LAST_AT = RID_AT_IMPLEMENTATION,

  RID_FIRST_PQ = RID_IN,

  RID_LAST_PQ = RID_ONEWAY,

  RID_FIRST_PATTR = RID_GETTER,

  RID_LAST_PATTR = RID_NONATOMIC

};

#define OBJC_IS_AT_KEYWORD(rid) \

  ((unsigned int) (rid) >= (unsigned int) RID_FIRST_AT && \

   (unsigned int) (rid) <= (unsigned int) RID_LAST_AT)

#define OBJC_IS_PQ_KEYWORD(rid) \

  ((unsigned int) (rid) >= (unsigned int) RID_FIRST_PQ && \

   (unsigned int) (rid) <= (unsigned int) RID_LAST_PQ)

#define OBJC_IS_PATTR_KEYWORD(rid) \

  ((unsigned int) (rid) >= (unsigned int) RID_FIRST_PATTR && \

   (unsigned int) (rid) <= (unsigned int) RID_LAST_PATTR)

/* OBJC_IS_CXX_KEYWORD recognizes the 'CXX_OBJC' keywords (such as

   'class') which are shared in a subtle way between Objective-C and

   C++.  When the lexer is lexing in Objective-C/Objective-C++, if it

   finds '@' followed by one of these identifiers (eg, '@class'), it

   recognizes the whole as an Objective-C keyword.  If the identifier

   is found elsewhere, it follows the rules of the C/C++ language.

 */

#define OBJC_IS_CXX_KEYWORD(rid) \

  (rid == RID_CLASS                                                     \

   || rid == RID_PUBLIC || rid == RID_PROTECTED || rid == RID_PRIVATE   \

   || rid == RID_TRY || rid == RID_THROW || rid == RID_CATCH)

/* The elements of `ridpointers' are identifier nodes for the reserved

   type names and storage classes.  It is indexed by a RID_... value.  */

extern GTY ((length ("(int) RID_MAX"))) tree *ridpointers;

/* Standard named or nameless data types of the C compiler.  */

enum c_tree_index

{

    CTI_CHAR16_TYPE,

    CTI_CHAR32_TYPE,

    CTI_WCHAR_TYPE,

    CTI_UNDERLYING_WCHAR_TYPE,

    CTI_WINT_TYPE,

    CTI_SIGNED_SIZE_TYPE, /* For format checking only.  */

    CTI_UNSIGNED_PTRDIFF_TYPE, /* For format checking only.  */

    CTI_INTMAX_TYPE,

    CTI_UINTMAX_TYPE,

    CTI_WIDEST_INT_LIT_TYPE,

    CTI_WIDEST_UINT_LIT_TYPE,

    /* Types for <stdint.h>, that may not be defined on all

       targets.  */

    CTI_SIG_ATOMIC_TYPE,

    CTI_INT8_TYPE,

    CTI_INT16_TYPE,

    CTI_INT32_TYPE,

    CTI_INT64_TYPE,

    CTI_UINT8_TYPE,

    CTI_UINT16_TYPE,

    CTI_UINT32_TYPE,

    CTI_UINT64_TYPE,

    CTI_INT_LEAST8_TYPE,

    CTI_INT_LEAST16_TYPE,

    CTI_INT_LEAST32_TYPE,

    CTI_INT_LEAST64_TYPE,

    CTI_UINT_LEAST8_TYPE,

    CTI_UINT_LEAST16_TYPE,

    CTI_UINT_LEAST32_TYPE,

    CTI_UINT_LEAST64_TYPE,

    CTI_INT_FAST8_TYPE,

    CTI_INT_FAST16_TYPE,

    CTI_INT_FAST32_TYPE,

    CTI_INT_FAST64_TYPE,

    CTI_UINT_FAST8_TYPE,

    CTI_UINT_FAST16_TYPE,

    CTI_UINT_FAST32_TYPE,

    CTI_UINT_FAST64_TYPE,

    CTI_INTPTR_TYPE,

    CTI_UINTPTR_TYPE,

    CTI_CHAR_ARRAY_TYPE,

    CTI_CHAR16_ARRAY_TYPE,

    CTI_CHAR32_ARRAY_TYPE,

    CTI_WCHAR_ARRAY_TYPE,

    CTI_INT_ARRAY_TYPE,

    CTI_STRING_TYPE,

    CTI_CONST_STRING_TYPE,

    /* Type for boolean expressions (bool in C++, int in C).  */

    CTI_TRUTHVALUE_TYPE,

    CTI_TRUTHVALUE_TRUE,

    CTI_TRUTHVALUE_FALSE,

    CTI_DEFAULT_FUNCTION_TYPE,

    /* These are not types, but we have to look them up all the time.  */

    CTI_FUNCTION_NAME_DECL,

    CTI_PRETTY_FUNCTION_NAME_DECL,

    CTI_C99_FUNCTION_NAME_DECL,

    CTI_SAVED_FUNCTION_NAME_DECLS,

    CTI_VOID_ZERO,

    CTI_NULL,

    CTI_MAX

};

#define C_CPP_HASHNODE(id) \

  (&(((struct c_common_identifier *) (id))->node))

#define C_RID_CODE(id) \

  ((enum rid) (((struct c_common_identifier *) (id))->node.rid_code))

#define C_SET_RID_CODE(id, code) \

  (((struct c_common_identifier *) (id))->node.rid_code = (unsigned char) code)

/* Identifier part common to the C front ends.  Inherits from

   tree_identifier, despite appearances.  */

struct GTY(()) c_common_identifier {

  struct tree_common common;

  struct cpp_hashnode node;

};

/* An entry in the reserved keyword table.  */

struct c_common_resword

{

  const char *const word;

  ENUM_BITFIELD(rid) const rid : 16;

  const unsigned int disable   : 16;

};

/* Extra cpp_ttype values for C++.  */

/* A token type for keywords, as opposed to ordinary identifiers.  */

#define CPP_KEYWORD ((enum cpp_ttype) (N_TTYPES + 1))

/* A token type for template-ids.  If a template-id is processed while

   parsing tentatively, it is replaced with a CPP_TEMPLATE_ID token;

   the value of the CPP_TEMPLATE_ID is whatever was returned by

   cp_parser_template_id.  */

#define CPP_TEMPLATE_ID ((enum cpp_ttype) (CPP_KEYWORD + 1))

/* A token type for nested-name-specifiers.  If a

   nested-name-specifier is processed while parsing tentatively, it is

   replaced with a CPP_NESTED_NAME_SPECIFIER token; the value of the

   CPP_NESTED_NAME_SPECIFIER is whatever was returned by

   cp_parser_nested_name_specifier_opt.  */

#define CPP_NESTED_NAME_SPECIFIER ((enum cpp_ttype) (CPP_TEMPLATE_ID + 1))

/* A token type for pre-parsed C++0x decltype.  */

#define CPP_DECLTYPE ((enum cpp_ttype) (CPP_NESTED_NAME_SPECIFIER + 1))

/* The number of token types, including C++-specific ones.  */

#define N_CP_TTYPES ((int) (CPP_DECLTYPE + 1))

/* Disable mask.  Keywords are disabled if (reswords[i].disable &

   mask) is _true_.  Thus for keywords which are present in all

   languages the disable field is zero.  */

#define D_CONLY         0x001   /* C only (not in C++).  */

#define D_CXXONLY       0x002   /* C++ only (not in C).  */

#define D_C99           0x004   /* In C, C99 only.  */

#define D_CXX0X         0x008   /* In C++, C++0X only.  */

#define D_EXT           0x010   /* GCC extension.  */

#define D_EXT89         0x020   /* GCC extension incorporated in C99.  */

#define D_ASM           0x040   /* Disabled by -fno-asm.  */

#define D_OBJC          0x080   /* In Objective C and neither C nor C++.  */

#define D_CXX_OBJC      0x100   /* In Objective C, and C++, but not C.  */

#define D_CXXWARN       0x200   /* In C warn with -Wcxx-compat.  */

/* The reserved keyword table.  */

extern const struct c_common_resword c_common_reswords[];

/* The number of items in the reserved keyword table.  */

extern const unsigned int num_c_common_reswords;

#define char16_type_node                c_global_trees[CTI_CHAR16_TYPE]

#define char32_type_node                c_global_trees[CTI_CHAR32_TYPE]

#define wchar_type_node                 c_global_trees[CTI_WCHAR_TYPE]

#define underlying_wchar_type_node      c_global_trees[CTI_UNDERLYING_WCHAR_TYPE]

#define wint_type_node                  c_global_trees[CTI_WINT_TYPE]

#define signed_size_type_node           c_global_trees[CTI_SIGNED_SIZE_TYPE]

#define unsigned_ptrdiff_type_node      c_global_trees[CTI_UNSIGNED_PTRDIFF_TYPE]

#define intmax_type_node                c_global_trees[CTI_INTMAX_TYPE]

#define uintmax_type_node               c_global_trees[CTI_UINTMAX_TYPE]

#define widest_integer_literal_type_node c_global_trees[CTI_WIDEST_INT_LIT_TYPE]

#define widest_unsigned_literal_type_node c_global_trees[CTI_WIDEST_UINT_LIT_TYPE]

#define sig_atomic_type_node            c_global_trees[CTI_SIG_ATOMIC_TYPE]

#define int8_type_node                  c_global_trees[CTI_INT8_TYPE]

#define int16_type_node                 c_global_trees[CTI_INT16_TYPE]

#define int32_type_node                 c_global_trees[CTI_INT32_TYPE]

#define int64_type_node                 c_global_trees[CTI_INT64_TYPE]

#define uint8_type_node                 c_global_trees[CTI_UINT8_TYPE]

#define uint16_type_node                c_global_trees[CTI_UINT16_TYPE]

#define c_uint32_type_node              c_global_trees[CTI_UINT32_TYPE]

#define c_uint64_type_node              c_global_trees[CTI_UINT64_TYPE]

#define int_least8_type_node            c_global_trees[CTI_INT_LEAST8_TYPE]

#define int_least16_type_node           c_global_trees[CTI_INT_LEAST16_TYPE]

#define int_least32_type_node           c_global_trees[CTI_INT_LEAST32_TYPE]

#define int_least64_type_node           c_global_trees[CTI_INT_LEAST64_TYPE]

#define uint_least8_type_node           c_global_trees[CTI_UINT_LEAST8_TYPE]

#define uint_least16_type_node          c_global_trees[CTI_UINT_LEAST16_TYPE]

#define uint_least32_type_node          c_global_trees[CTI_UINT_LEAST32_TYPE]

#define uint_least64_type_node          c_global_trees[CTI_UINT_LEAST64_TYPE]

#define int_fast8_type_node             c_global_trees[CTI_INT_FAST8_TYPE]

#define int_fast16_type_node            c_global_trees[CTI_INT_FAST16_TYPE]

#define int_fast32_type_node            c_global_trees[CTI_INT_FAST32_TYPE]

#define int_fast64_type_node            c_global_trees[CTI_INT_FAST64_TYPE]

#define uint_fast8_type_node            c_global_trees[CTI_UINT_FAST8_TYPE]

#define uint_fast16_type_node           c_global_trees[CTI_UINT_FAST16_TYPE]

#define uint_fast32_type_node           c_global_trees[CTI_UINT_FAST32_TYPE]

#define uint_fast64_type_node           c_global_trees[CTI_UINT_FAST64_TYPE]

#define intptr_type_node                c_global_trees[CTI_INTPTR_TYPE]

#define uintptr_type_node               c_global_trees[CTI_UINTPTR_TYPE]

#define truthvalue_type_node            c_global_trees[CTI_TRUTHVALUE_TYPE]

#define truthvalue_true_node            c_global_trees[CTI_TRUTHVALUE_TRUE]

#define truthvalue_false_node           c_global_trees[CTI_TRUTHVALUE_FALSE]

#define char_array_type_node            c_global_trees[CTI_CHAR_ARRAY_TYPE]

#define char16_array_type_node          c_global_trees[CTI_CHAR16_ARRAY_TYPE]

#define char32_array_type_node          c_global_trees[CTI_CHAR32_ARRAY_TYPE]

#define wchar_array_type_node           c_global_trees[CTI_WCHAR_ARRAY_TYPE]

#define int_array_type_node             c_global_trees[CTI_INT_ARRAY_TYPE]

#define string_type_node                c_global_trees[CTI_STRING_TYPE]

#define const_string_type_node          c_global_trees[CTI_CONST_STRING_TYPE]

#define default_function_type           c_global_trees[CTI_DEFAULT_FUNCTION_TYPE]

#define function_name_decl_node         c_global_trees[CTI_FUNCTION_NAME_DECL]

#define pretty_function_name_decl_node  c_global_trees[CTI_PRETTY_FUNCTION_NAME_DECL]

#define c99_function_name_decl_node             c_global_trees[CTI_C99_FUNCTION_NAME_DECL]

#define saved_function_name_decls       c_global_trees[CTI_SAVED_FUNCTION_NAME_DECLS]

/* A node for `((void) 0)'.  */

#define void_zero_node                  c_global_trees[CTI_VOID_ZERO]

/* The node for C++ `__null'.  */

#define null_node                       c_global_trees[CTI_NULL]

extern GTY(()) tree c_global_trees[CTI_MAX];

/* In a RECORD_TYPE, a sorted array of the fields of the type, not a

   tree for size reasons.  */

struct GTY((variable_size)) sorted_fields_type {

  int len;

  tree GTY((length ("%h.len"))) elts[1];

};

/* Mark which labels are explicitly declared.

   These may be shadowed, and may be referenced from nested functions.  */

#define C_DECLARED_LABEL_FLAG(label) TREE_LANG_FLAG_1 (label)

typedef enum c_language_kind

{

  clk_c         = 0,             /* C90, C94 or C99 */

  clk_objc      = 1,            /* clk_c with ObjC features.  */

  clk_cxx       = 2,            /* ANSI/ISO C++ */

  clk_objcxx    = 3             /* clk_cxx with ObjC features.  */

}

c_language_kind;

/* To test for a specific language use c_language, defined by each

   front end.  For "ObjC features" or "not C++" use the macros.  */

extern c_language_kind c_language;

#define c_dialect_cxx()         ((c_language & clk_cxx) != 0)

#define c_dialect_objc()        ((c_language & clk_objc) != 0)

/* The various name of operator that appears in error messages. */

typedef enum ref_operator {

  /* NULL */

  RO_NULL,

  /* array indexing */

  RO_ARRAY_INDEXING,

  /* unary * */

  RO_UNARY_STAR,

  /* -> */

  RO_ARROW,

  /* implicit conversion */

  RO_IMPLICIT_CONVERSION

} ref_operator;

/* Information about a statement tree.  */

struct GTY(()) stmt_tree_s {

  /* A stack of statement lists being collected.  */

  VEC(tree,gc) *x_cur_stmt_list;

  /* In C++, Nonzero if we should treat statements as full

     expressions.  In particular, this variable is non-zero if at the

     end of a statement we should destroy any temporaries created

     during that statement.  Similarly, if, at the end of a block, we

     should destroy any local variables in this block.  Normally, this

     variable is nonzero, since those are the normal semantics of

     C++.

     This flag has no effect in C.  */

  int stmts_are_full_exprs_p;

};

typedef struct stmt_tree_s *stmt_tree;

/* Global state pertinent to the current function.  Some C dialects

   extend this structure with additional fields.  */

struct GTY(()) c_language_function {

  /* While we are parsing the function, this contains information

     about the statement-tree that we are building.  */

  struct stmt_tree_s x_stmt_tree;

  /* Vector of locally defined typedefs, for

     -Wunused-local-typedefs.  */

  VEC(tree,gc) *local_typedefs;

};

#define stmt_list_stack (current_stmt_tree ()->x_cur_stmt_list)

/* When building a statement-tree, this is the current statement list

   being collected.  We define it in this convoluted way, rather than

   using VEC_last, because it must be an lvalue.  */

#define cur_stmt_list                                                   \

  (*(VEC_address (tree, stmt_list_stack)                                \

     + VEC_length (tree, stmt_list_stack) - 1))

#define building_stmt_list_p() (!VEC_empty (tree, stmt_list_stack))

/* Language-specific hooks.  */

/* If non-NULL, this function is called after a precompile header file

   is loaded.  */

extern void (*lang_post_pch_load) (void);

extern void push_file_scope (void);

extern void pop_file_scope (void);

extern stmt_tree current_stmt_tree (void);

extern tree push_stmt_list (void);

extern tree pop_stmt_list (tree);

extern tree add_stmt (tree);

extern void push_cleanup (tree, tree, bool);

extern tree pushdecl_top_level (tree);

extern tree pushdecl (tree);

extern tree build_modify_expr (location_t, tree, tree, enum tree_code,

                               location_t, tree, tree);

extern tree build_indirect_ref (location_t, tree, ref_operator);

extern int c_expand_decl (tree);

extern int field_decl_cmp (const void *, const void *);

extern void resort_sorted_fields (void *, void *, gt_pointer_operator,

                                  void *);

extern bool has_c_linkage (const_tree decl);

/* Switches common to the C front ends.  */

/* Nonzero means don't output line number information.  */

extern char flag_no_line_commands;

/* Nonzero causes -E output not to be done, but directives such as

   #define that have side effects are still obeyed.  */

extern char flag_no_output;

/* Nonzero means dump macros in some fashion; contains the 'D', 'M',

   'N' or 'U' of the command line switch.  */

extern char flag_dump_macros;

/* Nonzero means pass #include lines through to the output.  */

extern char flag_dump_includes;

/* Nonzero means process PCH files while preprocessing.  */

extern bool flag_pch_preprocess;

/* The file name to which we should write a precompiled header, or

   NULL if no header will be written in this compile.  */

extern const char *pch_file;

/* Nonzero if an ISO standard was selected.  It rejects macros in the

   user's namespace.  */

extern int flag_iso;

/* Warn about #pragma directives that are not recognized.  */

extern int warn_unknown_pragmas; /* Tri state variable.  */

/* Warn about format/argument anomalies in calls to formatted I/O functions

   (*printf, *scanf, strftime, strfmon, etc.).  */

extern int warn_format;

/* C/ObjC language option variables.  */

/* Nonzero means allow type mismatches in conditional expressions;

   just make their values `void'.  */

extern int flag_cond_mismatch;

/* Nonzero means enable C89 Amendment 1 features.  */

extern int flag_isoc94;

/* Nonzero means use the ISO C99 (or C11) dialect of C.  */

extern int flag_isoc99;

/* Nonzero means use the ISO C11 dialect of C.  */

extern int flag_isoc11;

/* Nonzero means that we have builtin functions, and main is an int.  */

extern int flag_hosted;

/* ObjC language option variables.  */

/* Tells the compiler that this is a special run.  Do not perform any

   compiling, instead we are to test some platform dependent features

   and output a C header file with appropriate definitions.  */

extern int print_struct_values;

/* Tells the compiler what is the constant string class for ObjC.  */

extern const char *constant_string_class_name;

/* C++ language option variables.  */

/* Nonzero means generate separate instantiation control files and

   juggle them at link time.  */

extern int flag_use_repository;

/* The supported C++ dialects.  */

enum cxx_dialect {

  /* C++98 with TC1  */

  cxx98,

  cxx03 = cxx98,

  /* C++11  */

  cxx0x,

  cxx11 = cxx0x

};

/* The C++ dialect being used. C++98 is the default.  */

extern enum cxx_dialect cxx_dialect;

/* Maximum template instantiation depth.  This limit is rather

   arbitrary, but it exists to limit the time it takes to notice

   excessively recursive template instantiations.  */

extern int max_tinst_depth;

/* Nonzero means that we should not issue warnings about problems that

   occur when the code is executed, because the code being processed

   is not expected to be executed.  This is set during parsing.  This

   is used for cases like sizeof() and "0 ? a : b".  This is a count,

   not a bool, because unexecuted expressions can nest.  */

extern int c_inhibit_evaluation_warnings;

/* Whether lexing has been completed, so subsequent preprocessor

   errors should use the compiler's input_location.  */

extern bool done_lexing;

/* C types are partitioned into three subsets: object, function, and

   incomplete types.  */

#define C_TYPE_OBJECT_P(type) \

  (TREE_CODE (type) != FUNCTION_TYPE && TYPE_SIZE (type))

#define C_TYPE_INCOMPLETE_P(type) \

  (TREE_CODE (type) != FUNCTION_TYPE && TYPE_SIZE (type) == 0)

#define C_TYPE_FUNCTION_P(type) \

  (TREE_CODE (type) == FUNCTION_TYPE)

/* For convenience we define a single macro to identify the class of

   object or incomplete types.  */

#define C_TYPE_OBJECT_OR_INCOMPLETE_P(type) \

  (!C_TYPE_FUNCTION_P (type))

struct visibility_flags

{

  unsigned inpragma : 1;        /* True when in #pragma GCC visibility.  */

  unsigned inlines_hidden : 1;  /* True when -finlineshidden in effect.  */

};

/* Global visibility options.  */

extern struct visibility_flags visibility_options;

/* Attribute table common to the C front ends.  */

extern const struct attribute_spec c_common_attribute_table[];

extern const struct attribute_spec c_common_format_attribute_table[];

/* Pointer to function to lazily generate the VAR_DECL for __FUNCTION__ etc.

   ID is the identifier to use, NAME is the string.

   TYPE_DEP indicates whether it depends on type of the function or not

   (i.e. __PRETTY_FUNCTION__).  */

extern tree (*make_fname_decl) (location_t, tree, int);

/* In c-decl.c and cp/tree.c.  FIXME.  */

extern void c_register_addr_space (const char *str, addr_space_t as);

/* In c-common.c.  */

extern bool in_late_binary_op;

extern const char *c_addr_space_name (addr_space_t as);

extern tree identifier_global_value (tree);

extern tree c_linkage_bindings (tree);

extern void record_builtin_type (enum rid, const char *, tree);

extern tree build_void_list_node (void);

extern void start_fname_decls (void);

extern void finish_fname_decls (void);

extern const char *fname_as_string (int);

extern tree fname_decl (location_t, unsigned, tree);

extern int check_user_alignment (const_tree, bool);

extern void check_function_arguments (const_tree, int, tree *);

extern void check_function_arguments_recurse (void (*)

                                              (void *, tree,

                                               unsigned HOST_WIDE_INT),

                                              void *, tree,

                                              unsigned HOST_WIDE_INT);

extern bool check_builtin_function_arguments (tree, int, tree *);

extern void check_function_format (tree, int, tree *);

extern void set_Wformat (int);

extern tree handle_format_attribute (tree *, tree, tree, int, bool *);

extern tree handle_format_arg_attribute (tree *, tree, tree, int, bool *);

extern bool attribute_takes_identifier_p (const_tree);

extern bool c_common_handle_option (size_t, const char *, int, int, location_t,

                                    const struct cl_option_handlers *);

extern bool default_handle_c_option (size_t, const char *, int);

extern tree c_common_type_for_mode (enum machine_mode, int);

extern tree c_common_type_for_size (unsigned int, int);

extern tree c_common_fixed_point_type_for_size (unsigned int, unsigned int,

                                                int, int);

extern tree c_common_unsigned_type (tree);

extern tree c_common_signed_type (tree);

extern tree c_common_signed_or_unsigned_type (int, tree);

extern void c_common_init_ts (void);

extern tree c_build_bitfield_integer_type (unsigned HOST_WIDE_INT, int);

extern bool unsafe_conversion_p (tree, tree, bool);

extern bool decl_with_nonnull_addr_p (const_tree);

extern tree c_fully_fold (tree, bool, bool *);

extern tree decl_constant_value_for_optimization (tree);

extern tree c_wrap_maybe_const (tree, bool);