Subversion Repositories openrisc

/* Subroutines shared by all languages that are variants of C.

/* Subroutines shared by all languages that are variants of C.

   Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,

   Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,

   2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010

   2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010

   Free Software Foundation, Inc.

   Free Software Foundation, Inc.

This file is part of GCC.

This file is part of GCC.

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

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

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

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

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

version.

version.

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

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

WARRANTY; without even the implied warranty of MERCHANTABILITY or

WARRANTY; without even the implied warranty of MERCHANTABILITY or

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

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

for more details.

for more details.

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

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

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

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

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

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

#include "config.h"

#include "config.h"

#include "system.h"

#include "system.h"

#include "coretypes.h"

#include "coretypes.h"

#include "tm.h"

#include "tm.h"

#include "intl.h"

#include "intl.h"

#include "tree.h"

#include "tree.h"

#include "flags.h"

#include "flags.h"

#include "output.h"

#include "output.h"

#include "c-pragma.h"

#include "c-pragma.h"

#include "rtl.h"

#include "rtl.h"

#include "ggc.h"

#include "ggc.h"

#include "varray.h"

#include "varray.h"

#include "expr.h"

#include "expr.h"

#include "c-common.h"

#include "c-common.h"

#include "tm_p.h"

#include "tm_p.h"

#include "obstack.h"

#include "obstack.h"

#include "cpplib.h"

#include "cpplib.h"

#include "target.h"

#include "target.h"

#include "langhooks.h"

#include "langhooks.h"

#include "tree-inline.h"

#include "tree-inline.h"

#include "c-tree.h"

#include "c-tree.h"

#include "toplev.h"

#include "toplev.h"

#include "diagnostic.h"

#include "diagnostic.h"

#include "tree-iterator.h"

#include "tree-iterator.h"

#include "hashtab.h"

#include "hashtab.h"

#include "tree-mudflap.h"

#include "tree-mudflap.h"

#include "opts.h"

#include "opts.h"

#include "real.h"

#include "real.h"

#include "cgraph.h"

#include "cgraph.h"

#include "target-def.h"

#include "target-def.h"

#include "gimple.h"

#include "gimple.h"

#include "fixed-value.h"

#include "fixed-value.h"

#include "libfuncs.h"

#include "libfuncs.h"

cpp_reader *parse_in;           /* Declared in c-pragma.h.  */

cpp_reader *parse_in;           /* Declared in c-pragma.h.  */

