Subversion Repositories openrisc_me

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

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

   2001, 2002, 2003, 2004, 2005, 2007 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/>.  */

#include "config.h"

#include "system.h"

#include "coretypes.h"

#include "tm.h"

#include "intl.h"

#include "tree.h"

#include "flags.h"

#include "output.h"

#include "c-pragma.h"

#include "rtl.h"

#include "ggc.h"

#include "varray.h"

#include "expr.h"

#include "c-common.h"

#include "diagnostic.h"

#include "tm_p.h"

#include "obstack.h"

#include "cpplib.h"

#include "target.h"

#include "langhooks.h"

#include "tree-inline.h"

#include "c-tree.h"

#include "toplev.h"

#include "tree-iterator.h"

#include "hashtab.h"

#include "tree-mudflap.h"

#include "opts.h"

#include "real.h"

#include "cgraph.h"

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

/* We let tm.h override the types used here, to handle trivial differences

   such as the choice of unsigned int or long unsigned int for size_t.

   When machines start needing nontrivial differences in the size type,

   it would be best to do something here to figure out automatically

   from other information what type to use.  */

#ifndef SIZE_TYPE

#define SIZE_TYPE "long unsigned int"

#endif

#ifndef PID_TYPE

#define PID_TYPE "int"

#endif

#ifndef WCHAR_TYPE

#define WCHAR_TYPE "int"

#endif

/* WCHAR_TYPE gets overridden by -fshort-wchar.  */

#define MODIFIED_WCHAR_TYPE \

        (flag_short_wchar ? "short unsigned int" : WCHAR_TYPE)

#ifndef PTRDIFF_TYPE

#define PTRDIFF_TYPE "long int"

#endif

#ifndef WINT_TYPE

#define WINT_TYPE "unsigned int"

#endif

#ifndef INTMAX_TYPE

#define INTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE)     \

                     ? "int"                                    \

                     : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \

                        ? "long int"                            \

                        : "long long int"))

#endif

#ifndef UINTMAX_TYPE

#define UINTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE)    \

                     ? "unsigned int"                           \

                     : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \

                        ? "long unsigned int"                   \

                        : "long long unsigned int"))

#endif

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

   listed here individually for documentation purposes.

   INTEGER_TYPE and REAL_TYPE nodes for the standard data types.

        tree short_integer_type_node;

        tree long_integer_type_node;

        tree long_long_integer_type_node;

        tree short_unsigned_type_node;

        tree long_unsigned_type_node;

        tree long_long_unsigned_type_node;

        tree truthvalue_type_node;

        tree truthvalue_false_node;

        tree truthvalue_true_node;

        tree ptrdiff_type_node;

        tree unsigned_char_type_node;

        tree signed_char_type_node;

        tree wchar_type_node;

        tree signed_wchar_type_node;

        tree unsigned_wchar_type_node;

        tree float_type_node;

        tree double_type_node;

        tree long_double_type_node;

        tree complex_integer_type_node;

        tree complex_float_type_node;

        tree complex_double_type_node;

        tree complex_long_double_type_node;

        tree dfloat32_type_node;

        tree dfloat64_type_node;

        tree_dfloat128_type_node;

        tree intQI_type_node;

        tree intHI_type_node;

        tree intSI_type_node;

        tree intDI_type_node;

        tree intTI_type_node;

        tree unsigned_intQI_type_node;

        tree unsigned_intHI_type_node;

        tree unsigned_intSI_type_node;

        tree unsigned_intDI_type_node;

        tree unsigned_intTI_type_node;

        tree widest_integer_literal_type_node;

        tree widest_unsigned_literal_type_node;

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

        tree ptr_type_node, const_ptr_type_node;

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

        tree string_type_node, const_string_type_node;

   Type `char[SOMENUMBER]'.

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

        tree char_array_type_node;

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

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

        tree int_array_type_node;

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

   Used when a wide string literal is created.

        tree wchar_array_type_node;

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

        tree default_function_type;

   A VOID_TYPE node, packaged in a TREE_LIST.

        tree void_list_node;

  The lazily created VAR_DECLs for __FUNCTION__, __PRETTY_FUNCTION__,

  and __func__. (C doesn't generate __FUNCTION__ and__PRETTY_FUNCTION__

  VAR_DECLS, but C++ does.)

        tree function_name_decl_node;

        tree pretty_function_name_decl_node;

        tree c99_function_name_decl_node;

  Stack of nested function name VAR_DECLs.

        tree saved_function_name_decls;

*/

tree c_global_trees[CTI_MAX];

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

/* Nonzero if prepreprocessing only.  */

int flag_preprocess_only;

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

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.  */

char flag_no_output;

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

char flag_dump_macros;

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

char flag_dump_includes;

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

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.  */

const char *pch_file;

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

   user's namespace.  */

int flag_iso;

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

   and assertions.  */

int flag_undef;

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

int flag_no_builtin;

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

   -ansi sets this.  */

int flag_no_nonansi_builtin;

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

int flag_short_double;

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

int flag_short_wchar;

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

int flag_ms_extensions;

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

int flag_no_asm;

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

int flag_signed_bitfields = 1;

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

int warn_unknown_pragmas; /* Tri state variable.  */

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

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

int warn_format;

/* 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

   size.  */

int warn_strict_null_sentinel;

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

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

   will most likely result in crashes.  */

int flag_nil_receivers = 1;

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

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

   affect other languages in the future.  */

int flag_zero_link = 0;

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

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

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

int flag_replace_objc_classes = 0;

/* C/ObjC language option variables.  */

/* Nonzero means allow type mismatches in conditional expressions;

   just make their values `void'.  */

