CbC/CbC_gcc: gcc/c-common.c comparison

comparison gcc/c-common.c @ 63:b7f97abdc517 gcc-4.6-20100522

update gcc from gcc-4.5.0 to gcc-4.6

author	ryoma <e075725@ie.u-ryukyu.ac.jp>
date	Mon, 24 May 2010 12:47:05 +0900
parents	77e2b8dfacca
children

comparison

equal deleted inserted replaced

-:3c8a44c06a95
+:b7f97abdc517
 /* 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, 2006, 2007, 2008, 2009
+2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
 Free Software Foundation, Inc.
 This file is part of GCC.
 GCC is free software; you can redistribute it and/or modify it under
 #include "flags.h"
 #include "output.h"
 #include "c-pragma.h"
 #include "rtl.h"
 #include "ggc.h"
-#include "varray.h"
+#include "expr.h" /* For vector_mode_valid_p */
-#include "expr.h"
 #include "c-common.h"
 #include "tm_p.h"
 #include "obstack.h"
 #include "cpplib.h"
 #include "target.h"
 #include "diagnostic.h"
 #include "tree-iterator.h"
 #include "hashtab.h"
 #include "tree-mudflap.h"
 #include "opts.h"
-#include "real.h"
 #include "cgraph.h"
 #include "target-def.h"
-#include "gimple.h"
-#include "fixed-value.h"
 #include "libfuncs.h"
 cpp_reader *parse_in;		/* Declared in c-pragma.h.  */
 /* The following symbols are subsumed in the c_global_trees array, and
 /* Nonzero means enable C89 Amendment 1 features.  */
 int flag_isoc94;
-/* Nonzero means use the ISO C99 dialect of C.  */
+/* Nonzero means use the ISO C99 (or C1X) dialect of C.  */
 int flag_isoc99;
+/* Nonzero means use the ISO C1X dialect of C.  */
+int flag_isoc1x;
 /* Nonzero means that we have builtin functions, and main is an int.  */
 int flag_hosted = 1;
 /* Nonzero if we want to pretty-print template specializations as the
 template signature followed by the arguments.  */
 int flag_pretty_templates = 1;
-/* Nonzero means warn about implicit declarations.  */
-int warn_implicit = 1;
 /* Maximum template instantiation depth.  This limit exists to limit the
 time it takes to notice infinite template instantiations; the default
 value of 1024 is likely to be in the next C++ standard.  */
 static tree handle_sentinel_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_target_attribute (tree *, tree, tree, int, bool *);
 static tree handle_optimize_attribute (tree *, tree, tree, int, bool *);
+static tree handle_fnspec_attribute (tree *, tree, tree, int, bool *);
 static void check_function_nonnull (tree, int, 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 *);
 { "_Decimal64",       RID_DFLOAT64,  D_CONLY | D_EXT },
 { "_Decimal128",      RID_DFLOAT128, D_CONLY | D_EXT },
 { "_Fract",           RID_FRACT,     D_CONLY | D_EXT },
 { "_Accum",           RID_ACCUM,     D_CONLY | D_EXT },
 { "_Sat",             RID_SAT,       D_CONLY | D_EXT },
+{ "_Static_assert",   RID_STATIC_ASSERT, D_CONLY },
 { "__FUNCTION__",	RID_FUNCTION_NAME, 0 },
 { "__PRETTY_FUNCTION__", RID_PRETTY_FUNCTION_NAME, 0 },
 { "__alignof",	RID_ALIGNOF,	0 },
 { "__alignof__",	RID_ALIGNOF,	0 },
 { "__asm",		RID_ASM,	0 },
 { "int",		RID_INT,	0 },
 { "long",		RID_LONG,	0 },
 { "mutable",		RID_MUTABLE,	D_CXXONLY | D_CXXWARN },
 { "namespace",	RID_NAMESPACE,	D_CXXONLY | D_CXXWARN },
 { "new",		RID_NEW,	D_CXXONLY | D_CXXWARN },