/* The following symbols are subsumed in the c_global_trees array, and

/* The following symbols are subsumed in the c_global_trees array, and

   listed here individually for documentation purposes.

   listed here individually for documentation purposes.

   INTEGER_TYPE and REAL_TYPE nodes for the standard data types.

   INTEGER_TYPE and REAL_TYPE nodes for the standard data types.

        tree short_integer_type_node;

        tree short_integer_type_node;

        tree long_integer_type_node;

        tree long_integer_type_node;

        tree long_long_integer_type_node;

        tree long_long_integer_type_node;

        tree short_unsigned_type_node;

        tree short_unsigned_type_node;

        tree long_unsigned_type_node;

        tree long_unsigned_type_node;

        tree long_long_unsigned_type_node;

        tree long_long_unsigned_type_node;

        tree truthvalue_type_node;

        tree truthvalue_type_node;

        tree truthvalue_false_node;

        tree truthvalue_false_node;

        tree truthvalue_true_node;

        tree truthvalue_true_node;

        tree ptrdiff_type_node;

        tree ptrdiff_type_node;

        tree unsigned_char_type_node;

        tree unsigned_char_type_node;

        tree signed_char_type_node;

        tree signed_char_type_node;

        tree wchar_type_node;

        tree wchar_type_node;

        tree char16_type_node;

        tree char16_type_node;

        tree char32_type_node;

        tree char32_type_node;

        tree float_type_node;

        tree float_type_node;

        tree double_type_node;

        tree double_type_node;

        tree long_double_type_node;

        tree long_double_type_node;

        tree complex_integer_type_node;

        tree complex_integer_type_node;

        tree complex_float_type_node;

        tree complex_float_type_node;

        tree complex_double_type_node;

        tree complex_double_type_node;

        tree complex_long_double_type_node;

        tree complex_long_double_type_node;

        tree dfloat32_type_node;

        tree dfloat32_type_node;

        tree dfloat64_type_node;

        tree dfloat64_type_node;

        tree_dfloat128_type_node;

        tree_dfloat128_type_node;

        tree intQI_type_node;

        tree intQI_type_node;

        tree intHI_type_node;

        tree intHI_type_node;

        tree intSI_type_node;

        tree intSI_type_node;

        tree intDI_type_node;

        tree intDI_type_node;

        tree intTI_type_node;

        tree intTI_type_node;

        tree unsigned_intQI_type_node;

        tree unsigned_intQI_type_node;

        tree unsigned_intHI_type_node;

        tree unsigned_intHI_type_node;

        tree unsigned_intSI_type_node;

        tree unsigned_intSI_type_node;

        tree unsigned_intDI_type_node;

        tree unsigned_intDI_type_node;

        tree unsigned_intTI_type_node;

        tree unsigned_intTI_type_node;

        tree widest_integer_literal_type_node;

        tree widest_integer_literal_type_node;

        tree widest_unsigned_literal_type_node;

        tree widest_unsigned_literal_type_node;

   Nodes for types `void *' and `const void *'.

   Nodes for types `void *' and `const void *'.

        tree ptr_type_node, const_ptr_type_node;

        tree ptr_type_node, const_ptr_type_node;

   Nodes for types `char *' and `const char *'.

   Nodes for types `char *' and `const char *'.

        tree string_type_node, const_string_type_node;

        tree string_type_node, const_string_type_node;

   Type `char[SOMENUMBER]'.

   Type `char[SOMENUMBER]'.

   Used when an array of char is needed and the size is irrelevant.

   Used when an array of char is needed and the size is irrelevant.

        tree char_array_type_node;

        tree char_array_type_node;

   Type `int[SOMENUMBER]' or something like it.

   Type `int[SOMENUMBER]' or something like it.

   Used when an array of int needed and the size is irrelevant.

   Used when an array of int needed and the size is irrelevant.

        tree int_array_type_node;

        tree int_array_type_node;

   Type `wchar_t[SOMENUMBER]' or something like it.

   Type `wchar_t[SOMENUMBER]' or something like it.

   Used when a wide string literal is created.

   Used when a wide string literal is created.

        tree wchar_array_type_node;

        tree wchar_array_type_node;

   Type `char16_t[SOMENUMBER]' or something like it.

   Type `char16_t[SOMENUMBER]' or something like it.

   Used when a UTF-16 string literal is created.

   Used when a UTF-16 string literal is created.

        tree char16_array_type_node;

        tree char16_array_type_node;

   Type `char32_t[SOMENUMBER]' or something like it.

   Type `char32_t[SOMENUMBER]' or something like it.

   Used when a UTF-32 string literal is created.

   Used when a UTF-32 string literal is created.

        tree char32_array_type_node;

        tree char32_array_type_node;

   Type `int ()' -- used for implicit declaration of functions.

   Type `int ()' -- used for implicit declaration of functions.

        tree default_function_type;

        tree default_function_type;

   A VOID_TYPE node, packaged in a TREE_LIST.

   A VOID_TYPE node, packaged in a TREE_LIST.

        tree void_list_node;

        tree void_list_node;

  The lazily created VAR_DECLs for __FUNCTION__, __PRETTY_FUNCTION__,

  The lazily created VAR_DECLs for __FUNCTION__, __PRETTY_FUNCTION__,

  and __func__. (C doesn't generate __FUNCTION__ and__PRETTY_FUNCTION__

  and __func__. (C doesn't generate __FUNCTION__ and__PRETTY_FUNCTION__

  VAR_DECLS, but C++ does.)

  VAR_DECLS, but C++ does.)

        tree function_name_decl_node;

        tree function_name_decl_node;

        tree pretty_function_name_decl_node;

        tree pretty_function_name_decl_node;

        tree c99_function_name_decl_node;

        tree c99_function_name_decl_node;

  Stack of nested function name VAR_DECLs.

  Stack of nested function name VAR_DECLs.

        tree saved_function_name_decls;

        tree saved_function_name_decls;

*/

*/

tree c_global_trees[CTI_MAX];

tree c_global_trees[CTI_MAX];

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

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

/* Nonzero if preprocessing only.  */

/* Nonzero if preprocessing only.  */

int flag_preprocess_only;

int flag_preprocess_only;

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

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

char flag_no_line_commands;

char flag_no_line_commands;

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

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

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

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

char flag_no_output;

char flag_no_output;

/* Nonzero means dump macros in some fashion.  */

/* Nonzero means dump macros in some fashion.  */

char flag_dump_macros;

char flag_dump_macros;

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

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

char flag_dump_includes;

char flag_dump_includes;

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

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

bool flag_pch_preprocess;

bool flag_pch_preprocess;

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

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

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

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

const char *pch_file;

const char *pch_file;

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

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

   user's namespace.  */

   user's namespace.  */

int flag_iso;

int flag_iso;

/* Nonzero if -undef was given.  It suppresses target built-in macros

/* Nonzero if -undef was given.  It suppresses target built-in macros

   and assertions.  */

   and assertions.  */

int flag_undef;

int flag_undef;

/* Nonzero means don't recognize the non-ANSI builtin functions.  */

/* Nonzero means don't recognize the non-ANSI builtin functions.  */

int flag_no_builtin;

int flag_no_builtin;

/* Nonzero means don't recognize the non-ANSI builtin functions.

/* Nonzero means don't recognize the non-ANSI builtin functions.

   -ansi sets this.  */

   -ansi sets this.  */

int flag_no_nonansi_builtin;

int flag_no_nonansi_builtin;

/* Nonzero means give `double' the same size as `float'.  */

/* Nonzero means give `double' the same size as `float'.  */

int flag_short_double;

int flag_short_double;

/* Nonzero means give `wchar_t' the same size as `short'.  */

/* Nonzero means give `wchar_t' the same size as `short'.  */

int flag_short_wchar;

int flag_short_wchar;

/* Nonzero means allow implicit conversions between vectors with

/* Nonzero means allow implicit conversions between vectors with

   differing numbers of subparts and/or differing element types.  */

   differing numbers of subparts and/or differing element types.  */