int flag_cond_mismatch;

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

int flag_isoc94;

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

int flag_isoc99;

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

int flag_hosted = 1;

/* Warn if main is suspicious.  */

int warn_main;

/* ObjC language option variables.  */

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

   requested (ObjC).  */

int flag_gen_declaration;

/* 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.  */

int print_struct_values;

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

const char *constant_string_class_name;

/* C++ language option variables.  */

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

int flag_no_gnu_keywords;

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

   they can be inlined.  */

int flag_implement_inlines = 1;

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

int flag_implicit_templates = 1;

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

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

   aren't.  */

int flag_implicit_inline_templates = 1;

/* Nonzero means generate separate instantiation control files and

   juggle them at link time.  */

int flag_use_repository;

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

   required.  */

int flag_optional_diags = 1;

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

int flag_elide_constructors = 1;

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

   inline by default.  */

int flag_default_inline = 1;

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

   run-time type information.  */

int flag_rtti = 1;

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

   by putting uninitialized data and runtime initialized data into

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

   definitions.  */

int flag_conserve_space;

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

int flag_access_control = 1;

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

   constructors if it is a null pointer.  */

int flag_check_new;

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

   initialization variables.

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

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

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

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

int flag_new_for_scope = 1;

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

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

   Otherwise, emit them as local symbols.  */

int flag_weak = 1;

/* 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

   means we should decide depending on whether debugging information

   is being emitted or not.  */

int flag_working_directory = -1;

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

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

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

int flag_use_cxa_atexit = DEFAULT_USE_CXA_ATEXIT;

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

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

int flag_use_cxa_get_exception_ptr = 2;

/* Nonzero means make the default pedwarns warnings instead of errors.

   The value of this flag is ignored if -pedantic is specified.  */

int flag_permissive;

/* Nonzero means to implement standard semantics for exception

   specifications, calling unexpected if an exception is thrown that

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

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

int flag_enforce_eh_specs = 1;

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

   statics.  */

int flag_threadsafe_statics = 1;

/* Nonzero means warn about implicit declarations.  */

int warn_implicit = 1;

/* Maximum template instantiation depth.  This limit is rather

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

   infinite template instantiations.  */

int max_tinst_depth = 500;

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

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

