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

comparison gcc/c-typeck.c @ 55:77e2b8dfacca gcc-4.4.5

update it from 4.4.3 to 4.5.0

author	ryoma <e075725@ie.u-ryukyu.ac.jp>
date	Fri, 12 Feb 2010 23:39:51 +0900
parents	3bfb6c00c1e0
children	326d9e06c2e3 b7f97abdc517

comparison

equal deleted inserted replaced

-:c156f1bd5cd9
+:77e2b8dfacca
 #include "tm.h"
 #include "rtl.h"
 #include "tree.h"
 #include "langhooks.h"
 #include "c-tree.h"
+#include "c-lang.h"
 #include "tm_p.h"
 #include "flags.h"
 #include "output.h"
 #include "expr.h"
 #include "toplev.h"
 ic_assign,
 ic_init,
 ic_return
 };
+/* Whether we are building a boolean conversion inside
+convert_for_assignment, or some other late binary operation.  If
+build_binary_op is called (from code shared with C++) in this case,
+then the operands have already been folded and the result will not
+be folded again, so C_MAYBE_CONST_EXPR should not be generated.  */
+bool in_late_binary_op;
 /* The level of nesting inside "__alignof__".  */
 int in_alignof;
 /* The level of nesting inside "sizeof".  */
 int in_sizeof;
 /* The level of nesting inside "typeof".  */
 int in_typeof;
-struct c_label_context_se *label_context_stack_se;
-struct c_label_context_vm *label_context_stack_vm;
 /* Nonzero if we've already printed a "missing braces around initializer"
 message within this initializer.  */
 static int missing_braces_mentioned;
 static int require_constant_value;
 static int require_constant_elements;
 static bool null_pointer_constant_p (const_tree);
 static tree qualify_type (tree, tree);
-static int tagged_types_tu_compatible_p (const_tree, const_tree);
+static int tagged_types_tu_compatible_p (const_tree, const_tree, bool *);
-static int comp_target_types (tree, tree);
+static int comp_target_types (location_t, tree, tree);
-static int function_types_compatible_p (const_tree, const_tree);
+static int function_types_compatible_p (const_tree, const_tree, bool *);
-static int type_lists_compatible_p (const_tree, const_tree);
+static int type_lists_compatible_p (const_tree, const_tree, bool *);
-static tree decl_constant_value_for_broken_optimization (tree);
 static tree lookup_field (tree, tree);
-static int convert_arguments (int, tree *, tree, tree, tree, tree);
+static int convert_arguments (tree, VEC(tree,gc) *, VEC(tree,gc) *, tree,
-static tree pointer_diff (tree, tree);
+			      tree);
-static tree convert_for_assignment (tree, tree, enum impl_conv, tree, tree,
+static tree pointer_diff (location_t, tree, tree);
-				    int);
+static tree convert_for_assignment (location_t, tree, tree, tree,
+				    enum impl_conv, bool, tree, tree, int);
 static tree valid_compound_expr_initializer (tree, tree);
 static void push_string (const char *);
 static void push_member_name (tree);
 static int spelling_length (void);
 static char *print_spelling (char *);
 static void warning_init (int, const char *);
-static tree digest_init (tree, tree, bool, int);
+static tree digest_init (location_t, tree, tree, tree, bool, bool, int);
-static void output_init_element (tree, bool, tree, tree, int, bool);
+static void output_init_element (tree, tree, bool, tree, tree, int, bool);
 static void output_pending_init_elements (int);
 static int set_designator (int);
 static void push_range_stack (tree);
-static void add_pending_init (tree, tree, bool);
+static void add_pending_init (tree, tree, tree, bool);
 static void set_nonincremental_init (void);
 static void set_nonincremental_init_from_string (tree);
 static tree find_init_member (tree);
 static void readonly_error (tree, enum lvalue_use);
+static void readonly_warning (tree, enum lvalue_use);
 static int lvalue_or_else (const_tree, enum lvalue_use);
-static int lvalue_p (const_tree);
 static void record_maybe_used_decl (tree);
-static int comptypes_internal (const_tree, const_tree);
+static int comptypes_internal (const_tree, const_tree, bool *);
 /* Return true if EXP is a null pointer constant, false otherwise.  */
 static bool
 null_pointer_constant_p (const_tree expr)
 	  && (INTEGRAL_TYPE_P (type)
 	      || (TREE_CODE (type) == POINTER_TYPE
 		  && VOID_TYPE_P (TREE_TYPE (type))
 		  && TYPE_QUALS (TREE_TYPE (type)) == TYPE_UNQUALIFIED)));
 }
+/* EXPR may appear in an unevaluated part of an integer constant
+expression, but not in an evaluated part.  Wrap it in a
+C_MAYBE_CONST_EXPR, or mark it with TREE_OVERFLOW if it is just an
+INTEGER_CST and we cannot create a C_MAYBE_CONST_EXPR.  */
+static tree
+note_integer_operands (tree expr)
+{
+tree ret;
+if (TREE_CODE (expr) == INTEGER_CST && in_late_binary_op)
+{
+ret = copy_node (expr);
+TREE_OVERFLOW (ret) = 1;
+}
+else
+{
+ret = build2 (C_MAYBE_CONST_EXPR, TREE_TYPE (expr), NULL_TREE, expr);
+C_MAYBE_CONST_EXPR_INT_OPERANDS (ret) = 1;
+}
+return ret;
+}
+/* Having checked whether EXPR may appear in an unevaluated part of an
+integer constant expression and found that it may, remove any
+C_MAYBE_CONST_EXPR noting this fact and return the resulting
+expression.  */
+static inline tree
+remove_c_maybe_const_expr (tree expr)
+{
+if (TREE_CODE (expr) == C_MAYBE_CONST_EXPR)
+return C_MAYBE_CONST_EXPR_EXPR (expr);
+else
+return expr;
+}
 /* This is a cache to hold if two types are compatible or not.  */
 struct tagged_tu_seen_cache {
 const struct tagged_tu_seen_cache * next;
 const_tree t1;
 }
 return type;
 }
+/* Return true if between two named address spaces, whether there is a superset
+named address space that encompasses both address spaces.  If there is a
+superset, return which address space is the superset.  */
+static bool
+addr_space_superset (addr_space_t as1, addr_space_t as2, addr_space_t *common)
+{
+if (as1 == as2)
+{
+*common = as1;
+return true;
+}
+else if (targetm.addr_space.subset_p (as1, as2))
+{
+*common = as2;
+return true;
+}
+else if (targetm.addr_space.subset_p (as2, as1))
+{
+*common = as1;
+return true;
+}
+else
+return false;
+}
 /* Return a variant of TYPE which has all the type qualifiers of LIKE
 as well as those of TYPE.  */
 static tree
 qualify_type (tree type, tree like)
 {
+addr_space_t as_type = TYPE_ADDR_SPACE (type);
+addr_space_t as_like = TYPE_ADDR_SPACE (like);
+addr_space_t as_common;
+/* If the two named address spaces are different, determine the common
+superset address space.  If there isn't one, raise an error.  */
+if (!addr_space_superset (as_type, as_like, &as_common))
+{
+as_common = as_type;
+error ("%qT and %qT are in disjoint named address spaces",
+	     type, like);
+}
 return c_build_qualified_type (type,
-				 TYPE_QUALS (type) | TYPE_QUALS (like));
+				 TYPE_QUALS_NO_ADDR_SPACE (type)
+				 | TYPE_QUALS_NO_ADDR_SPACE (like)
+				 | ENCODE_QUAL_ADDR_SPACE (as_common));
 }
 /* Return true iff the given tree T is a variable length array.  */
 bool
 	bool d1_variable, d2_variable;
 	bool d1_zero, d2_zero;
 	bool t1_complete, t2_complete;
 	/* We should not have any type quals on arrays at all.  */
-	gcc_assert (!TYPE_QUALS (t1) && !TYPE_QUALS (t2));
+	gcc_assert (!TYPE_QUALS_NO_ADDR_SPACE (t1)
+		    && !TYPE_QUALS_NO_ADDR_SPACE (t2));
 	t1_complete = COMPLETE_TYPE_P (t1);
 	t2_complete = COMPLETE_TYPE_P (t2);
 	d1_zero = d1 == 0 || !TYPE_MAX_VALUE (d1);
 		      mv3 = TYPE_MAIN_VARIANT (mv3);
 		    if (comptypes (mv3, mv2))
 		      {
 			TREE_VALUE (n) = composite_type (TREE_TYPE (memb),
 							 TREE_VALUE (p2));
 			pedwarn (input_location, OPT_pedantic,
 				 "function types not truly compatible in ISO C");
 			goto parm_done;
 		      }
 		  }
 	      }
 		      mv3 = TYPE_MAIN_VARIANT (mv3);
 		    if (comptypes (mv3, mv1))
 		      {
 			TREE_VALUE (n) = composite_type (TREE_TYPE (memb),
 							 TREE_VALUE (p1));
 			pedwarn (input_location, OPT_pedantic,
 				 "function types not truly compatible in ISO C");
 			goto parm_done;
 		      }
 		  }
 	      }
 tree attributes;
 tree pointed_to_1, mv1;
 tree pointed_to_2, mv2;
 tree target;
 unsigned target_quals;
+addr_space_t as1, as2, as_common;
+int quals1, quals2;
 /* Save time if the two types are the same.  */
 if (t1 == t2) return t1;
 target = composite_type (mv1, mv2);
 /* For function types do not merge const qualifiers, but drop them
 if used inconsistently.  The middle-end uses these to mark const
 and noreturn functions.  */
+quals1 = TYPE_QUALS_NO_ADDR_SPACE (pointed_to_1);
+quals2 = TYPE_QUALS_NO_ADDR_SPACE (pointed_to_2);
 if (TREE_CODE (pointed_to_1) == FUNCTION_TYPE)
-target_quals = TYPE_QUALS (pointed_to_1) & TYPE_QUALS (pointed_to_2);
+target_quals = (quals1 & quals2);
 else
-target_quals = TYPE_QUALS (pointed_to_1) | TYPE_QUALS (pointed_to_2);
+target_quals = (quals1 | quals2);
+/* If the two named address spaces are different, determine the common
+superset address space.  This is guaranteed to exist due to the
+assumption that comp_target_type returned non-zero.  */
+as1 = TYPE_ADDR_SPACE (pointed_to_1);
+as2 = TYPE_ADDR_SPACE (pointed_to_2);
+if (!addr_space_superset (as1, as2, &as_common))
+gcc_unreachable ();
+target_quals |= ENCODE_QUAL_ADDR_SPACE (as_common);
 t1 = build_pointer_type (c_build_qualified_type (target, target_quals));
 return build_type_attribute_variant (t1, attributes);
 }
 /* Return the common type for two arithmetic types under the usual
 comptypes (tree type1, tree type2)
 {
 const struct tagged_tu_seen_cache * tagged_tu_seen_base1 = tagged_tu_seen_base;
 int val;
-val = comptypes_internal (type1, type2);
+val = comptypes_internal (type1, type2, NULL);
+free_all_tagged_tu_seen_up_to (tagged_tu_seen_base1);
+return val;
+}
+/* Like comptypes, but if it returns non-zero because enum and int are
+compatible, it sets *ENUM_AND_INT_P to true.  */
+static int
+comptypes_check_enum_int (tree type1, tree type2, bool *enum_and_int_p)
+{
+const struct tagged_tu_seen_cache * tagged_tu_seen_base1 = tagged_tu_seen_base;
+int val;
+val = comptypes_internal (type1, type2, enum_and_int_p);
 free_all_tagged_tu_seen_up_to (tagged_tu_seen_base1);
 return val;
 }
 /* Return 1 if TYPE1 and TYPE2 are compatible types for assignment
 or various other operations.  Return 2 if they are compatible
-but a warning may be needed if you use them together.  This
+but a warning may be needed if you use them together.  If
-differs from comptypes, in that we don't free the seen types.  */
+ENUM_AND_INT_P is not NULL, and one type is an enum and the other a
+compatible integer type, then this sets *ENUM_AND_INT_P to true;
+*ENUM_AND_INT_P is never set to false.  This differs from
+comptypes, in that we don't free the seen types.  */
 static int
-comptypes_internal (const_tree type1, const_tree type2)
+comptypes_internal (const_tree type1, const_tree type2, bool *enum_and_int_p)
 {
 const_tree t1 = type1;
 const_tree t2 = type2;
 int attrval, val;
 /* Enumerated types are compatible with integer types, but this is
 not transitive: two enumerated types in the same translation unit
 are compatible with each other only if they are the same type.  */
 if (TREE_CODE (t1) == ENUMERAL_TYPE && TREE_CODE (t2) != ENUMERAL_TYPE)
-t1 = c_common_type_for_size (TYPE_PRECISION (t1), TYPE_UNSIGNED (t1));
+{
+t1 = c_common_type_for_size (TYPE_PRECISION (t1), TYPE_UNSIGNED (t1));
+if (enum_and_int_p != NULL && TREE_CODE (t2) != VOID_TYPE)
+	*enum_and_int_p = true;
+}
 else if (TREE_CODE (t2) == ENUMERAL_TYPE && TREE_CODE (t1) != ENUMERAL_TYPE)
-t2 = c_common_type_for_size (TYPE_PRECISION (t2), TYPE_UNSIGNED (t2));
+{
+t2 = c_common_type_for_size (TYPE_PRECISION (t2), TYPE_UNSIGNED (t2));
+if (enum_and_int_p != NULL && TREE_CODE (t1) != VOID_TYPE)
+	*enum_and_int_p = true;
+}
 if (t1 == t2)
 return 1;
 /* Different classes of types can't be compatible.  */
 /* Do not remove mode or aliasing information.  */
 if (TYPE_MODE (t1) != TYPE_MODE (t2)
 	  || TYPE_REF_CAN_ALIAS_ALL (t1) != TYPE_REF_CAN_ALIAS_ALL (t2))
 	break;
 val = (TREE_TYPE (t1) == TREE_TYPE (t2)
-	     ? 1 : comptypes_internal (TREE_TYPE (t1), TREE_TYPE (t2)));
+	     ? 1 : comptypes_internal (TREE_TYPE (t1), TREE_TYPE (t2),
+				       enum_and_int_p));
 break;
 case FUNCTION_TYPE:
-val = function_types_compatible_p (t1, t2);
+val = function_types_compatible_p (t1, t2, enum_and_int_p);
 break;
 case ARRAY_TYPE:
 {
 	tree d1 = TYPE_DOMAIN (t1);
 	bool d1_zero, d2_zero;
 	val = 1;
 	/* Target types must match incl. qualifiers.  */
 	if (TREE_TYPE (t1) != TREE_TYPE (t2)
-	    && 0 == (val = comptypes_internal (TREE_TYPE (t1), TREE_TYPE (t2))))
+	    && 0 == (val = comptypes_internal (TREE_TYPE (t1), TREE_TYPE (t2),
+					       enum_and_int_p)))
 	  return 0;
 	/* Sizes must match unless one is missing or variable.  */
 	if (d1 == 0 || d2 == 0 || d1 == d2)
 	  break;
 	  if (! attribute_list_contained (a1, a2)
 	      && ! attribute_list_contained (a2, a1))
 	    break;
 	  if (attrval != 2)
-	    return tagged_types_tu_compatible_p (t1, t2);
+	    return tagged_types_tu_compatible_p (t1, t2, enum_and_int_p);
-	  val = tagged_types_tu_compatible_p (t1, t2);
+	  val = tagged_types_tu_compatible_p (t1, t2, enum_and_int_p);
 	}
 break;
 case VECTOR_TYPE:
-val = TYPE_VECTOR_SUBPARTS (t1) == TYPE_VECTOR_SUBPARTS (t2)
+val = (TYPE_VECTOR_SUBPARTS (t1) == TYPE_VECTOR_SUBPARTS (t2)
-	    && comptypes_internal (TREE_TYPE (t1), TREE_TYPE (t2));
+	     && comptypes_internal (TREE_TYPE (t1), TREE_TYPE (t2),
+				    enum_and_int_p));
 break;
 default:
 break;
 }
 return attrval == 2 && val == 1 ? 2 : val;
 }
-/* Return 1 if TTL and TTR are pointers to types that are equivalent,
+/* Return 1 if TTL and TTR are pointers to types that are equivalent, ignoring
-ignoring their qualifiers.  */
+their qualifiers, except for named address spaces.  If the pointers point to
+different named addresses, then we must determine if one address space is a
+subset of the other.  */
 static int
-comp_target_types (tree ttl, tree ttr)
+comp_target_types (location_t location, tree ttl, tree ttr)
 {
 int val;
-tree mvl, mvr;
+tree mvl = TREE_TYPE (ttl);
+tree mvr = TREE_TYPE (ttr);
+addr_space_t asl = TYPE_ADDR_SPACE (mvl);
+addr_space_t asr = TYPE_ADDR_SPACE (mvr);
+addr_space_t as_common;
+bool enum_and_int_p;
+/* Fail if pointers point to incompatible address spaces.  */
+if (!addr_space_superset (asl, asr, &as_common))
+return 0;
 /* Do not lose qualifiers on element types of array types that are
 pointer targets by taking their TYPE_MAIN_VARIANT.  */
-mvl = TREE_TYPE (ttl);
-mvr = TREE_TYPE (ttr);
 if (TREE_CODE (mvl) != ARRAY_TYPE)
 mvl = TYPE_MAIN_VARIANT (mvl);
 if (TREE_CODE (mvr) != ARRAY_TYPE)
 mvr = TYPE_MAIN_VARIANT (mvr);
-val = comptypes (mvl, mvr);
+enum_and_int_p = false;
+val = comptypes_check_enum_int (mvl, mvr, &enum_and_int_p);
 if (val == 2)
-pedwarn (input_location, OPT_pedantic, "types are not quite compatible");
+pedwarn (location, OPT_pedantic, "types are not quite compatible");
+if (val == 1 && enum_and_int_p && warn_cxx_compat)
+warning_at (location, OPT_Wc___compat,
+		"pointer target types incompatible in C++");
 return val;
 }
 /* Subroutines of `comptypes'.  */
 /* Return 1 if two 'struct', 'union', or 'enum' types T1 and T2 are
 compatible.  If the two types are not the same (which has been
 checked earlier), this can only happen when multiple translation
 units are being compiled.  See C99 6.2.7 paragraph 1 for the exact
-rules.  */
+rules.  ENUM_AND_INT_P is as in comptypes_internal.  */
 static int
-tagged_types_tu_compatible_p (const_tree t1, const_tree t2)
+tagged_types_tu_compatible_p (const_tree t1, const_tree t2,
+			      bool *enum_and_int_p)
 {
 tree s1, s2;
 bool needs_warning = false;
 /* We have to verify that the tags of the types are the same.  This
 	  {
 	    int result;
 	    if (DECL_NAME (s1) != DECL_NAME (s2))
 	      break;
-	    result = comptypes_internal (TREE_TYPE (s1), TREE_TYPE (s2));
+	    result = comptypes_internal (TREE_TYPE (s1), TREE_TYPE (s2),
+					 enum_and_int_p);
 	    if (result != 1 && !DECL_NAME (s1))
 	      break;
 	    if (result == 0)
 	      {
 	    for (s2 = TYPE_FIELDS (t2); s2; s2 = TREE_CHAIN (s2))
 	      if (DECL_NAME (s1) == DECL_NAME (s2))
 		{
 		  int result;
-		  result = comptypes_internal (TREE_TYPE (s1), TREE_TYPE (s2));
+		  result = comptypes_internal (TREE_TYPE (s1), TREE_TYPE (s2),
+					       enum_and_int_p);
 		  if (result != 1 && !DECL_NAME (s1))
 		    continue;
 		  if (result == 0)
 		    {
 	  {
 	    int result;
 	    if (TREE_CODE (s1) != TREE_CODE (s2)
 		|| DECL_NAME (s1) != DECL_NAME (s2))
 	      break;
-	    result = comptypes_internal (TREE_TYPE (s1), TREE_TYPE (s2));
+	    result = comptypes_internal (TREE_TYPE (s1), TREE_TYPE (s2),
+					 enum_and_int_p);
 	    if (result == 0)
 	      break;
 	    if (result == 2)
 	      needs_warning = true;
 /* Return 1 if two function types F1 and F2 are compatible.
 If either type specifies no argument types,
 the other must specify a fixed number of self-promoting arg types.
 Otherwise, if one type specifies only the number of arguments,
 the other must specify that number of self-promoting arg types.
-Otherwise, the argument types must match.  */
+Otherwise, the argument types must match.
+ENUM_AND_INT_P is as in comptypes_internal.  */
 static int
-function_types_compatible_p (const_tree f1, const_tree f2)
+function_types_compatible_p (const_tree f1, const_tree f2,
+			     bool *enum_and_int_p)
 {
 tree args1, args2;
 /* 1 if no need for warning yet, 2 if warning cause has been seen.  */
 int val = 1;
 int val1;
 ret1 = build_qualified_type (TYPE_MAIN_VARIANT (ret1),
 				 TYPE_QUALS (ret1) & ~TYPE_QUAL_VOLATILE);
 if (TYPE_VOLATILE (ret2))
 ret2 = build_qualified_type (TYPE_MAIN_VARIANT (ret2),
 				 TYPE_QUALS (ret2) & ~TYPE_QUAL_VOLATILE);
-val = comptypes_internal (ret1, ret2);
+val = comptypes_internal (ret1, ret2, enum_and_int_p);
 if (val == 0)
 return 0;
 args1 = TYPE_ARG_TYPES (f1);
 args2 = TYPE_ARG_TYPES (f2);
 	return 0;
 /* If one of these types comes from a non-prototype fn definition,
 	 compare that with the other type's arglist.
 	 If they don't match, ask for a warning (but no error).  */
 if (TYPE_ACTUAL_ARG_TYPES (f1)
-	  && 1 != type_lists_compatible_p (args2, TYPE_ACTUAL_ARG_TYPES (f1)))
+	  && 1 != type_lists_compatible_p (args2, TYPE_ACTUAL_ARG_TYPES (f1),
+					   enum_and_int_p))
 	val = 2;
 return val;
 }
 if (args2 == 0)
 {
 if (!self_promoting_args_p (args1))
 	return 0;
 if (TYPE_ACTUAL_ARG_TYPES (f2)
-	  && 1 != type_lists_compatible_p (args1, TYPE_ACTUAL_ARG_TYPES (f2)))
+	  && 1 != type_lists_compatible_p (args1, TYPE_ACTUAL_ARG_TYPES (f2),
+					   enum_and_int_p))
 	val = 2;
 return val;
 }
 /* Both types have argument lists: compare them and propagate results.  */
-val1 = type_lists_compatible_p (args1, args2);
+val1 = type_lists_compatible_p (args1, args2, enum_and_int_p);
 return val1 != 1 ? val1 : val;
 }
-/* Check two lists of types for compatibility,
+/* Check two lists of types for compatibility, returning 0 for
-returning 0 for incompatible, 1 for compatible,
+incompatible, 1 for compatible, or 2 for compatible with
-or 2 for compatible with warning.  */
+warning.  ENUM_AND_INT_P is as in comptypes_internal.  */
 static int
-type_lists_compatible_p (const_tree args1, const_tree args2)
+type_lists_compatible_p (const_tree args1, const_tree args2,
+			 bool *enum_and_int_p)
 {
 /* 1 if no need for warning yet, 2 if warning cause has been seen.  */
 int val = 1;
 int newval = 0;
 	}
 /* If one of the lists has an error marker, ignore this arg.  */
 else if (TREE_CODE (a1) == ERROR_MARK
 	       || TREE_CODE (a2) == ERROR_MARK)
 	;
-else if (!(newval = comptypes_internal (mv1, mv2)))
+else if (!(newval = comptypes_internal (mv1, mv2, enum_and_int_p)))
 	{
 	  /* Allow  wait (union {union wait *u; int *i} *)
 	     and  wait (union wait *)  to be compatible.  */
 	  if (TREE_CODE (a1) == UNION_TYPE
 	      && (TYPE_NAME (a1) == 0
 		{
 		  tree mv3 = TREE_TYPE (memb);
 		  if (mv3 && mv3 != error_mark_node
 		      && TREE_CODE (mv3) != ARRAY_TYPE)
 		    mv3 = TYPE_MAIN_VARIANT (mv3);
-		  if (comptypes_internal (mv3, mv2))
+		  if (comptypes_internal (mv3, mv2, enum_and_int_p))
 		    break;
 		}
 	      if (memb == 0)
 		return 0;
 	    }
 		{
 		  tree mv3 = TREE_TYPE (memb);
 		  if (mv3 && mv3 != error_mark_node
 		      && TREE_CODE (mv3) != ARRAY_TYPE)
 		    mv3 = TYPE_MAIN_VARIANT (mv3);
-		  if (comptypes_internal (mv3, mv1))
+		  if (comptypes_internal (mv3, mv1, enum_and_int_p))
 		    break;
 		}
 	      if (memb == 0)
 		return 0;
 	    }
 error ("arithmetic on pointer to an incomplete type");
 return size_one_node;
 }
 /* Convert in case a char is more than one unit.  */
-return size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
+return size_binop_loc (input_location, CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
-		     size_int (TYPE_PRECISION (char_type_node)
+			 size_int (TYPE_PRECISION (char_type_node)
-			       / BITS_PER_UNIT));
+				   / BITS_PER_UNIT));
 }
 /* Return either DECL or its known constant value (if it has one).  */
 tree
 && TREE_CODE (DECL_INITIAL (decl)) != CONSTRUCTOR)
 return DECL_INITIAL (decl);
 return decl;
 }
-/* Return either DECL or its known constant value (if it has one), but
-return DECL if pedantic or DECL has mode BLKmode.  This is for
-bug-compatibility with the old behavior of decl_constant_value
-(before GCC 3.0); every use of this function is a bug and it should
-be removed before GCC 3.1.  It is not appropriate to use pedantic
-in a way that affects optimization, and BLKmode is probably not the
-right test for avoiding misoptimizations either.  */
-static tree
-decl_constant_value_for_broken_optimization (tree decl)
-{
-tree ret;
-if (pedantic || DECL_MODE (decl) == BLKmode)
-return decl;
-ret = decl_constant_value (decl);
-/* Avoid unwanted tree sharing between the initializer and current
-function's body where the tree can be modified e.g. by the
-gimplifier.  */
-if (ret != decl && TREE_STATIC (decl))
-ret = unshare_expr (ret);
-return ret;
-}
 /* Convert the array expression EXP to a pointer.  */
 static tree
-array_to_pointer_conversion (tree exp)
+array_to_pointer_conversion (location_t loc, tree exp)
 {
 tree orig_exp = exp;
 tree type = TREE_TYPE (exp);
 tree adr;
 tree restype = TREE_TYPE (type);
 ptrtype = build_pointer_type (restype);
 if (TREE_CODE (exp) == INDIRECT_REF)
 return convert (ptrtype, TREE_OPERAND (exp, 0));
-if (TREE_CODE (exp) == VAR_DECL)
+adr = build_unary_op (loc, ADDR_EXPR, exp, 1);
-{
-/* We are making an ADDR_EXPR of ptrtype.  This is a valid
-	 ADDR_EXPR because it's the best way of representing what
-	 happens in C when we take the address of an array and place
-	 it in a pointer to the element type.  */
-adr = build1 (ADDR_EXPR, ptrtype, exp);
-if (!c_mark_addressable (exp))
-	return error_mark_node;
-TREE_SIDE_EFFECTS (adr) = 0;   /* Default would be, same as EXP.  */
-return adr;
-}
-/* This way is better for a COMPONENT_REF since it can
-simplify the offset for a component.  */
-adr = build_unary_op (EXPR_LOCATION (exp), ADDR_EXPR, exp, 1);
 return convert (ptrtype, adr);
 }
 /* Convert the function expression EXP to a pointer.  */
 static tree
-function_to_pointer_conversion (tree exp)
+function_to_pointer_conversion (location_t loc, tree exp)
 {
 tree orig_exp = exp;
 gcc_assert (TREE_CODE (TREE_TYPE (exp)) == FUNCTION_TYPE);
 STRIP_TYPE_NOPS (exp);
 if (TREE_NO_WARNING (orig_exp))
 TREE_NO_WARNING (exp) = 1;
-return build_unary_op (EXPR_LOCATION (exp), ADDR_EXPR, exp, 0);
+return build_unary_op (loc, ADDR_EXPR, exp, 0);
 }
 /* Perform the default conversion of arrays and functions to pointers.
 Return the result of converting EXP.  For any other expression, just
-return EXP after removing NOPs.  */
+return EXP.
+LOC is the location of the expression.  */
 struct c_expr
-default_function_array_conversion (struct c_expr exp)
+default_function_array_conversion (location_t loc, struct c_expr exp)
 {
 tree orig_exp = exp.value;
 tree type = TREE_TYPE (exp.value);
 enum tree_code code = TREE_CODE (type);
 	       be used correctly inside sizeof or as a statement expression.
 	       Thus, do not give an error here; an error will result later.  */
 	    return exp;
 	  }
-	exp.value = array_to_pointer_conversion (exp.value);
+	exp.value = array_to_pointer_conversion (loc, exp.value);
 }
 break;
 case FUNCTION_TYPE:
-exp.value = function_to_pointer_conversion (exp.value);
+exp.value = function_to_pointer_conversion (loc, exp.value);
 break;
 default:
-STRIP_TYPE_NOPS (exp.value);
-if (TREE_NO_WARNING (orig_exp))
-	TREE_NO_WARNING (exp.value) = 1;
 break;
 }
 return exp;
 }
 default_conversion (tree exp)
 {
 tree orig_exp;
 tree type = TREE_TYPE (exp);
 enum tree_code code = TREE_CODE (type);
+tree promoted_type;
 /* Functions and arrays have been converted during parsing.  */
 gcc_assert (code != FUNCTION_TYPE);
 if (code == ARRAY_TYPE)
 return exp;
 /* Constants can be used directly unless they're not loadable.  */
 if (TREE_CODE (exp) == CONST_DECL)
 exp = DECL_INITIAL (exp);
-/* Replace a nonvolatile const static variable with its value unless
-it is an array, in which case we must be sure that taking the
-address of the array produces consistent results.  */
-else if (optimize && TREE_CODE (exp) == VAR_DECL && code != ARRAY_TYPE)
-{
-exp = decl_constant_value_for_broken_optimization (exp);
-type = TREE_TYPE (exp);
-}
 /* Strip no-op conversions.  */
 orig_exp = exp;
 STRIP_TYPE_NOPS (exp);
 if (TREE_NO_WARNING (orig_exp))
 }
 exp = require_complete_type (exp);
 if (exp == error_mark_node)
 return error_mark_node;