int flag_lax_vector_conversions;

int flag_lax_vector_conversions;

/* Nonzero means allow Microsoft extensions without warnings or errors.  */

/* Nonzero means allow Microsoft extensions without warnings or errors.  */

int flag_ms_extensions;

int flag_ms_extensions;

/* Nonzero means don't recognize the keyword `asm'.  */

/* Nonzero means don't recognize the keyword `asm'.  */

int flag_no_asm;

int flag_no_asm;

/* Nonzero means to treat bitfields as signed unless they say `unsigned'.  */

/* Nonzero means to treat bitfields as signed unless they say `unsigned'.  */

int flag_signed_bitfields = 1;

int flag_signed_bitfields = 1;

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

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

int warn_unknown_pragmas; /* Tri state variable.  */

int warn_unknown_pragmas; /* Tri state variable.  */

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

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

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

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

int warn_format;

int warn_format;

/* Warn about using __null (as NULL in C++) as sentinel.  For code compiled

/* Warn about using __null (as NULL in C++) as sentinel.  For code compiled

   with GCC this doesn't matter as __null is guaranteed to have the right

   with GCC this doesn't matter as __null is guaranteed to have the right

   size.  */

   size.  */

int warn_strict_null_sentinel;

int warn_strict_null_sentinel;

/* Zero means that faster, ...NonNil variants of objc_msgSend...

/* Zero means that faster, ...NonNil variants of objc_msgSend...

   calls will be used in ObjC; passing nil receivers to such calls

   calls will be used in ObjC; passing nil receivers to such calls

   will most likely result in crashes.  */

   will most likely result in crashes.  */

int flag_nil_receivers = 1;

int flag_nil_receivers = 1;

/* Nonzero means that code generation will be altered to support

/* Nonzero means that code generation will be altered to support

   "zero-link" execution.  This currently affects ObjC only, but may

   "zero-link" execution.  This currently affects ObjC only, but may

   affect other languages in the future.  */

   affect other languages in the future.  */

int flag_zero_link = 0;

int flag_zero_link = 0;

/* Nonzero means emit an '__OBJC, __image_info' for the current translation

/* Nonzero means emit an '__OBJC, __image_info' for the current translation

   unit.  It will inform the ObjC runtime that class definition(s) herein

   unit.  It will inform the ObjC runtime that class definition(s) herein

   contained are to replace one(s) previously loaded.  */

   contained are to replace one(s) previously loaded.  */

int flag_replace_objc_classes = 0;

int flag_replace_objc_classes = 0;

/* C/ObjC language option variables.  */

/* C/ObjC language option variables.  */

/* Nonzero means allow type mismatches in conditional expressions;

/* Nonzero means allow type mismatches in conditional expressions;

   just make their values `void'.  */

   just make their values `void'.  */

int flag_cond_mismatch;

int flag_cond_mismatch;

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

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

int flag_isoc94;

int flag_isoc94;

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

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

int flag_isoc99;

int flag_isoc99;

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

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

int flag_hosted = 1;

int flag_hosted = 1;

/* ObjC language option variables.  */

/* ObjC language option variables.  */

/* Open and close the file for outputting class declarations, if

/* Open and close the file for outputting class declarations, if

   requested (ObjC).  */

   requested (ObjC).  */

int flag_gen_declaration;

int flag_gen_declaration;

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

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

   compiling, instead we are to test some platform dependent features

   compiling, instead we are to test some platform dependent features

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

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

int print_struct_values;

int print_struct_values;

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

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

const char *constant_string_class_name;

const char *constant_string_class_name;

/* C++ language option variables.  */

/* C++ language option variables.  */

/* Nonzero means don't recognize any extension keywords.  */

/* Nonzero means don't recognize any extension keywords.  */

int flag_no_gnu_keywords;

int flag_no_gnu_keywords;

/* Nonzero means do emit exported implementations of functions even if

/* Nonzero means do emit exported implementations of functions even if

   they can be inlined.  */

   they can be inlined.  */

int flag_implement_inlines = 1;

int flag_implement_inlines = 1;

/* Nonzero means that implicit instantiations will be emitted if needed.  */

/* Nonzero means that implicit instantiations will be emitted if needed.  */

int flag_implicit_templates = 1;

int flag_implicit_templates = 1;

/* Nonzero means that implicit instantiations of inline templates will be

/* Nonzero means that implicit instantiations of inline templates will be

   emitted if needed, even if instantiations of non-inline templates

   emitted if needed, even if instantiations of non-inline templates

   aren't.  */

   aren't.  */

int flag_implicit_inline_templates = 1;

int flag_implicit_inline_templates = 1;

/* Nonzero means generate separate instantiation control files and

/* Nonzero means generate separate instantiation control files and

   juggle them at link time.  */

   juggle them at link time.  */

int flag_use_repository;

int flag_use_repository;

/* Nonzero if we want to issue diagnostics that the standard says are not

/* Nonzero if we want to issue diagnostics that the standard says are not

   required.  */

   required.  */

int flag_optional_diags = 1;

int flag_optional_diags = 1;

/* Nonzero means we should attempt to elide constructors when possible.  */

/* Nonzero means we should attempt to elide constructors when possible.  */

int flag_elide_constructors = 1;

int flag_elide_constructors = 1;

/* Nonzero means that member functions defined in class scope are

/* Nonzero means that member functions defined in class scope are

   inline by default.  */

   inline by default.  */

int flag_default_inline = 1;

int flag_default_inline = 1;

/* Controls whether compiler generates 'type descriptor' that give

/* Controls whether compiler generates 'type descriptor' that give

   run-time type information.  */

   run-time type information.  */

int flag_rtti = 1;

int flag_rtti = 1;

/* Nonzero if we want to conserve space in the .o files.  We do this

/* Nonzero if we want to conserve space in the .o files.  We do this

   by putting uninitialized data and runtime initialized data into

   by putting uninitialized data and runtime initialized data into

   .common instead of .data at the expense of not flagging multiple

   .common instead of .data at the expense of not flagging multiple

   definitions.  */

   definitions.  */

int flag_conserve_space;

int flag_conserve_space;

/* Nonzero if we want to obey access control semantics.  */

/* Nonzero if we want to obey access control semantics.  */

int flag_access_control = 1;

int flag_access_control = 1;

/* Nonzero if we want to check the return value of new and avoid calling

/* Nonzero if we want to check the return value of new and avoid calling

   constructors if it is a null pointer.  */

   constructors if it is a null pointer.  */

int flag_check_new;

int flag_check_new;

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

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

enum cxx_dialect cxx_dialect = cxx98;

enum cxx_dialect cxx_dialect = cxx98;

/* Nonzero if we want the new ISO rules for pushing a new scope for `for'