tree *ridpointers;

tree (*make_fname_decl) (tree, int);

/* Nonzero means the expression being parsed will never be evaluated.

   This is a count, since unevaluated expressions can nest.  */

int skip_evaluation;

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

struct fname_var_t

{

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

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

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

};

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

const struct fname_var_t fname_vars[] =

{

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

  {&c99_function_name_decl_node, RID_C99_FUNCTION_NAME, 0},

  /* GCC __FUNCTION__ compliant.  */

  {&function_name_decl_node, RID_FUNCTION_NAME, 0},

  /* GCC __PRETTY_FUNCTION__ compliant.  */

  {&pretty_function_name_decl_node, RID_PRETTY_FUNCTION_NAME, 1},

  {NULL, 0, 0},

};

static int constant_fits_type_p (tree, tree);

static tree check_case_value (tree);

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

static tree handle_packed_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_noreturn_attribute (tree *, tree, tree, int, bool *);

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

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

                                            bool *);

static tree handle_gnu_inline_attribute (tree *, tree, tree, int,

                                         bool *);

static tree handle_flatten_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_externally_visible_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,

                                                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_mode_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_weak_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_visibility_attribute (tree *, tree, tree, int,

                                         bool *);

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

                                        bool *);

static tree handle_no_instrument_function_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_no_limit_stack_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_deprecated_attribute (tree *, tree, tree, int,

                                         bool *);

static tree handle_vector_size_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_cleanup_attribute (tree *, tree, tree, int, bool *);

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

                                                 bool *);

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

static void check_function_nonnull (tree, tree);