+promoted_type = targetm.promoted_type (type);
+if (promoted_type)
+return convert (promoted_type, exp);
 if (INTEGRAL_TYPE_P (type))
 return perform_integral_promotions (exp);
 return exp;
 }
 return tree_cons (NULL_TREE, field, NULL_TREE);
 }
-/* Make an expression to refer to the COMPONENT field of
+/* Make an expression to refer to the COMPONENT field of structure or
-structure or union value DATUM.  COMPONENT is an IDENTIFIER_NODE.  */
+union value DATUM.  COMPONENT is an IDENTIFIER_NODE.  LOC is the
+location of the COMPONENT_REF.  */
 tree
-build_component_ref (tree datum, tree component)
+build_component_ref (location_t loc, tree datum, tree component)
 {
 tree type = TREE_TYPE (datum);
 enum tree_code code = TREE_CODE (type);
 tree field = NULL;
 tree ref;
+bool datum_lvalue = lvalue_p (datum);
 if (!objc_is_public (datum, component))
 return error_mark_node;
 /* See if there is a field or component with name COMPONENT.  */
 field = lookup_field (datum, component);
 if (!field)
 	{
-	  error ("%qT has no member named %qE", type, component);
+	  error_at (loc, "%qT has no member named %qE", type, component);
 	  return error_mark_node;
 	}
 /* Chain the COMPONENT_REFs if necessary down to the FIELD.
 	 This might be better solved in future the way the C++ front
 do
 	{
 	  tree subdatum = TREE_VALUE (field);
 	  int quals;
 	  tree subtype;
+	  bool use_datum_quals;
 	  if (TREE_TYPE (subdatum) == error_mark_node)
 	    return error_mark_node;
+	  /* If this is an rvalue, it does not have qualifiers in C
+	     standard terms and we must avoid propagating such
+	     qualifiers down to a non-lvalue array that is then
+	     converted to a pointer.  */
+	  use_datum_quals = (datum_lvalue
+			     || TREE_CODE (TREE_TYPE (subdatum)) != ARRAY_TYPE);
 	  quals = TYPE_QUALS (strip_array_types (TREE_TYPE (subdatum)));
-	  quals |= TYPE_QUALS (TREE_TYPE (datum));
+	  if (use_datum_quals)
+	    quals |= TYPE_QUALS (TREE_TYPE (datum));
 	  subtype = c_build_qualified_type (TREE_TYPE (subdatum), quals);
 	  ref = build3 (COMPONENT_REF, subtype, datum, subdatum,
 			NULL_TREE);
-	  if (TREE_READONLY (datum) || TREE_READONLY (subdatum))
+	  SET_EXPR_LOCATION (ref, loc);
+	  if (TREE_READONLY (subdatum)
+	      || (use_datum_quals && TREE_READONLY (datum)))
 	    TREE_READONLY (ref) = 1;
-	  if (TREE_THIS_VOLATILE (datum) || TREE_THIS_VOLATILE (subdatum))
+	  if (TREE_THIS_VOLATILE (subdatum)
+	      || (use_datum_quals && TREE_THIS_VOLATILE (datum)))
 	    TREE_THIS_VOLATILE (ref) = 1;
 	  if (TREE_DEPRECATED (subdatum))
-	    warn_deprecated_use (subdatum);
+	    warn_deprecated_use (subdatum, NULL_TREE);
 	  datum = ref;
 	  field = TREE_CHAIN (field);
 	}
 while (field);
 return ref;
 }
 else if (code != ERROR_MARK)
-error ("request for member %qE in something not a structure or union",
+error_at (loc,
-	   component);
+	      "request for member %qE in something not a structure or union",
+	      component);
 return error_mark_node;
 }
 /* Given an expression PTR for a pointer, return an expression
 ERRORSTRING is the name of the operator to appear in error messages.
 LOC is the location to use for the generated tree.  */
 tree
-build_indirect_ref (location_t loc, tree ptr, const char *errorstring)
+build_indirect_ref (location_t loc, tree ptr, ref_operator errstring)
 {
 tree pointer = default_conversion (ptr);
 tree type = TREE_TYPE (pointer);
 tree ref;
 	  if (!COMPLETE_OR_VOID_TYPE_P (t) && TREE_CODE (t) != ARRAY_TYPE)
 	    {
 	      error_at (loc, "dereferencing pointer to incomplete type");
 	      return error_mark_node;
 	    }
-	  if (VOID_TYPE_P (t) && skip_evaluation == 0)
+	  if (VOID_TYPE_P (t) && c_inhibit_evaluation_warnings == 0)
 	    warning_at (loc, 0, "dereferencing %<void *%> pointer");
 	  /* We *must* set TREE_READONLY when dereferencing a pointer to const,
 	     so that we get the proper error message if the result is used
 	     to assign to.  Also, &* is supposed to be a no-op.
 	  protected_set_expr_location (ref, loc);
 	  return ref;
 	}
 }
 else if (TREE_CODE (pointer) != ERROR_MARK)
-error_at (loc,
+switch (errstring)
-	      "invalid type argument of %qs (have %qT)", errorstring, type);
+{
+case RO_ARRAY_INDEXING:
+error_at (loc,
+"invalid type argument of array indexing (have %qT)",
+type);
+break;
+case RO_UNARY_STAR:
+error_at (loc,
+"invalid type argument of unary %<*%> (have %qT)",
+type);
+break;
+case RO_ARROW:
+error_at (loc,
+"invalid type argument of %<->%> (have %qT)",
+type);
+break;
+default:
+gcc_unreachable ();
+}
 return error_mark_node;
 }
 /* This handles expressions of the form "a[i]", which denotes
 an array reference.
 by functions).
 LOC is the location to use for the returned expression.  */
 tree
-build_array_ref (tree array, tree index, location_t loc)
+build_array_ref (location_t loc, tree array, tree index)
 {
 tree ret;
 bool swapped = false;
 if (TREE_TYPE (array) == error_mark_node
 || TREE_TYPE (index) == error_mark_node)
 	{
 	  tree foo = array;
 	  while (TREE_CODE (foo) == COMPONENT_REF)
 	    foo = TREE_OPERAND (foo, 0);
 	  if (TREE_CODE (foo) == VAR_DECL && C_DECL_REGISTER (foo))
 	    pedwarn (loc, OPT_pedantic,
 		     "ISO C forbids subscripting %<register%> array");
 	  else if (!flag_isoc99 && !lvalue_p (foo))
 	    pedwarn (loc, OPT_pedantic,
 		     "ISO C90 forbids subscripting non-lvalue array");
 	}
 type = TREE_TYPE (TREE_TYPE (array));
 rval = build4 (ARRAY_REF, type, array, index, NULL_TREE, NULL_TREE);
 	    /* This was added by rms on 16 Nov 91.
 	       It fixes  vol struct foo *a;  a->elts[1]
 	       in an inline function.
 	       Hope it doesn't break something else.  */
 	    | TREE_THIS_VOLATILE (array));
-ret = require_complete_type (fold (rval));
+ret = require_complete_type (rval);
 protected_set_expr_location (ret, loc);
 return ret;
 }
 else
 {
 gcc_assert (TREE_CODE (TREE_TYPE (ar)) == POINTER_TYPE);
 gcc_assert (TREE_CODE (TREE_TYPE (TREE_TYPE (ar))) != FUNCTION_TYPE);
 return build_indirect_ref
 	(loc, build_binary_op (loc, PLUS_EXPR, ar, index, 0),
-	 "array indexing");
+	 RO_ARRAY_INDEXING);
 }
 }
 /* Build an external reference to identifier ID.  FUN indicates
 whether this will be used for a function call.  LOC is the source
-location of the identifier.  */
+location of the identifier.  This sets *TYPE to the type of the
+identifier, which is not the same as the type of the returned value
+for CONST_DECLs defined as enum constants.  If the type of the
+identifier is not available, *TYPE is set to NULL.  */
 tree
-build_external_ref (tree id, int fun, location_t loc)
+build_external_ref (location_t loc, tree id, int fun, tree *type)
 {
 tree ref;
 tree decl = lookup_name (id);
 /* In Objective-C, an instance variable (ivar) may be preferred to
 whatever lookup_name() found.  */
 decl = objc_lookup_ivar (decl, id);
+*type = NULL;
 if (decl && decl != error_mark_node)
-ref = decl;
+{
+ref = decl;
+*type = TREE_TYPE (ref);
+}
 else if (fun)
 /* Implicit function declaration.  */
-ref = implicitly_declare (id);
+ref = implicitly_declare (loc, id);
 else if (decl == error_mark_node)
 /* Don't complain about something that's already been
 complained about.  */
 return error_mark_node;
 else
 {
-undeclared_variable (id, loc);
+undeclared_variable (loc, id);
 return error_mark_node;
 }
 if (TREE_TYPE (ref) == error_mark_node)
 return error_mark_node;
 if (TREE_DEPRECATED (ref))
-warn_deprecated_use (ref);
+warn_deprecated_use (ref, NULL_TREE);
 /* Recursive call does not count as usage.  */
 if (ref != current_function_decl)
 {
 TREE_USED (ref) = 1;
 }
 if (TREE_CODE (ref) == FUNCTION_DECL && !in_alignof)
 }
 if (TREE_CODE (ref) == CONST_DECL)
 {
 used_types_insert (TREE_TYPE (ref));
+if (warn_cxx_compat
+	  && TREE_CODE (TREE_TYPE (ref)) == ENUMERAL_TYPE
+	  && C_TYPE_DEFINED_IN_STRUCT (TREE_TYPE (ref)))
+	{
+	  warning_at (loc, OPT_Wc___compat,
+		      ("enum constant defined in struct or union "
+		       "is not visible in C++"));
+	  inform (DECL_SOURCE_LOCATION (ref), "enum constant defined here");
+	}
 ref = DECL_INITIAL (ref);
 TREE_CONSTANT (ref) = 1;
 }
 else if (current_function_decl != 0
 	   && !DECL_FILE_SCOPE_P (current_function_decl)
 	   && DECL_EXTERNAL (current_function_decl)
 	   && VAR_OR_FUNCTION_DECL_P (ref)
 	   && (TREE_CODE (ref) != VAR_DECL || TREE_STATIC (ref))
 	   && ! TREE_PUBLIC (ref)
 	   && DECL_CONTEXT (ref) != current_function_decl)
-pedwarn (loc, 0, "%qD is static but used in inline function %qD "
+record_inline_static (loc, current_function_decl, ref,
-	     "which is not static", ref, current_function_decl);
+			  csi_internal);
 return ref;
 }
 /* Record details of decls possibly used inside sizeof or typeof.  */
 }
 /* Return the result of sizeof applied to EXPR.  */
 struct c_expr
-c_expr_sizeof_expr (struct c_expr expr)
+c_expr_sizeof_expr (location_t loc, struct c_expr expr)
 {
 struct c_expr ret;
 if (expr.value == error_mark_node)
 {
 ret.value = error_mark_node;
 ret.original_code = ERROR_MARK;
+ret.original_type = NULL;
 pop_maybe_used (false);
 }
 else
 {
-ret.value = c_sizeof (TREE_TYPE (expr.value));
+bool expr_const_operands = true;
+tree folded_expr = c_fully_fold (expr.value, require_constant_value,
+				       &expr_const_operands);
+ret.value = c_sizeof (loc, TREE_TYPE (folded_expr));
 ret.original_code = ERROR_MARK;
-if (c_vla_type_p (TREE_TYPE (expr.value)))
+ret.original_type = NULL;
+if (c_vla_type_p (TREE_TYPE (folded_expr)))
 	{
 	  /* sizeof is evaluated when given a vla (C99 6.5.3.4p2).  */
-	  ret.value = build2 (COMPOUND_EXPR, TREE_TYPE (ret.value), expr.value, ret.value);
+	  ret.value = build2 (C_MAYBE_CONST_EXPR, TREE_TYPE (ret.value),
-	}
+			      folded_expr, ret.value);
-pop_maybe_used (C_TYPE_VARIABLE_SIZE (TREE_TYPE (expr.value)));
+	  C_MAYBE_CONST_EXPR_NON_CONST (ret.value) = !expr_const_operands;
+	  SET_EXPR_LOCATION (ret.value, loc);
+	}
+pop_maybe_used (C_TYPE_VARIABLE_SIZE (TREE_TYPE (folded_expr)));
 }
 return ret;
 }
 /* Return the result of sizeof applied to T, a structure for the type
-name passed to sizeof (rather than the type itself).  */
+name passed to sizeof (rather than the type itself).  LOC is the
+location of the original expression.  */
 struct c_expr
-c_expr_sizeof_type (struct c_type_name *t)
+c_expr_sizeof_type (location_t loc, struct c_type_name *t)
 {
 tree type;
 struct c_expr ret;
-type = groktypename (t);
+tree type_expr = NULL_TREE;
-ret.value = c_sizeof (type);
+bool type_expr_const = true;
+type = groktypename (t, &type_expr, &type_expr_const);
+ret.value = c_sizeof (loc, type);
 ret.original_code = ERROR_MARK;
+ret.original_type = NULL;
+if ((type_expr || TREE_CODE (ret.value) == INTEGER_CST)
+&& c_vla_type_p (type))
+{
+/* If the type is a [*] array, it is a VLA but is represented as
+	 having a size of zero.  In such a case we must ensure that
+	 the result of sizeof does not get folded to a constant by
+	 c_fully_fold, because if the size is evaluated the result is
+	 not constant and so constraints on zero or negative size
+	 arrays must not be applied when this sizeof call is inside
+	 another array declarator.  */
+if (!type_expr)
+	type_expr = integer_zero_node;
+ret.value = build2 (C_MAYBE_CONST_EXPR, TREE_TYPE (ret.value),
+			  type_expr, ret.value);
+C_MAYBE_CONST_EXPR_NON_CONST (ret.value) = !type_expr_const;
+}
 pop_maybe_used (type != error_mark_node
 		  ? C_TYPE_VARIABLE_SIZE (type) : false);
 return ret;
 }
 /* Build a function call to function FUNCTION with parameters PARAMS.
+The function call is at LOC.
 PARAMS is a list--a chain of TREE_LIST nodes--in which the
 TREE_VALUE of each node is a parameter-expression.
 FUNCTION's data type may be a function type or a pointer-to-function.  */
 tree
-build_function_call (tree function, tree params)
+build_function_call (location_t loc, tree function, tree params)
+{
+VEC(tree,gc) *vec;
+tree ret;
+vec = VEC_alloc (tree, gc, list_length (params));
+for (; params; params = TREE_CHAIN (params))
+VEC_quick_push (tree, vec, TREE_VALUE (params));
+ret = build_function_call_vec (loc, function, vec, NULL);
+VEC_free (tree, gc, vec);
+return ret;
+}
+/* Build a function call to function FUNCTION with parameters PARAMS.
+ORIGTYPES, if not NULL, is a vector of types; each element is
+either NULL or the original type of the corresponding element in
+PARAMS.  The original type may differ from TREE_TYPE of the
+parameter for enums.  FUNCTION's data type may be a function type
+or pointer-to-function.  This function changes the elements of
+PARAMS.  */
+tree
+build_function_call_vec (location_t loc, tree function, VEC(tree,gc) *params,
+			 VEC(tree,gc) *origtypes)
 {
 tree fntype, fundecl = 0;
 tree name = NULL_TREE, result;
 tree tem;
 int nargs;
 tree *argarray;
 /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue.  */
 STRIP_TYPE_NOPS (function);
 /* Convert anything with function type to a pointer-to-function.  */
 {
 /* Implement type-directed function overloading for builtins.
 	 resolve_overloaded_builtin and targetm.resolve_overloaded_builtin
 	 handle all the type checking.  The result is a complete expression
 	 that implements this function call.  */
-tem = resolve_overloaded_builtin (function, params);
+tem = resolve_overloaded_builtin (loc, function, params);
 if (tem)
 	return tem;
 name = DECL_NAME (function);
 fundecl = function;
 }
 if (TREE_CODE (TREE_TYPE (function)) == FUNCTION_TYPE)
-function = function_to_pointer_conversion (function);
+function = function_to_pointer_conversion (loc, function);
 /* For Objective-C, convert any calls via a cast to OBJC_TYPE_REF
 expressions, like those used for ObjC messenger dispatches.  */
-function = objc_rewrite_function_call (function, params);
+if (!VEC_empty (tree, params))
+function = objc_rewrite_function_call (function,
+					   VEC_index (tree, params, 0));
+function = c_fully_fold (function, false, NULL);
 fntype = TREE_TYPE (function);
 if (TREE_CODE (fntype) == ERROR_MARK)
 return error_mark_node;
 if (!(TREE_CODE (fntype) == POINTER_TYPE
 	&& TREE_CODE (TREE_TYPE (fntype)) == FUNCTION_TYPE))
 {
-error ("called object %qE is not a function", function);
+error_at (loc, "called object %qE is not a function", function);
 return error_mark_node;
 }
 if (fundecl && TREE_THIS_VOLATILE (fundecl))
 current_function_returns_abnormally = 1;
 fntype = TREE_TYPE (fntype);
 /* Convert the parameters to the types declared in the
 function prototype, or apply default promotions.  */
-nargs = list_length (params);
+nargs = convert_arguments (TYPE_ARG_TYPES (fntype), params, origtypes,
-argarray = (tree *) alloca (nargs * sizeof (tree));
+			     function, fundecl);
-nargs = convert_arguments (nargs, argarray, TYPE_ARG_TYPES (fntype),
-			     params, function, fundecl);
 if (nargs < 0)
 return error_mark_node;
 /* Check that the function is called through a compatible prototype.
 If it is not, replace the call by a trap, wrapped up in a compound
 && TREE_CODE (tem = TREE_OPERAND (function, 0)) == ADDR_EXPR
 && TREE_CODE (tem = TREE_OPERAND (tem, 0)) == FUNCTION_DECL
 && !comptypes (fntype, TREE_TYPE (tem)))
 {
 tree return_type = TREE_TYPE (fntype);
-tree trap = build_function_call (built_in_decls[BUILT_IN_TRAP],
+tree trap = build_function_call (loc, built_in_decls[BUILT_IN_TRAP],
 				       NULL_TREE);
 int i;
 /* This situation leads to run-time undefined behavior.  We can't,
 	 therefore, simply error unless we can prove that all possible
 	 executions of the program must execute the code.  */
-if (warning (0, "function called through a non-compatible type"))
+if (warning_at (loc, 0, "function called through a non-compatible type"))
 	/* We can, however, treat "undefined" any way we please.
 	   Call abort to encourage the user to fix the program.  */
-	inform (input_location, "if this code is reached, the program will abort");
+	inform (loc, "if this code is reached, the program will abort");
 /* Before the abort, allow the function arguments to exit or
 	 call longjmp.  */
 for (i = 0; i < nargs; i++)
-	trap = build2 (COMPOUND_EXPR, void_type_node, argarray[i], trap);
+	trap = build2 (COMPOUND_EXPR, void_type_node,
+		       VEC_index (tree, params, i), trap);
 if (VOID_TYPE_P (return_type))
-	return trap;
+	{
+	  if (TYPE_QUALS (return_type) != TYPE_UNQUALIFIED)
+	    pedwarn (loc, 0,
+		     "function with qualified void return type called");
+	  return trap;
+	}
 else
 	{
 	  tree rhs;
 	  if (AGGREGATE_TYPE_P (return_type))
-	    rhs = build_compound_literal (return_type,
+	    rhs = build_compound_literal (loc, return_type,
-					  build_constructor (return_type, 0));
+					  build_constructor (return_type, 0),
+					  false);
 	  else
-	    rhs = fold_convert (return_type, integer_zero_node);
+	    rhs = fold_convert_loc (loc, return_type, integer_zero_node);
-	  return build2 (COMPOUND_EXPR, return_type, trap, rhs);
+	  return require_complete_type (build2 (COMPOUND_EXPR, return_type,
-	}
+						trap, rhs));
-}
+	}
+}
+argarray = VEC_address (tree, params);
 /* Check that arguments to builtin functions match the expectations.  */
 if (fundecl
 && DECL_BUILT_IN (fundecl)
 && DECL_BUILT_IN_CLASS (fundecl) == BUILT_IN_NORMAL
 /* Check that the arguments to the function are valid.  */
 check_function_arguments (TYPE_ATTRIBUTES (fntype), nargs, argarray,
 			    TYPE_ARG_TYPES (fntype));
-if (require_constant_value)
+if (name != NULL_TREE
-{
+&& !strncmp (IDENTIFIER_POINTER (name), "__builtin_", 10))
-result = fold_build_call_array_initializer (TREE_TYPE (fntype),
+{
-						  function, nargs, argarray);
+if (require_constant_value)
-if (TREE_CONSTANT (result)
+	result =
-	  && (name == NULL_TREE
+	  fold_build_call_array_initializer_loc (loc, TREE_TYPE (fntype),
-	      || strncmp (IDENTIFIER_POINTER (name), "__builtin_", 10) != 0))
+						 function, nargs, argarray);
-	pedwarn_init (input_location, 0, "initializer element is not constant");
+else
+	result = fold_build_call_array_loc (loc, TREE_TYPE (fntype),
+					    function, nargs, argarray);
+if (TREE_CODE (result) == NOP_EXPR
+	  && TREE_CODE (TREE_OPERAND (result, 0)) == INTEGER_CST)
+	STRIP_TYPE_NOPS (result);
 }
 else
-result = fold_build_call_array (TREE_TYPE (fntype),
+result = build_call_array_loc (loc, TREE_TYPE (fntype),
-				    function, nargs, argarray);
+				   function, nargs, argarray);
 if (VOID_TYPE_P (TREE_TYPE (result)))
-return result;
+{
+if (TYPE_QUALS (TREE_TYPE (result)) != TYPE_UNQUALIFIED)
+	pedwarn (loc, 0,
+		 "function with qualified void return type called");
+return result;
+}
 return require_complete_type (result);
 }
-/* Convert the argument expressions in the list VALUES
+/* Convert the argument expressions in the vector VALUES
-to the types in the list TYPELIST.  The resulting arguments are
+to the types in the list TYPELIST.
-stored in the array ARGARRAY which has size NARGS.
 If TYPELIST is exhausted, or when an element has NULL as its type,
 perform the default conversions.
-PARMLIST is the chain of parm decls for the function being called.
+ORIGTYPES is the original types of the expressions in VALUES.  This
-It may be 0, if that info is not available.
+holds the type of enum values which have been converted to integral
-It is used only for generating error messages.
+types.  It may be NULL.
 FUNCTION is a tree for the called function.  It is used only for
 error messages, where it is formatted with %qE.
 This is also where warnings about wrong number of args are generated.
-VALUES is a chain of TREE_LIST nodes with the elements of the list
-in the TREE_VALUE slots of those nodes.
 Returns the actual number of arguments processed (which may be less
-than NARGS in some error situations), or -1 on failure.  */
+than the length of VALUES in some error situations), or -1 on
+failure.  */
 static int
-convert_arguments (int nargs, tree *argarray,
+convert_arguments (tree typelist, VEC(tree,gc) *values,
-		   tree typelist, tree values, tree function, tree fundecl)
+		   VEC(tree,gc) *origtypes, tree function, tree fundecl)
 {
-tree typetail, valtail;
+tree typetail, val;
-int parmnum;
+unsigned int parmnum;
 bool error_args = false;
 const bool type_generic = fundecl
 && lookup_attribute ("type generic", TYPE_ATTRIBUTES(TREE_TYPE (fundecl)));
+bool type_generic_remove_excess_precision = false;
 tree selector;
 /* Change pointer to function to the function itself for
 diagnostics.  */
 if (TREE_CODE (function) == ADDR_EXPR
 function = TREE_OPERAND (function, 0);
 /* Handle an ObjC selector specially for diagnostics.  */
 selector = objc_message_selector ();
+/* For type-generic built-in functions, determine whether excess
+precision should be removed (classification) or not
+(comparison).  */
+if (type_generic
+&& DECL_BUILT_IN (fundecl)
+&& DECL_BUILT_IN_CLASS (fundecl) == BUILT_IN_NORMAL)
+{
+switch (DECL_FUNCTION_CODE (fundecl))
+	{
+	case BUILT_IN_ISFINITE:
+	case BUILT_IN_ISINF:
+	case BUILT_IN_ISINF_SIGN:
+	case BUILT_IN_ISNAN:
+	case BUILT_IN_ISNORMAL:
+	case BUILT_IN_FPCLASSIFY:
+	  type_generic_remove_excess_precision = true;
+	  break;
+	default:
+	  type_generic_remove_excess_precision = false;
+	  break;
+	}
+}
 /* Scan the given expressions and types, producing individual
-converted arguments and storing them in ARGARRAY.  */
+converted arguments.  */
-for (valtail = values, typetail = typelist, parmnum = 0;
+for (typetail = typelist, parmnum = 0;
-valtail;
+VEC_iterate (tree, values, parmnum, val);
-valtail = TREE_CHAIN (valtail), parmnum++)
+++parmnum)
 {
 tree type = typetail ? TREE_VALUE (typetail) : 0;
-tree val = TREE_VALUE (valtail);
+tree valtype = TREE_TYPE (val);
 tree rname = function;
 int argnum = parmnum + 1;
 const char *invalid_func_diag;
+bool excess_precision = false;
+bool npc;
+tree parmval;
 if (type == void_type_node)
 	{
 	  error ("too many arguments to function %qE", function);
 	  return parmnum;
 	{
 	  rname = selector;
 	  argnum -= 2;
 	}
+npc = null_pointer_constant_p (val);
+/* If there is excess precision and a prototype, convert once to
+	 the required type rather than converting via the semantic
+	 type.  Likewise without a prototype a float value represented
+	 as long double should be converted once to double.  But for
+	 type-generic classification functions excess precision must
+	 be removed here.  */
+if (TREE_CODE (val) == EXCESS_PRECISION_EXPR
+	  && (type || !type_generic || !type_generic_remove_excess_precision))
+	{
+	  val = TREE_OPERAND (val, 0);
+	  excess_precision = true;
+	}
+val = c_fully_fold (val, false, NULL);
 STRIP_TYPE_NOPS (val);
 val = require_complete_type (val);
 if (type != 0)
 	{
 	  /* Formal parm type is specified by a function prototype.  */
-	  tree parmval;
 	  if (type == error_mark_node || !COMPLETE_TYPE_P (type))
 	    {
 	      error ("type of formal parameter %d is incomplete", parmnum + 1);
 	      parmval = val;
 	    }
 	  else
 	    {
+	      tree origtype;
 	      /* Optionally warn about conversions that
 		 differ from the default conversions.  */
 	      if (warn_traditional_conversion || warn_traditional)
 		{
 		  unsigned int formal_prec = TYPE_PRECISION (type);
 		  if (INTEGRAL_TYPE_P (type)
-		      && TREE_CODE (TREE_TYPE (val)) == REAL_TYPE)
+		      && TREE_CODE (valtype) == REAL_TYPE)
 		    warning (0, "passing argument %d of %qE as integer "
 			     "rather than floating due to prototype",
 			     argnum, rname);
 		  if (INTEGRAL_TYPE_P (type)
-		      && TREE_CODE (TREE_TYPE (val)) == COMPLEX_TYPE)
+		      && TREE_CODE (valtype) == COMPLEX_TYPE)
 		    warning (0, "passing argument %d of %qE as integer "
 			     "rather than complex due to prototype",
 			     argnum, rname);
 		  else if (TREE_CODE (type) == COMPLEX_TYPE
-			   && TREE_CODE (TREE_TYPE (val)) == REAL_TYPE)
+			   && TREE_CODE (valtype) == REAL_TYPE)
 		    warning (0, "passing argument %d of %qE as complex "
 			     "rather than floating due to prototype",
 			     argnum, rname);
 		  else if (TREE_CODE (type) == REAL_TYPE
-			   && INTEGRAL_TYPE_P (TREE_TYPE (val)))
+			   && INTEGRAL_TYPE_P (valtype))
 		    warning (0, "passing argument %d of %qE as floating "
 			     "rather than integer due to prototype",
 			     argnum, rname);
 		  else if (TREE_CODE (type) == COMPLEX_TYPE
-			   && INTEGRAL_TYPE_P (TREE_TYPE (val)))
+			   && INTEGRAL_TYPE_P (valtype))
 		    warning (0, "passing argument %d of %qE as complex "
 			     "rather than integer due to prototype",
 			     argnum, rname);
 		  else if (TREE_CODE (type) == REAL_TYPE
-			   && TREE_CODE (TREE_TYPE (val)) == COMPLEX_TYPE)
+			   && TREE_CODE (valtype) == COMPLEX_TYPE)
 		    warning (0, "passing argument %d of %qE as floating "
 			     "rather than complex due to prototype",
 			     argnum, rname);
 		  /* ??? At some point, messages should be written about
 		     conversions between complex types, but that's too messy
 		     to do now.  */
 		  else if (TREE_CODE (type) == REAL_TYPE
-			   && TREE_CODE (TREE_TYPE (val)) == REAL_TYPE)
+			   && TREE_CODE (valtype) == REAL_TYPE)
 		    {
 		      /* Warn if any argument is passed as `float',
 			 since without a prototype it would be `double'.  */
 		      if (formal_prec == TYPE_PRECISION (float_type_node)
 			  && type != dfloat32_type_node)
 		      /* Warn if mismatch between argument and prototype
 			 for decimal float types.  Warn of conversions with
 			 binary float types and of precision narrowing due to
 			 prototype. */
-		      else if (type != TREE_TYPE (val)
+		      else if (type != valtype
 			       && (type == dfloat32_type_node
 				   || type == dfloat64_type_node
 				   || type == dfloat128_type_node
-				   || TREE_TYPE (val) == dfloat32_type_node
+				   || valtype == dfloat32_type_node
-				   || TREE_TYPE (val) == dfloat64_type_node
+				   || valtype == dfloat64_type_node
-				   || TREE_TYPE (val) == dfloat128_type_node)
+				   || valtype == dfloat128_type_node)
 			       && (formal_prec
-				   <= TYPE_PRECISION (TREE_TYPE (val))
+				   <= TYPE_PRECISION (valtype)
 				   || (type == dfloat128_type_node
-				       && (TREE_TYPE (val)
+				       && (valtype
 					   != dfloat64_type_node
-					   && (TREE_TYPE (val)
+					   && (valtype
 					       != dfloat32_type_node)))
 				   || (type == dfloat64_type_node
-				       && (TREE_TYPE (val)
+				       && (valtype
 					   != dfloat32_type_node))))
 			warning (0, "passing argument %d of %qE as %qT "
 				 "rather than %qT due to prototype",
-				 argnum, rname, type, TREE_TYPE (val));
+				 argnum, rname, type, valtype);
 		    }
 		  /* Detect integer changing in width or signedness.
 		     These warnings are only activated with
 		     -Wtraditional-conversion, not with -Wtraditional.  */
 		  else if (warn_traditional_conversion && INTEGRAL_TYPE_P (type)
-			   && INTEGRAL_TYPE_P (TREE_TYPE (val)))
+			   && INTEGRAL_TYPE_P (valtype))
 		    {
 		      tree would_have_been = default_conversion (val);
 		      tree type1 = TREE_TYPE (would_have_been);
 		      if (TREE_CODE (type) == ENUMERAL_TYPE
 			  && (TYPE_MAIN_VARIANT (type)
-			      == TYPE_MAIN_VARIANT (TREE_TYPE (val))))
+			      == TYPE_MAIN_VARIANT (valtype)))
 			/* No warning if function asks for enum
 			   and the actual arg is that enum type.  */
 			;
 		      else if (formal_prec != TYPE_PRECISION (type1))