/* Nonzero if we want the new ISO rules for pushing a new scope for `for'

   initialization variables.

   initialization variables.

   0: Old rules, set by -fno-for-scope.

   0: Old rules, set by -fno-for-scope.

   2: New ISO rules, set by -ffor-scope.

   2: New ISO rules, set by -ffor-scope.

   1: Try to implement new ISO rules, but with backup compatibility

   1: Try to implement new ISO rules, but with backup compatibility

   (and warnings).  This is the default, for now.  */

   (and warnings).  This is the default, for now.  */

int flag_new_for_scope = 1;

int flag_new_for_scope = 1;

/* Nonzero if we want to emit defined symbols with common-like linkage as

/* Nonzero if we want to emit defined symbols with common-like linkage as

   weak symbols where possible, in order to conform to C++ semantics.

   weak symbols where possible, in order to conform to C++ semantics.

   Otherwise, emit them as local symbols.  */

   Otherwise, emit them as local symbols.  */

int flag_weak = 1;

int flag_weak = 1;

/* 0 means we want the preprocessor to not emit line directives for

/* 0 means we want the preprocessor to not emit line directives for

   the current working directory.  1 means we want it to do it.  -1

   the current working directory.  1 means we want it to do it.  -1

   means we should decide depending on whether debugging information

   means we should decide depending on whether debugging information

   is being emitted or not.  */

   is being emitted or not.  */

int flag_working_directory = -1;

int flag_working_directory = -1;

/* Nonzero to use __cxa_atexit, rather than atexit, to register

/* Nonzero to use __cxa_atexit, rather than atexit, to register

   destructors for local statics and global objects.  '2' means it has been

   destructors for local statics and global objects.  '2' means it has been

   set nonzero as a default, not by a command-line flag.  */

   set nonzero as a default, not by a command-line flag.  */

int flag_use_cxa_atexit = DEFAULT_USE_CXA_ATEXIT;

int flag_use_cxa_atexit = DEFAULT_USE_CXA_ATEXIT;

/* Nonzero to use __cxa_get_exception_ptr in C++ exception-handling

/* Nonzero to use __cxa_get_exception_ptr in C++ exception-handling

   code.  '2' means it has not been set explicitly on the command line.  */

   code.  '2' means it has not been set explicitly on the command line.  */

int flag_use_cxa_get_exception_ptr = 2;

int flag_use_cxa_get_exception_ptr = 2;

/* Nonzero means to implement standard semantics for exception

/* Nonzero means to implement standard semantics for exception

   specifications, calling unexpected if an exception is thrown that

   specifications, calling unexpected if an exception is thrown that

   doesn't match the specification.  Zero means to treat them as

   doesn't match the specification.  Zero means to treat them as

   assertions and optimize accordingly, but not check them.  */

   assertions and optimize accordingly, but not check them.  */

int flag_enforce_eh_specs = 1;

int flag_enforce_eh_specs = 1;

/* Nonzero means to generate thread-safe code for initializing local

/* Nonzero means to generate thread-safe code for initializing local

   statics.  */

   statics.  */

int flag_threadsafe_statics = 1;

int flag_threadsafe_statics = 1;

/* Nonzero if we want to pretty-print template specializations as the

/* Nonzero if we want to pretty-print template specializations as the

   template signature followed by the arguments.  */

   template signature followed by the arguments.  */

int flag_pretty_templates = 1;

int flag_pretty_templates = 1;

/* Nonzero means warn about implicit declarations.  */

/* Nonzero means warn about implicit declarations.  */

int warn_implicit = 1;

int warn_implicit = 1;