+{ "nullptr",		RID_NULLPTR,	D_CXXONLY | D_CXX0X | D_CXXWARN },
 { "operator",		RID_OPERATOR,	D_CXXONLY | D_CXXWARN },
 { "private",		RID_PRIVATE,	D_CXX_OBJC | D_CXXWARN },
 { "protected",	RID_PROTECTED,	D_CXX_OBJC | D_CXXWARN },
 { "public",		RID_PUBLIC,	D_CXX_OBJC | D_CXXWARN },
 { "register",		RID_REGISTER,	0 },
 			      handle_error_attribute },
 { "target",                 1, -1, true, false, false,
 			      handle_target_attribute },
 { "optimize",               1, -1, true, false, false,
 			      handle_optimize_attribute },
+/* For internal use (marking of builtins and runtime functions) only.
+The name contains space to prevent its usage in source code.  */
+{ "fn spec",	 	      1, 1, false, true, true,
+			      handle_fnspec_attribute },
 { NULL,                     0, 0, false, false, false, NULL }
 };
 /* Give the specifications for the format attributes, used by C and all
 descendants.  */
 all the range of values of the integer type cannot be
 represented by the real type.  */
 else if (TREE_CODE (expr_type) == INTEGER_TYPE
 && TREE_CODE (type) == REAL_TYPE)
 {
-tree type_low_bound = TYPE_MIN_VALUE (expr_type);
+	  tree type_low_bound, type_high_bound;
-tree type_high_bound = TYPE_MAX_VALUE (expr_type);
+REAL_VALUE_TYPE real_low_bound, real_high_bound;
-REAL_VALUE_TYPE real_low_bound
-	    = real_value_from_int_cst (0, type_low_bound);
+	  /* Don't warn about char y = 0xff; float x = (int) y;  */
-REAL_VALUE_TYPE real_high_bound
+	  expr = get_unwidened (expr, 0);
-	    = real_value_from_int_cst (0, type_high_bound);
+	  expr_type = TREE_TYPE (expr);
+type_low_bound = TYPE_MIN_VALUE (expr_type);
+type_high_bound = TYPE_MAX_VALUE (expr_type);
+real_low_bound = real_value_from_int_cst (0, type_low_bound);
+real_high_bound = real_value_from_int_cst (0, type_high_bound);
 if (!exact_real_truncate (TYPE_MODE (type), &real_low_bound)
 || !exact_real_truncate (TYPE_MODE (type), &real_high_bound))
 give_warning = true;
 }
 || TYPE_UNSIGNED (TREE_TYPE (intop)) != TYPE_UNSIGNED (sizetype))
 intop = convert (c_common_type_for_size (TYPE_PRECISION (sizetype),
 					     TYPE_UNSIGNED (sizetype)), intop);
 /* Replace the integer argument with a suitable product by the object size.
-Do this multiplication as signed, then convert to the appropriate
+Do this multiplication as signed, then convert to the appropriate type
-type for the pointer operation.  */
+for the pointer operation and disregard an overflow that occured only
-intop = convert (sizetype,
+because of the sign-extension change in the latter conversion.  */
-		   build_binary_op (loc,
+{
-				    MULT_EXPR, intop,
+tree t = build_binary_op (loc,
-				    convert (TREE_TYPE (intop), size_exp), 1));
+			      MULT_EXPR, intop,
+			      convert (TREE_TYPE (intop), size_exp), 1);
+intop = convert (sizetype, t);
+if (TREE_OVERFLOW_P (intop) && !TREE_OVERFLOW (t))
+intop = build_int_cst_wide (TREE_TYPE (intop), TREE_INT_CST_LOW (intop),
+				  TREE_INT_CST_HIGH (intop));
+}
 /* Create the sum or difference.  */
 if (resultcode == MINUS_EXPR)
 intop = fold_build1_loc (loc, NEGATE_EXPR, sizetype, intop);
 else if (!COMPLETE_TYPE_P (type))
 {
 if (complain)
 	error_at (loc, "invalid application of %qs to incomplete type %qT ",
 		  op_name, type);
-value = size_zero_node;
+return error_mark_node;
 }
 else
 {
 if (is_sizeof)
 	/* Convert in case a char is more than one unit.  */
 result = null_pointer_node;
 else
 {
 TREE_USED (label) = 1;
 result = build1 (ADDR_EXPR, ptr_type_node, label);
-/* The current function in not necessarily uninlinable.
+/* The current function is not necessarily uninlinable.
 	 Computed gotos are incompatible with inlining, but the value
 	 here could be used only in a diagnostic, for example.  */
 protected_set_expr_location (result, loc);
 }
 #undef DEF_ATTR_INT
 #undef DEF_ATTR_IDENT
 #undef DEF_ATTR_TREE_LIST
 }