static void check_nonnull_arg (void *, 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 int resort_field_decl_cmp (const void *, const void *);

/* Table of machine-independent attributes common to all C-like languages.  */

const struct attribute_spec c_common_attribute_table[] =

{

  /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */

  { "packed",                 0, 0, false, false, false,

                              handle_packed_attribute },

  { "nocommon",               0, 0, true,  false, false,

                              handle_nocommon_attribute },

  { "common",                 0, 0, true,  false, false,

                              handle_common_attribute },

  /* FIXME: logically, noreturn attributes should be listed as

     "false, true, true" and apply to function types.  But implementing this

     would require all the places in the compiler that use TREE_THIS_VOLATILE

     on a decl to identify non-returning functions to be located and fixed

     to check the function type instead.  */

  { "noreturn",               0, 0, true,  false, false,

                              handle_noreturn_attribute },

  { "volatile",               0, 0, true,  false, false,

                              handle_noreturn_attribute },

  { "noinline",               0, 0, true,  false, false,

                              handle_noinline_attribute },

  { "always_inline",          0, 0, true,  false, false,

                              handle_always_inline_attribute },

  { "gnu_inline",             0, 0, true,  false, false,

                              handle_gnu_inline_attribute },

  { "flatten",                0, 0, true,  false, false,

                              handle_flatten_attribute },

  { "used",                   0, 0, true,  false, false,

                              handle_used_attribute },

  { "unused",                 0, 0, false, false, false,

                              handle_unused_attribute },

  { "externally_visible",     0, 0, true,  false, false,

                              handle_externally_visible_attribute },

  /* The same comments as for noreturn attributes apply to const ones.  */

  { "const",                  0, 0, true,  false, false,

                              handle_const_attribute },

  { "transparent_union",      0, 0, false, false, false,

                              handle_transparent_union_attribute },

  { "constructor",            0, 0, true,  false, false,

                              handle_constructor_attribute },

  { "destructor",             0, 0, true,  false, false,

                              handle_destructor_attribute },

  { "mode",                   1, 1, false,  true, false,

                              handle_mode_attribute },

  { "section",                1, 1, true,  false, false,

                              handle_section_attribute },

  { "aligned",                0, 1, false, false, false,

                              handle_aligned_attribute },

  { "weak",                   0, 0, true,  false, false,

                              handle_weak_attribute },

  { "alias",                  1, 1, true,  false, false,

                              handle_alias_attribute },

  { "weakref",                0, 1, true,  false, false,

                              handle_weakref_attribute },

  { "no_instrument_function", 0, 0, true,  false, false,

                              handle_no_instrument_function_attribute },

  { "malloc",                 0, 0, true,  false, false,

                              handle_malloc_attribute },

  { "returns_twice",          0, 0, true,  false, false,

                              handle_returns_twice_attribute },

  { "no_stack_limit",         0, 0, true,  false, false,

                              handle_no_limit_stack_attribute },

  { "pure",                   0, 0, true,  false, false,

                              handle_pure_attribute },

  /* For internal use (marking of builtins) only.  The name contains space

     to prevent its usage in source code.  */

  { "no vops",                0, 0, true,  false, false,

                              handle_novops_attribute },

  { "deprecated",             0, 0, false, false, false,

                              handle_deprecated_attribute },

  { "vector_size",            1, 1, false, true, false,

                              handle_vector_size_attribute },

  { "visibility",             1, 1, false, false, false,

                              handle_visibility_attribute },

  { "tls_model",              1, 1, true,  false, false,

                              handle_tls_model_attribute },

  { "nonnull",                0, -1, false, true, true,

                              handle_nonnull_attribute },

  { "nothrow",                0, 0, true,  false, false,

                              handle_nothrow_attribute },

  { "may_alias",              0, 0, false, true, false, NULL },

  { "cleanup",                1, 1, true, false, false,

                              handle_cleanup_attribute },

  { "warn_unused_result",     0, 0, false, true, true,

                              handle_warn_unused_result_attribute },

  { "sentinel",               0, 1, false, true, true,

                              handle_sentinel_attribute },

  { NULL,                     0, 0, false, false, false, NULL }

};

/* Give the specifications for the format attributes, used by C and all

   descendants.  */

const struct attribute_spec c_common_format_attribute_table[] =

{

  /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */

  { "format",                 3, 3, false, true,  true,

                              handle_format_attribute },

  { "format_arg",             1, 1, false, true,  true,

                              handle_format_arg_attribute },

  { NULL,                     0, 0, false, false, false, NULL }

};

/* Push current bindings for the function name VAR_DECLS.  */

void

start_fname_decls (void)

{

  unsigned ix;

  tree saved = NULL_TREE;

  for (ix = 0; fname_vars[ix].decl; ix++)

    {

      tree decl = *fname_vars[ix].decl;

      if (decl)

        {

          saved = tree_cons (decl, build_int_cst (NULL_TREE, ix), saved);

          *fname_vars[ix].decl = NULL_TREE;

        }

    }

  if (saved || saved_function_name_decls)

    /* Normally they'll have been NULL, so only push if we've got a

       stack, or they are non-NULL.  */

    saved_function_name_decls = tree_cons (saved, NULL_TREE,

                                           saved_function_name_decls);

}

/* Finish up the current bindings, adding them into the current function's

   statement tree.  This must be done _before_ finish_stmt_tree is called.

   If there is no current function, we must be at file scope and no statements

   are involved. Pop the previous bindings.  */

void

finish_fname_decls (void)

{

  unsigned ix;

  tree stmts = NULL_TREE;

  tree stack = saved_function_name_decls;

  for (; stack && TREE_VALUE (stack); stack = TREE_CHAIN (stack))

    append_to_statement_list (TREE_VALUE (stack), &stmts);

  if (stmts)

    {

      tree *bodyp = &DECL_SAVED_TREE (current_function_decl);

      if (TREE_CODE (*bodyp) == BIND_EXPR)

        bodyp = &BIND_EXPR_BODY (*bodyp);

      append_to_statement_list_force (*bodyp, &stmts);

      *bodyp = stmts;

    }

  for (ix = 0; fname_vars[ix].decl; ix++)

    *fname_vars[ix].decl = NULL_TREE;

  if (stack)

    {