/* Maximum template instantiation depth.  This limit exists to limit the

/* Maximum template instantiation depth.  This limit exists to limit the

   time it takes to notice infinite template instantiations; the default

   time it takes to notice infinite template instantiations; the default

   value of 1024 is likely to be in the next C++ standard.  */

   value of 1024 is likely to be in the next C++ standard.  */

int max_tinst_depth = 1024;

int max_tinst_depth = 1024;

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

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

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

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

tree *ridpointers;

tree *ridpointers;

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

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

/* Nonzero means don't warn about problems that occur when the code is

/* Nonzero means don't warn about problems that occur when the code is

   executed.  */

   executed.  */

int c_inhibit_evaluation_warnings;

int c_inhibit_evaluation_warnings;

/* Whether lexing has been completed, so subsequent preprocessor

/* Whether lexing has been completed, so subsequent preprocessor

   errors should use the compiler's input_location.  */

   errors should use the compiler's input_location.  */

bool done_lexing = false;

bool done_lexing = false;

/* Information about how a function name is generated.  */

/* Information about how a function name is generated.  */

struct fname_var_t

struct fname_var_t

{

{

  tree *const decl;     /* pointer to the VAR_DECL.  */

  tree *const decl;     /* pointer to the VAR_DECL.  */

  const unsigned rid;   /* RID number for the identifier.  */

  const unsigned rid;   /* RID number for the identifier.  */

  const int pretty;     /* How pretty is it? */

  const int pretty;     /* How pretty is it? */

};

};

/* The three ways of getting then name of the current function.  */

/* The three ways of getting then name of the current function.  */

const struct fname_var_t fname_vars[] =

const struct fname_var_t fname_vars[] =

{

{

  /* C99 compliant __func__, must be first.  */

  /* C99 compliant __func__, must be first.  */

  {&c99_function_name_decl_node, RID_C99_FUNCTION_NAME, 0},

  {&c99_function_name_decl_node, RID_C99_FUNCTION_NAME, 0},

  /* GCC __FUNCTION__ compliant.  */

  /* GCC __FUNCTION__ compliant.  */

  {&function_name_decl_node, RID_FUNCTION_NAME, 0},

  {&function_name_decl_node, RID_FUNCTION_NAME, 0},

  /* GCC __PRETTY_FUNCTION__ compliant.  */

  /* GCC __PRETTY_FUNCTION__ compliant.  */

  {&pretty_function_name_decl_node, RID_PRETTY_FUNCTION_NAME, 1},

  {&pretty_function_name_decl_node, RID_PRETTY_FUNCTION_NAME, 1},

  {NULL, 0, 0},

  {NULL, 0, 0},

};

};

static tree c_fully_fold_internal (tree expr, bool, bool *, bool *);

static tree c_fully_fold_internal (tree expr, bool, bool *, bool *);

static tree check_case_value (tree);

static tree check_case_value (tree);

static bool check_case_bounds (tree, tree, tree *, tree *);

static bool check_case_bounds (tree, tree, tree *, tree *);

static tree handle_packed_attribute (tree *, tree, tree, int, bool *);

static tree handle_packed_attribute (tree *, tree, tree, int, bool *);

static tree handle_nocommon_attribute (tree *, tree, tree, int, bool *);

static tree handle_nocommon_attribute (tree *, tree, tree, int, bool *);

static tree handle_common_attribute (tree *, tree, tree, int, bool *);

static tree handle_common_attribute (tree *, tree, tree, int, bool *);

static tree handle_noreturn_attribute (tree *, tree, tree, int, bool *);

static tree handle_noreturn_attribute (tree *, tree, tree, int, bool *);

static tree handle_hot_attribute (tree *, tree, tree, int, bool *);

static tree handle_hot_attribute (tree *, tree, tree, int, bool *);

static tree handle_cold_attribute (tree *, tree, tree, int, bool *);

static tree handle_cold_attribute (tree *, tree, tree, int, bool *);

static tree handle_noinline_attribute (tree *, tree, tree, int, bool *);

static tree handle_noinline_attribute (tree *, tree, tree, int, bool *);

static tree handle_noclone_attribute (tree *, tree, tree, int, bool *);

static tree handle_noclone_attribute (tree *, tree, tree, int, bool *);

static tree handle_always_inline_attribute (tree *, tree, tree, int,

static tree handle_always_inline_attribute (tree *, tree, tree, int,

                                            bool *);

                                            bool *);

static tree handle_gnu_inline_attribute (tree *, tree, tree, int, bool *);

static tree handle_gnu_inline_attribute (tree *, tree, tree, int, bool *);

static tree handle_artificial_attribute (tree *, tree, tree, int, bool *);

static tree handle_artificial_attribute (tree *, tree, tree, int, bool *);

static tree handle_flatten_attribute (tree *, tree, tree, int, bool *);

static tree handle_flatten_attribute (tree *, tree, tree, int, bool *);

static tree handle_error_attribute (tree *, tree, tree, int, bool *);

static tree handle_error_attribute (tree *, tree, tree, int, bool *);

static tree handle_used_attribute (tree *, tree, tree, int, bool *);

static tree handle_used_attribute (tree *, tree, tree, int, bool *);

static tree handle_unused_attribute (tree *, tree, tree, int, bool *);

static tree handle_unused_attribute (tree *, tree, tree, int, bool *);