-			warning (OPT_Wtraditional_conversion, "passing argument %d of %qE "
+			warning (OPT_Wtraditional_conversion,
+				 "passing argument %d of %qE "
 				 "with different width due to prototype",
 				 argnum, rname);
 		      else if (TYPE_UNSIGNED (type) == TYPE_UNSIGNED (type1))
 			;
 		      /* Don't complain if the formal parameter type
 			;
 		      /* If the value is extended from a narrower
 			 unsigned type, it doesn't matter whether we
 			 pass it as signed or unsigned; the value
 			 certainly is the same either way.  */
-		      else if (TYPE_PRECISION (TREE_TYPE (val)) < TYPE_PRECISION (type)
+		      else if (TYPE_PRECISION (valtype) < TYPE_PRECISION (type)
-			       && TYPE_UNSIGNED (TREE_TYPE (val)))
+			       && TYPE_UNSIGNED (valtype))
 			;
 		      else if (TYPE_UNSIGNED (type))
-			warning (OPT_Wtraditional_conversion, "passing argument %d of %qE "
+			warning (OPT_Wtraditional_conversion,
+				 "passing argument %d of %qE "
 				 "as unsigned due to prototype",
 				 argnum, rname);
 		      else
-			warning (OPT_Wtraditional_conversion, "passing argument %d of %qE "
+			warning (OPT_Wtraditional_conversion,
+				 "passing argument %d of %qE "
 				 "as signed due to prototype", argnum, rname);
 		    }
 		}
-	      parmval = convert_for_assignment (type, val, ic_argpass,
+	      /* Possibly restore an EXCESS_PRECISION_EXPR for the
+		 sake of better warnings from convert_and_check.  */
+	      if (excess_precision)
+		val = build1 (EXCESS_PRECISION_EXPR, valtype, val);
+	      origtype = (origtypes == NULL
+			  ? NULL_TREE
+			  : VEC_index (tree, origtypes, parmnum));
+	      parmval = convert_for_assignment (input_location, type, val,
+						origtype, ic_argpass, npc,
 						fundecl, function,
 						parmnum + 1);
 	      if (targetm.calls.promote_prototypes (fundecl ? TREE_TYPE (fundecl) : 0)
 		  && INTEGRAL_TYPE_P (type)
 		  && (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)))
 		parmval = default_conversion (parmval);
 	    }
-	  argarray[parmnum] = parmval;
+	}
-	}
+else if (TREE_CODE (valtype) == REAL_TYPE
-else if (TREE_CODE (TREE_TYPE (val)) == REAL_TYPE
+	       && (TYPE_PRECISION (valtype)
-	       && (TYPE_PRECISION (TREE_TYPE (val))
 		   < TYPE_PRECISION (double_type_node))
-	       && !DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (val))))
+	       && !DECIMAL_FLOAT_MODE_P (TYPE_MODE (valtype)))
 {
 	  if (type_generic)
-	    argarray[parmnum] = val;
+	    parmval = val;
 	  else
 	    /* Convert `float' to `double'.  */
-	    argarray[parmnum] = convert (double_type_node, val);
+	    parmval = convert (double_type_node, val);
 	}
+else if (excess_precision && !type_generic)
+	/* A "double" argument with excess precision being passed
+	   without a prototype or in variable arguments.  */
+	parmval = convert (valtype, val);
 else if ((invalid_func_diag =
 		targetm.calls.invalid_arg_for_unprototyped_fn (typelist, fundecl, val)))
 	{
 	  error (invalid_func_diag);
 	  return -1;
 	}
 else
 	/* Convert `short' and `char' to full-size `int'.  */
-	argarray[parmnum] = default_conversion (val);
+	parmval = default_conversion (val);
-if (argarray[parmnum] == error_mark_node)
+VEC_replace (tree, values, parmnum, parmval);
+if (parmval == error_mark_node)
 	error_args = true;
 if (typetail)
 	typetail = TREE_CHAIN (typetail);
 }
-gcc_assert (parmnum == nargs);
+gcc_assert (parmnum == VEC_length (tree, values));
 if (typetail != 0 && TREE_VALUE (typetail) != void_type_node)
 {
 error ("too few arguments to function %qE", function);
 return -1;
 }
-return error_args ? -1 : parmnum;
+return error_args ? -1 : (int) parmnum;
 }
 /* This is the entry point used by the parser to build unary operators
 in the input.  CODE, a tree_code, specifies the unary operator, and
 ARG is the operand.  For unary plus, the C parser currently uses
 LOC is the location to use for the tree generated.
 */
 struct c_expr
-parser_build_unary_op (enum tree_code code, struct c_expr arg, location_t loc)
+parser_build_unary_op (location_t loc, enum tree_code code, struct c_expr arg)
 {
 struct c_expr result;
 result.value = build_unary_op (loc, code, arg.value, 0);
 result.original_code = code;
+result.original_type = NULL;
 if (TREE_OVERFLOW_P (result.value) && !TREE_OVERFLOW_P (arg.value))
-overflow_warning (result.value);
+overflow_warning (loc, result.value);
 return result;
 }
 /* This is the entry point used by the parser to build binary operators
 {
 struct c_expr result;
 enum tree_code code1 = arg1.original_code;
 enum tree_code code2 = arg2.original_code;
+tree type1 = (arg1.original_type
+? arg1.original_type
+: TREE_TYPE (arg1.value));
+tree type2 = (arg2.original_type
+? arg2.original_type
+: TREE_TYPE (arg2.value));
 result.value = build_binary_op (location, code,
 				  arg1.value, arg2.value, 1);
 result.original_code = code;
+result.original_type = NULL;
 if (TREE_CODE (result.value) == ERROR_MARK)
 return result;
 if (location != UNKNOWN_LOCATION)
 /* Check for cases such as x+y<<z which users are likely
 to misinterpret.  */
 if (warn_parentheses)
 warn_about_parentheses (code, code1, arg1.value, code2, arg2.value);
-if (TREE_CODE_CLASS (code1) != tcc_comparison)
+if (warn_logical_op)
-warn_logical_operator (code, arg1.value, arg2.value);
+warn_logical_operator (input_location, code, TREE_TYPE (result.value),
+			   code1, arg1.value, code2, arg2.value);
 /* Warn about comparisons against string literals, with the exception
 of testing for equality or inequality of a string literal with NULL.  */
 if (code == EQ_EXPR || code == NE_EXPR)
 {
 if ((code1 == STRING_CST && !integer_zerop (arg2.value))
 	  || (code2 == STRING_CST && !integer_zerop (arg1.value)))
-	warning (OPT_Waddress, "comparison with string literal results in unspecified behavior");
+	warning_at (location, OPT_Waddress,
+		    "comparison with string literal results in unspecified behavior");
 }
 else if (TREE_CODE_CLASS (code) == tcc_comparison
 	   && (code1 == STRING_CST || code2 == STRING_CST))
-warning (OPT_Waddress, "comparison with string literal results in unspecified behavior");
+warning_at (location, OPT_Waddress,
+		"comparison with string literal results in unspecified behavior");
-if (TREE_OVERFLOW_P (result.value)
-&& !TREE_OVERFLOW_P (arg1.value)
+if (TREE_OVERFLOW_P (result.value)
+&& !TREE_OVERFLOW_P (arg1.value)
 && !TREE_OVERFLOW_P (arg2.value))
-overflow_warning (result.value);
+overflow_warning (location, result.value);
+/* Warn about comparisons of different enum types.  */
+if (warn_enum_compare
+&& TREE_CODE_CLASS (code) == tcc_comparison
+&& TREE_CODE (type1) == ENUMERAL_TYPE
+&& TREE_CODE (type2) == ENUMERAL_TYPE
+&& TYPE_MAIN_VARIANT (type1) != TYPE_MAIN_VARIANT (type2))
+warning_at (location, OPT_Wenum_compare,
+		"comparison between %qT and %qT",
+		type1, type2);
 return result;
 }
 /* Return a tree for the difference of pointers OP0 and OP1.
 The resulting tree has type int.  */
 static tree
-pointer_diff (tree op0, tree op1)
+pointer_diff (location_t loc, tree op0, tree op1)
 {
 tree restype = ptrdiff_type_node;
+tree result, inttype;
+addr_space_t as0 = TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (op0)));
+addr_space_t as1 = TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (op1)));
 tree target_type = TREE_TYPE (TREE_TYPE (op0));
 tree con0, con1, lit0, lit1;
 tree orig_op1 = op1;
+/* If the operands point into different address spaces, we need to
+explicitly convert them to pointers into the common address space
+before we can subtract the numerical address values.  */
+if (as0 != as1)
+{
+addr_space_t as_common;
+tree common_type;
+/* Determine the common superset address space.  This is guaranteed
+	 to exist because the caller verified that comp_target_types
+	 returned non-zero.  */
+if (!addr_space_superset (as0, as1, &as_common))
+	gcc_unreachable ();
+common_type = common_pointer_type (TREE_TYPE (op0), TREE_TYPE (op1));
+op0 = convert (common_type, op0);
+op1 = convert (common_type, op1);
+}
+/* Determine integer type to perform computations in.  This will usually
+be the same as the result type (ptrdiff_t), but may need to be a wider
+type if pointers for the address space are wider than ptrdiff_t.  */
+if (TYPE_PRECISION (restype) < TYPE_PRECISION (TREE_TYPE (op0)))
+inttype = lang_hooks.types.type_for_size
+		(TYPE_PRECISION (TREE_TYPE (op0)), 0);
+else
+inttype = restype;
 if (TREE_CODE (target_type) == VOID_TYPE)
-pedwarn (input_location, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
+pedwarn (loc, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
 	     "pointer of type %<void *%> used in subtraction");
 if (TREE_CODE (target_type) == FUNCTION_TYPE)
-pedwarn (input_location, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
+pedwarn (loc, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
 	     "pointer to a function used in subtraction");
 /* If the conversion to ptrdiff_type does anything like widening or
 converting a partial to an integral mode, we get a convert_expression
 that is in the way to do any simplifications.
 /* First do the subtraction as integers;
 then drop through to build the divide operator.
 Do not do default conversions on the minus operator
 in case restype is a short type.  */
-op0 = build_binary_op (input_location,
+op0 = build_binary_op (loc,
-			 MINUS_EXPR, convert (restype, op0),
+			 MINUS_EXPR, convert (inttype, op0),
-			 convert (restype, op1), 0);
+			 convert (inttype, op1), 0);
 /* This generates an error if op1 is pointer to incomplete type.  */
 if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (TREE_TYPE (orig_op1))))
-error ("arithmetic on pointer to an incomplete type");
+error_at (loc, "arithmetic on pointer to an incomplete type");
 /* This generates an error if op0 is pointer to incomplete type.  */
 op1 = c_size_in_bytes (target_type);
 /* Divide by the size, in easiest possible way.  */
-return fold_build2 (EXACT_DIV_EXPR, restype, op0, convert (restype, op1));
+result = fold_build2_loc (loc, EXACT_DIV_EXPR, inttype,
+			    op0, convert (inttype, op1));
+/* Convert to final result type if necessary.  */
+return convert (restype, result);
 }
 /* Construct and perhaps optimize a tree representation
 for a unary operation.  CODE, a tree_code, specifies the operation
 and XARG is the operand.
 tree arg = xarg;
 tree argtype = 0;
 enum tree_code typecode;
 tree val;
 tree ret = error_mark_node;
+tree eptype = NULL_TREE;
 int noconvert = flag;
 const char *invalid_op_diag;
+bool int_operands;
+int_operands = EXPR_INT_CONST_OPERANDS (xarg);
+if (int_operands)
+arg = remove_c_maybe_const_expr (arg);
 if (code != ADDR_EXPR)
 arg = require_complete_type (arg);
 typecode = TREE_CODE (TREE_TYPE (arg));
 if ((invalid_op_diag
 = targetm.invalid_unary_op (code, TREE_TYPE (xarg))))
 {
 error_at (location, invalid_op_diag);
 return error_mark_node;
+}
+if (TREE_CODE (arg) == EXCESS_PRECISION_EXPR)
+{
+eptype = TREE_TYPE (arg);
+arg = TREE_OPERAND (arg, 0);
 }
 switch (code)
 {
 case CONVERT_EXPR:
 	  error_at (location, "wrong type argument to unary plus");
 	  return error_mark_node;
 	}
 else if (!noconvert)
 	arg = default_conversion (arg);
-arg = non_lvalue (arg);
+arg = non_lvalue_loc (location, arg);
 break;
 case NEGATE_EXPR:
 if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
 	    || typecode == FIXED_POINT_TYPE || typecode == COMPLEX_TYPE
 	    arg = default_conversion (arg);
 	}
 else if (typecode == COMPLEX_TYPE)
 	{
 	  code = CONJ_EXPR;
 	  pedwarn (location, OPT_pedantic,
 		   "ISO C does not support %<~%> for complex conjugation");
 	  if (!noconvert)
 	    arg = default_conversion (arg);
 	}
 else
 	  error_at (location,
 		    "wrong type argument to unary exclamation mark");
 	  return error_mark_node;
 	}
 arg = c_objc_common_truthvalue_conversion (location, arg);
-ret = invert_truthvalue (arg);
+ret = invert_truthvalue_loc (location, arg);
+/* If the TRUTH_NOT_EXPR has been folded, reset the location.  */
+if (EXPR_P (ret) && EXPR_HAS_LOCATION (ret))
+	location = EXPR_LOCATION (ret);
 goto return_build_unary_op;
 case REALPART_EXPR:
 if (TREE_CODE (arg) == COMPLEX_CST)
 	ret = TREE_REALPART (arg);
 else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
-	ret = fold_build1 (REALPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg);
+	ret = fold_build1_loc (location,
+			       REALPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg);
 else
 	ret = arg;
+if (eptype && TREE_CODE (eptype) == COMPLEX_TYPE)
+	eptype = TREE_TYPE (eptype);
 goto return_build_unary_op;
 case IMAGPART_EXPR:
 if (TREE_CODE (arg) == COMPLEX_CST)
 	ret = TREE_IMAGPART (arg);
 else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
-	ret = fold_build1 (IMAGPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg);
+	ret = fold_build1_loc (location,
+			       IMAGPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg);
 else
-	ret = omit_one_operand (TREE_TYPE (arg), integer_zero_node, arg);
+	ret = omit_one_operand_loc (location, TREE_TYPE (arg),
+				integer_zero_node, arg);
+if (eptype && TREE_CODE (eptype) == COMPLEX_TYPE)
+	eptype = TREE_TYPE (eptype);
 goto return_build_unary_op;
 case PREINCREMENT_EXPR:
 case POSTINCREMENT_EXPR:
 case PREDECREMENT_EXPR:
 case POSTDECREMENT_EXPR:
+if (TREE_CODE (arg) == C_MAYBE_CONST_EXPR)
+	{
+	  tree inner = build_unary_op (location, code,
+				       C_MAYBE_CONST_EXPR_EXPR (arg), flag);
+	  if (inner == error_mark_node)
+	    return error_mark_node;
+	  ret = build2 (C_MAYBE_CONST_EXPR, TREE_TYPE (inner),
+			C_MAYBE_CONST_EXPR_PRE (arg), inner);
+	  gcc_assert (!C_MAYBE_CONST_EXPR_INT_OPERANDS (arg));
+	  C_MAYBE_CONST_EXPR_NON_CONST (ret) = 1;
+	  goto return_build_unary_op;
+	}
+/* Complain about anything that is not a true lvalue.  */
+if (!lvalue_or_else (arg, ((code == PREINCREMENT_EXPR
+				  || code == POSTINCREMENT_EXPR)
+				 ? lv_increment
+				 : lv_decrement)))
+	return error_mark_node;
+if (warn_cxx_compat && TREE_CODE (TREE_TYPE (arg)) == ENUMERAL_TYPE)
+	{
+	  if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
+	    warning_at (location, OPT_Wc___compat,
+			"increment of enumeration value is invalid in C++");
+	  else
+	    warning_at (location, OPT_Wc___compat,
+			"decrement of enumeration value is invalid in C++");
+	}
+/* Ensure the argument is fully folded inside any SAVE_EXPR.  */
+arg = c_fully_fold (arg, false, NULL);
 /* Increment or decrement the real part of the value,
 	 and don't change the imaginary part.  */
 if (typecode == COMPLEX_TYPE)
 	{
 	  tree real, imag;
 	  pedwarn (location, OPT_pedantic,
 		   "ISO C does not support %<++%> and %<--%> on complex types");
 	  arg = stabilize_reference (arg);
 	  real = build_unary_op (EXPR_LOCATION (arg), REALPART_EXPR, arg, 1);
 	  imag = build_unary_op (EXPR_LOCATION (arg), IMAGPART_EXPR, arg, 1);
 	      }
 	    else if (TREE_CODE (TREE_TYPE (argtype)) == FUNCTION_TYPE
 		     || TREE_CODE (TREE_TYPE (argtype)) == VOID_TYPE)
 	      {
 		if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
 		  pedwarn (location, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
 			   "wrong type argument to increment");
 		else
 		  pedwarn (location, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
 			   "wrong type argument to decrement");
 	      }
 	    inc = c_size_in_bytes (TREE_TYPE (argtype));
-	    inc = fold_convert (sizetype, inc);
+	    inc = fold_convert_loc (location, sizetype, inc);
 	  }
 	else if (FRACT_MODE_P (TYPE_MODE (argtype)))
 	  {
 	    /* For signed fract types, we invert ++ to -- or
 	       -- to ++, and change inc from 1 to -1, because
 	  {
 	    inc = integer_one_node;
 	    inc = convert (argtype, inc);
 	  }
-	/* Complain about anything else that is not a true lvalue.  */
-	if (!lvalue_or_else (arg, ((code == PREINCREMENT_EXPR
-				    || code == POSTINCREMENT_EXPR)
-				   ? lv_increment
-				   : lv_decrement)))
-	  return error_mark_node;
 	/* Report a read-only lvalue.  */
-	if (TREE_READONLY (arg))
+	if (TYPE_READONLY (argtype))
 	  {
 	    readonly_error (arg,
 			    ((code == PREINCREMENT_EXPR
 			      || code == POSTINCREMENT_EXPR)
 			     ? lv_increment : lv_decrement));
 	    return error_mark_node;
 	  }
+	else if (TREE_READONLY (arg))
+	  readonly_warning (arg,
+			    ((code == PREINCREMENT_EXPR
+			      || code == POSTINCREMENT_EXPR)
+			     ? lv_increment : lv_decrement));
 	if (TREE_CODE (TREE_TYPE (arg)) == BOOLEAN_TYPE)
 	  val = boolean_increment (code, arg);
 	else
 	  val = build2 (code, TREE_TYPE (arg), arg, inc);
 }
 case ADDR_EXPR:
 /* Note that this operation never does default_conversion.  */
+/* The operand of unary '&' must be an lvalue (which excludes
+	 expressions of type void), or, in C99, the result of a [] or
+	 unary '*' operator.  */
+if (VOID_TYPE_P (TREE_TYPE (arg))
+	  && TYPE_QUALS (TREE_TYPE (arg)) == TYPE_UNQUALIFIED
+	  && (TREE_CODE (arg) != INDIRECT_REF
+	      || !flag_isoc99))
+	pedwarn (location, 0, "taking address of expression of type %<void%>");
 /* Let &* cancel out to simplify resulting code.  */
 if (TREE_CODE (arg) == INDIRECT_REF)
 	{
 	  /* Don't let this be an lvalue.  */
 	  if (lvalue_p (TREE_OPERAND (arg, 0)))
-	    return non_lvalue (TREE_OPERAND (arg, 0));
+	    return non_lvalue_loc (location, TREE_OPERAND (arg, 0));
 	  ret = TREE_OPERAND (arg, 0);
 	  goto return_build_unary_op;
 	}
 /* For &x[y], return x+y */
 	  tree op0 = TREE_OPERAND (arg, 0);
 	  if (!c_mark_addressable (op0))
 	    return error_mark_node;
 	  return build_binary_op (location, PLUS_EXPR,
 				  (TREE_CODE (TREE_TYPE (op0)) == ARRAY_TYPE
-				   ? array_to_pointer_conversion (op0)
+				   ? array_to_pointer_conversion (location,
+								  op0)
 				   : op0),
 				  TREE_OPERAND (arg, 1), 1);
 	}
 /* Anything not already handled and not a true memory reference
 	 or a non-lvalue array is an error.  */
 else if (typecode != FUNCTION_TYPE && !flag
 	       && !lvalue_or_else (arg, lv_addressof))
 	return error_mark_node;
+/* Move address operations inside C_MAYBE_CONST_EXPR to simplify
+	 folding later.  */
+if (TREE_CODE (arg) == C_MAYBE_CONST_EXPR)
+	{
+	  tree inner = build_unary_op (location, code,
+				       C_MAYBE_CONST_EXPR_EXPR (arg), flag);
+	  ret = build2 (C_MAYBE_CONST_EXPR, TREE_TYPE (inner),
+			C_MAYBE_CONST_EXPR_PRE (arg), inner);
+	  gcc_assert (!C_MAYBE_CONST_EXPR_INT_OPERANDS (arg));
+	  C_MAYBE_CONST_EXPR_NON_CONST (ret)
+	    = C_MAYBE_CONST_EXPR_NON_CONST (arg);
+	  goto return_build_unary_op;
+	}
 /* Ordinary case; arg is a COMPONENT_REF or a decl.  */
 argtype = TREE_TYPE (arg);
 /* If the lvalue is const or volatile, merge that into the type
 	 when we have proper support for integer constant expressions.  */
 val = get_base_address (arg);
 if (val && TREE_CODE (val) == INDIRECT_REF
 && TREE_CONSTANT (TREE_OPERAND (val, 0)))
 	{
-	  tree op0 = fold_convert (sizetype, fold_offsetof (arg, val)), op1;
+	  tree op0 = fold_convert_loc (location, sizetype,
+				       fold_offsetof (arg, val)), op1;
-	  op1 = fold_convert (argtype, TREE_OPERAND (val, 0));
-	  ret = fold_build2 (POINTER_PLUS_EXPR, argtype, op1, op0);
+	  op1 = fold_convert_loc (location, argtype, TREE_OPERAND (val, 0));
+	  ret = fold_build2_loc (location, POINTER_PLUS_EXPR, argtype, op1, op0);
 	  goto return_build_unary_op;
 	}
 val = build1 (ADDR_EXPR, argtype, arg);
 gcc_unreachable ();
 }
 if (argtype == 0)
 argtype = TREE_TYPE (arg);
-ret = require_constant_value ? fold_build1_initializer (code, argtype, arg)
+if (TREE_CODE (arg) == INTEGER_CST)
-			       : fold_build1 (code, argtype, arg);
+ret = (require_constant_value
+	   ? fold_build1_initializer_loc (location, code, argtype, arg)
+	   : fold_build1_loc (location, code, argtype, arg));
+else
+ret = build1 (code, argtype, arg);
 return_build_unary_op:
 gcc_assert (ret != error_mark_node);
+if (TREE_CODE (ret) == INTEGER_CST && !TREE_OVERFLOW (ret)
+&& !(TREE_CODE (xarg) == INTEGER_CST && !TREE_OVERFLOW (xarg)))
+ret = build1 (NOP_EXPR, TREE_TYPE (ret), ret);
+else if (TREE_CODE (ret) != INTEGER_CST && int_operands)
+ret = note_integer_operands (ret);
+if (eptype)
+ret = build1 (EXCESS_PRECISION_EXPR, eptype, ret);
 protected_set_expr_location (ret, location);
 return ret;
 }
 /* Return nonzero if REF is an lvalue valid for this language.
 Lvalues can be assigned, unless their type has TYPE_READONLY.
 Lvalues can have their address taken, unless they have C_DECL_REGISTER.  */