+/* Returns TRUE iff the attribute indicated by ATTR_ID takes a plain
+identifier as an argument, so the front end shouldn't look it up.  */
+bool
+attribute_takes_identifier_p (const_tree attr_id)
+{
+if (is_attribute_p ("mode", attr_id)
+|| is_attribute_p ("format", attr_id)
+|| is_attribute_p ("cleanup", attr_id))
+return true;
+else
+return targetm.attribute_takes_identifier_p (attr_id);
+}
 /* Attribute handlers common to C front ends.  */
 /* Handle a "packed" attribute; arguments as in
 struct attribute_spec.handler.  */
 if (TREE_CODE (node) == FUNCTION_DECL
 || (TREE_CODE (node) == VAR_DECL && TREE_STATIC (node)))
 {
 TREE_USED (node) = 1;
 DECL_PRESERVE_P (node) = 1;
+if (TREE_CODE (node) == VAR_DECL)
+	DECL_READ_P (node) = 1;
 }
 else
 {
 warning (OPT_Wattributes, "%qE attribute ignored", name);
 *no_add_attrs = true;
 if (TREE_CODE (decl) == PARM_DECL
 	  || TREE_CODE (decl) == VAR_DECL
 	  || TREE_CODE (decl) == FUNCTION_DECL
 	  || TREE_CODE (decl) == LABEL_DECL
 	  || TREE_CODE (decl) == TYPE_DECL)
-	TREE_USED (decl) = 1;
+	{
+	  TREE_USED (decl) = 1;
+	  if (TREE_CODE (decl) == VAR_DECL
+	      || TREE_CODE (decl) == PARM_DECL)
+	    DECL_READ_P (decl) = 1;
+	}
 else
 	{
 	  warning (OPT_Wattributes, "%qE attribute ignored", name);
 	  *no_add_attrs = true;
 	}
 	  /* A type variant isn't good enough, since we don't a cast
 	     to such a type removed as a no-op.  */
 	  *node = type = build_duplicate_type (type);
 	}
-TYPE_TRANSPARENT_UNION (type) = 1;
+TYPE_TRANSPARENT_AGGR (type) = 1;
 return NULL_TREE;
 }
 ignored:
 warning (OPT_Wattributes, "%qE attribute ignored", name);
 error ("requested alignment is too large");
 *no_add_attrs = true;
 }
 else if (is_type)
 {
+if ((flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
+	/* OK, modify the type in place.  */;
 /* If we have a TYPE_DECL, then copy the type, so that we
 	 don't accidentally modify a builtin type.  See pushdecl.  */
-if (decl && TREE_TYPE (decl) != error_mark_node
+else if (decl && TREE_TYPE (decl) != error_mark_node
-	  && DECL_ORIGINAL_TYPE (decl) == NULL_TREE)
+	       && DECL_ORIGINAL_TYPE (decl) == NULL_TREE)
 	{
 	  tree tt = TREE_TYPE (decl);
 	  *type = build_variant_type_copy (*type);
 	  DECL_ORIGINAL_TYPE (decl) = tt;
 	  TYPE_NAME (*type) = decl;
 	  TREE_USED (*type) = TREE_USED (decl);
 	  TREE_TYPE (decl) = *type;
 	}
-else if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
+else
 	*type = build_variant_type_copy (*type);
 TYPE_ALIGN (*type) = (1U << i) * BITS_PER_UNIT;
 TYPE_USER_ALIGN (*type) = 1;
 }
 	           "alloc_size parameter outside range");
 	  *no_add_attrs = true;
 	  return NULL_TREE;
 	}
 }