static tree handle_externally_visible_attribute (tree *, tree, tree, int,

static tree handle_externally_visible_attribute (tree *, tree, tree, int,

                                                 bool *);

                                                 bool *);

static tree handle_const_attribute (tree *, tree, tree, int, bool *);

static tree handle_const_attribute (tree *, tree, tree, int, bool *);

static tree handle_transparent_union_attribute (tree *, tree, tree,

static tree handle_transparent_union_attribute (tree *, tree, tree,

                                                int, bool *);

                                                int, bool *);

static tree handle_constructor_attribute (tree *, tree, tree, int, bool *);

static tree handle_constructor_attribute (tree *, tree, tree, int, bool *);

static tree handle_destructor_attribute (tree *, tree, tree, int, bool *);

static tree handle_destructor_attribute (tree *, tree, tree, int, bool *);

static tree handle_mode_attribute (tree *, tree, tree, int, bool *);

static tree handle_mode_attribute (tree *, tree, tree, int, bool *);

static tree handle_section_attribute (tree *, tree, tree, int, bool *);

static tree handle_section_attribute (tree *, tree, tree, int, bool *);

static tree handle_aligned_attribute (tree *, tree, tree, int, bool *);

static tree handle_aligned_attribute (tree *, tree, tree, int, bool *);

static tree handle_weak_attribute (tree *, tree, tree, int, bool *) ;

static tree handle_weak_attribute (tree *, tree, tree, int, bool *) ;

static tree handle_alias_attribute (tree *, tree, tree, int, bool *);

static tree handle_alias_attribute (tree *, tree, tree, int, bool *);

static tree handle_weakref_attribute (tree *, tree, tree, int, bool *) ;

static tree handle_weakref_attribute (tree *, tree, tree, int, bool *) ;

static tree handle_visibility_attribute (tree *, tree, tree, int,

static tree handle_visibility_attribute (tree *, tree, tree, int,

                                         bool *);

                                         bool *);

static tree handle_tls_model_attribute (tree *, tree, tree, int,

static tree handle_tls_model_attribute (tree *, tree, tree, int,

                                        bool *);

                                        bool *);

static tree handle_no_instrument_function_attribute (tree *, tree,

static tree handle_no_instrument_function_attribute (tree *, tree,

                                                     tree, int, bool *);

                                                     tree, int, bool *);

static tree handle_malloc_attribute (tree *, tree, tree, int, bool *);

static tree handle_malloc_attribute (tree *, tree, tree, int, bool *);

static tree handle_returns_twice_attribute (tree *, tree, tree, int, bool *);

static tree handle_returns_twice_attribute (tree *, tree, tree, int, bool *);

static tree handle_no_limit_stack_attribute (tree *, tree, tree, int,

static tree handle_no_limit_stack_attribute (tree *, tree, tree, int,

                                             bool *);

                                             bool *);

static tree handle_pure_attribute (tree *, tree, tree, int, bool *);

static tree handle_pure_attribute (tree *, tree, tree, int, bool *);

static tree handle_novops_attribute (tree *, tree, tree, int, bool *);

static tree handle_novops_attribute (tree *, tree, tree, int, bool *);

static tree handle_deprecated_attribute (tree *, tree, tree, int,

static tree handle_deprecated_attribute (tree *, tree, tree, int,

                                         bool *);

                                         bool *);

static tree handle_vector_size_attribute (tree *, tree, tree, int,

static tree handle_vector_size_attribute (tree *, tree, tree, int,

                                          bool *);

                                          bool *);

static tree handle_nonnull_attribute (tree *, tree, tree, int, bool *);

static tree handle_nonnull_attribute (tree *, tree, tree, int, bool *);

static tree handle_nothrow_attribute (tree *, tree, tree, int, bool *);

static tree handle_nothrow_attribute (tree *, tree, tree, int, bool *);

static tree handle_cleanup_attribute (tree *, tree, tree, int, bool *);

static tree handle_cleanup_attribute (tree *, tree, tree, int, bool *);

static tree handle_warn_unused_result_attribute (tree *, tree, tree, int,

static tree handle_warn_unused_result_attribute (tree *, tree, tree, int,

                                                 bool *);

                                                 bool *);

static tree handle_sentinel_attribute (tree *, tree, tree, int, bool *);

static tree handle_sentinel_attribute (tree *, tree, tree, int, bool *);

static tree handle_type_generic_attribute (tree *, tree, tree, int, bool *);

static tree handle_type_generic_attribute (tree *, tree, tree, int, bool *);

static tree handle_alloc_size_attribute (tree *, tree, tree, int, bool *);

static tree handle_alloc_size_attribute (tree *, tree, tree, int, bool *);

static tree handle_target_attribute (tree *, tree, tree, int, bool *);

static tree handle_target_attribute (tree *, tree, tree, int, bool *);

static tree handle_optimize_attribute (tree *, tree, tree, int, bool *);

static tree handle_optimize_attribute (tree *, tree, tree, int, bool *);

static void check_function_nonnull (tree, int, tree *);

static void check_function_nonnull (tree, int, tree *);

static void check_nonnull_arg (void *, tree, unsigned HOST_WIDE_INT);