-static int
+bool
 lvalue_p (const_tree ref)
 {
 const enum tree_code code = TREE_CODE (ref);
 switch (code)
 {
 case REALPART_EXPR:
 case IMAGPART_EXPR:
 case COMPONENT_REF:
 return lvalue_p (TREE_OPERAND (ref, 0));
+case C_MAYBE_CONST_EXPR:
+return lvalue_p (TREE_OPERAND (ref, 1));
 case COMPOUND_LITERAL_EXPR:
 case STRING_CST:
 return 1;
 error (READONLY_MSG (G_("assignment of read-only location %qE"),
 			 G_("increment of read-only location %qE"),
 			 G_("decrement of read-only location %qE"),
 			 G_("read-only location %qE used as %<asm%> output")),
 	   arg);
+}
+/* Give a warning for storing in something that is read-only in GCC
+terms but not const in ISO C terms.  */
+static void
+readonly_warning (tree arg, enum lvalue_use use)
+{
+switch (use)
+{
+case lv_assign:
+warning (0, "assignment of read-only location %qE", arg);
+break;
+case lv_increment:
+warning (0, "increment of read-only location %qE", arg);
+break;
+case lv_decrement:
+warning (0, "decrement of read-only location %qE", arg);
+break;
+default:
+gcc_unreachable ();
+}
+return;
 }
 /* Return nonzero if REF is an lvalue valid for this language;
 otherwise, print an error message and return zero.  USE says
 default:
 	return true;
 }
 }
-/* Build and return a conditional expression IFEXP ? OP1 : OP2.  */
+/* Build and return a conditional expression IFEXP ? OP1 : OP2.  If
+IFEXP_BCP then the condition is a call to __builtin_constant_p, and
+if folded to an integer constant then the unselected half may
+contain arbitrary operations not normally permitted in constant
+expressions.  Set the location of the expression to LOC.  */
 tree
-build_conditional_expr (tree ifexp, tree op1, tree op2)
+build_conditional_expr (location_t colon_loc, tree ifexp, bool ifexp_bcp,
+			tree op1, tree op1_original_type, tree op2,
+			tree op2_original_type)
 {
 tree type1;
 tree type2;
 enum tree_code code1;
 enum tree_code code2;
 tree result_type = NULL;
+tree ep_result_type = NULL;
 tree orig_op1 = op1, orig_op2 = op2;
+bool int_const, op1_int_operands, op2_int_operands, int_operands;
+bool ifexp_int_operands;
+tree ret;
 bool objc_ok;
+op1_int_operands = EXPR_INT_CONST_OPERANDS (orig_op1);
+if (op1_int_operands)
+op1 = remove_c_maybe_const_expr (op1);
+op2_int_operands = EXPR_INT_CONST_OPERANDS (orig_op2);
+if (op2_int_operands)
+op2 = remove_c_maybe_const_expr (op2);
+ifexp_int_operands = EXPR_INT_CONST_OPERANDS (ifexp);
+if (ifexp_int_operands)
+ifexp = remove_c_maybe_const_expr (ifexp);
 /* Promote both alternatives.  */
 if (TREE_CODE (TREE_TYPE (op1)) != VOID_TYPE)
 op1 = default_conversion (op1);
 /* C90 does not permit non-lvalue arrays in conditional expressions.
 In C99 they will be pointers by now.  */
 if (code1 == ARRAY_TYPE || code2 == ARRAY_TYPE)
 {
-error ("non-lvalue array in conditional expression");
+error_at (colon_loc, "non-lvalue array in conditional expression");
 return error_mark_node;
 }
 objc_ok = objc_compare_types (type1, type2, -3, NULL_TREE);
+if ((TREE_CODE (op1) == EXCESS_PRECISION_EXPR
+|| TREE_CODE (op2) == EXCESS_PRECISION_EXPR)
+&& (code1 == INTEGER_TYPE || code1 == REAL_TYPE
+	  || code1 == COMPLEX_TYPE)
+&& (code2 == INTEGER_TYPE || code2 == REAL_TYPE
+	  || code2 == COMPLEX_TYPE))
+{
+ep_result_type = c_common_type (type1, type2);
+if (TREE_CODE (op1) == EXCESS_PRECISION_EXPR)
+	{
+	  op1 = TREE_OPERAND (op1, 0);
+	  type1 = TREE_TYPE (op1);
+	  gcc_assert (TREE_CODE (type1) == code1);
+	}
+if (TREE_CODE (op2) == EXCESS_PRECISION_EXPR)
+	{
+	  op2 = TREE_OPERAND (op2, 0);
+	  type2 = TREE_TYPE (op2);
+	  gcc_assert (TREE_CODE (type2) == code2);
+	}
+}
+if (warn_cxx_compat)
+{
+tree t1 = op1_original_type ? op1_original_type : TREE_TYPE (orig_op1);
+tree t2 = op2_original_type ? op2_original_type : TREE_TYPE (orig_op2);
+if (TREE_CODE (t1) == ENUMERAL_TYPE
+	  && TREE_CODE (t2) == ENUMERAL_TYPE
+	  && TYPE_MAIN_VARIANT (t1) != TYPE_MAIN_VARIANT (t2))
+	warning_at (colon_loc, OPT_Wc___compat,
+		    ("different enum types in conditional is "
+		     "invalid in C++: %qT vs %qT"),
+		    t1, t2);
+}
 /* Quickly detect the usual case where op1 and op2 have the same type
 after promotion.  */
 if (TYPE_MAIN_VARIANT (type1) == TYPE_MAIN_VARIANT (type2))
 {
 /* If -Wsign-compare, warn here if type1 and type2 have
 	 different signedness.  We'll promote the signed to unsigned
 	 and later code won't know it used to be different.
 	 Do this check on the original types, so that explicit casts
 	 will be considered, but default promotions won't.  */
-if (warn_sign_compare && !skip_evaluation)
+if (c_inhibit_evaluation_warnings == 0)
 	{
 	  int unsigned_op1 = TYPE_UNSIGNED (TREE_TYPE (orig_op1));
 	  int unsigned_op2 = TYPE_UNSIGNED (TREE_TYPE (orig_op2));
 	  if (unsigned_op1 ^ unsigned_op2)
 	      /* Do not warn if the result type is signed, since the
 		 signed type will only be chosen if it can represent
 		 all the values of the unsigned type.  */
 	      if (!TYPE_UNSIGNED (result_type))
 		/* OK */;
-	      /* Do not warn if the signed quantity is an unsuffixed
-		 integer literal (or some static constant expression
-		 involving such literals) and it is non-negative.  */
-	      else if ((unsigned_op2
-			&& tree_expr_nonnegative_warnv_p (op1, &ovf))
-		       || (unsigned_op1
-			   && tree_expr_nonnegative_warnv_p (op2, &ovf)))
-		/* OK */;
 	      else
-		warning (OPT_Wsign_compare, "signed and unsigned type in conditional expression");
+		{
+		  bool op1_maybe_const = true;
+		  bool op2_maybe_const = true;
+		  /* Do not warn if the signed quantity is an
+		     unsuffixed integer literal (or some static
+		     constant expression involving such literals) and
+		     it is non-negative.  This warning requires the
+		     operands to be folded for best results, so do
+		     that folding in this case even without
+		     warn_sign_compare to avoid warning options
+		     possibly affecting code generation.  */
+		  c_inhibit_evaluation_warnings
+		    += (ifexp == truthvalue_false_node);
+		  op1 = c_fully_fold (op1, require_constant_value,
+				      &op1_maybe_const);
+		  c_inhibit_evaluation_warnings
+		    -= (ifexp == truthvalue_false_node);
+		  c_inhibit_evaluation_warnings
+		    += (ifexp == truthvalue_true_node);
+		  op2 = c_fully_fold (op2, require_constant_value,
+				      &op2_maybe_const);
+		  c_inhibit_evaluation_warnings
+		    -= (ifexp == truthvalue_true_node);
+		  if (warn_sign_compare)
+		    {
+		      if ((unsigned_op2
+			   && tree_expr_nonnegative_warnv_p (op1, &ovf))
+			  || (unsigned_op1
+			      && tree_expr_nonnegative_warnv_p (op2, &ovf)))
+			/* OK */;
+		      else
+			warning_at (colon_loc, OPT_Wsign_compare,
+				    ("signed and unsigned type in "
+				     "conditional expression"));
+		    }
+		  if (!op1_maybe_const || TREE_CODE (op1) != INTEGER_CST)
+		    op1 = c_wrap_maybe_const (op1, !op1_maybe_const);
+		  if (!op2_maybe_const || TREE_CODE (op2) != INTEGER_CST)
+		    op2 = c_wrap_maybe_const (op2, !op2_maybe_const);
+		}
 	    }
 	}
 }
 else if (code1 == VOID_TYPE || code2 == VOID_TYPE)
 {
 if (code1 != VOID_TYPE || code2 != VOID_TYPE)
-	pedwarn (input_location, OPT_pedantic,
+	pedwarn (colon_loc, OPT_pedantic,
 		 "ISO C forbids conditional expr with only one void side");
 result_type = void_type_node;
 }
 else if (code1 == POINTER_TYPE && code2 == POINTER_TYPE)
 {
-if (comp_target_types (type1, type2))
+addr_space_t as1 = TYPE_ADDR_SPACE (TREE_TYPE (type1));
+addr_space_t as2 = TYPE_ADDR_SPACE (TREE_TYPE (type2));
+addr_space_t as_common;
+if (comp_target_types (colon_loc, type1, type2))
 	result_type = common_pointer_type (type1, type2);
 else if (null_pointer_constant_p (orig_op1))
-	result_type = qualify_type (type2, type1);
+	result_type = type2;
 else if (null_pointer_constant_p (orig_op2))
-	result_type = qualify_type (type1, type2);
+	result_type = type1;
+else if (!addr_space_superset (as1, as2, &as_common))
+	{
+	  error_at (colon_loc, "pointers to disjoint address spaces "
+		    "used in conditional expression");
+	  return error_mark_node;
+	}
 else if (VOID_TYPE_P (TREE_TYPE (type1)))
 	{
 	  if (TREE_CODE (TREE_TYPE (type2)) == FUNCTION_TYPE)
-	    pedwarn (input_location, OPT_pedantic,
+	    pedwarn (colon_loc, OPT_pedantic,
 		     "ISO C forbids conditional expr between "
 		     "%<void *%> and function pointer");
 	  result_type = build_pointer_type (qualify_type (TREE_TYPE (type1),
 							  TREE_TYPE (type2)));
 	}
 else if (VOID_TYPE_P (TREE_TYPE (type2)))
 	{
 	  if (TREE_CODE (TREE_TYPE (type1)) == FUNCTION_TYPE)
-	    pedwarn (input_location, OPT_pedantic,
+	    pedwarn (colon_loc, OPT_pedantic,
 		     "ISO C forbids conditional expr between "
 		     "%<void *%> and function pointer");
 	  result_type = build_pointer_type (qualify_type (TREE_TYPE (type2),
 							  TREE_TYPE (type1)));
 	}
 else
 	{
+	  int qual = ENCODE_QUAL_ADDR_SPACE (as_common);
 	  if (!objc_ok)
-	    pedwarn (input_location, 0,
+	    pedwarn (colon_loc, 0,
 		     "pointer type mismatch in conditional expression");
-	  result_type = build_pointer_type (void_type_node);
+	  result_type = build_pointer_type
+			  (build_qualified_type (void_type_node, qual));
 	}
 }
 else if (code1 == POINTER_TYPE && code2 == INTEGER_TYPE)
 {
 if (!null_pointer_constant_p (orig_op2))
-	pedwarn (input_location, 0,
+	pedwarn (colon_loc, 0,
 		 "pointer/integer type mismatch in conditional expression");
 else
 	{
 	  op2 = null_pointer_node;
 	}
 result_type = type1;
 }
 else if (code2 == POINTER_TYPE && code1 == INTEGER_TYPE)
 {
 if (!null_pointer_constant_p (orig_op1))
-	pedwarn (input_location, 0,
+	pedwarn (colon_loc, 0,
 		 "pointer/integer type mismatch in conditional expression");
 else
 	{
 	  op1 = null_pointer_node;
 	}
 {
 if (flag_cond_mismatch)
 	result_type = void_type_node;
 else
 	{
-	  error ("type mismatch in conditional expression");
+	  error_at (colon_loc, "type mismatch in conditional expression");
 	  return error_mark_node;
 	}
 }
 /* Merge const and volatile flags of the incoming types.  */
 result_type
 = build_type_variant (result_type,
-			  TREE_READONLY (op1) || TREE_READONLY (op2),
+			  TYPE_READONLY (type1) || TYPE_READONLY (type2),
-			  TREE_THIS_VOLATILE (op1) || TREE_THIS_VOLATILE (op2));
+			  TYPE_VOLATILE (type1) || TYPE_VOLATILE (type2));
-if (result_type != TREE_TYPE (op1))
+if (result_type != type1)
 op1 = convert_and_check (result_type, op1);
-if (result_type != TREE_TYPE (op2))
+if (result_type != type2)
 op2 = convert_and_check (result_type, op2);
-return fold_build3 (COND_EXPR, result_type, ifexp, op1, op2);
+if (ifexp_bcp && ifexp == truthvalue_true_node)
+{
+op2_int_operands = true;
+op1 = c_fully_fold (op1, require_constant_value, NULL);
+}
+if (ifexp_bcp && ifexp == truthvalue_false_node)
+{
+op1_int_operands = true;
+op2 = c_fully_fold (op2, require_constant_value, NULL);
+}
+int_const = int_operands = (ifexp_int_operands
+			      && op1_int_operands
+			      && op2_int_operands);
+if (int_operands)
+{
+int_const = ((ifexp == truthvalue_true_node
+		    && TREE_CODE (orig_op1) == INTEGER_CST
+		    && !TREE_OVERFLOW (orig_op1))
+		   || (ifexp == truthvalue_false_node
+		       && TREE_CODE (orig_op2) == INTEGER_CST
+		       && !TREE_OVERFLOW (orig_op2)));
+}
+if (int_const || (ifexp_bcp && TREE_CODE (ifexp) == INTEGER_CST))
+ret = fold_build3_loc (colon_loc, COND_EXPR, result_type, ifexp, op1, op2);
+else
+{
+ret = build3 (COND_EXPR, result_type, ifexp, op1, op2);
+if (int_operands)
+	ret = note_integer_operands (ret);
+}
+if (ep_result_type)
+ret = build1 (EXCESS_PRECISION_EXPR, ep_result_type, ret);
+protected_set_expr_location (ret, colon_loc);
+return ret;
 }
 /* Return a compound expression that performs two expressions and
-returns the value of the second of them.  */
+returns the value of the second of them.
+LOC is the location of the COMPOUND_EXPR.  */
 tree
-build_compound_expr (tree expr1, tree expr2)
+build_compound_expr (location_t loc, tree expr1, tree expr2)
 {
+bool expr1_int_operands, expr2_int_operands;
+tree eptype = NULL_TREE;
+tree ret;
+expr1_int_operands = EXPR_INT_CONST_OPERANDS (expr1);
+if (expr1_int_operands)
+expr1 = remove_c_maybe_const_expr (expr1);
+expr2_int_operands = EXPR_INT_CONST_OPERANDS (expr2);
+if (expr2_int_operands)
+expr2 = remove_c_maybe_const_expr (expr2);
+if (TREE_CODE (expr1) == EXCESS_PRECISION_EXPR)
+expr1 = TREE_OPERAND (expr1, 0);
+if (TREE_CODE (expr2) == EXCESS_PRECISION_EXPR)
+{
+eptype = TREE_TYPE (expr2);
+expr2 = TREE_OPERAND (expr2, 0);
+}
 if (!TREE_SIDE_EFFECTS (expr1))
 {
 /* The left-hand operand of a comma expression is like an expression
 	 statement: with -Wunused, we should warn if it doesn't have
 	 any side-effects, unless it was explicitly cast to (void).  */
 	  else if (VOID_TYPE_P (TREE_TYPE (expr1))
 		   && TREE_CODE (expr1) == COMPOUND_EXPR
 		   && CONVERT_EXPR_P (TREE_OPERAND (expr1, 1)))
 	    ; /* (void) a, (void) b, c */
 	  else
-	    warning (OPT_Wunused_value,
+	    warning_at (loc, OPT_Wunused_value,
-		     "left-hand operand of comma expression has no effect");
+			"left-hand operand of comma expression has no effect");
 	}
 }
 /* With -Wunused, we should also warn if the left-hand operand does have
 side-effects, but computes a value which is not used.  For example, in
 `foo() + bar(), baz()' the result of the `+' operator is not used,
 so we should issue a warning.  */
 else if (warn_unused_value)
-warn_if_unused_value (expr1, input_location);
+warn_if_unused_value (expr1, loc);
 if (expr2 == error_mark_node)
 return error_mark_node;
-return build2 (COMPOUND_EXPR, TREE_TYPE (expr2), expr1, expr2);
+ret = build2 (COMPOUND_EXPR, TREE_TYPE (expr2), expr1, expr2);
-}
+if (flag_isoc99
-/* Build an expression representing a cast to type TYPE of expression EXPR.  */
+&& expr1_int_operands
+&& expr2_int_operands)
+ret = note_integer_operands (ret);
+if (eptype)
+ret = build1 (EXCESS_PRECISION_EXPR, eptype, ret);
+protected_set_expr_location (ret, loc);
+return ret;
+}
+/* Issue -Wcast-qual warnings when appropriate.  TYPE is the type to
+which we are casting.  OTYPE is the type of the expression being
+cast.  Both TYPE and OTYPE are pointer types.  -Wcast-qual appeared
+on the command line.  Named address space qualifiers are not handled
+here, because they result in different warnings.  */
+static void
+handle_warn_cast_qual (tree type, tree otype)
+{
+tree in_type = type;
+tree in_otype = otype;
+int added = 0;
+int discarded = 0;
+bool is_const;
+/* Check that the qualifiers on IN_TYPE are a superset of the
+qualifiers of IN_OTYPE.  The outermost level of POINTER_TYPE
+nodes is uninteresting and we stop as soon as we hit a
+non-POINTER_TYPE node on either type.  */
+do
+{
+in_otype = TREE_TYPE (in_otype);
+in_type = TREE_TYPE (in_type);
+/* GNU C allows cv-qualified function types.  'const' means the
+	 function is very pure, 'volatile' means it can't return.  We
+	 need to warn when such qualifiers are added, not when they're
+	 taken away.  */
+if (TREE_CODE (in_otype) == FUNCTION_TYPE
+	  && TREE_CODE (in_type) == FUNCTION_TYPE)
+	added |= (TYPE_QUALS_NO_ADDR_SPACE (in_type)
+		  & ~TYPE_QUALS_NO_ADDR_SPACE (in_otype));
+else
+	discarded |= (TYPE_QUALS_NO_ADDR_SPACE (in_otype)
+		      & ~TYPE_QUALS_NO_ADDR_SPACE (in_type));
+}
+while (TREE_CODE (in_type) == POINTER_TYPE
+	 && TREE_CODE (in_otype) == POINTER_TYPE);
+if (added)
+warning (OPT_Wcast_qual, "cast adds new qualifiers to function type");
+if (discarded)
+/* There are qualifiers present in IN_OTYPE that are not present
+in IN_TYPE.  */
+warning (OPT_Wcast_qual,
+	     "cast discards qualifiers from pointer target type");
+if (added || discarded)
+return;
+/* A cast from **T to const **T is unsafe, because it can cause a
+const value to be changed with no additional warning.  We only
+issue this warning if T is the same on both sides, and we only
+issue the warning if there are the same number of pointers on
+both sides, as otherwise the cast is clearly unsafe anyhow.  A
+cast is unsafe when a qualifier is added at one level and const
+is not present at all outer levels.
+To issue this warning, we check at each level whether the cast
+adds new qualifiers not already seen.  We don't need to special
+case function types, as they won't have the same
+TYPE_MAIN_VARIANT.  */
+if (TYPE_MAIN_VARIANT (in_type) != TYPE_MAIN_VARIANT (in_otype))
+return;
+if (TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE)
+return;
+in_type = type;
+in_otype = otype;
+is_const = TYPE_READONLY (TREE_TYPE (in_type));
+do
+{
+in_type = TREE_TYPE (in_type);
+in_otype = TREE_TYPE (in_otype);
+if ((TYPE_QUALS (in_type) &~ TYPE_QUALS (in_otype)) != 0
+	  && !is_const)
+	{
+	  warning (OPT_Wcast_qual,
+		   ("new qualifiers in middle of multi-level non-const cast "
+		    "are unsafe"));
+	  break;
+	}
+if (is_const)
+	is_const = TYPE_READONLY (in_type);
+}
+while (TREE_CODE (in_type) == POINTER_TYPE);
+}
+/* Build an expression representing a cast to type TYPE of expression EXPR.
+LOC is the location of the cast-- typically the open paren of the cast.  */
 tree
-build_c_cast (tree type, tree expr)
+build_c_cast (location_t loc, tree type, tree expr)
 {
-tree value = expr;
+tree value;
+if (TREE_CODE (expr) == EXCESS_PRECISION_EXPR)
+expr = TREE_OPERAND (expr, 0);
+value = expr;
 if (type == error_mark_node || expr == error_mark_node)
 return error_mark_node;
 /* The ObjC front-end uses TYPE_MAIN_VARIANT to tie together types differing
 type = TYPE_MAIN_VARIANT (type);
 if (TREE_CODE (type) == ARRAY_TYPE)
 {
-error ("cast specifies array type");
+error_at (loc, "cast specifies array type");
 return error_mark_node;
 }
 if (TREE_CODE (type) == FUNCTION_TYPE)
 {
-error ("cast specifies function type");
+error_at (loc, "cast specifies function type");
 return error_mark_node;
 }
 if (!VOID_TYPE_P (type))
 {
 if (type == TYPE_MAIN_VARIANT (TREE_TYPE (value)))
 {
 if (TREE_CODE (type) == RECORD_TYPE
 	  || TREE_CODE (type) == UNION_TYPE)
-	pedwarn (input_location, OPT_pedantic,
+	pedwarn (loc, OPT_pedantic,
 		 "ISO C forbids casting nonscalar to the same type");
 }
 else if (TREE_CODE (type) == UNION_TYPE)
 {
 tree field;
 if (field)
 	{
 	  tree t;
-	  pedwarn (input_location, OPT_pedantic,
+	  pedwarn (loc, OPT_pedantic, "ISO C forbids casts to union type");
-		   "ISO C forbids casts to union type");
+	  t = digest_init (loc, type,
-	  t = digest_init (type,
 			   build_constructor_single (type, field, value),
-			   true, 0);
+			   NULL_TREE, false, true, 0);
 	  TREE_CONSTANT (t) = TREE_CONSTANT (value);
 	  return t;
 	}
-error ("cast to union type from type not present in union");
+error_at (loc, "cast to union type from type not present in union");
 return error_mark_node;
 }
 else
 {
 tree otype, ovalue;
 if (type == void_type_node)
-	return build1 (CONVERT_EXPR, type, value);
+	{
+	  tree t = build1 (CONVERT_EXPR, type, value);
+	  SET_EXPR_LOCATION (t, loc);
+	  return t;
+	}
 otype = TREE_TYPE (value);
 /* Optionally warn about potentially worrisome casts.  */
 if (warn_cast_qual
 	  && TREE_CODE (type) == POINTER_TYPE
 	  && TREE_CODE (otype) == POINTER_TYPE)
-	{
+	handle_warn_cast_qual (type, otype);
-	  tree in_type = type;
-	  tree in_otype = otype;
+/* Warn about conversions between pointers to disjoint
-	  int added = 0;
+	 address spaces.  */
-	  int discarded = 0;
+if (TREE_CODE (type) == POINTER_TYPE
+	  && TREE_CODE (otype) == POINTER_TYPE
-	  /* Check that the qualifiers on IN_TYPE are a superset of
+	  && !null_pointer_constant_p (value))
-	     the qualifiers of IN_OTYPE.  The outermost level of
+	{
-	     POINTER_TYPE nodes is uninteresting and we stop as soon
+	  addr_space_t as_to = TYPE_ADDR_SPACE (TREE_TYPE (type));
-	     as we hit a non-POINTER_TYPE node on either type.  */
+	  addr_space_t as_from = TYPE_ADDR_SPACE (TREE_TYPE (otype));
-	  do
+	  addr_space_t as_common;
+	  if (!addr_space_superset (as_to, as_from, &as_common))
 	    {
-	      in_otype = TREE_TYPE (in_otype);
+	      if (ADDR_SPACE_GENERIC_P (as_from))
-	      in_type = TREE_TYPE (in_type);
+		warning_at (loc, 0, "cast to %s address space pointer "
+			    "from disjoint generic address space pointer",
-	      /* GNU C allows cv-qualified function types.  'const'
+			    c_addr_space_name (as_to));
-		 means the function is very pure, 'volatile' means it
-		 can't return.  We need to warn when such qualifiers
+	      else if (ADDR_SPACE_GENERIC_P (as_to))
-		 are added, not when they're taken away.  */
+		warning_at (loc, 0, "cast to generic address space pointer "
-	      if (TREE_CODE (in_otype) == FUNCTION_TYPE
+			    "from disjoint %s address space pointer",
-		  && TREE_CODE (in_type) == FUNCTION_TYPE)
+			    c_addr_space_name (as_from));
-		added |= (TYPE_QUALS (in_type) & ~TYPE_QUALS (in_otype));
 	      else
-		discarded |= (TYPE_QUALS (in_otype) & ~TYPE_QUALS (in_type));
+		warning_at (loc, 0, "cast to %s address space pointer "
+			    "from disjoint %s address space pointer",
+			    c_addr_space_name (as_to),
+			    c_addr_space_name (as_from));
 	    }
-	  while (TREE_CODE (in_type) == POINTER_TYPE
-		 && TREE_CODE (in_otype) == POINTER_TYPE);
-	  if (added)
-	    warning (OPT_Wcast_qual, "cast adds new qualifiers to function type");
-	  if (discarded)
-	    /* There are qualifiers present in IN_OTYPE that are not
-	       present in IN_TYPE.  */
-	    warning (OPT_Wcast_qual, "cast discards qualifiers from pointer target type");
 	}
 /* Warn about possible alignment problems.  */
 if (STRICT_ALIGNMENT
 	  && TREE_CODE (type) == POINTER_TYPE
 	     restriction is unknown.  */
 	  && !((TREE_CODE (TREE_TYPE (otype)) == UNION_TYPE
 		|| TREE_CODE (TREE_TYPE (otype)) == RECORD_TYPE)
 	       && TYPE_MODE (TREE_TYPE (otype)) == VOIDmode)
 	  && TYPE_ALIGN (TREE_TYPE (type)) > TYPE_ALIGN (TREE_TYPE (otype)))
-	warning (OPT_Wcast_align,
+	warning_at (loc, OPT_Wcast_align,
-		 "cast increases required alignment of target type");
+		    "cast increases required alignment of target type");
 if (TREE_CODE (type) == INTEGER_TYPE
 	  && TREE_CODE (otype) == POINTER_TYPE
 	  && TYPE_PRECISION (type) != TYPE_PRECISION (otype))
 /* Unlike conversion of integers to pointers, where the
 warning is disabled for converting constants because
 of cases such as SIG_*, warn about converting constant
 pointers to integers. In some cases it may cause unwanted
 sign extension, and a warning is appropriate.  */
-	warning (OPT_Wpointer_to_int_cast,
+	warning_at (loc, OPT_Wpointer_to_int_cast,
-		 "cast from pointer to integer of different size");
+		    "cast from pointer to integer of different size");
 if (TREE_CODE (value) == CALL_EXPR
 	  && TREE_CODE (type) != TREE_CODE (otype))
-	warning (OPT_Wbad_function_cast, "cast from function call of type %qT "
+	warning_at (loc, OPT_Wbad_function_cast,
-		 "to non-matching type %qT", otype, type);
+		    "cast from function call of type %qT "
+		    "to non-matching type %qT", otype, type);
 if (TREE_CODE (type) == POINTER_TYPE
 	  && TREE_CODE (otype) == INTEGER_TYPE
 	  && TYPE_PRECISION (type) != TYPE_PRECISION (otype)
 	  /* Don't warn about converting any constant.  */
 	  && !TREE_CONSTANT (value))
-	warning (OPT_Wint_to_pointer_cast, "cast to pointer from integer "
+	warning_at (loc,
-		 "of different size");
+		    OPT_Wint_to_pointer_cast, "cast to pointer from integer "
+		    "of different size");
 if (warn_strict_aliasing <= 2)
 strict_aliasing_warning (otype, type, expr);
 /* If pedantic, warn for conversions between function and object
 if (pedantic
 	  && TREE_CODE (type) == POINTER_TYPE
 	  && TREE_CODE (otype) == POINTER_TYPE
 	  && TREE_CODE (TREE_TYPE (otype)) == FUNCTION_TYPE
 	  && TREE_CODE (TREE_TYPE (type)) != FUNCTION_TYPE)
-	pedwarn (input_location, OPT_pedantic, "ISO C forbids "
+	pedwarn (loc, OPT_pedantic, "ISO C forbids "
 		 "conversion of function pointer to object pointer type");
 if (pedantic
 	  && TREE_CODE (type) == POINTER_TYPE
 	  && TREE_CODE (otype) == POINTER_TYPE
 	  && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE
 	  && TREE_CODE (TREE_TYPE (otype)) != FUNCTION_TYPE
 	  && !null_pointer_constant_p (value))
-	pedwarn (input_location, OPT_pedantic, "ISO C forbids "
+	pedwarn (loc, OPT_pedantic, "ISO C forbids "
 		 "conversion of object pointer to function pointer type");
 ovalue = value;
 value = convert (type, value);
 /* Ignore any integer overflow caused by the cast.  */
-if (TREE_CODE (value) == INTEGER_CST)
+if (TREE_CODE (value) == INTEGER_CST && !FLOAT_TYPE_P (otype))
 	{
 	  if (CONSTANT_CLASS_P (ovalue) && TREE_OVERFLOW (ovalue))
 	    {
 	      if (!TREE_OVERFLOW (value))
 		{
 	}
 }
 /* Don't let a cast be an lvalue.  */
 if (value == expr)
-value = non_lvalue (value);
+value = non_lvalue_loc (loc, value);
+/* Don't allow the results of casting to floating-point or complex
+types be confused with actual constants, or casts involving
+integer and pointer types other than direct integer-to-integer
+and integer-to-pointer be confused with integer constant
+expressions and null pointer constants.  */
+if (TREE_CODE (value) == REAL_CST
+|| TREE_CODE (value) == COMPLEX_CST
+|| (TREE_CODE (value) == INTEGER_CST
+	  && !((TREE_CODE (expr) == INTEGER_CST
+		&& INTEGRAL_TYPE_P (TREE_TYPE (expr)))
+	       || TREE_CODE (expr) == REAL_CST
+	       || TREE_CODE (expr) == COMPLEX_CST)))
+value = build1 (NOP_EXPR, type, value);
+if (CAN_HAVE_LOCATION_P (value))
+SET_EXPR_LOCATION (value, loc);
 return value;
 }
-/* Interpret a cast of expression EXPR to type TYPE.  */
+/* Interpret a cast of expression EXPR to type TYPE.  LOC is the
+location of the open paren of the cast, or the position of the cast
+expr.  */
 tree
-c_cast_expr (struct c_type_name *type_name, tree expr)
+c_cast_expr (location_t loc, struct c_type_name *type_name, tree expr)
 {
 tree type;
+tree type_expr = NULL_TREE;
+bool type_expr_const = true;
+tree ret;
 int saved_wsp = warn_strict_prototypes;
 /* This avoids warnings about unprototyped casts on
 integers.  E.g. "#define SIG_DFL (void(*)())0".  */
 if (TREE_CODE (expr) == INTEGER_CST)
 warn_strict_prototypes = 0;
-type = groktypename (type_name);
+type = groktypename (type_name, &type_expr, &type_expr_const);
 warn_strict_prototypes = saved_wsp;
-return build_c_cast (type, expr);
+ret = build_c_cast (loc, type, expr);
+if (type_expr)
+{
+ret = build2 (C_MAYBE_CONST_EXPR, TREE_TYPE (ret), type_expr, ret);
+C_MAYBE_CONST_EXPR_NON_CONST (ret) = !type_expr_const;
+SET_EXPR_LOCATION (ret, loc);
+}
+if (CAN_HAVE_LOCATION_P (ret) && !EXPR_HAS_LOCATION (ret))
+SET_EXPR_LOCATION (ret, loc);
+/* C++ does not permits types to be defined in a cast.  */
+if (warn_cxx_compat && type_name->specs->tag_defined_p)
+warning_at (loc, OPT_Wc___compat,
+		"defining a type in a cast is invalid in C++");
+return ret;
 }
 /* Build an assignment expression of lvalue LHS from value RHS.
+If LHS_ORIGTYPE is not NULL, it is the original type of LHS, which
+may differ from TREE_TYPE (LHS) for an enum bitfield.
 MODIFYCODE is the code for a binary operator that we use
 to combine the old value of LHS with RHS to get the new value.
 Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment.
+If RHS_ORIGTYPE is not NULL_TREE, it is the original type of RHS,
-LOCATION is the location of the MODIFYCODE operator.  */
+which may differ from TREE_TYPE (RHS) for an enum value.
+LOCATION is the location of the MODIFYCODE operator.
+RHS_LOC is the location of the RHS.  */
 tree
-build_modify_expr (location_t location,
+build_modify_expr (location_t location, tree lhs, tree lhs_origtype,
-		   tree lhs, enum tree_code modifycode, tree rhs)
+		   enum tree_code modifycode,
+		   location_t rhs_loc, tree rhs, tree rhs_origtype)
 {
 tree result;
 tree newrhs;
+tree rhs_semantic_type = NULL_TREE;
 tree lhstype = TREE_TYPE (lhs);
 tree olhstype = lhstype;
+bool npc;
 /* Types that aren't fully specified cannot be used in assignments.  */
 lhs = require_complete_type (lhs);
 /* Avoid duplicate error messages from operands that had errors.  */
 return error_mark_node;
 if (!lvalue_or_else (lhs, lv_assign))
 return error_mark_node;
-STRIP_TYPE_NOPS (rhs);
+if (TREE_CODE (rhs) == EXCESS_PRECISION_EXPR)
+{
+rhs_semantic_type = TREE_TYPE (rhs);
+rhs = TREE_OPERAND (rhs, 0);
+}
 newrhs = rhs;
+if (TREE_CODE (lhs) == C_MAYBE_CONST_EXPR)
+{
+tree inner = build_modify_expr (location, C_MAYBE_CONST_EXPR_EXPR (lhs),
+				      lhs_origtype, modifycode, rhs_loc, rhs,
+				      rhs_origtype);
+if (inner == error_mark_node)
+	return error_mark_node;
+result = build2 (C_MAYBE_CONST_EXPR, TREE_TYPE (inner),
+		       C_MAYBE_CONST_EXPR_PRE (lhs), inner);
+gcc_assert (!C_MAYBE_CONST_EXPR_INT_OPERANDS (lhs));
+C_MAYBE_CONST_EXPR_NON_CONST (result) = 1;
+protected_set_expr_location (result, location);
+return result;
+}
 /* If a binary op has been requested, combine the old LHS value with the RHS
 producing the value we should actually store into the LHS.  */
 if (modifycode != NOP_EXPR)
 {
+lhs = c_fully_fold (lhs, false, NULL);
 lhs = stabilize_reference (lhs);
 newrhs = build_binary_op (location,
 				modifycode, lhs, rhs, 1);
+/* The original type of the right hand side is no longer
+	 meaningful.  */
+rhs_origtype = NULL_TREE;
 }
 /* Give an error for storing in something that is 'const'.  */
-if (TREE_READONLY (lhs) || TYPE_READONLY (lhstype)
+if (TYPE_READONLY (lhstype)
 || ((TREE_CODE (lhstype) == RECORD_TYPE
 	   || TREE_CODE (lhstype) == UNION_TYPE)
 	  && C_TYPE_FIELDS_READONLY (lhstype)))
 {
 readonly_error (lhs, lv_assign);
 return error_mark_node;
 }
+else if (TREE_READONLY (lhs))
+readonly_warning (lhs, lv_assign);
 /* If storing into a structure or union member,
 it has probably been given type `int'.
 Compute the type that would go with
 the actual amount of storage the member occupies.  */
 {
 lhs = copy_node (lhs);
 TREE_TYPE (lhs) = lhstype;
 }
-/* Convert new value to destination type.  */
+/* Issue -Wc++-compat warnings about an assignment to an enum type
+when LHS does not have its original type.  This happens for,
-newrhs = convert_for_assignment (lhstype, newrhs, ic_assign,
+e.g., an enum bitfield in a struct.  */
-				   NULL_TREE, NULL_TREE, 0);
+if (warn_cxx_compat
+&& lhs_origtype != NULL_TREE
+&& lhs_origtype != lhstype
+&& TREE_CODE (lhs_origtype) == ENUMERAL_TYPE)
+{
+tree checktype = (rhs_origtype != NULL_TREE
+			? rhs_origtype
+			: TREE_TYPE (rhs));
+if (checktype != error_mark_node
+	  && TYPE_MAIN_VARIANT (checktype) != TYPE_MAIN_VARIANT (lhs_origtype))
+	warning_at (location, OPT_Wc___compat,
+		    "enum conversion in assignment is invalid in C++");
+}
+/* Convert new value to destination type.  Fold it first, then
+restore any excess precision information, for the sake of
+conversion warnings.  */
+npc = null_pointer_constant_p (newrhs);
+newrhs = c_fully_fold (newrhs, false, NULL);
+if (rhs_semantic_type)
+newrhs = build1 (EXCESS_PRECISION_EXPR, rhs_semantic_type, newrhs);
+newrhs = convert_for_assignment (location, lhstype, newrhs, rhs_origtype,
+				   ic_assign, npc, NULL_TREE, NULL_TREE, 0);
 if (TREE_CODE (newrhs) == ERROR_MARK)
 return error_mark_node;
 /* Emit ObjC write barrier, if necessary.  */
 if (c_dialect_objc () && flag_objc_gc)
 as the LHS argument.  */
 if (olhstype == TREE_TYPE (result))
 return result;
-result = convert_for_assignment (olhstype, result, ic_assign,
+result = convert_for_assignment (location, olhstype, result, rhs_origtype,
-				   NULL_TREE, NULL_TREE, 0);
+				   ic_assign, false, NULL_TREE, NULL_TREE, 0);
 protected_set_expr_location (result, location);
 return result;
 }
-/* Convert value RHS to type TYPE as preparation for an assignment
+/* Convert value RHS to type TYPE as preparation for an assignment to
-to an lvalue of type TYPE.
+an lvalue of type TYPE.  If ORIGTYPE is not NULL_TREE, it is the
+original type of RHS; this differs from TREE_TYPE (RHS) for enum
+types.  NULL_POINTER_CONSTANT says whether RHS was a null pointer
+constant before any folding.
 The real work of conversion is done by `convert'.
 The purpose of this function is to generate error messages
 for assignments that are not allowed in C.
 ERRTYPE says whether it is argument passing, assignment,
 initialization or return.
+LOCATION is the location of the RHS.
 FUNCTION is a tree for the function being called.
 PARMNUM is the number of the argument, for printing in error messages.  */
 static tree
-convert_for_assignment (tree type, tree rhs, enum impl_conv errtype,
+convert_for_assignment (location_t location, tree type, tree rhs,
-			tree fundecl, tree function, int parmnum)
+			tree origtype, enum impl_conv errtype,
+			bool null_pointer_constant, tree fundecl,
+			tree function, int parmnum)
 {
 enum tree_code codel = TREE_CODE (type);
+tree orig_rhs = rhs;
 tree rhstype;
 enum tree_code coder;
 tree rname = NULL_TREE;
 bool objc_ok = false;
 }
 /* This macro is used to emit diagnostics to ensure that all format
 strings are complete sentences, visible to gettext and checked at
 compile time.  */
-#define WARN_FOR_ASSIGNMENT(LOCATION, OPT, AR, AS, IN, RE)               \
+#define WARN_FOR_ASSIGNMENT(LOCATION, OPT, AR, AS, IN, RE)             	 \
 do {                                                                   \
 switch (errtype)                                                     \
 {                                                                  \
 case ic_argpass:                                                   \
 if (pedwarn (LOCATION, OPT, AR, parmnum, rname))                 \
-inform ((fundecl && !DECL_IS_BUILTIN (fundecl))                \
+inform ((fundecl && !DECL_IS_BUILTIN (fundecl))	         \
-		  ? DECL_SOURCE_LOCATION (fundecl) : LOCATION,           \
+	      	  ? DECL_SOURCE_LOCATION (fundecl) : LOCATION,		 \
 "expected %qT but argument is of type %qT",            \
 type, rhstype);                                        \
 break;                                                           \
 case ic_assign:                                                    \
 pedwarn (LOCATION, OPT, AS);                                     \
 break;                                                           \
 case ic_init:                                                      \
 pedwarn (LOCATION, OPT, IN);                                     \
 break;                                                           \
 case ic_return:                                                    \
-pedwarn (LOCATION, OPT, RE);                                     \
+pedwarn (LOCATION, OPT, RE);                                 	 \
 break;                                                           \
 default:                                                           \
 gcc_unreachable ();                                              \
 }                                                                  \
 } while (0)
-STRIP_TYPE_NOPS (rhs);
+if (TREE_CODE (rhs) == EXCESS_PRECISION_EXPR)
+rhs = TREE_OPERAND (rhs, 0);
-if (optimize && TREE_CODE (rhs) == VAR_DECL
-	   && TREE_CODE (TREE_TYPE (rhs)) != ARRAY_TYPE)
-rhs = decl_constant_value_for_broken_optimization (rhs);
 rhstype = TREE_TYPE (rhs);
 coder = TREE_CODE (rhstype);
 if (coder == ERROR_MARK)
 	  parmno = parmnum;
 	  break;
 	}
 objc_ok = objc_compare_types (type, rhstype, parmno, rname);
+}
+if (warn_cxx_compat)
+{
+tree checktype = origtype != NULL_TREE ? origtype : rhstype;
+if (checktype != error_mark_node
+	  && TREE_CODE (type) == ENUMERAL_TYPE
+	  && TYPE_MAIN_VARIANT (checktype) != TYPE_MAIN_VARIANT (type))
+	{
+	  WARN_FOR_ASSIGNMENT (input_location, OPT_Wc___compat,
+			       G_("enum conversion when passing argument "
+				  "%d of %qE is invalid in C++"),
+			       G_("enum conversion in assignment is "
+				  "invalid in C++"),
+			       G_("enum conversion in initialization is "
+				  "invalid in C++"),
+			       G_("enum conversion in return is "
+				  "invalid in C++"));
+	}
 }
 if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (rhstype))
 return rhs;
 /* Except for passing an argument to an unprototyped function,
 	 this is a constraint violation.  When passing an argument to
 	 an unprototyped function, it is compile-time undefined;
 	 making it a constraint in that case was rejected in
 	 DR#252.  */
-error ("void value not ignored as it ought to be");
+error_at (location, "void value not ignored as it ought to be");
 return error_mark_node;
 }
 rhs = require_complete_type (rhs);
 if (rhs == error_mark_node)
 return error_mark_node;
 if (codel == REFERENCE_TYPE
 && comptypes (TREE_TYPE (type), TREE_TYPE (rhs)) == 1)
 {
 if (!lvalue_p (rhs))
 	{
-	  error ("cannot pass rvalue to reference parameter");
+	  error_at (location, "cannot pass rvalue to reference parameter");
 	  return error_mark_node;
 	}
 if (!c_mark_addressable (rhs))
 	return error_mark_node;
 rhs = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (rhs)), rhs);
+SET_EXPR_LOCATION (rhs, location);
 /* We already know that these two types are compatible, but they
 	 may not be exactly identical.  In fact, `TREE_TYPE (type)' is
 	 likely to be __builtin_va_list and `TREE_TYPE (rhs)' is
 	 likely to be va_list, a typedef to __builtin_va_list, which
 	 is different enough that it will cause problems later.  */
 if (TREE_TYPE (TREE_TYPE (rhs)) != TREE_TYPE (type))
-	rhs = build1 (NOP_EXPR, build_pointer_type (TREE_TYPE (type)), rhs);
+	{
+	  rhs = build1 (NOP_EXPR, build_pointer_type (TREE_TYPE (type)), rhs);
+	  SET_EXPR_LOCATION (rhs, location);
+	}
 rhs = build1 (NOP_EXPR, type, rhs);
+SET_EXPR_LOCATION (rhs, location);
 return rhs;
 }
 /* Some types can interconvert without explicit casts.  */
 else if (codel == VECTOR_TYPE && coder == VECTOR_TYPE
 	   && vector_types_convertible_p (type, TREE_TYPE (rhs), true))
 	    || codel == BOOLEAN_TYPE)
 	   && (coder == INTEGER_TYPE || coder == REAL_TYPE
 	       || coder == FIXED_POINT_TYPE
 	       || coder == ENUMERAL_TYPE || coder == COMPLEX_TYPE
 	       || coder == BOOLEAN_TYPE))