+return NULL_TREE;
+}
+/* Handle a "fn spec" attribute; arguments as in
+struct attribute_spec.handler.  */
+static tree
+handle_fnspec_attribute (tree *node ATTRIBUTE_UNUSED, tree ARG_UNUSED (name),
+			 tree args, int ARG_UNUSED (flags),
+			 bool *no_add_attrs ATTRIBUTE_UNUSED)
+{
+gcc_assert (args
+	      && TREE_CODE (TREE_VALUE (args)) == STRING_CST
+	      && !TREE_CHAIN (args));
 return NULL_TREE;
 }
 /* Handle a "returns_twice" attribute; arguments as in
 struct attribute_spec.handler.  */
 }
 (*callback) (ctx, param, param_num);
 }
-/* Checks the number of arguments NARGS against the required number
+/* Checks for a builtin function FNDECL that the number of arguments
-REQUIRED and issues an error if there is a mismatch.  Returns true
+NARGS against the required number REQUIRED and issues an error if
-if the number of arguments is correct, otherwise false.  */
+there is a mismatch.  Returns true if the number of arguments is
+correct, otherwise false.  */
 static bool
-validate_nargs (tree fndecl, int nargs, int required)
+builtin_function_validate_nargs (tree fndecl, int nargs, int required)
 {
 if (nargs < required)
 {
-error ("not enough arguments to function %qE", fndecl);
+error_at (input_location,
+		"not enough arguments to function %qE", fndecl);
 return false;
 }
 else if (nargs > required)
 {
-error ("too many arguments to function %qE", fndecl);
+error_at (input_location,
+		"too many arguments to function %qE", fndecl);
 return false;
 }
 return true;
 }
 return true;
 switch (DECL_FUNCTION_CODE (fndecl))
 {
 case BUILT_IN_CONSTANT_P:
-return validate_nargs (fndecl, nargs, 1);
+return builtin_function_validate_nargs (fndecl, nargs, 1);
 case BUILT_IN_ISFINITE:
 case BUILT_IN_ISINF:
 case BUILT_IN_ISINF_SIGN:
 case BUILT_IN_ISNAN:
 case BUILT_IN_ISNORMAL:
-if (validate_nargs (fndecl, nargs, 1))
+if (builtin_function_validate_nargs (fndecl, nargs, 1))
 	{
 	  if (TREE_CODE (TREE_TYPE (args[0])) != REAL_TYPE)
 	    {
 	      error ("non-floating-point argument in call to "
 		     "function %qE", fndecl);
 case BUILT_IN_ISGREATEREQUAL:
 case BUILT_IN_ISLESS:
 case BUILT_IN_ISLESSEQUAL:
 case BUILT_IN_ISLESSGREATER:
 case BUILT_IN_ISUNORDERED:
-if (validate_nargs (fndecl, nargs, 2))
+if (builtin_function_validate_nargs (fndecl, nargs, 2))
 	{
 	  enum tree_code code0, code1;
 	  code0 = TREE_CODE (TREE_TYPE (args[0]));
 	  code1 = TREE_CODE (TREE_TYPE (args[1]));
 	  if (!((code0 == REAL_TYPE && code1 == REAL_TYPE)
 	  return true;
 	}
 return false;
 case BUILT_IN_FPCLASSIFY:
-if (validate_nargs (fndecl, nargs, 6))
+if (builtin_function_validate_nargs (fndecl, nargs, 6))
 	{
 	  unsigned i;
 	  for (i=0; i<5; i++)
 	    if (TREE_CODE (args[i]) != INTEGER_CST)
 free (message);
 }
 #undef catenate_messages
 }
+/* Mapping for cpp message reasons to the options that enable them.  */
+struct reason_option_codes_t
+{
+const int reason;		/* cpplib message reason.  */
+const int option_code;	/* gcc option that controls this message.  */
+};
+static const struct reason_option_codes_t option_codes[] = {
+{CPP_W_DEPRECATED,			OPT_Wdeprecated},
+{CPP_W_COMMENTS,			OPT_Wcomments},
+{CPP_W_TRIGRAPHS,			OPT_Wtrigraphs},
+{CPP_W_MULTICHAR,			OPT_Wmultichar},
+{CPP_W_TRADITIONAL,			OPT_Wtraditional},
+{CPP_W_LONG_LONG,			OPT_Wlong_long},
+{CPP_W_ENDIF_LABELS,			OPT_Wendif_labels},
+{CPP_W_VARIADIC_MACROS,		OPT_Wvariadic_macros},
+{CPP_W_BUILTIN_MACRO_REDEFINED,	OPT_Wbuiltin_macro_redefined},
+{CPP_W_UNDEF,				OPT_Wundef},
+{CPP_W_UNUSED_MACROS,			OPT_Wunused_macros},
+{CPP_W_CXX_OPERATOR_NAMES,		OPT_Wc___compat},
+{CPP_W_NORMALIZE,			OPT_Wnormalized_},
+{CPP_W_INVALID_PCH,			OPT_Winvalid_pch},
+{CPP_W_WARNING_DIRECTIVE,		OPT_Wcpp},
+{CPP_W_NONE,				0}
+};
+/* Return the gcc option code associated with the reason for a cpp
+message, or 0 if none.  */
+static int
+c_option_controlling_cpp_error (int reason)
+{
+const struct reason_option_codes_t *entry;
+for (entry = option_codes; entry->reason != CPP_W_NONE; entry++)
+{
+if (entry->reason == reason)
+	return entry->option_code;
+}
+return 0;
+}
 /* Callback from cpp_error for PFILE to print diagnostics from the
-preprocessor.  The diagnostic is of type LEVEL, at location
+preprocessor.  The diagnostic is of type LEVEL, with REASON set
+to the reason code if LEVEL is represents a warning, at location
 LOCATION unless this is after lexing and the compiler's location
 should be used instead, with column number possibly overridden by
 COLUMN_OVERRIDE if not zero; MSG is the translated message and AP
 the arguments.  Returns true if a diagnostic was emitted, false
 otherwise.  */
 bool
-c_cpp_error (cpp_reader *pfile ATTRIBUTE_UNUSED, int level,
+c_cpp_error (cpp_reader *pfile ATTRIBUTE_UNUSED, int level, int reason,
 	     location_t location, unsigned int column_override,
 	     const char *msg, va_list *ap)
 {
 diagnostic_info diagnostic;
 diagnostic_t dlevel;
 location = input_location;
 diagnostic_set_info_translated (&diagnostic, msg, ap,
 				  location, dlevel);
 if (column_override)
 diagnostic_override_column (&diagnostic, column_override);
+diagnostic_override_option_index (&diagnostic,
+c_option_controlling_cpp_error (reason));
 ret = report_diagnostic (&diagnostic);
 if (level == CPP_DL_WARNING_SYSHDR)
 warn_system_headers = save_warn_system_headers;
 return ret;
 }
 static bool
 sync_resolve_params (tree orig_function, tree function, VEC(tree, gc) *params)
 {
 tree arg_types = TYPE_ARG_TYPES (TREE_TYPE (function));
 tree ptype;
-int number;
 unsigned int parmnum;
 /* We've declared the implementation functions to use "volatile void *"
 as the pointer parameter, so we shouldn't get any complaints from the
 call to check_function_arguments what ever type the user used.  */
 arg_types = TREE_CHAIN (arg_types);
 ptype = TREE_TYPE (TREE_TYPE (VEC_index (tree, params, 0)));
-number = 2;
 /* For the rest of the values, we need to cast these to FTYPE, so that we
 don't get warnings for passing pointer types, etc.  */
 parmnum = 0;
 while (arg_types != void_list_node)
 val = convert (ptype, val);
 val = convert (TREE_VALUE (arg_types), val);
 VEC_replace (tree, params, parmnum, val);
 arg_types = TREE_CHAIN (arg_types);
-number++;
 }
 /* The definition of these primitives is variadic, with the remaining
 being "an optional list of variables protected by the memory barrier".
 No clue what that's supposed to mean, precisely, but we consider all

Mercurial > hg > CbC > CbC_gcc

comparison gcc/c-common.c @ 63:b7f97abdc517 gcc-4.6-20100522