static void check_nonnull_arg (void *, tree, unsigned HOST_WIDE_INT);

static bool nonnull_check_p (tree, unsigned HOST_WIDE_INT);

static bool nonnull_check_p (tree, unsigned HOST_WIDE_INT);

static bool get_nonnull_operand (tree, unsigned HOST_WIDE_INT *);

static bool get_nonnull_operand (tree, unsigned HOST_WIDE_INT *);

static int resort_field_decl_cmp (const void *, const void *);

static int resort_field_decl_cmp (const void *, const void *);

/* Reserved words.  The third field is a mask: keywords are disabled

/* Reserved words.  The third field is a mask: keywords are disabled

   if they match the mask.

   if they match the mask.

   Masks for languages:

   Masks for languages:

   C --std=c89: D_C99 | D_CXXONLY | D_OBJC | D_CXX_OBJC

   C --std=c89: D_C99 | D_CXXONLY | D_OBJC | D_CXX_OBJC

   C --std=c99: D_CXXONLY | D_OBJC

   C --std=c99: D_CXXONLY | D_OBJC

   ObjC is like C except that D_OBJC and D_CXX_OBJC are not set

   ObjC is like C except that D_OBJC and D_CXX_OBJC are not set

   C++ --std=c98: D_CONLY | D_CXXOX | D_OBJC

   C++ --std=c98: D_CONLY | D_CXXOX | D_OBJC

   C++ --std=c0x: D_CONLY | D_OBJC

   C++ --std=c0x: D_CONLY | D_OBJC

   ObjC++ is like C++ except that D_OBJC is not set

   ObjC++ is like C++ except that D_OBJC is not set

   If -fno-asm is used, D_ASM is added to the mask.  If

   If -fno-asm is used, D_ASM is added to the mask.  If

   -fno-gnu-keywords is used, D_EXT is added.  If -fno-asm and C in

   -fno-gnu-keywords is used, D_EXT is added.  If -fno-asm and C in

   C89 mode, D_EXT89 is added for both -fno-asm and -fno-gnu-keywords.

   C89 mode, D_EXT89 is added for both -fno-asm and -fno-gnu-keywords.

   In C with -Wc++-compat, we warn if D_CXXWARN is set.  */

   In C with -Wc++-compat, we warn if D_CXXWARN is set.  */

const struct c_common_resword c_common_reswords[] =

const struct c_common_resword c_common_reswords[] =