-return convert_and_check (type, rhs);
+{
+tree ret;
+bool save = in_late_binary_op;
+if (codel == BOOLEAN_TYPE)
+	in_late_binary_op = true;
+ret = convert_and_check (type, orig_rhs);
+if (codel == BOOLEAN_TYPE)
+	in_late_binary_op = save;
+return ret;
+}
 /* Aggregates in different TUs might need conversion.  */
 if ((codel == RECORD_TYPE || codel == UNION_TYPE)
 && codel == coder
 && comptypes (type, rhstype))
 	      /* Any non-function converts to a [const][volatile] void *
 		 and vice versa; otherwise, targets must be the same.
 		 Meanwhile, the lhs target must have all the qualifiers of
 		 the rhs.  */
 	      if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr)
-		  || comp_target_types (memb_type, rhstype))
+		  || comp_target_types (location, memb_type, rhstype))
 		{
 		  /* If this type won't generate any warnings, use it.  */
 		  if (TYPE_QUALS (ttl) == TYPE_QUALS (ttr)
 		      || ((TREE_CODE (ttr) == FUNCTION_TYPE
 			   && TREE_CODE (ttl) == FUNCTION_TYPE)
 		    marginal_memb = memb;
 		}
 	    }
 	  /* Can convert integer zero to any pointer type.  */
-	  if (null_pointer_constant_p (rhs))
+	  if (null_pointer_constant)
 	    {
 	      rhs = null_pointer_node;
 	      break;
 	    }
 	}
 		  /* Because const and volatile on functions are
 		     restrictions that say the function will not do
 		     certain things, it is okay to use a const or volatile
 		     function where an ordinary one is wanted, but not
 		     vice-versa.  */
-		  if (TYPE_QUALS (ttl) & ~TYPE_QUALS (ttr))
+		  if (TYPE_QUALS_NO_ADDR_SPACE (ttl)
-		    WARN_FOR_ASSIGNMENT (input_location, 0,
+		      & ~TYPE_QUALS_NO_ADDR_SPACE (ttr))
+		    WARN_FOR_ASSIGNMENT (location, 0,
 					 G_("passing argument %d of %qE "
 					    "makes qualified function "
 					    "pointer from unqualified"),
 					 G_("assignment makes qualified "
 					    "function pointer from "
 					    "function pointer from "
 					    "unqualified"),
 					 G_("return makes qualified function "
 					    "pointer from unqualified"));
 		}
-	      else if (TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl))
+	      else if (TYPE_QUALS_NO_ADDR_SPACE (ttr)
-		WARN_FOR_ASSIGNMENT (input_location, 0,
+		       & ~TYPE_QUALS_NO_ADDR_SPACE (ttl))
+		WARN_FOR_ASSIGNMENT (location, 0,
 				     G_("passing argument %d of %qE discards "
 					"qualifiers from pointer target type"),
 				     G_("assignment discards qualifiers "
 					"from pointer target type"),
 				     G_("initialization discards qualifiers "
 	      memb = marginal_memb;
 	    }
 	  if (!fundecl || !DECL_IN_SYSTEM_HEADER (fundecl))
-	    pedwarn (input_location, OPT_pedantic,
+	    pedwarn (location, OPT_pedantic,
 		     "ISO C prohibits argument conversion to union type");
-	  rhs = fold_convert (TREE_TYPE (memb), rhs);
+	  rhs = fold_convert_loc (location, TREE_TYPE (memb), rhs);
 	  return build_constructor_single (type, memb, rhs);
 	}
 }
 /* Conversions among pointers */
 tree ttr = TREE_TYPE (rhstype);
 tree mvl = ttl;
 tree mvr = ttr;
 bool is_opaque_pointer;
 int target_cmp = 0;   /* Cache comp_target_types () result.  */
+addr_space_t asl;
+addr_space_t asr;
 if (TREE_CODE (mvl) != ARRAY_TYPE)
 	mvl = TYPE_MAIN_VARIANT (mvl);
 if (TREE_CODE (mvr) != ARRAY_TYPE)
 	mvr = TYPE_MAIN_VARIANT (mvr);
 		int *p = NULL;
 	 where NULL is typically defined in C to be '(void *) 0'.  */
 if (VOID_TYPE_P (ttr) && rhs != null_pointer_node && !VOID_TYPE_P (ttl))
-	warning (OPT_Wc___compat, "request for implicit conversion from "
+	warning_at (location, OPT_Wc___compat,
-		 "%qT to %qT not permitted in C++", rhstype, type);
+	    	    "request for implicit conversion "
+		    "from %qT to %qT not permitted in C++", rhstype, type);
+/* See if the pointers point to incompatible address spaces.  */
+asl = TYPE_ADDR_SPACE (ttl);
+asr = TYPE_ADDR_SPACE (ttr);
+if (!null_pointer_constant_p (rhs)
+	  && asr != asl && !targetm.addr_space.subset_p (asr, asl))
+	{
+	  switch (errtype)
+	    {
+	    case ic_argpass:
+	      error_at (location, "passing argument %d of %qE from pointer to "
+			"non-enclosed address space", parmnum, rname);
+	      break;
+	    case ic_assign:
+	      error_at (location, "assignment from pointer to "
+			"non-enclosed address space");
+	      break;
+	    case ic_init:
+	      error_at (location, "initialization from pointer to "
+			"non-enclosed address space");
+	      break;
+	    case ic_return:
+	      error_at (location, "return from pointer to "
+			"non-enclosed address space");
+	      break;
+	    default:
+	      gcc_unreachable ();
+	    }
+	  return error_mark_node;
+	}
 /* Check if the right-hand side has a format attribute but the
 	 left-hand side doesn't.  */
 if (warn_missing_format_attribute
 	  && check_missing_format_attribute (type, rhstype))
 	{
 	  switch (errtype)
 	  {
 	  case ic_argpass:
-	    warning (OPT_Wmissing_format_attribute,
+	    warning_at (location, OPT_Wmissing_format_attribute,
-		     "argument %d of %qE might be "
+			"argument %d of %qE might be "
-		     "a candidate for a format attribute",
+			"a candidate for a format attribute",
-		     parmnum, rname);
+			parmnum, rname);
 	    break;
 	  case ic_assign:
-	    warning (OPT_Wmissing_format_attribute,
+	    warning_at (location, OPT_Wmissing_format_attribute,
-		     "assignment left-hand side might be "
+			"assignment left-hand side might be "
-		     "a candidate for a format attribute");
+			"a candidate for a format attribute");
 	    break;
 	  case ic_init:
-	    warning (OPT_Wmissing_format_attribute,
+	    warning_at (location, OPT_Wmissing_format_attribute,
-		     "initialization left-hand side might be "
+			"initialization left-hand side might be "
-		     "a candidate for a format attribute");
+			"a candidate for a format attribute");
 	    break;
 	  case ic_return:
-	    warning (OPT_Wmissing_format_attribute,
+	    warning_at (location, OPT_Wmissing_format_attribute,
-		     "return type might be "
+			"return type might be "
-		     "a candidate for a format attribute");
+			"a candidate for a format attribute");
 	    break;
 	  default:
 	    gcc_unreachable ();
 	  }
 	}
 /* Any non-function converts to a [const][volatile] void *
 	 and vice versa; otherwise, targets must be the same.
 	 Meanwhile, the lhs target must have all the qualifiers of the rhs.  */
 if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr)
