Home | History | Annotate | Download | only in include
      1 /* Definitions for c-common.c.
      2    Copyright (C) 1987, 1993, 1994, 1995, 1997, 1998,
      3    1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008
      4    Free Software Foundation, Inc.
      5 
      6 This file is part of GCC.
      7 
      8 GCC is free software; you can redistribute it and/or modify it under
      9 the terms of the GNU General Public License as published by the Free
     10 Software Foundation; either version 3, or (at your option) any later
     11 version.
     12 
     13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
     14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
     15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
     16 for more details.
     17 
     18 You should have received a copy of the GNU General Public License
     19 along with GCC; see the file COPYING3.  If not see
     20 <http://www.gnu.org/licenses/>.  */
     21 
     22 #ifndef GCC_C_COMMON_H
     23 #define GCC_C_COMMON_H
     24 
     25 #include "splay-tree.h"
     26 #include "cpplib.h"
     27 #include "ggc.h"
     28 
     29 /* Usage of TREE_LANG_FLAG_?:
     30    0: TREE_NEGATED_INT (in INTEGER_CST).
     31       IDENTIFIER_MARKED (used by search routines).
     32       DECL_PRETTY_FUNCTION_P (in VAR_DECL)
     33    1: C_DECLARED_LABEL_FLAG (in LABEL_DECL)
     34       STATEMENT_LIST_STMT_EXPR (in STATEMENT_LIST)
     35    2: unused
     36    3: STATEMENT_LIST_HAS_LABEL (in STATEMENT_LIST)
     37    4: unused
     38 */
     39 
     40 /* Reserved identifiers.  This is the union of all the keywords for C,
     41    C++, and Objective-C.  All the type modifiers have to be in one
     42    block at the beginning, because they are used as mask bits.  There
     43    are 27 type modifiers; if we add many more we will have to redesign
     44    the mask mechanism.  */
     45 
     46 enum rid
     47 {
     48   /* Modifiers: */
     49   /* C, in empirical order of frequency.  */
     50   RID_STATIC = 0,
     51   RID_UNSIGNED, RID_LONG,    RID_CONST, RID_EXTERN,
     52   RID_REGISTER, RID_TYPEDEF, RID_SHORT, RID_INLINE,
     53   RID_VOLATILE, RID_SIGNED,  RID_AUTO,  RID_RESTRICT,
     54 
     55   /* C extensions */
     56   RID_COMPLEX, RID_THREAD, RID_SAT,
     57 
     58   /* C++ */
     59   RID_FRIEND, RID_VIRTUAL, RID_EXPLICIT, RID_EXPORT, RID_MUTABLE,
     60 
     61   /* ObjC */
     62   RID_IN, RID_OUT, RID_INOUT, RID_BYCOPY, RID_BYREF, RID_ONEWAY,
     63 
     64   /* C */
     65   RID_INT,     RID_CHAR,   RID_FLOAT,    RID_DOUBLE, RID_VOID,
     66   RID_ENUM,    RID_STRUCT, RID_UNION,    RID_IF,     RID_ELSE,
     67   RID_WHILE,   RID_DO,     RID_FOR,      RID_SWITCH, RID_CASE,
     68   RID_DEFAULT, RID_BREAK,  RID_CONTINUE, RID_RETURN, RID_GOTO,
     69   RID_SIZEOF,
     70 
     71   /* C extensions */
     72   RID_ASM,       RID_TYPEOF,   RID_ALIGNOF,  RID_ATTRIBUTE,  RID_VA_ARG,
     73   RID_EXTENSION, RID_IMAGPART, RID_REALPART, RID_LABEL,      RID_CHOOSE_EXPR,
     74   RID_TYPES_COMPATIBLE_P,
     75   RID_DFLOAT32, RID_DFLOAT64, RID_DFLOAT128,
     76   RID_FRACT, RID_ACCUM,
     77 
     78   /* This means to warn that this is a C++ keyword, and then treat it
     79      as a normal identifier.  */
     80   RID_CXX_COMPAT_WARN,
     81 
     82   /* Too many ways of getting the name of a function as a string */
     83   RID_FUNCTION_NAME, RID_PRETTY_FUNCTION_NAME, RID_C99_FUNCTION_NAME,
     84 
     85   /* C++ */
     86   RID_BOOL,     RID_WCHAR,    RID_CLASS,
     87   RID_PUBLIC,   RID_PRIVATE,  RID_PROTECTED,
     88   RID_TEMPLATE, RID_NULL,     RID_CATCH,
     89   RID_DELETE,   RID_FALSE,    RID_NAMESPACE,
     90   RID_NEW,      RID_OFFSETOF, RID_OPERATOR,
     91   RID_THIS,     RID_THROW,    RID_TRUE,
     92   RID_TRY,      RID_TYPENAME, RID_TYPEID,
     93   RID_USING,    RID_CHAR16,   RID_CHAR32,
     94 
     95   /* casts */
     96   RID_CONSTCAST, RID_DYNCAST, RID_REINTCAST, RID_STATCAST,
     97 
     98   /* C++ extensions */
     99   RID_HAS_NOTHROW_ASSIGN,      RID_HAS_NOTHROW_CONSTRUCTOR,
    100   RID_HAS_NOTHROW_COPY,        RID_HAS_TRIVIAL_ASSIGN,
    101   RID_HAS_TRIVIAL_CONSTRUCTOR, RID_HAS_TRIVIAL_COPY,
    102   RID_HAS_TRIVIAL_DESTRUCTOR,  RID_HAS_VIRTUAL_DESTRUCTOR,
    103   RID_IS_ABSTRACT,             RID_IS_BASE_OF,
    104   RID_IS_CONVERTIBLE_TO,       RID_IS_CLASS,
    105   RID_IS_EMPTY,                RID_IS_ENUM,
    106   RID_IS_POD,                  RID_IS_POLYMORPHIC,
    107   RID_IS_UNION,
    108 
    109   /* C++0x */
    110   RID_STATIC_ASSERT, RID_DECLTYPE,
    111 
    112   /* Objective-C */
    113   RID_AT_ENCODE,   RID_AT_END,
    114   RID_AT_CLASS,    RID_AT_ALIAS,     RID_AT_DEFS,
    115   RID_AT_PRIVATE,  RID_AT_PROTECTED, RID_AT_PUBLIC,
    116   RID_AT_PROTOCOL, RID_AT_SELECTOR,
    117   RID_AT_THROW,	   RID_AT_TRY,       RID_AT_CATCH,
    118   RID_AT_FINALLY,  RID_AT_SYNCHRONIZED,
    119   RID_AT_INTERFACE,
    120   RID_AT_IMPLEMENTATION,
    121 
    122   RID_MAX,
    123 
    124   RID_FIRST_MODIFIER = RID_STATIC,
    125   RID_LAST_MODIFIER = RID_ONEWAY,
    126 
    127   RID_FIRST_CXX0X = RID_STATIC_ASSERT,
    128   RID_LAST_CXX0X = RID_DECLTYPE,
    129   RID_FIRST_AT = RID_AT_ENCODE,
    130   RID_LAST_AT = RID_AT_IMPLEMENTATION,
    131   RID_FIRST_PQ = RID_IN,
    132   RID_LAST_PQ = RID_ONEWAY
    133 };
    134 
    135 #define OBJC_IS_AT_KEYWORD(rid) \
    136   ((unsigned int) (rid) >= (unsigned int) RID_FIRST_AT && \
    137    (unsigned int) (rid) <= (unsigned int) RID_LAST_AT)
    138 
    139 #define OBJC_IS_PQ_KEYWORD(rid) \
    140   ((unsigned int) (rid) >= (unsigned int) RID_FIRST_PQ && \
    141    (unsigned int) (rid) <= (unsigned int) RID_LAST_PQ)
    142 
    143 /* The elements of `ridpointers' are identifier nodes for the reserved
    144    type names and storage classes.  It is indexed by a RID_... value.  */
    145 extern GTY ((length ("(int) RID_MAX"))) tree *ridpointers;
    146 
    147 /* Standard named or nameless data types of the C compiler.  */
    148 
    149 enum c_tree_index
    150 {
    151     CTI_CHAR16_TYPE,
    152     CTI_CHAR32_TYPE,
    153     CTI_WCHAR_TYPE,
    154     CTI_SIGNED_WCHAR_TYPE,
    155     CTI_UNSIGNED_WCHAR_TYPE,
    156     CTI_WINT_TYPE,
    157     CTI_SIGNED_SIZE_TYPE, /* For format checking only.  */
    158     CTI_UNSIGNED_PTRDIFF_TYPE, /* For format checking only.  */
    159     CTI_INTMAX_TYPE,
    160     CTI_UINTMAX_TYPE,
    161     CTI_WIDEST_INT_LIT_TYPE,
    162     CTI_WIDEST_UINT_LIT_TYPE,
    163 
    164     CTI_CHAR_ARRAY_TYPE,
    165     CTI_CHAR16_ARRAY_TYPE,
    166     CTI_CHAR32_ARRAY_TYPE,
    167     CTI_WCHAR_ARRAY_TYPE,
    168     CTI_INT_ARRAY_TYPE,
    169     CTI_STRING_TYPE,
    170     CTI_CONST_STRING_TYPE,
    171 
    172     /* Type for boolean expressions (bool in C++, int in C).  */
    173     CTI_TRUTHVALUE_TYPE,
    174     CTI_TRUTHVALUE_TRUE,
    175     CTI_TRUTHVALUE_FALSE,
    176 
    177     CTI_DEFAULT_FUNCTION_TYPE,
    178 
    179     /* These are not types, but we have to look them up all the time.  */
    180     CTI_FUNCTION_NAME_DECL,
    181     CTI_PRETTY_FUNCTION_NAME_DECL,
    182     CTI_C99_FUNCTION_NAME_DECL,
    183     CTI_SAVED_FUNCTION_NAME_DECLS,
    184 
    185     CTI_VOID_ZERO,
    186 
    187     CTI_NULL,
    188 
    189     CTI_MAX
    190 };
    191 
    192 #define C_CPP_HASHNODE(id) \
    193   (&(((struct c_common_identifier *) (id))->node))
    194 #define C_RID_CODE(id) \
    195   ((enum rid) (((struct c_common_identifier *) (id))->node.rid_code))
    196 #define C_SET_RID_CODE(id, code) \
    197   (((struct c_common_identifier *) (id))->node.rid_code = (unsigned char) code)
    198 
    199 /* Identifier part common to the C front ends.  Inherits from
    200    tree_identifier, despite appearances.  */
    201 struct c_common_identifier GTY(())
    202 {
    203   struct tree_common common;
    204   struct cpp_hashnode node;
    205 };
    206 
    207 /* An entry in the reserved keyword table.  */
    208 
    209 struct c_common_resword
    210 {
    211   const char *const word;
    212   ENUM_BITFIELD(rid) const rid : 16;
    213   const unsigned int disable   : 16;
    214 };
    215 
    216 /* Disable mask.  Keywords are disabled if (reswords[i].disable &
    217    mask) is _true_.  Thus for keywords which are present in all
    218    languages the disable field is zero.  */
    219 
    220 #define D_CONLY		0x001	/* C only (not in C++).  */
    221 #define D_CXXONLY	0x002	/* C++ only (not in C).  */
    222 #define D_C99		0x004	/* In C, C99 only.  */
    223 #define D_CXX0X         0x008	/* In C++, C++0X only.  */
    224 #define D_EXT		0x010	/* GCC extension.  */
    225 #define D_EXT89		0x020	/* GCC extension incorporated in C99.  */
    226 #define D_ASM		0x040	/* Disabled by -fno-asm.  */
    227 #define D_OBJC		0x080	/* In Objective C and neither C nor C++.  */
    228 #define D_CXX_OBJC	0x100	/* In Objective C, and C++, but not C.  */
    229 #define D_CXXWARN	0x200	/* In C warn with -Wcxx-compat.  */
    230 
    231 /* The reserved keyword table.  */
    232 extern const struct c_common_resword c_common_reswords[];
    233 
    234 /* The number of items in the reserved keyword table.  */
    235 extern const unsigned int num_c_common_reswords;
    236 
    237 #define char16_type_node		c_global_trees[CTI_CHAR16_TYPE]
    238 #define char32_type_node		c_global_trees[CTI_CHAR32_TYPE]
    239 #define wchar_type_node			c_global_trees[CTI_WCHAR_TYPE]
    240 #define signed_wchar_type_node		c_global_trees[CTI_SIGNED_WCHAR_TYPE]
    241 #define unsigned_wchar_type_node	c_global_trees[CTI_UNSIGNED_WCHAR_TYPE]
    242 #define wint_type_node			c_global_trees[CTI_WINT_TYPE]
    243 #define signed_size_type_node		c_global_trees[CTI_SIGNED_SIZE_TYPE]
    244 #define unsigned_ptrdiff_type_node	c_global_trees[CTI_UNSIGNED_PTRDIFF_TYPE]
    245 #define intmax_type_node		c_global_trees[CTI_INTMAX_TYPE]
    246 #define uintmax_type_node		c_global_trees[CTI_UINTMAX_TYPE]
    247 #define widest_integer_literal_type_node c_global_trees[CTI_WIDEST_INT_LIT_TYPE]
    248 #define widest_unsigned_literal_type_node c_global_trees[CTI_WIDEST_UINT_LIT_TYPE]
    249 
    250 #define truthvalue_type_node		c_global_trees[CTI_TRUTHVALUE_TYPE]
    251 #define truthvalue_true_node		c_global_trees[CTI_TRUTHVALUE_TRUE]
    252 #define truthvalue_false_node		c_global_trees[CTI_TRUTHVALUE_FALSE]
    253 
    254 #define char_array_type_node		c_global_trees[CTI_CHAR_ARRAY_TYPE]
    255 #define char16_array_type_node		c_global_trees[CTI_CHAR16_ARRAY_TYPE]
    256 #define char32_array_type_node		c_global_trees[CTI_CHAR32_ARRAY_TYPE]
    257 #define wchar_array_type_node		c_global_trees[CTI_WCHAR_ARRAY_TYPE]
    258 #define int_array_type_node		c_global_trees[CTI_INT_ARRAY_TYPE]
    259 #define string_type_node		c_global_trees[CTI_STRING_TYPE]
    260 #define const_string_type_node		c_global_trees[CTI_CONST_STRING_TYPE]
    261 
    262 #define default_function_type		c_global_trees[CTI_DEFAULT_FUNCTION_TYPE]
    263 
    264 #define function_name_decl_node		c_global_trees[CTI_FUNCTION_NAME_DECL]
    265 #define pretty_function_name_decl_node	c_global_trees[CTI_PRETTY_FUNCTION_NAME_DECL]
    266 #define c99_function_name_decl_node		c_global_trees[CTI_C99_FUNCTION_NAME_DECL]
    267 #define saved_function_name_decls	c_global_trees[CTI_SAVED_FUNCTION_NAME_DECLS]
    268 
    269 /* A node for `((void) 0)'.  */
    270 #define void_zero_node                  c_global_trees[CTI_VOID_ZERO]
    271 
    272 /* The node for C++ `__null'.  */
    273 #define null_node                       c_global_trees[CTI_NULL]
    274 
    275 extern GTY(()) tree c_global_trees[CTI_MAX];
    276 
    277 /* In a RECORD_TYPE, a sorted array of the fields of the type, not a
    278    tree for size reasons.  */
    279 struct sorted_fields_type GTY(())
    280 {
    281   int len;
    282   tree GTY((length ("%h.len"))) elts[1];
    283 };
    284 
    285 /* Mark which labels are explicitly declared.
    286    These may be shadowed, and may be referenced from nested functions.  */
    287 #define C_DECLARED_LABEL_FLAG(label) TREE_LANG_FLAG_1 (label)
    288 
    289 typedef enum c_language_kind
    290 {
    291   clk_c		= 0,		/* C90, C94 or C99 */
    292   clk_objc	= 1,		/* clk_c with ObjC features.  */
    293   clk_cxx	= 2,		/* ANSI/ISO C++ */
    294   clk_objcxx	= 3		/* clk_cxx with ObjC features.  */
    295 }
    296 c_language_kind;
    297 
    298 /* To test for a specific language use c_language, defined by each
    299    front end.  For "ObjC features" or "not C++" use the macros.  */
    300 extern c_language_kind c_language;
    301 
    302 #define c_dialect_cxx()		(c_language & clk_cxx)
    303 #define c_dialect_objc()	(c_language & clk_objc)
    304 
    305 /* Information about a statement tree.  */
    306 
    307 struct stmt_tree_s GTY(()) {
    308   /* The current statement list being collected.  */
    309   tree x_cur_stmt_list;
    310 
    311   /* In C++, Nonzero if we should treat statements as full
    312      expressions.  In particular, this variable is no-zero if at the
    313      end of a statement we should destroy any temporaries created
    314      during that statement.  Similarly, if, at the end of a block, we
    315      should destroy any local variables in this block.  Normally, this
    316      variable is nonzero, since those are the normal semantics of
    317      C++.
    318 
    319      However, in order to represent aggregate initialization code as
    320      tree structure, we use statement-expressions.  The statements
    321      within the statement expression should not result in cleanups
    322      being run until the entire enclosing statement is complete.
    323 
    324      This flag has no effect in C.  */
    325   int stmts_are_full_exprs_p;
    326 };
    327 
    328 typedef struct stmt_tree_s *stmt_tree;
    329 
    330 /* Global state pertinent to the current function.  Some C dialects
    331    extend this structure with additional fields.  */
    332 
    333 struct c_language_function GTY(()) {
    334   /* While we are parsing the function, this contains information
    335      about the statement-tree that we are building.  */
    336   struct stmt_tree_s x_stmt_tree;
    337 };
    338 
    339 /* When building a statement-tree, this is the current statement list
    340    being collected.  It's TREE_CHAIN is a back-pointer to the previous
    341    statement list.  */
    342 
    343 #define cur_stmt_list (current_stmt_tree ()->x_cur_stmt_list)
    344 
    345 /* Language-specific hooks.  */
    346 
    347 /* If non-NULL, this function is called after a precompile header file
    348    is loaded.  */
    349 extern void (*lang_post_pch_load) (void);
    350 
    351 extern void push_file_scope (void);
    352 extern void pop_file_scope (void);
    353 extern stmt_tree current_stmt_tree (void);
    354 extern tree push_stmt_list (void);
    355 extern tree pop_stmt_list (tree);
    356 extern tree add_stmt (tree);
    357 extern void push_cleanup (tree, tree, bool);
    358 extern tree pushdecl_top_level (tree);
    359 extern tree pushdecl (tree);
    360 extern tree build_modify_expr (location_t, tree, enum tree_code, tree);
    361 extern tree build_indirect_ref (location_t, tree, const char *);
    362 
    363 extern int c_expand_decl (tree);
    364 
    365 extern int field_decl_cmp (const void *, const void *);
    366 extern void resort_sorted_fields (void *, void *, gt_pointer_operator,
    367 				  void *);
    368 extern bool has_c_linkage (const_tree decl);
    369 
    370 /* Switches common to the C front ends.  */
    372 
    373 /* Nonzero if prepreprocessing only.  */
    374 
    375 extern int flag_preprocess_only;
    376 
    377 /* Zero means that faster, ...NonNil variants of objc_msgSend...
    378    calls will be used in ObjC; passing nil receivers to such calls
    379    will most likely result in crashes.  */
    380 extern int flag_nil_receivers;
    381 
    382 /* Nonzero means that we will allow new ObjC exception syntax (@throw,
    383    @try, etc.) in source code.  */
    384 extern int flag_objc_exceptions;
    385 
    386 /* Nonzero means that we generate NeXT setjmp based exceptions.  */
    387 extern int flag_objc_sjlj_exceptions;
    388 
    389 /* Nonzero means that code generation will be altered to support
    390    "zero-link" execution.  This currently affects ObjC only, but may
    391    affect other languages in the future.  */
    392 extern int flag_zero_link;
    393 
    394 /* Nonzero means emit an '__OBJC, __image_info' for the current translation
    395    unit.  It will inform the ObjC runtime that class definition(s) herein
    396    contained are to replace one(s) previously loaded.  */
    397 extern int flag_replace_objc_classes;
    398 
    399 /* Nonzero means don't output line number information.  */
    400 
    401 extern char flag_no_line_commands;
    402 
    403 /* Nonzero causes -E output not to be done, but directives such as
    404    #define that have side effects are still obeyed.  */
    405 
    406 extern char flag_no_output;
    407 
    408 /* Nonzero means dump macros in some fashion; contains the 'D', 'M',
    409    'N' or 'U' of the command line switch.  */
    410 
    411 extern char flag_dump_macros;
    412 
    413 /* Nonzero means pass #include lines through to the output.  */
    414 
    415 extern char flag_dump_includes;
    416 
    417 /* Nonzero means process PCH files while preprocessing.  */
    418 
    419 extern bool flag_pch_preprocess;
    420 
    421 /* The file name to which we should write a precompiled header, or
    422    NULL if no header will be written in this compile.  */
    423 
    424 extern const char *pch_file;
    425 
    426 /* Nonzero if an ISO standard was selected.  It rejects macros in the
    427    user's namespace.  */
    428 
    429 extern int flag_iso;
    430 
    431 /* Nonzero if -undef was given.  It suppresses target built-in macros
    432    and assertions.  */
    433 
    434 extern int flag_undef;
    435 
    436 /* Nonzero means don't recognize the non-ANSI builtin functions.  */
    437 
    438 extern int flag_no_builtin;
    439 
    440 /* Nonzero means don't recognize the non-ANSI builtin functions.
    441    -ansi sets this.  */
    442 
    443 extern int flag_no_nonansi_builtin;
    444 
    445 /* Nonzero means give `double' the same size as `float'.  */
    446 
    447 extern int flag_short_double;
    448 
    449 /* Nonzero means give `wchar_t' the same size as `short'.  */
    450 
    451 extern int flag_short_wchar;
    452 
    453 /* Nonzero means allow implicit conversions between vectors with
    454    differing numbers of subparts and/or differing element types.  */
    455 extern int flag_lax_vector_conversions;
    456 
    457 /* Nonzero means allow Microsoft extensions without warnings or errors.  */
    458 extern int flag_ms_extensions;
    459 
    460 /* Nonzero means don't recognize the keyword `asm'.  */
    461 
    462 extern int flag_no_asm;
    463 
    464 /* Nonzero means give string constants the type `const char *', as mandated
    465    by the standard.  */
    466 
    467 extern int flag_const_strings;
    468 
    469 /* Nonzero means to treat bitfields as signed unless they say `unsigned'.  */
    470 
    471 extern int flag_signed_bitfields;
    472 
    473 /* Warn about #pragma directives that are not recognized.  */
    474 
    475 extern int warn_unknown_pragmas; /* Tri state variable.  */
    476 
    477 /* Warn about format/argument anomalies in calls to formatted I/O functions
    478    (*printf, *scanf, strftime, strfmon, etc.).  */
    479 
    480 extern int warn_format;
    481 
    482 
    483 /* C/ObjC language option variables.  */
    484 
    485 
    486 /* Nonzero means allow type mismatches in conditional expressions;
    487    just make their values `void'.  */
    488 
    489 extern int flag_cond_mismatch;
    490 
    491 /* Nonzero means enable C89 Amendment 1 features.  */
    492 
    493 extern int flag_isoc94;
    494 
    495 /* Nonzero means use the ISO C99 dialect of C.  */
    496 
    497 extern int flag_isoc99;
    498 
    499 /* Nonzero means that we have builtin functions, and main is an int.  */
    500 
    501 extern int flag_hosted;
    502 
    503 /* ObjC language option variables.  */
    504 
    505 
    506 /* Open and close the file for outputting class declarations, if
    507    requested (ObjC).  */
    508 
    509 extern int flag_gen_declaration;
    510 
    511 /* Tells the compiler that this is a special run.  Do not perform any
    512    compiling, instead we are to test some platform dependent features
    513    and output a C header file with appropriate definitions.  */
    514 
    515 extern int print_struct_values;
    516 
    517 /* ???.  Undocumented.  */
    518 
    519 extern const char *constant_string_class_name;
    520 
    521 
    522 /* C++ language option variables.  */
    523 
    524 
    525 /* Nonzero means don't recognize any extension keywords.  */
    526 
    527 extern int flag_no_gnu_keywords;
    528 
    529 /* Nonzero means do emit exported implementations of functions even if
    530    they can be inlined.  */
    531 
    532 extern int flag_implement_inlines;
    533 
    534 /* Nonzero means that implicit instantiations will be emitted if needed.  */
    535 
    536 extern int flag_implicit_templates;
    537 
    538 /* Nonzero means that implicit instantiations of inline templates will be
    539    emitted if needed, even if instantiations of non-inline templates
    540    aren't.  */
    541 
    542 extern int flag_implicit_inline_templates;
    543 
    544 /* Nonzero means generate separate instantiation control files and
    545    juggle them at link time.  */
    546 
    547 extern int flag_use_repository;
    548 
    549 /* Nonzero if we want to issue diagnostics that the standard says are not
    550    required.  */
    551 
    552 extern int flag_optional_diags;
    553 
    554 /* Nonzero means we should attempt to elide constructors when possible.  */
    555 
    556 extern int flag_elide_constructors;
    557 
    558 /* Nonzero means that member functions defined in class scope are
    559    inline by default.  */
    560 
    561 extern int flag_default_inline;
    562 
    563 /* Controls whether compiler generates 'type descriptor' that give
    564    run-time type information.  */
    565 
    566 extern int flag_rtti;
    567 
    568 /* Nonzero if we want to conserve space in the .o files.  We do this
    569    by putting uninitialized data and runtime initialized data into
    570    .common instead of .data at the expense of not flagging multiple
    571    definitions.  */
    572 
    573 extern int flag_conserve_space;
    574 
    575 /* Nonzero if we want to obey access control semantics.  */
    576 
    577 extern int flag_access_control;
    578 
    579 /* Nonzero if we want to check the return value of new and avoid calling
    580    constructors if it is a null pointer.  */
    581 
    582 extern int flag_check_new;
    583 
    584 /* The supported C++ dialects.  */
    585 
    586 enum cxx_dialect {
    587   /* C++98  */
    588   cxx98,
    589   /* Experimental features that are likely to become part of
    590      C++0x.  */
    591   cxx0x
    592 };
    593 
    594 /* The C++ dialect being used. C++98 is the default.  */
    595 extern enum cxx_dialect cxx_dialect;
    596 
    597 /* Nonzero if we want the new ISO rules for pushing a new scope for `for'
    598    initialization variables.
    599    0: Old rules, set by -fno-for-scope.
    600    2: New ISO rules, set by -ffor-scope.
    601    1: Try to implement new ISO rules, but with backup compatibility
    602    (and warnings).  This is the default, for now.  */
    603 
    604 extern int flag_new_for_scope;
    605 
    606 /* Nonzero if we want to emit defined symbols with common-like linkage as
    607    weak symbols where possible, in order to conform to C++ semantics.
    608    Otherwise, emit them as local symbols.  */
    609 
    610 extern int flag_weak;
    611 
    612 /* 0 means we want the preprocessor to not emit line directives for
    613    the current working directory.  1 means we want it to do it.  -1
    614    means we should decide depending on whether debugging information
    615    is being emitted or not.  */
    616 
    617 extern int flag_working_directory;
    618 
    619 /* Nonzero to use __cxa_atexit, rather than atexit, to register
    620    destructors for local statics and global objects.  */
    621 
    622 extern int flag_use_cxa_atexit;
    623 
    624 /* Nonzero to use __cxa_get_exception_ptr in the C++ exception-handling
    625    logic.  */
    626 
    627 extern int flag_use_cxa_get_exception_ptr;
    628 
    629 /* Nonzero means to implement standard semantics for exception
    630    specifications, calling unexpected if an exception is thrown that
    631    doesn't match the specification.  Zero means to treat them as
    632    assertions and optimize accordingly, but not check them.  */
    633 
    634 extern int flag_enforce_eh_specs;
    635 
    636 /* Nonzero (the default) means to generate thread-safe code for
    637    initializing local statics.  */
    638 
    639 extern int flag_threadsafe_statics;
    640 
    641 /* Nonzero means warn about implicit declarations.  */
    642 
    643 extern int warn_implicit;
    644 
    645 /* Warn about using __null (as NULL in C++) as sentinel.  For code compiled
    646    with GCC this doesn't matter as __null is guaranteed to have the right
    647    size.  */
    648 
    649 extern int warn_strict_null_sentinel;
    650 
    651 /* Maximum template instantiation depth.  This limit is rather
    652    arbitrary, but it exists to limit the time it takes to notice
    653    infinite template instantiations.  */
    654 
    655 extern int max_tinst_depth;
    656 
    657 /* Nonzero means the expression being parsed will never be evaluated.
    658    This is a count, since unevaluated expressions can nest.  */
    659 
    660 extern int skip_evaluation;
    661 
    662 /* C types are partitioned into three subsets: object, function, and
    663    incomplete types.  */
    664 #define C_TYPE_OBJECT_P(type) \
    665   (TREE_CODE (type) != FUNCTION_TYPE && TYPE_SIZE (type))
    666 
    667 #define C_TYPE_INCOMPLETE_P(type) \
    668   (TREE_CODE (type) != FUNCTION_TYPE && TYPE_SIZE (type) == 0)
    669 
    670 #define C_TYPE_FUNCTION_P(type) \
    671   (TREE_CODE (type) == FUNCTION_TYPE)
    672 
    673 /* For convenience we define a single macro to identify the class of
    674    object or incomplete types.  */
    675 #define C_TYPE_OBJECT_OR_INCOMPLETE_P(type) \
    676   (!C_TYPE_FUNCTION_P (type))
    677 
    678 /* Attribute table common to the C front ends.  */
    679 extern const struct attribute_spec c_common_attribute_table[];
    680 extern const struct attribute_spec c_common_format_attribute_table[];
    681 
    682 /* Pointer to function to lazily generate the VAR_DECL for __FUNCTION__ etc.
    683    ID is the identifier to use, NAME is the string.
    684    TYPE_DEP indicates whether it depends on type of the function or not
    685    (i.e. __PRETTY_FUNCTION__).  */
    686 
    687 extern tree (*make_fname_decl) (tree, int);
    688 
    689 extern tree identifier_global_value (tree);
    690 extern void record_builtin_type (enum rid, const char *, tree);
    691 extern tree build_void_list_node (void);
    692 extern void start_fname_decls (void);
    693 extern void finish_fname_decls (void);
    694 extern const char *fname_as_string (int);
    695 extern tree fname_decl (location_t, unsigned, tree);
    696 
    697 extern void check_function_arguments (tree, int, tree *, tree);
    698 extern void check_function_arguments_recurse (void (*)
    699 					      (void *, tree,
    700 					       unsigned HOST_WIDE_INT),
    701 					      void *, tree,
    702 					      unsigned HOST_WIDE_INT);
    703 extern bool check_builtin_function_arguments (tree, int, tree *);
    704 extern void check_function_format (tree, int, tree *);
    705 extern void set_Wformat (int);
    706 extern tree handle_format_attribute (tree *, tree, tree, int, bool *);
    707 extern tree handle_format_arg_attribute (tree *, tree, tree, int, bool *);
    708 extern int c_common_handle_option (size_t code, const char *arg, int value);
    709 extern bool c_common_missing_argument (const char *opt, size_t code);
    710 extern tree c_common_type_for_mode (enum machine_mode, int);
    711 extern tree c_common_type_for_size (unsigned int, int);
    712 extern tree c_common_fixed_point_type_for_size (unsigned int, unsigned int,
    713 						int, int);
    714 extern tree c_common_unsigned_type (tree);
    715 extern tree c_common_signed_type (tree);
    716 extern tree c_common_signed_or_unsigned_type (int, tree);
    717 extern tree c_build_bitfield_integer_type (unsigned HOST_WIDE_INT, int);
    718 extern bool decl_with_nonnull_addr_p (const_tree);
    719 extern tree c_common_truthvalue_conversion (location_t, tree);
    720 extern void c_apply_type_quals_to_decl (int, tree);
    721 extern tree c_sizeof_or_alignof_type (tree, bool, int);
    722 extern tree c_alignof_expr (tree);
    723 /* Print an error message for invalid operands to arith operation CODE.
    724    NOP_EXPR is used as a special case (see truthvalue_conversion).  */
    725 extern void binary_op_error (location_t, enum tree_code, tree, tree);
    726 extern tree fix_string_type (tree);
    727 struct varray_head_tag;
    728 extern void constant_expression_warning (tree);
    729 extern void constant_expression_error (tree);
    730 extern bool strict_aliasing_warning (tree, tree, tree);
    731 extern void warnings_for_convert_and_check (tree, tree, tree);
    732 extern tree convert_and_check (tree, tree);
    733 extern void overflow_warning (tree);
    734 extern void warn_logical_operator (enum tree_code, tree, tree);
    735 extern void check_main_parameter_types (tree decl);
    736 extern bool c_determine_visibility (tree);
    737 extern bool same_scalar_type_ignoring_signedness (tree, tree);
    738 
    739 #define c_sizeof(T)  c_sizeof_or_alignof_type (T, true, 1)
    740 #define c_alignof(T) c_sizeof_or_alignof_type (T, false, 1)
    741 
    742 /* Subroutine of build_binary_op, used for certain operations.  */
    743 extern tree shorten_binary_op (tree result_type, tree op0, tree op1, bool bitwise);
    744 
    745 /* Subroutine of build_binary_op, used for comparison operations.
    746    See if the operands have both been converted from subword integer types
    747    and, if so, perhaps change them both back to their original type.  */
    748 extern tree shorten_compare (tree *, tree *, tree *, enum tree_code *);
    749 
    750 extern tree pointer_int_sum (enum tree_code, tree, tree);
    751 
    752 /* Add qualifiers to a type, in the fashion for C.  */
    753 extern tree c_build_qualified_type (tree, int);
    754 
    755 /* Build tree nodes and builtin functions common to both C and C++ language
    756    frontends.  */
    757 extern void c_common_nodes_and_builtins (void);
    758 
    759 extern void set_builtin_user_assembler_name (tree decl, const char *asmspec);
    760 
    761 extern void disable_builtin_function (const char *);
    762 
    763 extern void set_compound_literal_name (tree decl);
    764 
    765 extern tree build_va_arg (tree, tree);
    766 
    767 extern unsigned int c_common_init_options (unsigned int, const char **);
    768 extern bool c_common_post_options (const char **);
    769 extern bool c_common_init (void);
    770 extern void c_common_finish (void);
    771 extern void c_common_parse_file (int);
    772 extern alias_set_type c_common_get_alias_set (tree);
    773 extern void c_register_builtin_type (tree, const char*);
    774 extern bool c_promoting_integer_type_p (const_tree);
    775 extern int self_promoting_args_p (const_tree);
    776 extern tree strip_pointer_operator (tree);
    777 extern tree strip_pointer_or_array_types (tree);
    778 extern HOST_WIDE_INT c_common_to_target_charset (HOST_WIDE_INT);
    779 
    780 /* This is the basic parsing function.  */
    781 extern void c_parse_file (void);
    782 /* This is misnamed, it actually performs end-of-compilation processing.  */
    783 extern void finish_file	(void);
    784 
    785 
    786 /* These macros provide convenient access to the various _STMT nodes.  */
    787 
    788 /* Nonzero if a given STATEMENT_LIST represents the outermost binding
    789    if a statement expression.  */
    790 #define STATEMENT_LIST_STMT_EXPR(NODE) \
    791   TREE_LANG_FLAG_1 (STATEMENT_LIST_CHECK (NODE))
    792 
    793 /* Nonzero if a label has been added to the statement list.  */
    794 #define STATEMENT_LIST_HAS_LABEL(NODE) \
    795   TREE_LANG_FLAG_3 (STATEMENT_LIST_CHECK (NODE))
    796 
    797 /* COMPOUND_LITERAL_EXPR accessors.  */
    798 #define COMPOUND_LITERAL_EXPR_DECL_STMT(NODE)		\
    799   TREE_OPERAND (COMPOUND_LITERAL_EXPR_CHECK (NODE), 0)
    800 #define COMPOUND_LITERAL_EXPR_DECL(NODE)			\
    801   DECL_EXPR_DECL (COMPOUND_LITERAL_EXPR_DECL_STMT (NODE))
    802 
    803 /* In a FIELD_DECL, nonzero if the decl was originally a bitfield.  */
    804 #define DECL_C_BIT_FIELD(NODE) \
    805   (DECL_LANG_FLAG_4 (FIELD_DECL_CHECK (NODE)) == 1)
    806 #define SET_DECL_C_BIT_FIELD(NODE) \
    807   (DECL_LANG_FLAG_4 (FIELD_DECL_CHECK (NODE)) = 1)
    808 #define CLEAR_DECL_C_BIT_FIELD(NODE) \
    809   (DECL_LANG_FLAG_4 (FIELD_DECL_CHECK (NODE)) = 0)
    810 
    811 extern void emit_local_var (tree);
    812 extern tree do_case (tree, tree);
    813 extern tree build_stmt (enum tree_code, ...);
    814 extern tree build_case_label (tree, tree, tree);
    815 
    816 /* These functions must be defined by each front-end which implements
    817    a variant of the C language.  They are used in c-common.c.  */
    818 
    819 extern tree build_unary_op (location_t, enum tree_code, tree, int);
    820 extern tree build_binary_op (location_t, enum tree_code, tree, tree, int);
    821 extern tree perform_integral_promotions (tree);
    822 
    823 /* These functions must be defined by each front-end which implements
    824    a variant of the C language.  They are used by port files.  */
    825 
    826 extern tree default_conversion (tree);
    827 
    828 /* Given two integer or real types, return the type for their sum.
    829    Given two compatible ANSI C types, returns the merged type.  */
    830 
    831 extern tree common_type (tree, tree);
    832 
    833 extern tree decl_constant_value (tree);
    834 
    835 /* Handle increment and decrement of boolean types.  */
    836 extern tree boolean_increment (enum tree_code, tree);
    837 
    838 extern int case_compare (splay_tree_key, splay_tree_key);
    839 
    840 extern tree c_add_case_label (splay_tree, tree, tree, tree, tree);
    841 
    842 extern void c_do_switch_warnings (splay_tree, location_t, tree, tree);
    843 
    844 extern tree build_function_call (tree, tree);
    845 
    846 extern tree resolve_overloaded_builtin (tree, tree);
    847 
    848 extern tree finish_label_address_expr (tree, location_t);
    849 
    850 /* Same function prototype, but the C and C++ front ends have
    851    different implementations.  Used in c-common.c.  */
    852 extern tree lookup_label (tree);
    853 extern tree lookup_name (tree);
    854 
    855 extern bool vector_targets_convertible_p (const_tree t1, const_tree t2);
    856 extern bool vector_types_convertible_p (const_tree t1, const_tree t2, bool emit_lax_note);
    857 
    858 extern rtx c_expand_expr (tree, rtx, enum machine_mode, int, rtx *);
    859 
    860 extern tree c_staticp (tree);
    861 
    862 extern void init_c_lex (void);
    863 
    864 extern void c_cpp_builtins (cpp_reader *);
    865 extern void c_cpp_builtins_optimize_pragma (cpp_reader *, tree, tree);
    866 
    867 /* Positive if an implicit `extern "C"' scope has just been entered;
    868    negative if such a scope has just been exited.  */
    869 extern GTY(()) int pending_lang_change;
    870 
    871 /* Information recorded about each file examined during compilation.  */
    872 
    873 struct c_fileinfo
    874 {
    875   int time;	/* Time spent in the file.  */
    876 
    877   /* Flags used only by C++.
    878      INTERFACE_ONLY nonzero means that we are in an "interface" section
    879      of the compiler.  INTERFACE_UNKNOWN nonzero means we cannot trust
    880      the value of INTERFACE_ONLY.  If INTERFACE_UNKNOWN is zero and
    881      INTERFACE_ONLY is zero, it means that we are responsible for
    882      exporting definitions that others might need.  */
    883   short interface_only;
    884   short interface_unknown;
    885 };
    886 
    887 struct c_fileinfo *get_fileinfo (const char *);
    888 extern void dump_time_statistics (void);
    889 
    890 extern bool c_dump_tree (void *, tree);
    891 
    892 extern void c_warn_unused_result (gimple_seq);
    893 
    894 extern void verify_sequence_points (tree);
    895 
    896 extern tree fold_offsetof (tree, tree);
    897 
    898 /* Places where an lvalue, or modifiable lvalue, may be required.
    899    Used to select diagnostic messages in lvalue_error and
    900    readonly_error.  */
    901 enum lvalue_use {
    902   lv_assign,
    903   lv_increment,
    904   lv_decrement,
    905   lv_addressof,
    906   lv_asm
    907 };
    908 
    909 extern void lvalue_error (enum lvalue_use);
    910 
    911 extern int complete_array_type (tree *, tree, bool);
    912 
    913 extern tree builtin_type_for_size (int, bool);
    914 
    915 extern void warn_array_subscript_with_type_char (tree);
    916 extern void warn_about_parentheses (enum tree_code,
    917 				    enum tree_code, tree,
    918 				    enum tree_code, tree);
    919 extern void warn_for_unused_label (tree label);
    920 extern void warn_for_div_by_zero (location_t, tree divisor);
    921 extern void warn_for_sign_compare (location_t,
    922 				   tree orig_op0, tree orig_op1,
    923 				   tree op0, tree op1,
    924 				   tree result_type,
    925 				   enum tree_code resultcode);
    926 
    927 /* In c-gimplify.c  */
    928 extern void c_genericize (tree);
    929 extern int c_gimplify_expr (tree *, gimple_seq *, gimple_seq *);
    930 extern tree c_build_bind_expr (tree, tree);
    931 
    932 /* In c-pch.c  */
    933 extern void pch_init (void);
    934 extern int c_common_valid_pch (cpp_reader *pfile, const char *name, int fd);
    935 extern void c_common_read_pch (cpp_reader *pfile, const char *name, int fd,
    936 			       const char *orig);
    937 extern void c_common_write_pch (void);
    938 extern void c_common_no_more_pch (void);
    939 extern void c_common_pch_pragma (cpp_reader *pfile, const char *);
    940 extern void c_common_print_pch_checksum (FILE *f);
    941 
    942 /* In *-checksum.c */
    943 extern const unsigned char executable_checksum[16];
    944 
    945 /* In c-cppbuiltin.c  */
    946 extern void builtin_define_std (const char *macro);
    947 extern void builtin_define_with_value (const char *, const char *, int);
    948 extern void c_stddef_cpp_builtins (void);
    949 extern void fe_file_change (const struct line_map *);
    950 extern void c_parse_error (const char *, enum cpp_ttype, tree);
    951 
    952 /* Objective-C / Objective-C++ entry points.  */
    953 
    954 /* The following ObjC/ObjC++ functions are called by the C and/or C++
    955    front-ends; they all must have corresponding stubs in stub-objc.c.  */
    956 extern tree objc_is_class_name (tree);
    957 extern tree objc_is_object_ptr (tree);
    958 extern void objc_check_decl (tree);
    959 extern int objc_is_reserved_word (tree);
    960 extern bool objc_compare_types (tree, tree, int, tree);
    961 extern void objc_volatilize_decl (tree);
    962 extern bool objc_type_quals_match (tree, tree);
    963 extern tree objc_rewrite_function_call (tree, tree);
    964 extern tree objc_message_selector (void);
    965 extern tree objc_lookup_ivar (tree, tree);
    966 extern void objc_clear_super_receiver (void);
    967 extern int objc_is_public (tree, tree);
    968 extern tree objc_is_id (tree);
    969 extern void objc_declare_alias (tree, tree);
    970 extern void objc_declare_class (tree);
    971 extern void objc_declare_protocols (tree);
    972 extern tree objc_build_message_expr (tree);
    973 extern tree objc_finish_message_expr (tree, tree, tree);
    974 extern tree objc_build_selector_expr (tree);
    975 extern tree objc_build_protocol_expr (tree);
    976 extern tree objc_build_encode_expr (tree);
    977 extern tree objc_build_string_object (tree);
    978 extern tree objc_get_protocol_qualified_type (tree, tree);
    979 extern tree objc_get_class_reference (tree);
    980 extern tree objc_get_class_ivars (tree);
    981 extern void objc_start_class_interface (tree, tree, tree);
    982 extern void objc_start_category_interface (tree, tree, tree);
    983 extern void objc_start_protocol (tree, tree);
    984 extern void objc_continue_interface (void);
    985 extern void objc_finish_interface (void);
    986 extern void objc_start_class_implementation (tree, tree);
    987 extern void objc_start_category_implementation (tree, tree);
    988 extern void objc_continue_implementation (void);
    989 extern void objc_finish_implementation (void);
    990 extern void objc_set_visibility (int);
    991 extern void objc_set_method_type (enum tree_code);
    992 extern tree objc_build_method_signature (tree, tree, tree, bool);
    993 extern void objc_add_method_declaration (tree);
    994 extern void objc_start_method_definition (tree);
    995 extern void objc_finish_method_definition (tree);
    996 extern void objc_add_instance_variable (tree);
    997 extern tree objc_build_keyword_decl (tree, tree, tree);
    998 extern tree objc_build_throw_stmt (tree);
    999 extern void objc_begin_try_stmt (location_t, tree);
   1000 extern tree objc_finish_try_stmt (void);
   1001 extern void objc_begin_catch_clause (tree);
   1002 extern void objc_finish_catch_clause (void);
   1003 extern void objc_build_finally_clause (location_t, tree);
   1004 extern tree objc_build_synchronized (location_t, tree, tree);
   1005 extern int objc_static_init_needed_p (void);
   1006 extern tree objc_generate_static_init_call (tree);
   1007 extern tree objc_generate_write_barrier (tree, enum tree_code, tree);
   1008 
   1009 /* The following are provided by the C and C++ front-ends, and called by
   1010    ObjC/ObjC++.  */
   1011 extern void *objc_get_current_scope (void);
   1012 extern void objc_mark_locals_volatile (void *);
   1013 
   1014 /* In c-ppoutput.c  */
   1015 extern void init_pp_output (FILE *);
   1016 extern void preprocess_file (cpp_reader *);
   1017 extern void pp_file_change (const struct line_map *);
   1018 extern void pp_dir_change (cpp_reader *, const char *);
   1019 extern bool check_missing_format_attribute (tree, tree);
   1020 
   1021 /* In c-omp.c  */
   1022 extern tree c_finish_omp_master (tree);
   1023 extern tree c_finish_omp_critical (tree, tree);
   1024 extern tree c_finish_omp_ordered (tree);
   1025 extern void c_finish_omp_barrier (void);
   1026 extern tree c_finish_omp_atomic (enum tree_code, tree, tree);
   1027 extern void c_finish_omp_flush (void);
   1028 extern void c_finish_omp_taskwait (void);
   1029 extern tree c_finish_omp_for (location_t, tree, tree, tree, tree, tree, tree);
   1030 extern void c_split_parallel_clauses (tree, tree *, tree *);
   1031 extern enum omp_clause_default_kind c_omp_predetermined_sharing (tree);
   1032 
   1033 /* Not in c-omp.c; provided by the front end.  */
   1034 extern bool c_omp_sharing_predetermined (tree);
   1035 extern tree c_omp_remap_decl (tree, bool);
   1036 
   1037 /* In order for the format checking to accept the C frontend
   1038    diagnostic framework extensions, you must include this file before
   1039    toplev.h, not after.  The C front end formats are a subset of those
   1040    for C++, so they are the appropriate set to use in common code;
   1041    cp-tree.h overrides this for C++.  */
   1042 #ifndef GCC_DIAG_STYLE
   1043 #define GCC_DIAG_STYLE __gcc_cdiag__
   1044 #endif
   1045 
   1046 #endif /* ! GCC_C_COMMON_H */
   1047