{

{

  { "_Bool",            RID_BOOL,      D_CONLY },

  { "_Bool",            RID_BOOL,      D_CONLY },

  { "_Complex",         RID_COMPLEX,    0 },

  { "_Complex",         RID_COMPLEX,    0 },

  { "_Imaginary",       RID_IMAGINARY, D_CONLY },

  { "_Imaginary",       RID_IMAGINARY, D_CONLY },

  { "_Decimal32",       RID_DFLOAT32,  D_CONLY | D_EXT },

  { "_Decimal32",       RID_DFLOAT32,  D_CONLY | D_EXT },

  { "_Decimal64",       RID_DFLOAT64,  D_CONLY | D_EXT },

  { "_Decimal64",       RID_DFLOAT64,  D_CONLY | D_EXT },

  { "_Decimal128",      RID_DFLOAT128, D_CONLY | D_EXT },

  { "_Decimal128",      RID_DFLOAT128, D_CONLY | D_EXT },

  { "_Fract",           RID_FRACT,     D_CONLY | D_EXT },

  { "_Fract",           RID_FRACT,     D_CONLY | D_EXT },

  { "_Accum",           RID_ACCUM,     D_CONLY | D_EXT },

  { "_Accum",           RID_ACCUM,     D_CONLY | D_EXT },

  { "_Sat",             RID_SAT,       D_CONLY | D_EXT },

  { "_Sat",             RID_SAT,       D_CONLY | D_EXT },

  { "__FUNCTION__",     RID_FUNCTION_NAME, 0 },

  { "__FUNCTION__",     RID_FUNCTION_NAME, 0 },

  { "__PRETTY_FUNCTION__", RID_PRETTY_FUNCTION_NAME, 0 },

  { "__PRETTY_FUNCTION__", RID_PRETTY_FUNCTION_NAME, 0 },

  { "__alignof",        RID_ALIGNOF,    0 },

  { "__alignof",        RID_ALIGNOF,    0 },

  { "__alignof__",      RID_ALIGNOF,    0 },

  { "__alignof__",      RID_ALIGNOF,    0 },

  { "__asm",            RID_ASM,        0 },

  { "__asm",            RID_ASM,        0 },

  { "__asm__",          RID_ASM,        0 },

  { "__asm__",          RID_ASM,        0 },

  { "__attribute",      RID_ATTRIBUTE,  0 },

  { "__attribute",      RID_ATTRIBUTE,  0 },

  { "__attribute__",    RID_ATTRIBUTE,  0 },

  { "__attribute__",    RID_ATTRIBUTE,  0 },

  { "__builtin_choose_expr", RID_CHOOSE_EXPR, D_CONLY },

  { "__builtin_choose_expr", RID_CHOOSE_EXPR, D_CONLY },

  { "__builtin_offsetof", RID_OFFSETOF, 0 },

  { "__builtin_offsetof", RID_OFFSETOF, 0 },

  { "__builtin_types_compatible_p", RID_TYPES_COMPATIBLE_P, D_CONLY },

  { "__builtin_types_compatible_p", RID_TYPES_COMPATIBLE_P, D_CONLY },

  { "__builtin_va_arg", RID_VA_ARG,     0 },

  { "__builtin_va_arg", RID_VA_ARG,     0 },

  { "__complex",        RID_COMPLEX,    0 },

  { "__complex",        RID_COMPLEX,    0 },

  { "__complex__",      RID_COMPLEX,    0 },

  { "__complex__",      RID_COMPLEX,    0 },

  { "__const",          RID_CONST,      0 },

  { "__const",          RID_CONST,      0 },

  { "__const__",        RID_CONST,      0 },

  { "__const__",        RID_CONST,      0 },

  { "__decltype",       RID_DECLTYPE,   D_CXXONLY },

  { "__decltype",       RID_DECLTYPE,   D_CXXONLY },

  { "__extension__",    RID_EXTENSION,  0 },

  { "__extension__",    RID_EXTENSION,  0 },

  { "__func__",         RID_C99_FUNCTION_NAME, 0 },

  { "__func__",         RID_C99_FUNCTION_NAME, 0 },

  { "__has_nothrow_assign", RID_HAS_NOTHROW_ASSIGN, D_CXXONLY },

  { "__has_nothrow_assign", RID_HAS_NOTHROW_ASSIGN, D_CXXONLY },

  { "__has_nothrow_constructor", RID_HAS_NOTHROW_CONSTRUCTOR, D_CXXONLY },

  { "__has_nothrow_constructor", RID_HAS_NOTHROW_CONSTRUCTOR, D_CXXONLY },

  { "__has_nothrow_copy", RID_HAS_NOTHROW_COPY, D_CXXONLY },

  { "__has_nothrow_copy", RID_HAS_NOTHROW_COPY, D_CXXONLY },

  { "__has_trivial_assign", RID_HAS_TRIVIAL_ASSIGN, D_CXXONLY },

  { "__has_trivial_assign", RID_HAS_TRIVIAL_ASSIGN, D_CXXONLY },

  { "__has_trivial_constructor", RID_HAS_TRIVIAL_CONSTRUCTOR, D_CXXONLY },

  { "__has_trivial_constructor", RID_HAS_TRIVIAL_CONSTRUCTOR, D_CXXONLY },

  { "__has_trivial_copy", RID_HAS_TRIVIAL_COPY, D_CXXONLY },

  { "__has_trivial_copy", RID_HAS_TRIVIAL_COPY, D_CXXONLY },

  { "__has_trivial_destructor", RID_HAS_TRIVIAL_DESTRUCTOR, D_CXXONLY },

  { "__has_trivial_destructor", RID_HAS_TRIVIAL_DESTRUCTOR, D_CXXONLY },

  { "__has_virtual_destructor", RID_HAS_VIRTUAL_DESTRUCTOR, D_CXXONLY },

  { "__has_virtual_destructor", RID_HAS_VIRTUAL_DESTRUCTOR, D_CXXONLY },

  { "__is_abstract",    RID_IS_ABSTRACT, D_CXXONLY },

  { "__is_abstract",    RID_IS_ABSTRACT, D_CXXONLY },

  { "__is_base_of",     RID_IS_BASE_OF, D_CXXONLY },

  { "__is_base_of",     RID_IS_BASE_OF, D_CXXONLY },

  { "__is_class",       RID_IS_CLASS,   D_CXXONLY },

  { "__is_class",       RID_IS_CLASS,   D_CXXONLY },

  { "__is_convertible_to", RID_IS_CONVERTIBLE_TO, D_CXXONLY },

  { "__is_convertible_to", RID_IS_CONVERTIBLE_TO, D_CXXONLY },

  { "__is_empty",       RID_IS_EMPTY,   D_CXXONLY },

  { "__is_empty",       RID_IS_EMPTY,   D_CXXONLY },

  { "__is_enum",        RID_IS_ENUM,    D_CXXONLY },

  { "__is_enum",        RID_IS_ENUM,    D_CXXONLY },

  { "__is_pod",         RID_IS_POD,     D_CXXONLY },

  { "__is_pod",         RID_IS_POD,     D_CXXONLY },

  { "__is_polymorphic", RID_IS_POLYMORPHIC, D_CXXONLY },

  { "__is_polymorphic", RID_IS_POLYMORPHIC, D_CXXONLY },

  { "__is_standard_layout", RID_IS_STD_LAYOUT, D_CXXONLY },

  { "__is_standard_layout", RID_IS_STD_LAYOUT, D_CXXONLY },

  { "__is_trivial",     RID_IS_TRIVIAL, D_CXXONLY },

  { "__is_trivial",     RID_IS_TRIVIAL, D_CXXONLY },

  { "__is_union",       RID_IS_UNION,   D_CXXONLY },

  { "__is_union",       RID_IS_UNION,   D_CXXONLY },

  { "__imag",           RID_IMAGPART,   0 },

  { "__imag",           RID_IMAGPART,   0 },

  { "__imag__",         RID_IMAGPART,   0 },

  { "__imag__",         RID_IMAGPART,   0 },