-	  || (target_cmp = comp_target_types (type, rhstype))
+	  || (target_cmp = comp_target_types (location, type, rhstype))
 	  || is_opaque_pointer
 	  || (c_common_unsigned_type (mvl)
 	      == c_common_unsigned_type (mvr)))
 	{
 	  if (pedantic
 	      && ((VOID_TYPE_P (ttl) && TREE_CODE (ttr) == FUNCTION_TYPE)
 		  ||
 		  (VOID_TYPE_P (ttr)
-		   && !null_pointer_constant_p (rhs)
+		   && !null_pointer_constant
 		   && TREE_CODE (ttl) == FUNCTION_TYPE)))
-	    WARN_FOR_ASSIGNMENT (input_location, OPT_pedantic,
+	    WARN_FOR_ASSIGNMENT (location, OPT_pedantic,
 				 G_("ISO C forbids passing argument %d of "
 				    "%qE between function pointer "
 				    "and %<void *%>"),
 				 G_("ISO C forbids assignment between "
 				    "function pointer and %<void *%>"),
 	  /* Const and volatile mean something different for function types,
 	     so the usual warnings are not appropriate.  */
 	  else if (TREE_CODE (ttr) != FUNCTION_TYPE
 		   && TREE_CODE (ttl) != FUNCTION_TYPE)
 	    {
-	      if (TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl))
+	      if (TYPE_QUALS_NO_ADDR_SPACE (ttr)
+		  & ~TYPE_QUALS_NO_ADDR_SPACE (ttl))
 		{
 		  /* Types differing only by the presence of the 'volatile'
 		     qualifier are acceptable if the 'volatile' has been added
 		     in by the Objective-C EH machinery.  */
 		  if (!objc_type_quals_match (ttl, ttr))
-		    WARN_FOR_ASSIGNMENT (input_location, 0,
+		    WARN_FOR_ASSIGNMENT (location, 0,
 					 G_("passing argument %d of %qE discards "
 					    "qualifiers from pointer target type"),
 					 G_("assignment discards qualifiers "
 					    "from pointer target type"),
 					 G_("initialization discards qualifiers "
 	      else if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr)
 		       || target_cmp)
 		;
 	      /* If there is a mismatch, do warn.  */
 	      else if (warn_pointer_sign)
-		WARN_FOR_ASSIGNMENT (input_location, OPT_Wpointer_sign,
+		WARN_FOR_ASSIGNMENT (location, OPT_Wpointer_sign,
 				     G_("pointer targets in passing argument "
 					"%d of %qE differ in signedness"),
 				     G_("pointer targets in assignment "
 					"differ in signedness"),
 				     G_("pointer targets in initialization "
 	    {
 	      /* Because const and volatile on functions are restrictions
 		 that say the function will not do certain things,
 		 it is okay to use a const or volatile function
 		 where an ordinary one is wanted, but not vice-versa.  */
-	      if (TYPE_QUALS (ttl) & ~TYPE_QUALS (ttr))
+	      if (TYPE_QUALS_NO_ADDR_SPACE (ttl)
-		WARN_FOR_ASSIGNMENT (input_location, 0,
+		  & ~TYPE_QUALS_NO_ADDR_SPACE (ttr))
+		WARN_FOR_ASSIGNMENT (location, 0,
 				     G_("passing argument %d of %qE makes "
 					"qualified function pointer "
 					"from unqualified"),
 				     G_("assignment makes qualified function "
 					"pointer from unqualified"),
 	    }
 	}
 else
 	/* Avoid warning about the volatile ObjC EH puts on decls.  */
 	if (!objc_ok)
-	  WARN_FOR_ASSIGNMENT (input_location, 0,
+	  WARN_FOR_ASSIGNMENT (location, 0,
 			       G_("passing argument %d of %qE from "
 				  "incompatible pointer type"),
 			       G_("assignment from incompatible pointer type"),
 			       G_("initialization from incompatible "
 				  "pointer type"),
 }
 else if (codel == POINTER_TYPE && coder == ARRAY_TYPE)
 {
 /* ??? This should not be an error when inlining calls to
 	 unprototyped functions.  */
-error ("invalid use of non-lvalue array");
+error_at (location, "invalid use of non-lvalue array");
 return error_mark_node;
 }
 else if (codel == POINTER_TYPE && coder == INTEGER_TYPE)
 {
 /* An explicit constant 0 can convert to a pointer,
 	 or one that results from arithmetic, even including
 	 a cast to integer type.  */
-if (!null_pointer_constant_p (rhs))
+if (!null_pointer_constant)
-	WARN_FOR_ASSIGNMENT (input_location, 0,
+	WARN_FOR_ASSIGNMENT (location, 0,
 			     G_("passing argument %d of %qE makes "
 				"pointer from integer without a cast"),
 			     G_("assignment makes pointer from integer "
 				"without a cast"),
 			     G_("initialization makes pointer from "
 return convert (type, rhs);
 }
 else if (codel == INTEGER_TYPE && coder == POINTER_TYPE)
 {
-WARN_FOR_ASSIGNMENT (input_location, 0,
+WARN_FOR_ASSIGNMENT (location, 0,
 			   G_("passing argument %d of %qE makes integer "
 			      "from pointer without a cast"),
 			   G_("assignment makes integer from pointer "
 			      "without a cast"),
 			   G_("initialization makes integer from pointer "
 			   G_("return makes integer from pointer "
 			      "without a cast"));
 return convert (type, rhs);
 }
 else if (codel == BOOLEAN_TYPE && coder == POINTER_TYPE)
-return convert (type, rhs);
+{
+tree ret;
+bool save = in_late_binary_op;
+in_late_binary_op = true;
+ret = convert (type, rhs);
+in_late_binary_op = save;
+return ret;
+}
 switch (errtype)
 {
 case ic_argpass:
-error ("incompatible type for argument %d of %qE", parmnum, rname);
+error_at (location, "incompatible type for argument %d of %qE", parmnum, rname);
 inform ((fundecl && !DECL_IS_BUILTIN (fundecl))
 	      ? DECL_SOURCE_LOCATION (fundecl) : input_location,
 	      "expected %qT but argument is of type %qT", type, rhstype);
 break;
 case ic_assign:
-error ("incompatible types when assigning to type %qT from type %qT",
+error_at (location, "incompatible types when assigning to type %qT from "
-	     type, rhstype);
+		"type %qT", type, rhstype);
 break;
 case ic_init:
-error ("incompatible types when initializing type %qT using type %qT",
+error_at (location,
-	     type, rhstype);
+	  	"incompatible types when initializing type %qT using type %qT",
+		type, rhstype);
 break;
 case ic_return:
-error ("incompatible types when returning type %qT but %qT was expected",
+error_at (location,
-	     rhstype, type);
+	  	"incompatible types when returning type %qT but %qT was "
+		"expected", rhstype, type);
 break;
 default:
 gcc_unreachable ();
 }
 }
 /* Perform appropriate conversions on the initial value of a variable,
 store it in the declaration DECL,
 and print any error messages that are appropriate.
-If the init is invalid, store an ERROR_MARK.  */
+If ORIGTYPE is not NULL_TREE, it is the original type of INIT.
+If the init is invalid, store an ERROR_MARK.
+INIT_LOC is the location of the initial value.  */
 void
-store_init_value (tree decl, tree init)
+store_init_value (location_t init_loc, tree decl, tree init, tree origtype)
 {
 tree value, type;
+bool npc = false;
 /* If variable's type was invalidly declared, just ignore it.  */
 type = TREE_TYPE (decl);
 if (TREE_CODE (type) == ERROR_MARK)
 return;
 /* Digest the specified initializer into an expression.  */
-value = digest_init (type, init, true, TREE_STATIC (decl));
+if (init)
+npc = null_pointer_constant_p (init);
+value = digest_init (init_loc, type, init, origtype, npc,
+		       true, TREE_STATIC (decl));
 /* Store the expression if valid; else report error.  */
 if (!in_system_header
 && AGGREGATE_TYPE_P (TREE_TYPE (decl)) && !TREE_STATIC (decl))
 DECL_INITIAL (decl) = value;
 /* ANSI wants warnings about out-of-range constant initializers.  */
 STRIP_TYPE_NOPS (value);
 if (TREE_STATIC (decl))
 constant_expression_warning (value);
 /* Check if we need to set array size from compound literal size.  */
 if (TREE_CODE (type) == ARRAY_TYPE
 && TYPE_DOMAIN (type) == 0
 static void
 push_member_name (tree decl)
 {
 const char *const string
-= DECL_NAME (decl) ? IDENTIFIER_POINTER (DECL_NAME (decl)) : "<anonymous>";
+= (DECL_NAME (decl)
+? identifier_to_locale (IDENTIFIER_POINTER (DECL_NAME (decl)))
+: _("<anonymous>"));
 PUSH_SPELLING (SPELLING_MEMBER, string, u.s);
 }
 /* Push an array bounds on the stack.  Printed as [BOUNDS].  */
 ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
 if (*ofwhat)
 pedwarn (location, opt, "(near initialization for %qs)", ofwhat);
 }
 /* Issue a warning for a bad initializer component.
 OPT is the OPT_W* value corresponding to the warning option that
 controls this warning.  MSGID identifies the message.  The
 component name is taken from the spelling stack.  */
 {
 if (pedantic
 && TREE_CODE (type) == ARRAY_TYPE
 && TREE_CODE (expr.value) == STRING_CST
 && expr.original_code != STRING_CST)
 pedwarn_init (input_location, OPT_pedantic,
 		  "array initialized from parenthesized string constant");
 }
 /* Digest the parser output INIT as an initializer for type TYPE.
 Return a C expression of type TYPE to represent the initial value.
+If ORIGTYPE is not NULL_TREE, it is the original type of INIT.
+NULL_POINTER_CONSTANT is true if INIT is a null pointer constant.
 If INIT is a string constant, STRICT_STRING is true if it is
 unparenthesized or we should not warn here for it being parenthesized.
 For other types of INIT, STRICT_STRING is not used.
+INIT_LOC is the location of the INIT.
 REQUIRE_CONSTANT requests an error if non-constant initializers or
 elements are seen.  */
 static tree
-digest_init (tree type, tree init, bool strict_string, int require_constant)
+digest_init (location_t init_loc, tree type, tree init, tree origtype,
+	     bool null_pointer_constant, bool strict_string,
+	     int require_constant)
 {
 enum tree_code code = TREE_CODE (type);
 tree inside_init = init;
+tree semantic_type = NULL_TREE;
+bool maybe_const = true;
 if (type == error_mark_node
 || !init
 || init == error_mark_node
 || TREE_TYPE (init) == error_mark_node)
 return error_mark_node;
 STRIP_TYPE_NOPS (inside_init);
-inside_init = fold (inside_init);
+if (TREE_CODE (inside_init) == EXCESS_PRECISION_EXPR)
+{
+semantic_type = TREE_TYPE (inside_init);
+inside_init = TREE_OPERAND (inside_init, 0);
+}
+inside_init = c_fully_fold (inside_init, require_constant, &maybe_const);
+inside_init = decl_constant_value_for_optimization (inside_init);
 /* Initialization of an array of chars from a string constant
 optionally enclosed in braces.  */
 if (code == ARRAY_TYPE && inside_init
 	{
 	  struct c_expr expr;
 	  tree typ2 = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (inside_init)));
 	  expr.value = inside_init;
 	  expr.original_code = (strict_string ? STRING_CST : ERROR_MARK);
+	  expr.original_type = NULL;
 	  maybe_warn_string_init (type, expr);
+	  if (TYPE_DOMAIN (type) && !TYPE_MAX_VALUE (TYPE_DOMAIN (type)))
+	    pedwarn_init (init_loc, OPT_pedantic,
+			  "initialization of a flexible array member");
 	  if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
 			 TYPE_MAIN_VARIANT (type)))
 	    return inside_init;
 	    }
 	  TREE_TYPE (inside_init) = type;
 	  if (TYPE_DOMAIN (type) != 0
 	      && TYPE_SIZE (type) != 0
-	      && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST
+	      && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST)
+	    {
+	      unsigned HOST_WIDE_INT len = TREE_STRING_LENGTH (inside_init);
 	      /* Subtract the size of a single (possibly wide) character
 		 because it's ok to ignore the terminating null char
 		 that is counted in the length of the constant.  */
-	      && 0 > compare_tree_int (TYPE_SIZE_UNIT (type),
+	      if (0 > compare_tree_int (TYPE_SIZE_UNIT (type),
-				       TREE_STRING_LENGTH (inside_init)
+					(len
-				       - (TYPE_PRECISION (typ1)
+					 - (TYPE_PRECISION (typ1)
-					  / BITS_PER_UNIT)))
+					    / BITS_PER_UNIT))))
-	    pedwarn_init (input_location, 0,
+		pedwarn_init (init_loc, 0,
-			  "initializer-string for array of chars is too long");
+			      ("initializer-string for array of chars "
+			       "is too long"));
+	      else if (warn_cxx_compat
+		       && 0 > compare_tree_int (TYPE_SIZE_UNIT (type), len))
+		warning_at (init_loc, OPT_Wc___compat,
+			    ("initializer-string for array chars "
+			     "is too long for C++"));
+	    }
 	  return inside_init;
 	}
 else if (INTEGRAL_TYPE_P (typ1))
 	{
 	{
 	  if (TREE_CODE (TREE_TYPE (inside_init)) == ARRAY_TYPE)
 	    {
 	      if (TREE_CODE (inside_init) == STRING_CST
 		  || TREE_CODE (inside_init) == COMPOUND_LITERAL_EXPR)
-		inside_init = array_to_pointer_conversion (inside_init);
+		inside_init = array_to_pointer_conversion
+		  (init_loc, inside_init);
 	      else
 		{
 		  error_init ("invalid use of non-lvalue array");
 		  return error_mark_node;
 		}
 	{
 	  error_init ("array initialized from non-constant array expression");
 	  return error_mark_node;
 	}
-if (optimize && TREE_CODE (inside_init) == VAR_DECL)
-	inside_init = decl_constant_value_for_broken_optimization (inside_init);
 /* Compound expressions can only occur here if -pedantic or
 	 -pedantic-errors is specified.  In the later case, we always want
 	 an error.  In the former case, we simply want a warning.  */
 if (require_constant && pedantic
 	  && TREE_CODE (inside_init) == COMPOUND_EXPR)
 	    = valid_compound_expr_initializer (inside_init,
 					       TREE_TYPE (inside_init));
 	  if (inside_init == error_mark_node)
 	    error_init ("initializer element is not constant");
 	  else
-	    pedwarn_init (input_location, OPT_pedantic,
+	    pedwarn_init (init_loc, OPT_pedantic,
 			  "initializer element is not constant");
 	  if (flag_pedantic_errors)
 	    inside_init = error_mark_node;
 	}
 else if (require_constant
 						 TREE_TYPE (inside_init)))
 	{
 	  error_init ("initializer element is not constant");
 	  inside_init = error_mark_node;
 	}
+else if (require_constant && !maybe_const)
+	pedwarn_init (init_loc, 0,
+		      "initializer element is not a constant expression");
 /* Added to enable additional -Wmissing-format-attribute warnings.  */
 if (TREE_CODE (TREE_TYPE (inside_init)) == POINTER_TYPE)
-	inside_init = convert_for_assignment (type, inside_init, ic_init, NULL_TREE,
+	inside_init = convert_for_assignment (init_loc, type, inside_init,
-					      NULL_TREE, 0);
+	    				      origtype,
+					      ic_init, null_pointer_constant,
+					      NULL_TREE, NULL_TREE, 0);
 return inside_init;
 }
 /* Handle scalar types, including conversions.  */
 || code == COMPLEX_TYPE || code == VECTOR_TYPE)
 {
 if (TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE
 	  && (TREE_CODE (init) == STRING_CST
 	      || TREE_CODE (init) == COMPOUND_LITERAL_EXPR))
-	init = array_to_pointer_conversion (init);
+	inside_init = init = array_to_pointer_conversion (init_loc, init);
+if (semantic_type)
+	inside_init = build1 (EXCESS_PRECISION_EXPR, semantic_type,
+			      inside_init);
 inside_init
-	= convert_for_assignment (type, init, ic_init,
+	= convert_for_assignment (init_loc, type, inside_init, origtype,
+	    			  ic_init, null_pointer_constant,
 				  NULL_TREE, NULL_TREE, 0);
 /* Check to see if we have already given an error message.  */
 if (inside_init == error_mark_node)
 	;
 						 TREE_TYPE (inside_init)))
 	{
 	  error_init ("initializer element is not computable at load time");
 	  inside_init = error_mark_node;
 	}
+else if (require_constant && !maybe_const)
+	pedwarn_init (init_loc, 0,
+		      "initializer element is not a constant expression");
 return inside_init;
 }
 /* Come here only for records and arrays.  */
 /* 1 if so far this constructor's elements are all compile-time constants.  */
 static int constructor_constant;
 /* 1 if so far this constructor's elements are all valid address constants.  */
 static int constructor_simple;
+/* 1 if this constructor has an element that cannot be part of a
+constant expression.  */
+static int constructor_nonconst;
 /* 1 if this constructor is erroneous so far.  */
 static int constructor_erroneous;
 /* Structure for managing pending initializer elements, organized as an
 struct init_node *left, *right;
 struct init_node *parent;
 int balance;
 tree purpose;
 tree value;
+tree origtype;
 };
 /* Tree of pending elements at this constructor level.
 These are elements encountered out of order
 which belong at places we haven't reached yet in actually
 constructor at this level.  */
 struct c_expr replacement_value;
 struct constructor_range_stack *range_stack;
 char constant;
 char simple;
+char nonconst;
 char implicit;
 char erroneous;
 char outer;
 char incremental;
 char designated;
 	      even within braces.  */
 	   && (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
 	       || TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE
 	       || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE
 	       || TREE_CODE (TREE_TYPE (decl)) == QUAL_UNION_TYPE));
-locus = IDENTIFIER_POINTER (DECL_NAME (decl));
+locus = identifier_to_locale (IDENTIFIER_POINTER (DECL_NAME (decl)));
 }
 else
 {
 require_constant_value = 0;
 require_constant_elements = 0;
-locus = "(anonymous)";
+locus = _("(anonymous)");
 }
 constructor_stack = 0;
 constructor_range_stack = 0;
 struct constructor_stack *p = XNEW (struct constructor_stack);
 if (type == 0)
 type = TREE_TYPE (constructor_decl);
-if (targetm.vector_opaque_p (type))
+if (TREE_CODE (type) == VECTOR_TYPE
+&& TYPE_VECTOR_OPAQUE (type))
 error ("opaque vector types cannot be initialized");
 p->type = constructor_type;
 p->fields = constructor_fields;
 p->index = constructor_index;
 p->unfilled_fields = constructor_unfilled_fields;
 p->bit_index = constructor_bit_index;
 p->elements = constructor_elements;
 p->constant = constructor_constant;
 p->simple = constructor_simple;
+p->nonconst = constructor_nonconst;
 p->erroneous = constructor_erroneous;
 p->pending_elts = constructor_pending_elts;
 p->depth = constructor_depth;
 p->replacement_value.value = 0;
 p->replacement_value.original_code = ERROR_MARK;
+p->replacement_value.original_type = NULL;
 p->implicit = 0;
 p->range_stack = 0;
 p->outer = 0;
 p->incremental = constructor_incremental;
 p->designated = constructor_designated;
 p->next = 0;
 constructor_stack = p;
 constructor_constant = 1;
 constructor_simple = 1;
+constructor_nonconst = 0;
 constructor_depth = SPELLING_DEPTH ();
 constructor_elements = 0;
 constructor_pending_elts = 0;
 constructor_type = type;
 constructor_incremental = 1;
 p->unfilled_fields = constructor_unfilled_fields;
 p->bit_index = constructor_bit_index;
 p->elements = constructor_elements;
 p->constant = constructor_constant;
 p->simple = constructor_simple;
+p->nonconst = constructor_nonconst;
 p->erroneous = constructor_erroneous;
 p->pending_elts = constructor_pending_elts;
 p->depth = constructor_depth;
 p->replacement_value.value = 0;
 p->replacement_value.original_code = ERROR_MARK;
+p->replacement_value.original_type = NULL;
 p->implicit = implicit;
 p->outer = 0;
 p->incremental = constructor_incremental;
 p->designated = constructor_designated;
 p->next = constructor_stack;
 p->range_stack = 0;
 constructor_stack = p;
 constructor_constant = 1;
 constructor_simple = 1;
+constructor_nonconst = 0;
 constructor_depth = SPELLING_DEPTH ();
 constructor_elements = 0;
 constructor_incremental = 1;
 constructor_designated = 0;
 constructor_pending_elts = 0;
 if (value && TREE_CODE (value) == CONSTRUCTOR)
 {
 constructor_constant = TREE_CONSTANT (value);
 constructor_simple = TREE_STATIC (value);
+constructor_nonconst = CONSTRUCTOR_NON_CONST (value);
 constructor_elements = CONSTRUCTOR_ELTS (value);
 if (!VEC_empty (constructor_elt, constructor_elements)
 	  && (TREE_CODE (constructor_type) == RECORD_TYPE
 	      || TREE_CODE (constructor_type) == ARRAY_TYPE))
 	set_nonincremental_init ();
 {
 struct constructor_stack *p;
 struct c_expr ret;
 ret.value = 0;
 ret.original_code = ERROR_MARK;
+ret.original_type = NULL;
 if (implicit == 0)
 {
 /* When we come to an explicit close brace,
 	 pop any inner levels that didn't have explicit braces.  */
 					 constructor_elements);
 	  if (constructor_constant)
 	    TREE_CONSTANT (ret.value) = 1;
 	  if (constructor_constant && constructor_simple)
 	    TREE_STATIC (ret.value) = 1;
-	}
+	  if (constructor_nonconst)
+	    CONSTRUCTOR_NON_CONST (ret.value) = 1;
+	}
+}
+if (ret.value && TREE_CODE (ret.value) != CONSTRUCTOR)
+{
+if (constructor_nonconst)
+	ret.original_code = C_MAYBE_CONST_EXPR;
+else if (ret.original_code == C_MAYBE_CONST_EXPR)
+	ret.original_code = ERROR_MARK;
 }
 constructor_type = p->type;
 constructor_fields = p->fields;
 constructor_index = p->index;
 constructor_unfilled_fields = p->unfilled_fields;
 constructor_bit_index = p->bit_index;
 constructor_elements = p->elements;
 constructor_constant = p->constant;
 constructor_simple = p->simple;
+constructor_nonconst = p->nonconst;
 constructor_erroneous = p->erroneous;
 constructor_incremental = p->incremental;
 constructor_designated = p->designated;
 constructor_pending_elts = p->pending_elts;
 constructor_depth = p->depth;
 if (!INTEGRAL_TYPE_P (TREE_TYPE (first))
 || (last && !INTEGRAL_TYPE_P (TREE_TYPE (last))))
 {
 error_init ("array index in initializer not of integer type");
 return;
+}
+if (TREE_CODE (first) != INTEGER_CST)
+{
+first = c_fully_fold (first, false, NULL);
+if (TREE_CODE (first) == INTEGER_CST)
+	pedwarn_init (input_location, OPT_pedantic,
+		      "array index in initializer is not "
+		      "an integer constant expression");
+}
+if (last && TREE_CODE (last) != INTEGER_CST)
+{
+last = c_fully_fold (last, false, NULL);
+if (TREE_CODE (last) == INTEGER_CST)
+	pedwarn_init (input_location, OPT_pedantic,
+		      "array index in initializer is not "
+		      "an integer constant expression");
 }
 if (TREE_CODE (first) != INTEGER_CST)
 error_init ("nonconstant array index in initializer");
 else if (last != 0 && TREE_CODE (last) != INTEGER_CST)
 else if (constructor_max_index
 	   && tree_int_cst_lt (constructor_max_index, first))
 error_init ("array index in initializer exceeds array bounds");
 else
 {
+constant_expression_warning (first);
+if (last)
+	constant_expression_warning (last);
 constructor_index = convert (bitsizetype, first);
 if (last)
 	{
 	  if (tree_int_cst_equal (first, last))
 }
 }
 /* Add a new initializer to the tree of pending initializers.  PURPOSE
 identifies the initializer, either array index or field in a structure.
-VALUE is the value of that index or field.
+VALUE is the value of that index or field.  If ORIGTYPE is not
+NULL_TREE, it is the original type of VALUE.
 IMPLICIT is true if value comes from pop_init_level (1),
 the new initializer has been merged with the existing one
 and thus no warnings should be emitted about overriding an
 existing initializer.  */
 static void
-add_pending_init (tree purpose, tree value, bool implicit)
+add_pending_init (tree purpose, tree value, tree origtype, bool implicit)
 {
 struct init_node *p, **q, *r;
 q = &constructor_pending_elts;
 p = 0;
 		    warning_init (0, "initialized field with side-effects overwritten");
 		  else if (warn_override_init)
 		    warning_init (OPT_Woverride_init, "initialized field overwritten");
 		}
 	      p->value = value;
+	      p->origtype = origtype;
 	      return;
 	    }
 	}
 }
 else
 		    warning_init (0, "initialized field with side-effects overwritten");
 		  else if (warn_override_init)
 		    warning_init (OPT_Woverride_init, "initialized field overwritten");
 		}
 	      p->value = value;
+	      p->origtype = origtype;
 	      return;
 	    }
 	}
 }
 r = GGC_NEW (struct init_node);
 r->purpose = purpose;
 r->value = value;
+r->origtype = origtype;
 *q = r;
 r->parent = p;
 r->left = 0;
 r->right = 0;
 if (TREE_CODE (constructor_type) != RECORD_TYPE
 && TREE_CODE (constructor_type) != ARRAY_TYPE)
 return;
 FOR_EACH_CONSTRUCTOR_ELT (constructor_elements, ix, index, value)
-add_pending_init (index, value, false);
+add_pending_init (index, value, NULL_TREE, false);
 constructor_elements = 0;
 if (TREE_CODE (constructor_type) == RECORD_TYPE)
 {
 constructor_unfilled_fields = TYPE_FIELDS (constructor_type);
 /* Skip any nameless bit fields at the beginning.  */
 	    val[0] |= ((HOST_WIDE_INT) -1)
 		      << (bitpos - HOST_BITS_PER_WIDE_INT);
 	}
 value = build_int_cst_wide (type, val[1], val[0]);
-add_pending_init (purpose, value, false);
+add_pending_init (purpose, value, NULL_TREE, false);
 }
 constructor_incremental = 0;
 }
 }
 /* "Output" the next constructor element.
 At top level, really output it to assembler code now.
 Otherwise, collect it in a list from which we will make a CONSTRUCTOR.
+If ORIGTYPE is not NULL_TREE, it is the original type of VALUE.
 TYPE is the data type that the containing data type wants here.
 FIELD is the field (a FIELD_DECL) or the index that this element fills.
 If VALUE is a string constant, STRICT_STRING is true if it is
 unparenthesized or we should not warn here for it being parenthesized.
 For other types of VALUE, STRICT_STRING is not used.
 the new initializer has been merged with the existing one
 and thus no warnings should be emitted about overriding an
 existing initializer.  */
 static void
-output_init_element (tree value, bool strict_string, tree type, tree field,
+output_init_element (tree value, tree origtype, bool strict_string, tree type,
-		     int pending, bool implicit)
+		     tree field, int pending, bool implicit)
 {
+tree semantic_type = NULL_TREE;
 constructor_elt *celt;
+bool maybe_const = true;
+bool npc;
 if (type == error_mark_node || value == error_mark_node)
 {
 constructor_erroneous = 1;
 return;
 && !(TREE_CODE (value) == STRING_CST
 	   && TREE_CODE (type) == ARRAY_TYPE
 	   && INTEGRAL_TYPE_P (TREE_TYPE (type)))
 && !comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (value)),
 		     TYPE_MAIN_VARIANT (type)))
-value = array_to_pointer_conversion (value);
+value = array_to_pointer_conversion (input_location, value);
 if (TREE_CODE (value) == COMPOUND_LITERAL_EXPR
 && require_constant_value && !flag_isoc99 && pending)
 {
 /* As an extension, allow initializing objects with static storage
 	 duration with compound literals (which are then treated just as
 	 the brace enclosed list they contain).  */
 tree decl = COMPOUND_LITERAL_EXPR_DECL (value);
 value = DECL_INITIAL (decl);
 }
+npc = null_pointer_constant_p (value);
+if (TREE_CODE (value) == EXCESS_PRECISION_EXPR)
+{
+semantic_type = TREE_TYPE (value);
+value = TREE_OPERAND (value, 0);
+}
+value = c_fully_fold (value, require_constant_value, &maybe_const);
 if (value == error_mark_node)
 constructor_erroneous = 1;
 else if (!TREE_CONSTANT (value))
 constructor_constant = 0;
 	   || ((TREE_CODE (constructor_type) == RECORD_TYPE
 		|| TREE_CODE (constructor_type) == UNION_TYPE)
 	       && DECL_C_BIT_FIELD (field)
 	       && TREE_CODE (value) != INTEGER_CST))
 constructor_simple = 0;
+if (!maybe_const)
+constructor_nonconst = 1;
 if (!initializer_constant_valid_p (value, TREE_TYPE (value)))
 {
 if (require_constant_value)
 	{
 	  value = error_mark_node;
 	}
 else if (require_constant_elements)
 	pedwarn (input_location, 0,
 		 "initializer element is not computable at load time");
+}
+else if (!maybe_const
+	   && (require_constant_value || require_constant_elements))
+pedwarn_init (input_location, 0,
+		  "initializer element is not a constant expression");
+/* Issue -Wc++-compat warnings about initializing a bitfield with
+enum type.  */
+if (warn_cxx_compat
+&& field != NULL_TREE
+&& TREE_CODE (field) == FIELD_DECL
+&& DECL_BIT_FIELD_TYPE (field) != NULL_TREE
+&& (TYPE_MAIN_VARIANT (DECL_BIT_FIELD_TYPE (field))
+	  != TYPE_MAIN_VARIANT (type))
+&& TREE_CODE (DECL_BIT_FIELD_TYPE (field)) == ENUMERAL_TYPE)
+{
+tree checktype = origtype != NULL_TREE ? origtype : TREE_TYPE (value);
+if (checktype != error_mark_node
+	  && (TYPE_MAIN_VARIANT (checktype)
+	      != TYPE_MAIN_VARIANT (DECL_BIT_FIELD_TYPE (field))))
+	warning_init (OPT_Wc___compat,
+		      "enum conversion in initialization is invalid in C++");
 }
 /* If this field is empty (and not at the end of structure),
 don't do anything other than checking the initializer.  */
 if (field
 	      && integer_zerop (TYPE_SIZE (TREE_TYPE (field)))
 	      && (TREE_CODE (constructor_type) == ARRAY_TYPE
 		  || TREE_CHAIN (field)))))
 return;
-value = digest_init (type, value, strict_string, require_constant_value);
+if (semantic_type)
+value = build1 (EXCESS_PRECISION_EXPR, semantic_type, value);
+value = digest_init (input_location, type, value, origtype, npc,
+		       strict_string, require_constant_value);
 if (value == error_mark_node)
 {
 constructor_erroneous = 1;
 return;
 }
+if (require_constant_value || require_constant_elements)
+constant_expression_warning (value);
 /* If this element doesn't come next in sequence,
 put it on constructor_pending_elts.  */
 if (TREE_CODE (constructor_type) == ARRAY_TYPE
 && (!constructor_incremental
 {
 if (constructor_incremental
 	  && tree_int_cst_lt (field, constructor_unfilled_index))
 	set_nonincremental_init ();
-add_pending_init (field, value, implicit);
+add_pending_init (field, value, origtype, implicit);
 return;
 }
 else if (TREE_CODE (constructor_type) == RECORD_TYPE
 	   && (!constructor_incremental
 	       || field != constructor_unfilled_fields))
 	      if (tree_int_cst_lt (bitpos, unfillpos))
 		set_nonincremental_init ();
 	    }
 	}
-add_pending_init (field, value, implicit);
+add_pending_init (field, value, origtype, implicit);
 return;
 }
 else if (TREE_CODE (constructor_type) == UNION_TYPE
 	   && !VEC_empty (constructor_elt, constructor_elements))
 {
 celt->value = value;
 /* Advance the variable that indicates sequential elements output.  */
 if (TREE_CODE (constructor_type) == ARRAY_TYPE)
 constructor_unfilled_index
-= size_binop (PLUS_EXPR, constructor_unfilled_index,
+= size_binop_loc (input_location, PLUS_EXPR, constructor_unfilled_index,
-		    bitsize_one_node);
+			bitsize_one_node);
 else if (TREE_CODE (constructor_type) == RECORD_TYPE)
 {
 constructor_unfilled_fields
 	= TREE_CHAIN (constructor_unfilled_fields);
 {
 if (TREE_CODE (constructor_type) == ARRAY_TYPE)
 	{
 	  if (tree_int_cst_equal (elt->purpose,
 				  constructor_unfilled_index))
-	    output_init_element (elt->value, true,
+	    output_init_element (elt->value, elt->origtype, true,
 				 TREE_TYPE (constructor_type),
 				 constructor_unfilled_index, 0, false);
 	  else if (tree_int_cst_lt (constructor_unfilled_index,
 				    elt->purpose))
 	    {
 	  /* We can't compare fields here because there might be empty
 	     fields in between.  */
 	  if (tree_int_cst_equal (elt_bitpos, ctor_unfilled_bitpos))
 	    {
 	      constructor_unfilled_fields = elt->purpose;
-	      output_init_element (elt->value, true, TREE_TYPE (elt->purpose),
+	      output_init_element (elt->value, elt->origtype, true,
+				   TREE_TYPE (elt->purpose),
 				   elt->purpose, 0, false);
 	    }
 	  else if (tree_int_cst_lt (ctor_unfilled_bitpos, elt_bitpos))
 	    {
 	      /* Advance to the next smaller node.  */
 {
 if ((TREE_CODE (constructor_type) == RECORD_TYPE
 	   || TREE_CODE (constructor_type) == UNION_TYPE)
 	  && constructor_fields == 0)
 	process_init_element (pop_init_level (1), true);
-else if (TREE_CODE (constructor_type) == ARRAY_TYPE
+else if ((TREE_CODE (constructor_type) == ARRAY_TYPE
+	        || TREE_CODE (constructor_type) == VECTOR_TYPE)
 	       && (constructor_max_index == 0
 		   || tree_int_cst_lt (constructor_max_index,
 				       constructor_index)))
 	process_init_element (pop_init_level (1), true);
 else
 /* If value is a compound literal and we'll be just using its
 	 content, don't put it into a SAVE_EXPR.  */
 if (TREE_CODE (value.value) != COMPOUND_LITERAL_EXPR
 	  || !require_constant_value
 	  || flag_isoc99)
-	value.value = save_expr (value.value);
+	{
+	  tree semantic_type = NULL_TREE;
+	  if (TREE_CODE (value.value) == EXCESS_PRECISION_EXPR)
+	    {
+	      semantic_type = TREE_TYPE (value.value);
+	      value.value = TREE_OPERAND (value.value, 0);
+	    }
+	  value.value = c_save_expr (value.value);
+	  if (semantic_type)
+	    value.value = build1 (EXCESS_PRECISION_EXPR, semantic_type,
+				  value.value);
+	}
 }
 while (1)
 {
 if (TREE_CODE (constructor_type) == RECORD_TYPE)
 	     and we don't have an element of its type, push into it.  */
 	  else if (value.value != 0
 		   && value.value != error_mark_node
 		   && TYPE_MAIN_VARIANT (TREE_TYPE (value.value)) != fieldtype
 		   && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE
-		       || fieldcode == UNION_TYPE))
+		       || fieldcode == UNION_TYPE || fieldcode == VECTOR_TYPE))
 	    {
 	      push_init_level (1);
 	      continue;
 	    }
 	  if (value.value)
 	    {
 	      push_member_name (constructor_fields);
-	      output_init_element (value.value, strict_string,
+	      output_init_element (value.value, value.original_type,
-				   fieldtype, constructor_fields, 1, implicit);
+				   strict_string, fieldtype,
+				   constructor_fields, 1, implicit);
 	      RESTORE_SPELLING_DEPTH (constructor_depth);
 	    }
 	  else
 	    /* Do the bookkeeping for an element that was
 	       directly output as a constructor.  */
 	    {
 	      /* For a record, keep track of end position of last field.  */
 	      if (DECL_SIZE (constructor_fields))
 		constructor_bit_index
-		  = size_binop (PLUS_EXPR,
+		  = size_binop_loc (input_location, PLUS_EXPR,
-				bit_position (constructor_fields),
+				    bit_position (constructor_fields),
-				DECL_SIZE (constructor_fields));
+				    DECL_SIZE (constructor_fields));
 	      /* If the current field was the first one not yet written out,
 		 it isn't now, so update.  */
 	      if (constructor_unfilled_fields == constructor_fields)
 		{
 	     and we don't have an element of its type, push into it.  */
 	  else if (value.value != 0
 		   && value.value != error_mark_node
 		   && TYPE_MAIN_VARIANT (TREE_TYPE (value.value)) != fieldtype
 		   && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE
-		       || fieldcode == UNION_TYPE))
+		       || fieldcode == UNION_TYPE || fieldcode == VECTOR_TYPE))
 	    {
 	      push_init_level (1);
 	      continue;
 	    }
 	  if (value.value)
 	    {
 	      push_member_name (constructor_fields);
-	      output_init_element (value.value, strict_string,
+	      output_init_element (value.value, value.original_type,
-				   fieldtype, constructor_fields, 1, implicit);
+				   strict_string, fieldtype,
+				   constructor_fields, 1, implicit);
 	      RESTORE_SPELLING_DEPTH (constructor_depth);
 	    }
 	  else
 	    /* Do the bookkeeping for an element that was
 	       directly output as a constructor.  */
 	     and we don't have an element of its type, push into it.  */
 	  else if (value.value != 0
 		   && value.value != error_mark_node
 		   && TYPE_MAIN_VARIANT (TREE_TYPE (value.value)) != elttype
 		   && (eltcode == RECORD_TYPE || eltcode == ARRAY_TYPE
-		       || eltcode == UNION_TYPE))
+		       || eltcode == UNION_TYPE || eltcode == VECTOR_TYPE))
 	    {
 	      push_init_level (1);
 	      continue;
 	    }
 	  /* Now output the actual element.  */
 	  if (value.value)
 	    {
 	      push_array_bounds (tree_low_cst (constructor_index, 1));
-	      output_init_element (value.value, strict_string,
+	      output_init_element (value.value, value.original_type,
-				   elttype, constructor_index, 1, implicit);
+				   strict_string, elttype,
+				   constructor_index, 1, implicit);
 	      RESTORE_SPELLING_DEPTH (constructor_depth);
 	    }
 	  constructor_index
-	    = size_binop (PLUS_EXPR, constructor_index, bitsize_one_node);
+	    = size_binop_loc (input_location, PLUS_EXPR,
+			      constructor_index, bitsize_one_node);
 	  if (!value.value)
 	    /* If we are doing the bookkeeping for an element that was
 	       directly output as a constructor, we must update
 	       constructor_unfilled_index.  */
 	      break;
 	    }
 	  /* Now output the actual element.  */
 	  if (value.value)
-	    output_init_element (value.value, strict_string,
+	    {
-				 elttype, constructor_index, 1, implicit);
+	      if (TREE_CODE (value.value) == VECTOR_CST)
+		elttype = TYPE_MAIN_VARIANT (constructor_type);
+	      output_init_element (value.value, value.original_type,
+				   strict_string, elttype,
+				   constructor_index, 1, implicit);
+	    }
 	  constructor_index
-	    = size_binop (PLUS_EXPR, constructor_index, bitsize_one_node);
+	    = size_binop_loc (input_location,
+			      PLUS_EXPR, constructor_index, bitsize_one_node);
 	  if (!value.value)
 	    /* If we are doing the bookkeeping for an element that was
 	       directly output as a constructor, we must update
 	       constructor_unfilled_index.  */
 	  break;
 	}
 else
 	{
 	  if (value.value)
-	    output_init_element (value.value, strict_string,
+	    output_init_element (value.value, value.original_type,
-				 constructor_type, NULL_TREE, 1, implicit);
+				 strict_string, constructor_type,
+				 NULL_TREE, 1, implicit);
 	  constructor_fields = 0;
 	}
 /* Handle range initializers either at this level or anywhere higher
 	 in the designator stack.  */
 	    {
 	      gcc_assert (constructor_stack->implicit);
 	      process_init_element (pop_init_level (1), true);
 	    }
-	  p->index = size_binop (PLUS_EXPR, p->index, bitsize_one_node);
+	  p->index = size_binop_loc (input_location,
+				     PLUS_EXPR, p->index, bitsize_one_node);
 	  if (tree_int_cst_equal (p->index, p->range_end) && !p->prev)
 	    finish = 1;
 	  while (1)
 	    {
 some INPUTS, and some CLOBBERS.  The latter three may be NULL.
 SIMPLE indicates whether there was anything at all after the
 string in the asm expression -- asm("blah") and asm("blah" : )
 are subtly different.  We use a ASM_EXPR node to represent this.  */
 tree
-build_asm_expr (tree string, tree outputs, tree inputs, tree clobbers,
+build_asm_expr (location_t loc, tree string, tree outputs, tree inputs,
-		bool simple)
+		tree clobbers, tree labels, bool simple)
 {
 tree tail;
 tree args;
 int i;
 const char *constraint;
 ninputs = list_length (inputs);
 noutputs = list_length (outputs);
 oconstraints = (const char **) alloca (noutputs * sizeof (const char *));
-string = resolve_asm_operand_names (string, outputs, inputs);
+string = resolve_asm_operand_names (string, outputs, inputs, labels);
 /* Remove output conversions that change the type but not the mode.  */
 for (i = 0, tail = outputs; tail; ++i, tail = TREE_CHAIN (tail))
 {
 tree output = TREE_VALUE (tail);
 	input = error_mark_node;
 TREE_VALUE (tail) = input;
 }
-args = build_stmt (ASM_EXPR, string, outputs, inputs, clobbers);
+/* ASMs with labels cannot have outputs.  This should have been
+enforced by the parser.  */
+gcc_assert (outputs == NULL || labels == NULL);
+args = build_stmt (loc, ASM_EXPR, string, outputs, inputs, clobbers, labels);
 /* asm statements without outputs, including simple ones, are treated
 as volatile.  */
 ASM_INPUT_P (args) = simple;
 ASM_VOLATILE_P (args) = (noutputs == 0);
 return args;
 }
-/* Generate a goto statement to LABEL.  */
+/* Generate a goto statement to LABEL.  LOC is the location of the
+GOTO.  */
 tree
-c_finish_goto_label (tree label)
+c_finish_goto_label (location_t loc, tree label)
 {
-tree decl = lookup_label (label);
+tree decl = lookup_label_for_goto (loc, label);
 if (!decl)
 return NULL_TREE;
-if (C_DECL_UNJUMPABLE_STMT_EXPR (decl))
-{
-error ("jump into statement expression");
-return NULL_TREE;
-}
-if (C_DECL_UNJUMPABLE_VM (decl))
-{
-error ("jump into scope of identifier with variably modified type");
-return NULL_TREE;
-}
-if (!C_DECL_UNDEFINABLE_STMT_EXPR (decl))
-{
-/* No jump from outside this statement expression context, so
-	 record that there is a jump from within this context.  */
-struct c_label_list *nlist;
-nlist = XOBNEW (&parser_obstack, struct c_label_list);
-nlist->next = label_context_stack_se->labels_used;
-nlist->label = decl;
-label_context_stack_se->labels_used = nlist;
-}
-if (!C_DECL_UNDEFINABLE_VM (decl))
-{
-/* No jump from outside this context context of identifiers with
-	 variably modified type, so record that there is a jump from
-	 within this context.  */
-struct c_label_list *nlist;
-nlist = XOBNEW (&parser_obstack, struct c_label_list);
-nlist->next = label_context_stack_vm->labels_used;
-nlist->label = decl;
-label_context_stack_vm->labels_used = nlist;
-}
 TREE_USED (decl) = 1;
-return add_stmt (build1 (GOTO_EXPR, void_type_node, decl));
+{
-}
+tree t = build1 (GOTO_EXPR, void_type_node, decl);
+SET_EXPR_LOCATION (t, loc);
-/* Generate a computed goto statement to EXPR.  */
+return add_stmt (t);
+}
+}
+/* Generate a computed goto statement to EXPR.  LOC is the location of
+the GOTO.  */
 tree
-c_finish_goto_ptr (tree expr)
+c_finish_goto_ptr (location_t loc, tree expr)
 {
-pedwarn (input_location, OPT_pedantic, "ISO C forbids %<goto *expr;%>");
+tree t;
+pedwarn (loc, OPT_pedantic, "ISO C forbids %<goto *expr;%>");
+expr = c_fully_fold (expr, false, NULL);
 expr = convert (ptr_type_node, expr);
-return add_stmt (build1 (GOTO_EXPR, void_type_node, expr));
+t = build1 (GOTO_EXPR, void_type_node, expr);
+SET_EXPR_LOCATION (t, loc);
+return add_stmt (t);
 }
 /* Generate a C `return' statement.  RETVAL is the expression for what
-to return, or a null pointer for `return;' with no value.  */
+to return, or a null pointer for `return;' with no value.  LOC is
+the location of the return statement.  If ORIGTYPE is not NULL_TREE, it
+is the original type of RETVAL.  */
 tree
-c_finish_return (tree retval)
+c_finish_return (location_t loc, tree retval, tree origtype)
 {
 tree valtype = TREE_TYPE (TREE_TYPE (current_function_decl)), ret_stmt;
 bool no_warning = false;
+bool npc = false;
 if (TREE_THIS_VOLATILE (current_function_decl))
-warning (0, "function declared %<noreturn%> has a %<return%> statement");
+warning_at (loc, 0,
+		"function declared %<noreturn%> has a %<return%> statement");
+if (retval)
+{
+tree semantic_type = NULL_TREE;
+npc = null_pointer_constant_p (retval);
+if (TREE_CODE (retval) == EXCESS_PRECISION_EXPR)
+	{
+	  semantic_type = TREE_TYPE (retval);
+	  retval = TREE_OPERAND (retval, 0);
+	}
+retval = c_fully_fold (retval, false, NULL);
+if (semantic_type)
+	retval = build1 (EXCESS_PRECISION_EXPR, semantic_type, retval);
+}
 if (!retval)
 {
 current_function_returns_null = 1;
 if ((warn_return_type || flag_isoc99)
 	  && valtype != 0 && TREE_CODE (valtype) != VOID_TYPE)
 	{
-	  pedwarn_c99 (input_location, flag_isoc99 ? 0 : OPT_Wreturn_type,
+	  pedwarn_c99 (loc, flag_isoc99 ? 0 : OPT_Wreturn_type,
 		       "%<return%> with no value, in "
 		       "function returning non-void");
 	  no_warning = true;
 	}
 }
 else if (valtype == 0 || TREE_CODE (valtype) == VOID_TYPE)
 {
 current_function_returns_null = 1;
 if (TREE_CODE (TREE_TYPE (retval)) != VOID_TYPE)
-	pedwarn (input_location, 0,
+	pedwarn (loc, 0,
 		 "%<return%> with a value, in function returning void");
 else
-	pedwarn (input_location, OPT_pedantic, "ISO C forbids "
+	pedwarn (loc, OPT_pedantic, "ISO C forbids "
 		 "%<return%> with expression, in function returning void");
 }
 else
 {
-tree t = convert_for_assignment (valtype, retval, ic_return,
+tree t = convert_for_assignment (loc, valtype, retval, origtype,
-				       NULL_TREE, NULL_TREE, 0);
+	  			       ic_return,
+				       npc, NULL_TREE, NULL_TREE, 0);
 tree res = DECL_RESULT (current_function_decl);
 tree inner;
 current_function_returns_value = 1;
 if (t == error_mark_node)
 	      if (DECL_P (inner)
 		  && !DECL_EXTERNAL (inner)
 		  && !TREE_STATIC (inner)
 		  && DECL_CONTEXT (inner) == current_function_decl)
-		warning (0, "function returns address of local variable");
+		warning_at (loc,
+			    0, "function returns address of local variable");
 	      break;
 	    default:
 	      break;
 	    }
 	  break;
 	}
 retval = build2 (MODIFY_EXPR, TREE_TYPE (res), res, t);
+SET_EXPR_LOCATION (retval, loc);
 if (warn_sequence_point)
 	verify_sequence_points (retval);
 }
-ret_stmt = build_stmt (RETURN_EXPR, retval);
+ret_stmt = build_stmt (loc, RETURN_EXPR, retval);
 TREE_NO_WARNING (ret_stmt) |= no_warning;
 return add_stmt (ret_stmt);
 }
 struct c_switch {
 determine whether or not a new case label duplicates an old case
 label.  We need a tree, rather than simply a hash table, because
 of the GNU case range extension.  */
 splay_tree cases;
-/* Number of nested statement expressions within this switch
+/* The bindings at the point of the switch.  This is used for
-statement; if nonzero, case and default labels may not
+warnings crossing decls when branching to a case label.  */
-appear.  */
+struct c_spot_bindings *bindings;
-unsigned int blocked_stmt_expr;
-/* Scope of outermost declarations of identifiers with variably
-modified type within this switch statement; if nonzero, case and
-default labels may not appear.  */
-unsigned int blocked_vm;
 /* The next node on the stack.  */
 struct c_switch *next;
 };
 collect at that point.  */
 struct c_switch *c_switch_stack;
 /* Start a C switch statement, testing expression EXP.  Return the new
-SWITCH_EXPR.  */
+SWITCH_EXPR.  SWITCH_LOC is the location of the `switch'.
+SWITCH_COND_LOC is the location of the switch's condition.  */
 tree
-c_start_case (tree exp)
+c_start_case (location_t switch_loc,
+	      location_t switch_cond_loc,
+	      tree exp)
 {
 tree orig_type = error_mark_node;
 struct c_switch *cs;
 if (exp != error_mark_node)
 if (!INTEGRAL_TYPE_P (orig_type))
 	{
 	  if (orig_type != error_mark_node)
 	    {
-	      error ("switch quantity not an integer");
+	      error_at (switch_cond_loc, "switch quantity not an integer");
 	      orig_type = error_mark_node;
 	    }
 	  exp = integer_zero_node;
 	}
 else
 	  tree type = TYPE_MAIN_VARIANT (orig_type);
 	  if (!in_system_header
 	      && (type == long_integer_type_node
 		  || type == long_unsigned_type_node))
-	    warning (OPT_Wtraditional, "%<long%> switch expression not "
+	    warning_at (switch_cond_loc,
-		     "converted to %<int%> in ISO C");
+			OPT_Wtraditional, "%<long%> switch expression not "
+			"converted to %<int%> in ISO C");
+	  exp = c_fully_fold (exp, false, NULL);
 	  exp = default_conversion (exp);
 	  if (warn_sequence_point)
 	    verify_sequence_points (exp);
 	}
 }
 /* Add this new SWITCH_EXPR to the stack.  */
 cs = XNEW (struct c_switch);
 cs->switch_expr = build3 (SWITCH_EXPR, orig_type, exp, NULL_TREE, NULL_TREE);
+SET_EXPR_LOCATION (cs->switch_expr, switch_loc);
 cs->orig_type = orig_type;
 cs->cases = splay_tree_new (case_compare, NULL, NULL);
-cs->blocked_stmt_expr = 0;
+cs->bindings = c_get_switch_bindings ();
-cs->blocked_vm = 0;
 cs->next = c_switch_stack;
 c_switch_stack = cs;
 return add_stmt (cs->switch_expr);
 }
-/* Process a case label.  */
+/* Process a case label at location LOC.  */
 tree
-do_case (tree low_value, tree high_value)
+do_case (location_t loc, tree low_value, tree high_value)
 {
 tree label = NULL_TREE;
-if (c_switch_stack && !c_switch_stack->blocked_stmt_expr
+if (low_value && TREE_CODE (low_value) != INTEGER_CST)
-&& !c_switch_stack->blocked_vm)
+{
-{
+low_value = c_fully_fold (low_value, false, NULL);
-label = c_add_case_label (c_switch_stack->cases,
+if (TREE_CODE (low_value) == INTEGER_CST)
-				SWITCH_COND (c_switch_stack->switch_expr),
+	pedwarn (input_location, OPT_pedantic,
-				c_switch_stack->orig_type,
+		 "case label is not an integer constant expression");
-				low_value, high_value);
+}
-if (label == error_mark_node)
-	label = NULL_TREE;
+if (high_value && TREE_CODE (high_value) != INTEGER_CST)
-}
+{
-else if (c_switch_stack && c_switch_stack->blocked_stmt_expr)
+high_value = c_fully_fold (high_value, false, NULL);
+if (TREE_CODE (high_value) == INTEGER_CST)
+	pedwarn (input_location, OPT_pedantic,
+		 "case label is not an integer constant expression");
+}
+if (c_switch_stack == NULL)
 {
 if (low_value)
-	error ("case label in statement expression not containing "
+	error_at (loc, "case label not within a switch statement");
-	       "enclosing switch statement");
 else
-	error ("%<default%> label in statement expression not containing "
+	error_at (loc, "%<default%> label not within a switch statement");
-	       "enclosing switch statement");
+return NULL_TREE;
 }
-else if (c_switch_stack && c_switch_stack->blocked_vm)
-{
+if (c_check_switch_jump_warnings (c_switch_stack->bindings,
-if (low_value)
+				    EXPR_LOCATION (c_switch_stack->switch_expr),
-	error ("case label in scope of identifier with variably modified "
+				    loc))
-	       "type not containing enclosing switch statement");
+return NULL_TREE;
-else
-	error ("%<default%> label in scope of identifier with variably "
+label = c_add_case_label (loc, c_switch_stack->cases,
-	       "modified type not containing enclosing switch statement");
+			    SWITCH_COND (c_switch_stack->switch_expr),
-}
+			    c_switch_stack->orig_type,
-else if (low_value)
+			    low_value, high_value);
-error ("case label not within a switch statement");
+if (label == error_mark_node)
-else
+label = NULL_TREE;
-error ("%<default%> label not within a switch statement");
 return label;
 }
 /* Finish the switch statement.  */
 struct c_switch *cs = c_switch_stack;
 location_t switch_location;
 SWITCH_BODY (cs->switch_expr) = body;
-/* We must not be within a statement expression nested in the switch
-at this point; we might, however, be within the scope of an
-identifier with variably modified type nested in the switch.  */
-gcc_assert (!cs->blocked_stmt_expr);
 /* Emit warnings as needed.  */
-if (EXPR_HAS_LOCATION (cs->switch_expr))
+switch_location = EXPR_LOCATION (cs->switch_expr);
-switch_location = EXPR_LOCATION (cs->switch_expr);
-else
-switch_location = input_location;
 c_do_switch_warnings (cs->cases, switch_location,
 			TREE_TYPE (cs->switch_expr),
 			SWITCH_COND (cs->switch_expr));
 /* Pop the stack.  */
 c_switch_stack = cs->next;
 splay_tree_delete (cs->cases);
+c_release_switch_bindings (cs->bindings);
 XDELETE (cs);
 }
 /* Emit an if statement.  IF_LOCUS is the location of the 'if'.  COND,
 THEN_BLOCK and ELSE_BLOCK are expressions to be used; ELSE_BLOCK
 	    gcc_unreachable ();
 	  }
 found:
 if (COND_EXPR_ELSE (inner_if))
-	 warning (OPT_Wparentheses,
+	 warning_at (if_locus, OPT_Wparentheses,
-		  "%Hsuggest explicit braces to avoid ambiguous %<else%>",
+		     "suggest explicit braces to avoid ambiguous %<else%>");
-		  &if_locus);
 }
 stmt = build3 (COND_EXPR, void_type_node, cond, then_block, else_block);
 SET_EXPR_LOCATION (stmt, if_locus);
 add_stmt (stmt);
 	      SET_EXPR_LOCATION (t, start_locus);
 	      add_stmt (t);
 	    }
 	  t = build_and_jump (&blab);
-	  exit = fold_build3 (COND_EXPR, void_type_node, cond, exit, t);
 	  if (cond_is_first)
-	    SET_EXPR_LOCATION (exit, start_locus);
+	    exit = fold_build3_loc (start_locus,
+				COND_EXPR, void_type_node, cond, exit, t);
 	  else
-	    SET_EXPR_LOCATION (exit, input_location);
+	    exit = fold_build3_loc (input_location,
+				COND_EXPR, void_type_node, cond, exit, t);
 	}
 add_stmt (top);
 }
 if (blab)
 add_stmt (build1 (LABEL_EXPR, void_type_node, blab));
 }
 tree
-c_finish_bc_stmt (tree *label_p, bool is_break)
+c_finish_bc_stmt (location_t loc, tree *label_p, bool is_break)
 {
 bool skip;
 tree label = *label_p;
 /* In switch statements break is sometimes stylistically used after
 skip = !block_may_fallthru (cur_stmt_list);
 if (!label)
 {
 if (!skip)
-	*label_p = label = create_artificial_label ();
+	*label_p = label = create_artificial_label (loc);
 }
 else if (TREE_CODE (label) == LABEL_DECL)
 ;
 else switch (TREE_INT_CST_LOW (label))
 {
 case 0:
 if (is_break)
-	error ("break statement not within loop or switch");
+	error_at (loc, "break statement not within loop or switch");
 else
-	error ("continue statement not within a loop");
+	error_at (loc, "continue statement not within a loop");
 return NULL_TREE;
 case 1:
 gcc_assert (is_break);
-error ("break statement used with OpenMP for loop");
+error_at (loc, "break statement used with OpenMP for loop");
 return NULL_TREE;
 default:
 gcc_unreachable ();
 }
 }
 /* A helper routine for c_process_expr_stmt and c_finish_stmt_expr.  */
 static void
-emit_side_effect_warnings (tree expr)
+emit_side_effect_warnings (location_t loc, tree expr)
 {
 if (expr == error_mark_node)
 ;
 else if (!TREE_SIDE_EFFECTS (expr))
 {
 if (!VOID_TYPE_P (TREE_TYPE (expr)) && !TREE_NO_WARNING (expr))
-	warning (OPT_Wunused_value, "%Hstatement with no effect",
+	warning_at (loc, OPT_Wunused_value, "statement with no effect");
-		 EXPR_HAS_LOCATION (expr) ? EXPR_LOCUS (expr) : &input_location);
 }
 else
-warn_if_unused_value (expr, input_location);
+warn_if_unused_value (expr, loc);
 }
 /* Process an expression as if it were a complete statement.  Emit
-diagnostics, but do not call ADD_STMT.  */
+diagnostics, but do not call ADD_STMT.  LOC is the location of the
+statement.  */
 tree
-c_process_expr_stmt (tree expr)
+c_process_expr_stmt (location_t loc, tree expr)
 {
 if (!expr)
 return NULL_TREE;
+expr = c_fully_fold (expr, false, NULL);
 if (warn_sequence_point)
 verify_sequence_points (expr);
 if (TREE_TYPE (expr) != error_mark_node
 && !COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (expr))
 && TREE_CODE (TREE_TYPE (expr)) != ARRAY_TYPE)
-error ("expression statement has incomplete type");
+error_at (loc, "expression statement has incomplete type");
 /* If we're not processing a statement expression, warn about unused values.
 Warnings for statement expressions will be emitted later, once we figure
 out which is the result.  */
 if (!STATEMENT_LIST_STMT_EXPR (cur_stmt_list)
 && warn_unused_value)
-emit_side_effect_warnings (expr);
+emit_side_effect_warnings (loc, expr);
 /* If the expression is not of a type to which we cannot assign a line
 number, wrap the thing in a no-op NOP_EXPR.  */
 if (DECL_P (expr) || CONSTANT_CLASS_P (expr))
-expr = build1 (NOP_EXPR, TREE_TYPE (expr), expr);
+{
+expr = build1 (NOP_EXPR, TREE_TYPE (expr), expr);
-if (CAN_HAVE_LOCATION_P (expr))
+SET_EXPR_LOCATION (expr, loc);
-SET_EXPR_LOCATION (expr, input_location);
+}
 return expr;
 }
-/* Emit an expression as a statement.  */
+/* Emit an expression as a statement.  LOC is the location of the
+expression.  */
 tree
-c_finish_expr_stmt (tree expr)
+c_finish_expr_stmt (location_t loc, tree expr)
 {
 if (expr)
-return add_stmt (c_process_expr_stmt (expr));
+return add_stmt (c_process_expr_stmt (loc, expr));
 else
 return NULL;
 }
 /* Do the opposite and emit a statement as an expression.  To begin,
 tree
 c_begin_stmt_expr (void)
 {
 tree ret;
-struct c_label_context_se *nstack;
-struct c_label_list *glist;
 /* We must force a BLOCK for this level so that, if it is not expanded
 later, there is a way to turn off the entire subtree of blocks that
 are contained in it.  */
 keep_next_level ();
 ret = c_begin_compound_stmt (true);
-if (c_switch_stack)
-{
+c_bindings_start_stmt_expr (c_switch_stack == NULL
-c_switch_stack->blocked_stmt_expr++;
+			      ? NULL
-gcc_assert (c_switch_stack->blocked_stmt_expr != 0);
+			      : c_switch_stack->bindings);
-}
-for (glist = label_context_stack_se->labels_used;
-glist != NULL;
-glist = glist->next)
-{
-C_DECL_UNDEFINABLE_STMT_EXPR (glist->label) = 1;
-}
-nstack = XOBNEW (&parser_obstack, struct c_label_context_se);
-nstack->labels_def = NULL;
-nstack->labels_used = NULL;
-nstack->next = label_context_stack_se;
-label_context_stack_se = nstack;
 /* Mark the current statement list as belonging to a statement list.  */
 STATEMENT_LIST_STMT_EXPR (ret) = 1;
 return ret;
 }
+/* LOC is the location of the compound statement to which this body
+belongs.  */
 tree
-c_finish_stmt_expr (tree body)
+c_finish_stmt_expr (location_t loc, tree body)
 {
 tree last, type, tmp, val;
 tree *last_p;
-struct c_label_list *dlist, *glist, *glist_prev = NULL;
+body = c_end_compound_stmt (loc, body, true);
-body = c_end_compound_stmt (body, true);
-if (c_switch_stack)
+c_bindings_end_stmt_expr (c_switch_stack == NULL
-{
+			    ? NULL
-gcc_assert (c_switch_stack->blocked_stmt_expr != 0);
+			    : c_switch_stack->bindings);
-c_switch_stack->blocked_stmt_expr--;
-}
-/* It is no longer possible to jump to labels defined within this
-statement expression.  */
-for (dlist = label_context_stack_se->labels_def;
-dlist != NULL;
-dlist = dlist->next)
-{
-C_DECL_UNJUMPABLE_STMT_EXPR (dlist->label) = 1;
-}
-/* It is again possible to define labels with a goto just outside
-this statement expression.  */
-for (glist = label_context_stack_se->next->labels_used;
-glist != NULL;
-glist = glist->next)
-{
-C_DECL_UNDEFINABLE_STMT_EXPR (glist->label) = 0;
-glist_prev = glist;
-}
-if (glist_prev != NULL)
-glist_prev->next = label_context_stack_se->labels_used;
-else
-label_context_stack_se->next->labels_used
-= label_context_stack_se->labels_used;
-label_context_stack_se = label_context_stack_se->next;
 /* Locate the last statement in BODY.  See c_end_compound_stmt
 about always returning a BIND_EXPR.  */
 last_p = &BIND_EXPR_BODY (body);
 last = BIND_EXPR_BODY (body);
 /* If we're supposed to generate side effects warnings, process
 	 all of the statements except the last.  */
 if (warn_unused_value)
 	{
 	  for (i = tsi_start (last); !tsi_one_before_end_p (i); tsi_next (&i))
-	    emit_side_effect_warnings (tsi_stmt (i));
+	    {
+	      location_t tloc;
+	      tree t = tsi_stmt (i);
+	      tloc = EXPR_HAS_LOCATION (t) ? EXPR_LOCATION (t) : loc;
+	      emit_side_effect_warnings (tloc, t);
+	    }
 	}
 else
 	i = tsi_last (last);
 last_p = tsi_stmt_ptr (i);
 last = *last_p;
 last_p = &TREE_OPERAND (last, 0);
 last = *last_p;
 goto continue_searching;
 }
+if (last == error_mark_node)
+return last;
 /* In the case that the BIND_EXPR is not necessary, return the
 expression out from inside it.  */
-if (last == error_mark_node
+if (last == BIND_EXPR_BODY (body)
-|| (last == BIND_EXPR_BODY (body)
+&& BIND_EXPR_VARS (body) == NULL)
-	  && BIND_EXPR_VARS (body) == NULL))
+{
-{
+/* Even if this looks constant, do not allow it in a constant
+	 expression.  */
+last = c_wrap_maybe_const (last, true);
 /* Do not warn if the return value of a statement expression is
 	 unused.  */
-if (CAN_HAVE_LOCATION_P (last))
+TREE_NO_WARNING (last) = 1;
-	TREE_NO_WARNING (last) = 1;
 return last;
 }
 /* Extract the type of said expression.  */
 type = TREE_TYPE (last);
 if (TREE_CODE (val) == NOP_EXPR
 && TREE_TYPE (val) == TREE_TYPE (TREE_OPERAND (val, 0)))
 val = TREE_OPERAND (val, 0);
 *last_p = build2 (MODIFY_EXPR, void_type_node, tmp, val);
-SET_EXPR_LOCUS (*last_p, EXPR_LOCUS (last));
+SET_EXPR_LOCATION (*last_p, EXPR_LOCATION (last));
-return build4 (TARGET_EXPR, type, tmp, body, NULL_TREE, NULL_TREE);
+{
-}
+tree t = build4 (TARGET_EXPR, type, tmp, body, NULL_TREE, NULL_TREE);
+SET_EXPR_LOCATION (t, loc);
-/* Begin the scope of an identifier of variably modified type, scope
+return t;
-number SCOPE.  Jumping from outside this scope to inside it is not
+}
-permitted.  */
-void
-c_begin_vm_scope (unsigned int scope)
-{
-struct c_label_context_vm *nstack;
-struct c_label_list *glist;
-gcc_assert (scope > 0);
-/* At file_scope, we don't have to do any processing.  */
-if (label_context_stack_vm == NULL)
-return;
-if (c_switch_stack && !c_switch_stack->blocked_vm)
-c_switch_stack->blocked_vm = scope;
-for (glist = label_context_stack_vm->labels_used;
-glist != NULL;
-glist = glist->next)
-{
-C_DECL_UNDEFINABLE_VM (glist->label) = 1;
-}
-nstack = XOBNEW (&parser_obstack, struct c_label_context_vm);
-nstack->labels_def = NULL;
-nstack->labels_used = NULL;
-nstack->scope = scope;
-nstack->next = label_context_stack_vm;
-label_context_stack_vm = nstack;
-}
-/* End a scope which may contain identifiers of variably modified
-type, scope number SCOPE.  */
-void
-c_end_vm_scope (unsigned int scope)
-{
-if (label_context_stack_vm == NULL)
-return;
-if (c_switch_stack && c_switch_stack->blocked_vm == scope)
-c_switch_stack->blocked_vm = 0;
-/* We may have a number of nested scopes of identifiers with
-variably modified type, all at this depth.  Pop each in turn.  */
-while (label_context_stack_vm->scope == scope)
-{
-struct c_label_list *dlist, *glist, *glist_prev = NULL;
-/* It is no longer possible to jump to labels defined within this
-	 scope.  */
-for (dlist = label_context_stack_vm->labels_def;
-	   dlist != NULL;
-	   dlist = dlist->next)
-	{
-	  C_DECL_UNJUMPABLE_VM (dlist->label) = 1;
-	}
-/* It is again possible to define labels with a goto just outside
-	 this scope.  */
-for (glist = label_context_stack_vm->next->labels_used;
-	   glist != NULL;
-	   glist = glist->next)
-	{
-	  C_DECL_UNDEFINABLE_VM (glist->label) = 0;
-	  glist_prev = glist;
-	}
-if (glist_prev != NULL)
-	glist_prev->next = label_context_stack_vm->labels_used;
-else
-	label_context_stack_vm->next->labels_used
-	  = label_context_stack_vm->labels_used;
-label_context_stack_vm = label_context_stack_vm->next;
-}
 }
 /* Begin and end compound statements.  This is as simple as pushing
 and popping new statement lists from the tree.  */
 if (do_scope)
 push_scope ();
 return stmt;
 }
+/* End a compound statement.  STMT is the statement.  LOC is the
+location of the compound statement-- this is usually the location
+of the opening brace.  */
 tree
-c_end_compound_stmt (tree stmt, bool do_scope)
+c_end_compound_stmt (location_t loc, tree stmt, bool do_scope)
 {
 tree block = NULL;
 if (do_scope)
 {
 	objc_clear_super_receiver ();
 block = pop_scope ();
 }
 stmt = pop_stmt_list (stmt);
-stmt = c_build_bind_expr (block, stmt);
+stmt = c_build_bind_expr (loc, block, stmt);
 /* If this compound statement is nested immediately inside a statement
 expression, then force a BIND_EXPR to be created.  Otherwise we'll
 do the wrong thing for ({ { 1; } }) or ({ 1; { } }).  In particular,
 STATEMENT_LISTs merge, and thus we can lose track of what statement
 && STATEMENT_LIST_STMT_EXPR (cur_stmt_list)
 && TREE_CODE (stmt) != BIND_EXPR)
 {
 stmt = build3 (BIND_EXPR, void_type_node, NULL, stmt, NULL);
 TREE_SIDE_EFFECTS (stmt) = 1;
+SET_EXPR_LOCATION (stmt, loc);
 }
 return stmt;
 }
 /* Queue a cleanup.  CLEANUP is an expression/statement to be executed
 when the current scope is exited.  EH_ONLY is true when this is not
 meant to apply to normal control flow transfer.  */
 void
-push_cleanup (tree ARG_UNUSED (decl), tree cleanup, bool eh_only)
+push_cleanup (tree decl, tree cleanup, bool eh_only)
 {
 enum tree_code code;
 tree stmt, list;
 bool stmt_expr;
 code = eh_only ? TRY_CATCH_EXPR : TRY_FINALLY_EXPR;
-stmt = build_stmt (code, NULL, cleanup);
+stmt = build_stmt (DECL_SOURCE_LOCATION (decl), code, NULL, cleanup);
 add_stmt (stmt);
 stmt_expr = STATEMENT_LIST_STMT_EXPR (cur_stmt_list);
 list = push_stmt_list ();
 TREE_OPERAND (stmt, 0) = list;
 STATEMENT_LIST_STMT_EXPR (list) = stmt_expr;
 tree
 build_binary_op (location_t location, enum tree_code code,
 		 tree orig_op0, tree orig_op1, int convert_p)
 {
-tree type0, type1;
+tree type0, type1, orig_type0, orig_type1;
+tree eptype;
 enum tree_code code0, code1;
 tree op0, op1;
 tree ret = error_mark_node;
 const char *invalid_op_diag;
+bool op0_int_operands, op1_int_operands;
+bool int_const, int_const_or_overflow, int_operands;
 /* Expression code to give to the expression when it is built.
 Normally this is CODE, which is what the caller asked for,
 but in some special cases we change it.  */
 enum tree_code resultcode = code;
 /* Data type in which the computation is to be performed.
 In the simplest cases this is the common type of the arguments.  */
 tree result_type = NULL;
+/* When the computation is in excess precision, the type of the
+final EXCESS_PRECISION_EXPR.  */
+tree real_result_type = NULL;
 /* Nonzero means operands have already been type-converted
 in whatever way is necessary.
 Zero means they need to be converted to RESULT_TYPE.  */
 int converted = 0;
 int common = 0;
 /* True means types are compatible as far as ObjC is concerned.  */
 bool objc_ok;
+/* True means this is an arithmetic operation that may need excess
+precision.  */
+bool may_need_excess_precision;
 if (location == UNKNOWN_LOCATION)
 location = input_location;
+op0 = orig_op0;
+op1 = orig_op1;
+op0_int_operands = EXPR_INT_CONST_OPERANDS (orig_op0);
+if (op0_int_operands)
+op0 = remove_c_maybe_const_expr (op0);
+op1_int_operands = EXPR_INT_CONST_OPERANDS (orig_op1);
+if (op1_int_operands)
+op1 = remove_c_maybe_const_expr (op1);
+int_operands = (op0_int_operands && op1_int_operands);
+if (int_operands)
+{
+int_const_or_overflow = (TREE_CODE (orig_op0) == INTEGER_CST
+			       && TREE_CODE (orig_op1) == INTEGER_CST);
+int_const = (int_const_or_overflow
+		   && !TREE_OVERFLOW (orig_op0)
+		   && !TREE_OVERFLOW (orig_op1));
+}
+else
+int_const = int_const_or_overflow = false;
 if (convert_p)
 {
-op0 = default_conversion (orig_op0);
+op0 = default_conversion (op0);
-op1 = default_conversion (orig_op1);
+op1 = default_conversion (op1);
 }
-else
-{
+orig_type0 = type0 = TREE_TYPE (op0);
-op0 = orig_op0;
+orig_type1 = type1 = TREE_TYPE (op1);
-op1 = orig_op1;
-}
-type0 = TREE_TYPE (op0);
-type1 = TREE_TYPE (op1);
 /* The expression codes of the data types of the arguments tell us
 whether the arguments are integers, floating, pointers, etc.  */
 code0 = TREE_CODE (type0);
 code1 = TREE_CODE (type1);
 {
 error_at (location, invalid_op_diag);
 return error_mark_node;
 }
+switch (code)
+{
+case PLUS_EXPR:
+case MINUS_EXPR:
+case MULT_EXPR:
+case TRUNC_DIV_EXPR:
+case CEIL_DIV_EXPR:
+case FLOOR_DIV_EXPR:
+case ROUND_DIV_EXPR:
+case EXACT_DIV_EXPR:
+may_need_excess_precision = true;
+break;
+default:
+may_need_excess_precision = false;
+break;
+}
+if (TREE_CODE (op0) == EXCESS_PRECISION_EXPR)
+{
+op0 = TREE_OPERAND (op0, 0);
+type0 = TREE_TYPE (op0);
+}
+else if (may_need_excess_precision
+	   && (eptype = excess_precision_type (type0)) != NULL_TREE)
+{
+type0 = eptype;
+op0 = convert (eptype, op0);
+}
+if (TREE_CODE (op1) == EXCESS_PRECISION_EXPR)
+{
+op1 = TREE_OPERAND (op1, 0);
+type1 = TREE_TYPE (op1);
+}
+else if (may_need_excess_precision
+	   && (eptype = excess_precision_type (type1)) != NULL_TREE)
+{
+type1 = eptype;
+op1 = convert (eptype, op1);
+}
 objc_ok = objc_compare_types (type0, type1, -3, NULL_TREE);
 switch (code)
 {
 case PLUS_EXPR:
 /* Handle the pointer + int case.  */
 if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
 	{
-	  ret = pointer_int_sum (PLUS_EXPR, op0, op1);
+	  ret = pointer_int_sum (location, PLUS_EXPR, op0, op1);
 	  goto return_build_binary_op;
 	}
 else if (code1 == POINTER_TYPE && code0 == INTEGER_TYPE)
 	{
-	  ret = pointer_int_sum (PLUS_EXPR, op1, op0);
+	  ret = pointer_int_sum (location, PLUS_EXPR, op1, op0);
 	  goto return_build_binary_op;
 	}
 else
 	common = 1;
 break;
 case MINUS_EXPR:
 /* Subtraction of two similar pointers.
 	 We must subtract them as integers, then divide by object size.  */
 if (code0 == POINTER_TYPE && code1 == POINTER_TYPE
-	  && comp_target_types (type0, type1))
+	  && comp_target_types (location, type0, type1))
 	{
-	  ret = pointer_diff (op0, op1);
+	  ret = pointer_diff (location, op0, op1);
 	  goto return_build_binary_op;
 	}
 /* Handle pointer minus int.  Just like pointer plus int.  */
 else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
 	{
-	  ret = pointer_int_sum (MINUS_EXPR, op0, op1);
+	  ret = pointer_int_sum (location, MINUS_EXPR, op0, op1);
 	  goto return_build_binary_op;
 	}
 else
 	common = 1;
 break;
 case TRUNC_MOD_EXPR:
 case FLOOR_MOD_EXPR:
 warn_for_div_by_zero (location, op1);
-if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
+if (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE
+	  && TREE_CODE (TREE_TYPE (type0)) == INTEGER_TYPE
+	  && TREE_CODE (TREE_TYPE (type1)) == INTEGER_TYPE)
+	common = 1;
+else if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
 	{
 	  /* Although it would be tempting to shorten always here, that loses
 	     on some targets, since the modulo instruction is undefined if the
 	     quotient can't be represented in the computation mode.  We shorten
 	     only if unsigned or if dividing by something we know != -1.  */
 	  result_type = integer_type_node;
 	  op0 = c_common_truthvalue_conversion (location, op0);
 	  op1 = c_common_truthvalue_conversion (location, op1);
 	  converted = 1;
 	}
+if (code == TRUTH_ANDIF_EXPR)
+	{
+	  int_const_or_overflow = (int_operands
+				   && TREE_CODE (orig_op0) == INTEGER_CST
+				   && (op0 == truthvalue_false_node
+				       || TREE_CODE (orig_op1) == INTEGER_CST));
+	  int_const = (int_const_or_overflow
+		       && !TREE_OVERFLOW (orig_op0)
+		       && (op0 == truthvalue_false_node
+			   || !TREE_OVERFLOW (orig_op1)));
+	}
+else if (code == TRUTH_ORIF_EXPR)
+	{
+	  int_const_or_overflow = (int_operands
+				   && TREE_CODE (orig_op0) == INTEGER_CST
+				   && (op0 == truthvalue_true_node
+				       || TREE_CODE (orig_op1) == INTEGER_CST));
+	  int_const = (int_const_or_overflow
+		       && !TREE_OVERFLOW (orig_op0)
+		       && (op0 == truthvalue_true_node
+			   || !TREE_OVERFLOW (orig_op1)));
+	}
 break;
 /* Shift operations: result has same type as first operand;
 	 always convert second operand to int.
 	 Also set SHORT_SHIFT if shifting rightward.  */
 case RSHIFT_EXPR:
 if ((code0 == INTEGER_TYPE || code0 == FIXED_POINT_TYPE)
 	  && code1 == INTEGER_TYPE)
 	{
-	  if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0)
+	  if (TREE_CODE (op1) == INTEGER_CST)
 	    {
 	      if (tree_int_cst_sgn (op1) < 0)
-		warning (0, "right shift count is negative");
+		{
+		  int_const = false;
+		  if (c_inhibit_evaluation_warnings == 0)
+		    warning (0, "right shift count is negative");
+		}
 	      else
 		{
 		  if (!integer_zerop (op1))
 		    short_shift = 1;
 		  if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
-		    warning (0, "right shift count >= width of type");
+		    {
+		      int_const = false;
+		      if (c_inhibit_evaluation_warnings == 0)
+			warning (0, "right shift count >= width of type");
+		    }
 		}
 	    }
 	  /* Use the type of the value to be shifted.  */
 	  result_type = type0;
 case LSHIFT_EXPR:
 if ((code0 == INTEGER_TYPE || code0 == FIXED_POINT_TYPE)
 	  && code1 == INTEGER_TYPE)
 	{
-	  if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0)
+	  if (TREE_CODE (op1) == INTEGER_CST)
 	    {
 	      if (tree_int_cst_sgn (op1) < 0)
-		warning (0, "left shift count is negative");
+		{
+		  int_const = false;
+		  if (c_inhibit_evaluation_warnings == 0)
+		    warning (0, "left shift count is negative");
+		}
 	      else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
-		warning (0, "left shift count >= width of type");
+		{
+		  int_const = false;
+		  if (c_inhibit_evaluation_warnings == 0)
+		    warning (0, "left shift count >= width of type");
+		}
 	    }
 	  /* Use the type of the value to be shifted.  */
 	  result_type = type0;
 	  /* Convert the shift-count to an integer, regardless of size
 	short_compare = 1;
 else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
 	{
 	  tree tt0 = TREE_TYPE (type0);
 	  tree tt1 = TREE_TYPE (type1);
+	  addr_space_t as0 = TYPE_ADDR_SPACE (tt0);
+	  addr_space_t as1 = TYPE_ADDR_SPACE (tt1);
+	  addr_space_t as_common = ADDR_SPACE_GENERIC;
 	  /* Anything compares with void *.  void * compares with anything.
 	     Otherwise, the targets must be compatible
 	     and both must be object or both incomplete.  */
-	  if (comp_target_types (type0, type1))
+	  if (comp_target_types (location, type0, type1))
 	    result_type = common_pointer_type (type0, type1);
+	  else if (null_pointer_constant_p (orig_op0))
+	    result_type = type1;
+	  else if (null_pointer_constant_p (orig_op1))
+	    result_type = type0;
+	  else if (!addr_space_superset (as0, as1, &as_common))
+	    {
+	      error_at (location, "comparison of pointers to "
+			"disjoint address spaces");
+	      return error_mark_node;
+	    }
 	  else if (VOID_TYPE_P (tt0))
 	    {
-	      /* op0 != orig_op0 detects the case of something
+	      if (pedantic && TREE_CODE (tt1) == FUNCTION_TYPE)
-		 whose value is 0 but which isn't a valid null ptr const.  */
-	      if (pedantic && !null_pointer_constant_p (orig_op0)
-		  && TREE_CODE (tt1) == FUNCTION_TYPE)
 		pedwarn (location, OPT_pedantic, "ISO C forbids "
 			 "comparison of %<void *%> with function pointer");
 	    }
 	  else if (VOID_TYPE_P (tt1))
 	    {
-	      if (pedantic && !null_pointer_constant_p (orig_op1)
+	      if (pedantic && TREE_CODE (tt0) == FUNCTION_TYPE)
-		  && TREE_CODE (tt0) == FUNCTION_TYPE)
 		pedwarn (location, OPT_pedantic, "ISO C forbids "
 			 "comparison of %<void *%> with function pointer");
 	    }
 	  else
 	    /* Avoid warning about the volatile ObjC EH puts on decls.  */
 	    if (!objc_ok)
 	      pedwarn (location, 0,
 		       "comparison of distinct pointer types lacks a cast");
 	  if (result_type == NULL_TREE)
-	    result_type = ptr_type_node;
+	    {
+	      int qual = ENCODE_QUAL_ADDR_SPACE (as_common);
+	      result_type = build_pointer_type
+			      (build_qualified_type (void_type_node, qual));
+	    }
 	}
 else if (code0 == POINTER_TYPE && null_pointer_constant_p (orig_op1))
 	{
 	  if (TREE_CODE (op0) == ADDR_EXPR
 	      && decl_with_nonnull_addr_p (TREE_OPERAND (op0, 0)))
 	  && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
 	      || code1 == FIXED_POINT_TYPE))
 	short_compare = 1;
 else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
 	{
-	  if (comp_target_types (type0, type1))
+	  addr_space_t as0 = TYPE_ADDR_SPACE (TREE_TYPE (type0));
+	  addr_space_t as1 = TYPE_ADDR_SPACE (TREE_TYPE (type1));
+	  addr_space_t as_common;
+	  if (comp_target_types (location, type0, type1))
 	    {
 	      result_type = common_pointer_type (type0, type1);
 	      if (!COMPLETE_TYPE_P (TREE_TYPE (type0))
 		  != !COMPLETE_TYPE_P (TREE_TYPE (type1)))
 		pedwarn (location, 0,
 			 "comparison of complete and incomplete pointers");
 	      else if (TREE_CODE (TREE_TYPE (type0)) == FUNCTION_TYPE)
 		pedwarn (location, OPT_pedantic, "ISO C forbids "
 			 "ordered comparisons of pointers to functions");
 	    }
+	  else if (!addr_space_superset (as0, as1, &as_common))
+	    {
+	      error_at (location, "comparison of pointers to "
+			"disjoint address spaces");
+	      return error_mark_node;
+	    }
 	  else
 	    {
-	      result_type = ptr_type_node;
+	      int qual = ENCODE_QUAL_ADDR_SPACE (as_common);
+	      result_type = build_pointer_type
+			      (build_qualified_type (void_type_node, qual));
 	      pedwarn (location, 0,
 		       "comparison of distinct pointer types lacks a cast");
 	    }
 	}
 else if (code0 == POINTER_TYPE && null_pointer_constant_p (orig_op1))
 	{
 	  result_type = type0;
 	  if (pedantic)
 	    pedwarn (location, OPT_pedantic,
 		     "ordered comparison of pointer with integer zero");
 	  else if (extra_warnings)
 	    warning_at (location, OPT_Wextra,
 		     "ordered comparison of pointer with integer zero");
 	}
 else if (code1 == POINTER_TYPE && null_pointer_constant_p (orig_op0))
 	{
 	  result_type = type1;
 	  pedwarn (location, OPT_pedantic,
 		   "ordered comparison of pointer with integer zero");
 	}
 else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
 	{
 	  result_type = type0;
 || code0 == FIXED_POINT_TYPE || code0 == VECTOR_TYPE)
 &&
 (code1 == INTEGER_TYPE || code1 == REAL_TYPE || code1 == COMPLEX_TYPE
 || code1 == FIXED_POINT_TYPE || code1 == VECTOR_TYPE))
 {
-int none_complex = (code0 != COMPLEX_TYPE && code1 != COMPLEX_TYPE);
+bool first_complex = (code0 == COMPLEX_TYPE);
+bool second_complex = (code1 == COMPLEX_TYPE);
+int none_complex = (!first_complex && !second_complex);
 if (shorten || common || short_compare)
 	{
 	  result_type = c_common_type (type0, type1);
 	  if (result_type == error_mark_node)
 	    return error_mark_node;
+	}
+if (first_complex != second_complex
+	  && (code == PLUS_EXPR
+	      || code == MINUS_EXPR
+	      || code == MULT_EXPR
+	      || (code == TRUNC_DIV_EXPR && first_complex))
+	  && TREE_CODE (TREE_TYPE (result_type)) == REAL_TYPE
+	  && flag_signed_zeros)
+	{
+	  /* An operation on mixed real/complex operands must be
+	     handled specially, but the language-independent code can
+	     more easily optimize the plain complex arithmetic if
+	     -fno-signed-zeros.  */
+	  tree real_type = TREE_TYPE (result_type);
+	  tree real, imag;
+	  if (type0 != orig_type0 || type1 != orig_type1)
+	    {
+	      gcc_assert (may_need_excess_precision && common);
+	      real_result_type = c_common_type (orig_type0, orig_type1);
+	    }
+	  if (first_complex)
+	    {
+	      if (TREE_TYPE (op0) != result_type)
+		op0 = convert_and_check (result_type, op0);
+	      if (TREE_TYPE (op1) != real_type)
+		op1 = convert_and_check (real_type, op1);
+	    }
+	  else
+	    {
+	      if (TREE_TYPE (op0) != real_type)
+		op0 = convert_and_check (real_type, op0);
+	      if (TREE_TYPE (op1) != result_type)
+		op1 = convert_and_check (result_type, op1);
+	    }
+	  if (TREE_CODE (op0) == ERROR_MARK || TREE_CODE (op1) == ERROR_MARK)
+	    return error_mark_node;
+	  if (first_complex)
+	    {
+	      op0 = c_save_expr (op0);
+	      real = build_unary_op (EXPR_LOCATION (orig_op0), REALPART_EXPR,
+				     op0, 1);
+	      imag = build_unary_op (EXPR_LOCATION (orig_op0), IMAGPART_EXPR,
+				     op0, 1);
+	      switch (code)
+		{
+		case MULT_EXPR:
+		case TRUNC_DIV_EXPR:
+		  imag = build2 (resultcode, real_type, imag, op1);
+		  /* Fall through.  */
+		case PLUS_EXPR:
+		case MINUS_EXPR:
+		  real = build2 (resultcode, real_type, real, op1);
+		  break;
+		default:
+		  gcc_unreachable();
+		}
+	    }
+	  else
+	    {
+	      op1 = c_save_expr (op1);
+	      real = build_unary_op (EXPR_LOCATION (orig_op1), REALPART_EXPR,
+				     op1, 1);
+	      imag = build_unary_op (EXPR_LOCATION (orig_op1), IMAGPART_EXPR,
+				     op1, 1);
+	      switch (code)
+		{
+		case MULT_EXPR:
+		  imag = build2 (resultcode, real_type, op0, imag);
+		  /* Fall through.  */
+		case PLUS_EXPR:
+		  real = build2 (resultcode, real_type, op0, real);
+		  break;
+		case MINUS_EXPR:
+		  real = build2 (resultcode, real_type, op0, real);
+		  imag = build1 (NEGATE_EXPR, real_type, imag);
+		  break;
+		default:
+		  gcc_unreachable();
+		}
+	    }
+	  ret = build2 (COMPLEX_EXPR, result_type, real, imag);
+	  goto return_build_binary_op;
 	}
 /* For certain operations (which identify themselves by shorten != 0)
 	 if both args were extended from the same smaller type,
 	 do the arithmetic in that type and then extend.
 	 but calculated in (unsigned short) it would be (unsigned short)-1.  */
 if (shorten && none_complex)
 	{
 	  final_type = result_type;
 	  result_type = shorten_binary_op (result_type, op0, op1,
 					   shorten == -1);
 	}
 /* Shifts can be shortened if shifting right.  */
 	  op0 = xop0, op1 = xop1;
 	  converted = 1;
 	  resultcode = xresultcode;
-	  if (warn_sign_compare && !skip_evaluation)
+	  if (c_inhibit_evaluation_warnings == 0)
-{
+	    {
-warn_for_sign_compare (location, orig_op0, orig_op1, op0, op1,
+	      bool op0_maybe_const = true;
-result_type, resultcode);
+	      bool op1_maybe_const = true;
+	      tree orig_op0_folded, orig_op1_folded;
+	      if (in_late_binary_op)
+		{
+		  orig_op0_folded = orig_op0;
+		  orig_op1_folded = orig_op1;
+		}
+	      else
+		{
+		  /* Fold for the sake of possible warnings, as in
+		     build_conditional_expr.  This requires the
+		     "original" values to be folded, not just op0 and
+		     op1.  */
+		  c_inhibit_evaluation_warnings++;
+		  op0 = c_fully_fold (op0, require_constant_value,
+				      &op0_maybe_const);
+		  op1 = c_fully_fold (op1, require_constant_value,
+				      &op1_maybe_const);
+		  c_inhibit_evaluation_warnings--;
+		  orig_op0_folded = c_fully_fold (orig_op0,
+						  require_constant_value,
+						  NULL);
+		  orig_op1_folded = c_fully_fold (orig_op1,
+						  require_constant_value,
+						  NULL);
+		}
+	      if (warn_sign_compare)
+		warn_for_sign_compare (location, orig_op0_folded,
+				       orig_op1_folded, op0, op1,
+				       result_type, resultcode);
+	      if (!in_late_binary_op)
+		{
+		  if (!op0_maybe_const || TREE_CODE (op0) != INTEGER_CST)
+		    op0 = c_wrap_maybe_const (op0, !op0_maybe_const);
+		  if (!op1_maybe_const || TREE_CODE (op1) != INTEGER_CST)
+		    op1 = c_wrap_maybe_const (op1, !op1_maybe_const);
+		}
 	    }
 	}
 }
 /* At this point, RESULT_TYPE must be nonzero to avoid an error message.
 if (TREE_CODE (op0) == ERROR_MARK || TREE_CODE (op1) == ERROR_MARK)
 	return error_mark_node;
 }
 if (build_type == NULL_TREE)
-build_type = result_type;
+{
+build_type = result_type;
+if (type0 != orig_type0 || type1 != orig_type1)
+	{
+	  gcc_assert (may_need_excess_precision && common);
+	  real_result_type = c_common_type (orig_type0, orig_type1);
+	}
+}
 /* Treat expressions in initializers specially as they can't trap.  */
-ret = require_constant_value ? fold_build2_initializer (resultcode,
+if (int_const_or_overflow)
-							  build_type,
+ret = (require_constant_value
-							  op0, op1)
+	   ? fold_build2_initializer_loc (location, resultcode, build_type,
-			       : fold_build2 (resultcode, build_type,
+					  op0, op1)
-					      op0, op1);
+	   : fold_build2_loc (location, resultcode, build_type, op0, op1));
+else
+ret = build2 (resultcode, build_type, op0, op1);
 if (final_type != 0)
 ret = convert (final_type, ret);
 return_build_binary_op:
 gcc_assert (ret != error_mark_node);
+if (TREE_CODE (ret) == INTEGER_CST && !TREE_OVERFLOW (ret) && !int_const)
+ret = (int_operands
+	   ? note_integer_operands (ret)
+	   : build1 (NOP_EXPR, TREE_TYPE (ret), ret));
+else if (TREE_CODE (ret) != INTEGER_CST && int_operands
+	   && !in_late_binary_op)
+ret = note_integer_operands (ret);
+if (real_result_type)
+ret = build1 (EXCESS_PRECISION_EXPR, real_result_type, ret);
 protected_set_expr_location (ret, location);
 return ret;
 }
 purpose.  LOCATION is the source location for the expression.  */
 tree
 c_objc_common_truthvalue_conversion (location_t location, tree expr)
 {
+bool int_const, int_operands;
 switch (TREE_CODE (TREE_TYPE (expr)))
 {
 case ARRAY_TYPE:
 error_at (location, "used array that cannot be converted to pointer where scalar is required");
 return error_mark_node;
 default:
 break;
 }
+int_const = (TREE_CODE (expr) == INTEGER_CST && !TREE_OVERFLOW (expr));
+int_operands = EXPR_INT_CONST_OPERANDS (expr);
+if (int_operands)
+expr = remove_c_maybe_const_expr (expr);
 /* ??? Should we also give an error for void and vectors rather than
 leaving those to give errors later?  */
-return c_common_truthvalue_conversion (location, expr);
+expr = c_common_truthvalue_conversion (location, expr);
+if (TREE_CODE (expr) == INTEGER_CST && int_operands && !int_const)
+{
+if (TREE_OVERFLOW (expr))
+	return expr;
+else
+	return note_integer_operands (expr);
+}
+if (TREE_CODE (expr) == INTEGER_CST && !int_const)
+return build1 (NOP_EXPR, TREE_TYPE (expr), expr);
+return expr;
 }
 /* Convert EXPR to a contained DECL, updating *TC, *TI and *SE as
 required.  */
 block = c_begin_compound_stmt (true);
 return block;
 }
-/* Generate OMP_PARALLEL, with CLAUSES and BLOCK as its compound statement.  */
+/* Generate OMP_PARALLEL, with CLAUSES and BLOCK as its compound
+statement.  LOC is the location of the OMP_PARALLEL.  */
 tree
-c_finish_omp_parallel (tree clauses, tree block)
+c_finish_omp_parallel (location_t loc, tree clauses, tree block)
 {
 tree stmt;
-block = c_end_compound_stmt (block, true);
+block = c_end_compound_stmt (loc, block, true);
 stmt = make_node (OMP_PARALLEL);
 TREE_TYPE (stmt) = void_type_node;
 OMP_PARALLEL_CLAUSES (stmt) = clauses;
 OMP_PARALLEL_BODY (stmt) = block;
+SET_EXPR_LOCATION (stmt, loc);
 return add_stmt (stmt);
 }
 /* Like c_begin_compound_stmt, except force the retention of the BLOCK.  */
 block = c_begin_compound_stmt (true);
 return block;
 }
-/* Generate OMP_TASK, with CLAUSES and BLOCK as its compound statement.  */
+/* Generate OMP_TASK, with CLAUSES and BLOCK as its compound
+statement.  LOC is the location of the #pragma.  */
 tree
-c_finish_omp_task (tree clauses, tree block)
+c_finish_omp_task (location_t loc, tree clauses, tree block)
 {
 tree stmt;
-block = c_end_compound_stmt (block, true);
+block = c_end_compound_stmt (loc, block, true);
 stmt = make_node (OMP_TASK);
 TREE_TYPE (stmt) = void_type_node;
 OMP_TASK_CLAUSES (stmt) = clauses;
 OMP_TASK_BODY (stmt) = block;
+SET_EXPR_LOCATION (stmt, loc);
 return add_stmt (stmt);
 }
 /* For all elements of CLAUSES, validate them vs OpenMP constraints.
 	  need_implicitly_determined = true;
 	  t = OMP_CLAUSE_DECL (c);
 	  if (AGGREGATE_TYPE_P (TREE_TYPE (t))
 	      || POINTER_TYPE_P (TREE_TYPE (t)))
 	    {
-	      error ("%qE has invalid type for %<reduction%>", t);
+	      error_at (OMP_CLAUSE_LOCATION (c),
+			"%qE has invalid type for %<reduction%>", t);
 	      remove = true;
 	    }
 	  else if (FLOAT_TYPE_P (TREE_TYPE (t)))
 	    {
 	      enum tree_code r_code = OMP_CLAUSE_REDUCTION_CODE (c);
 		default:
 		  gcc_unreachable ();
 		}
 	      if (r_name)
 		{
-		  error ("%qE has invalid type for %<reduction(%s)%>",
+		  error_at (OMP_CLAUSE_LOCATION (c),
-			 t, r_name);
+			    "%qE has invalid type for %<reduction(%s)%>",
+			    t, r_name);
 		  remove = true;
 		}
 	    }
 	  goto check_dup_generic;
 	case OMP_CLAUSE_COPYIN:
 	  name = "copyin";
 	  t = OMP_CLAUSE_DECL (c);
 	  if (TREE_CODE (t) != VAR_DECL || !DECL_THREAD_LOCAL_P (t))
 	    {
-	      error ("%qE must be %<threadprivate%> for %<copyin%>", t);
+	      error_at (OMP_CLAUSE_LOCATION (c),
+			"%qE must be %<threadprivate%> for %<copyin%>", t);
 	      remove = true;
 	    }
 	  goto check_dup_generic;
 	check_dup_generic:
 	  t = OMP_CLAUSE_DECL (c);
 	  if (TREE_CODE (t) != VAR_DECL && TREE_CODE (t) != PARM_DECL)
 	    {
-	      error ("%qE is not a variable in clause %qs", t, name);
+	      error_at (OMP_CLAUSE_LOCATION (c),
+			"%qE is not a variable in clause %qs", t, name);
 	      remove = true;
 	    }
 	  else if (bitmap_bit_p (&generic_head, DECL_UID (t))
 		   || bitmap_bit_p (&firstprivate_head, DECL_UID (t))
 		   || bitmap_bit_p (&lastprivate_head, DECL_UID (t)))
 	    {
-	      error ("%qE appears more than once in data clauses", t);
+	      error_at (OMP_CLAUSE_LOCATION (c),
+			"%qE appears more than once in data clauses", t);
 	      remove = true;
 	    }
 	  else
 	    bitmap_set_bit (&generic_head, DECL_UID (t));
 	  break;
 	  t = OMP_CLAUSE_DECL (c);
 	  need_complete = true;
 	  need_implicitly_determined = true;
 	  if (TREE_CODE (t) != VAR_DECL && TREE_CODE (t) != PARM_DECL)
 	    {
-	      error ("%qE is not a variable in clause %<firstprivate%>", t);
+	      error_at (OMP_CLAUSE_LOCATION (c),
+			"%qE is not a variable in clause %<firstprivate%>", t);
 	      remove = true;
 	    }
 	  else if (bitmap_bit_p (&generic_head, DECL_UID (t))
 		   || bitmap_bit_p (&firstprivate_head, DECL_UID (t)))
 	    {
-	      error ("%qE appears more than once in data clauses", t);
+	      error_at (OMP_CLAUSE_LOCATION (c),
+			"%qE appears more than once in data clauses", t);
 	      remove = true;
 	    }
 	  else
 	    bitmap_set_bit (&firstprivate_head, DECL_UID (t));
 	  break;
 	  t = OMP_CLAUSE_DECL (c);
 	  need_complete = true;
 	  need_implicitly_determined = true;
 	  if (TREE_CODE (t) != VAR_DECL && TREE_CODE (t) != PARM_DECL)
 	    {
-	      error ("%qE is not a variable in clause %<lastprivate%>", t);
+	      error_at (OMP_CLAUSE_LOCATION (c),
+			"%qE is not a variable in clause %<lastprivate%>", t);
 	      remove = true;
 	    }
 	  else if (bitmap_bit_p (&generic_head, DECL_UID (t))
 		   || bitmap_bit_p (&lastprivate_head, DECL_UID (t)))
 	    {
-	      error ("%qE appears more than once in data clauses", t);
+	      error_at (OMP_CLAUSE_LOCATION (c),
+		     "%qE appears more than once in data clauses", t);
 	      remove = true;
 	    }
 	  else
 	    bitmap_set_bit (&lastprivate_head, DECL_UID (t));
 	  break;
 		default:
 		  gcc_unreachable ();
 		}
 	      if (share_name)
 		{
-		  error ("%qE is predetermined %qs for %qs",
+		  error_at (OMP_CLAUSE_LOCATION (c),
-			 t, share_name, name);
+			    "%qE is predetermined %qs for %qs",
+			    t, share_name, name);
 		  remove = true;
 		}
 	    }
 	}
 || (domain && TYPE_STRUCTURAL_EQUALITY_P (domain)))
 SET_TYPE_STRUCTURAL_EQUALITY (t);
 else if (TYPE_CANONICAL (element_type) != element_type
 || (domain && TYPE_CANONICAL (domain) != domain))
 {
 tree unqualified_canon
 = build_array_type (TYPE_CANONICAL (element_type),
 domain? TYPE_CANONICAL (domain)
 : NULL_TREE);
 TYPE_CANONICAL (t)
 = c_build_qualified_type (unqualified_canon, type_quals);
 }
 else
 TYPE_CANONICAL (t) = t;
 	}
 type_quals &= ~TYPE_QUAL_RESTRICT;
 }
 return build_qualified_type (type, type_quals);
 }
+/* Build a VA_ARG_EXPR for the C parser.  */
+tree
+c_build_va_arg (location_t loc, tree expr, tree type)
+{
+if (warn_cxx_compat && TREE_CODE (type) == ENUMERAL_TYPE)
+warning_at (loc, OPT_Wc___compat,
+		"C++ requires promoted type, not enum type, in %<va_arg%>");
+return build_va_arg (loc, expr, type);
+}

Mercurial > hg > CbC > CbC_gcc

comparison gcc/c-typeck.c @ 55:77e2b8dfacca gcc-4.4.5