CbC/CbC_gcc: gcc/fold-const.c comparison

comparison gcc/fold-const.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	b7f97abdc517

comparison

equal deleted inserted replaced

-:c156f1bd5cd9
+:77e2b8dfacca
 static void decode (HOST_WIDE_INT *, unsigned HOST_WIDE_INT *, HOST_WIDE_INT *);
 static bool negate_mathfn_p (enum built_in_function);
 static bool negate_expr_p (tree);
 static tree negate_expr (tree);
 static tree split_tree (tree, enum tree_code, tree *, tree *, tree *, int);
-static tree associate_trees (tree, tree, enum tree_code, tree);
+static tree associate_trees (location_t, tree, tree, enum tree_code, tree);
 static tree const_binop (enum tree_code, tree, tree, int);
 static enum comparison_code comparison_to_compcode (enum tree_code);
 static enum tree_code compcode_to_comparison (enum comparison_code);
-static tree combine_comparisons (enum tree_code, enum tree_code,
-				 enum tree_code, tree, tree, tree);
 static int operand_equal_for_comparison_p (tree, tree, tree);
 static int twoval_comparison_p (tree, tree *, tree *, int *);
-static tree eval_subst (tree, tree, tree, tree, tree);
+static tree eval_subst (location_t, tree, tree, tree, tree, tree);
-static tree pedantic_omit_one_operand (tree, tree, tree);
+static tree pedantic_omit_one_operand_loc (location_t, tree, tree, tree);
-static tree distribute_bit_expr (enum tree_code, tree, tree, tree);
+static tree distribute_bit_expr (location_t, enum tree_code, tree, tree, tree);
-static tree make_bit_field_ref (tree, tree, HOST_WIDE_INT, HOST_WIDE_INT, int);
+static tree make_bit_field_ref (location_t, tree, tree,
-static tree optimize_bit_field_compare (enum tree_code, tree, tree, tree);
+				HOST_WIDE_INT, HOST_WIDE_INT, int);
-static tree decode_field_reference (tree, HOST_WIDE_INT *, HOST_WIDE_INT *,
+static tree optimize_bit_field_compare (location_t, enum tree_code,
+					tree, tree, tree);
+static tree decode_field_reference (location_t, tree, HOST_WIDE_INT *,
+				    HOST_WIDE_INT *,
 				    enum machine_mode *, int *, int *,
 				    tree *, tree *);
 static int all_ones_mask_p (const_tree, int);
 static tree sign_bit_p (tree, const_tree);
 static int simple_operand_p (const_tree);
 static tree range_binop (enum tree_code, tree, tree, int, tree, int);
 static tree range_predecessor (tree);
 static tree range_successor (tree);
-static tree make_range (tree, int *, tree *, tree *, bool *);
+extern tree make_range (tree, int *, tree *, tree *, bool *);
-static tree build_range_check (tree, tree, int, tree, tree);
+extern bool merge_ranges (int *, tree *, tree *, int, tree, tree, int,
-static int merge_ranges (int *, tree *, tree *, int, tree, tree, int, tree,
+			  tree, tree);
-			 tree);
+static tree fold_range_test (location_t, enum tree_code, tree, tree, tree);
-static tree fold_range_test (enum tree_code, tree, tree, tree);
+static tree fold_cond_expr_with_comparison (location_t, tree, tree, tree, tree);
-static tree fold_cond_expr_with_comparison (tree, tree, tree, tree);
 static tree unextend (tree, int, int, tree);
-static tree fold_truthop (enum tree_code, tree, tree, tree);
+static tree fold_truthop (location_t, enum tree_code, tree, tree, tree);
-static tree optimize_minmax_comparison (enum tree_code, tree, tree, tree);
+static tree optimize_minmax_comparison (location_t, enum tree_code,
+					tree, tree, tree);
 static tree extract_muldiv (tree, tree, enum tree_code, tree, bool *);
 static tree extract_muldiv_1 (tree, tree, enum tree_code, tree, bool *);
-static tree fold_binary_op_with_conditional_arg (enum tree_code, tree,
+static tree fold_binary_op_with_conditional_arg (location_t,
+						 enum tree_code, tree,
 						 tree, tree,
 						 tree, tree, int);
-static tree fold_mathfn_compare (enum built_in_function, enum tree_code,
+static tree fold_mathfn_compare (location_t,
+				 enum built_in_function, enum tree_code,
 				 tree, tree, tree);
-static tree fold_inf_compare (enum tree_code, tree, tree, tree);
+static tree fold_inf_compare (location_t, enum tree_code, tree, tree, tree);
-static tree fold_div_compare (enum tree_code, tree, tree, tree);
+static tree fold_div_compare (location_t, enum tree_code, tree, tree, tree);
 static bool reorder_operands_p (const_tree, const_tree);
 static tree fold_negate_const (tree, tree);
 static tree fold_not_const (tree, tree);
 static tree fold_relational_const (enum tree_code, tree, tree, tree);
+static tree fold_convert_const (enum tree_code, tree, tree);
 /* We know that A1 + B1 = SUM1, using 2's complement arithmetic and ignoring
 overflow.  Suppose A, B and SUM have the same respective signs as A1, B1,
 and SUM1.  Then this yields nonzero if overflow occurred during the
 fit_double_type (unsigned HOST_WIDE_INT l1, HOST_WIDE_INT h1,
 		 unsigned HOST_WIDE_INT *lv, HOST_WIDE_INT *hv, const_tree type)
 {
 unsigned HOST_WIDE_INT low0 = l1;
 HOST_WIDE_INT high0 = h1;
-unsigned int prec;
+unsigned int prec = TYPE_PRECISION (type);
 int sign_extended_type;
-if (POINTER_TYPE_P (type)
-|| TREE_CODE (type) == OFFSET_TYPE)
-prec = POINTER_SIZE;
-else
-prec = TYPE_PRECISION (type);
 /* Size types *are* sign extended.  */
 sign_extended_type = (!TYPE_UNSIGNED (type)
 			|| (TREE_CODE (type) == INTEGER_TYPE
 			    && TYPE_IS_SIZETYPE (type)));
 {
 unsigned HOST_WIDE_INT l;
 HOST_WIDE_INT h;
 l = l1 + l2;
-h = (HOST_WIDE_INT) ((unsigned HOST_WIDE_INT) h1
+h = h1 + h2 + (l < l1);
-		       + (unsigned HOST_WIDE_INT) h2
-		       + (l < l1));
 *lv = l;
 *hv = h;
 if (unsigned_p)
-return ((unsigned HOST_WIDE_INT) h < (unsigned HOST_WIDE_INT) h1
+return (unsigned HOST_WIDE_INT) h < (unsigned HOST_WIDE_INT) h1;
-	    || (h == h1
-		&& l < l1));
 else
 return OVERFLOW_SUM_SIGN (h1, h2, h);
 }
 /* Negate a doubleword integer with doubleword result.
 /* If ARG2 divides ARG1 with zero remainder, carries out the division
 of type CODE and returns the quotient.
 Otherwise returns NULL_TREE.  */
-static tree
+tree
 div_if_zero_remainder (enum tree_code code, const_tree arg1, const_tree arg2)
 {
 unsigned HOST_WIDE_INT int1l, int2l;
 HOST_WIDE_INT int1h, int2h;
 unsigned HOST_WIDE_INT quol, reml;
 HOST_WIDE_INT quoh, remh;
-tree type = TREE_TYPE (arg1);
+int uns;
-int uns = TYPE_UNSIGNED (type);
+/* The sign of the division is according to operand two, that
+does the correct thing for POINTER_PLUS_EXPR where we want
+a signed division.  */
+uns = TYPE_UNSIGNED (TREE_TYPE (arg2));
+if (TREE_CODE (TREE_TYPE (arg2)) == INTEGER_TYPE
+&& TYPE_IS_SIZETYPE (TREE_TYPE (arg2)))
+uns = false;
 int1l = TREE_INT_CST_LOW (arg1);
 int1h = TREE_INT_CST_HIGH (arg1);
-/* &obj[0] + -128 really should be compiled as &obj[-8] rather than
-&obj[some_exotic_number].  */
-if (POINTER_TYPE_P (type))
-{
-uns = false;
-type = signed_type_for (type);
-fit_double_type (int1l, int1h, &int1l, &int1h,
-		       type);
-}
-else
-fit_double_type (int1l, int1h, &int1l, &int1h, type);
 int2l = TREE_INT_CST_LOW (arg2);
 int2h = TREE_INT_CST_HIGH (arg2);
 div_and_round_double (code, uns, int1l, int1h, int2l, int2h,
 		  	&quol, &quoh, &reml, &remh);
 if (remh != 0 || reml != 0)
 return NULL_TREE;
-return build_int_cst_wide (type, quol, quoh);
+return build_int_cst_wide (TREE_TYPE (arg1), quol, quoh);
 }
 /* This is nonzero if we should defer warnings about undefined
 overflow.  This facility exists because these warnings are a
 special case.  The code to estimate loop iterations does not want
 if (fold_deferring_overflow_warnings > 0)
 {
 if (fold_deferred_overflow_warning != NULL
 	  && code != 0
 	  && code < (int) fold_deferred_overflow_code)
-	fold_deferred_overflow_code = code;
+	fold_deferred_overflow_code = (enum warn_strict_overflow_code) code;
 return;
 }
 warnmsg = fold_deferred_overflow_warning;
 fold_deferred_overflow_warning = NULL;
 if (stmt == NULL)
 locus = input_location;
 else
 locus = gimple_location (stmt);
-warning (OPT_Wstrict_overflow, "%H%s", &locus, warnmsg);
+warning_at (locus, OPT_Wstrict_overflow, "%s", warnmsg);
 }
 /* Stop deferring overflow warnings, ignoring any deferred
 warnings.  */
 CASE_FLT_FN (BUILT_IN_LLRINT):
 CASE_FLT_FN (BUILT_IN_LRINT):
 CASE_FLT_FN (BUILT_IN_NEARBYINT):
 CASE_FLT_FN (BUILT_IN_RINT):
 return !flag_rounding_math;
 default:
 break;
 }
 return false;
 }
 simplification is possible.
 If negate_expr_p would return true for T, NULL_TREE will never be
 returned.  */
 static tree
-fold_negate_expr (tree t)
+fold_negate_expr (location_t loc, tree t)
 {
 tree type = TREE_TYPE (t);
 tree tem;
 switch (TREE_CODE (t))
 {
 /* Convert - (~A) to A + 1.  */
 case BIT_NOT_EXPR:
 if (INTEGRAL_TYPE_P (type))
-return fold_build2 (PLUS_EXPR, type, TREE_OPERAND (t, 0),
+return fold_build2_loc (loc, PLUS_EXPR, type, TREE_OPERAND (t, 0),
 build_int_cst (type, 1));
 break;
 case INTEGER_CST:
 tem = fold_negate_const (t, type);
 if (TREE_OVERFLOW (tem) == TREE_OVERFLOW (t)
 	  || !TYPE_OVERFLOW_TRAPS (type))
 	return tem;
 }
 break;
 case COMPLEX_EXPR:
 if (negate_expr_p (t))
-	return fold_build2 (COMPLEX_EXPR, type,
+	return fold_build2_loc (loc, COMPLEX_EXPR, type,
-			    fold_negate_expr (TREE_OPERAND (t, 0)),
+			    fold_negate_expr (loc, TREE_OPERAND (t, 0)),
-			    fold_negate_expr (TREE_OPERAND (t, 1)));
+			    fold_negate_expr (loc, TREE_OPERAND (t, 1)));
 break;
 case CONJ_EXPR:
 if (negate_expr_p (t))
-	return fold_build1 (CONJ_EXPR, type,
+	return fold_build1_loc (loc, CONJ_EXPR, type,
-			    fold_negate_expr (TREE_OPERAND (t, 0)));
+			    fold_negate_expr (loc, TREE_OPERAND (t, 0)));
 break;
 case NEGATE_EXPR:
 return TREE_OPERAND (t, 0);
 	  if (negate_expr_p (TREE_OPERAND (t, 1))
 	      && reorder_operands_p (TREE_OPERAND (t, 0),
 				     TREE_OPERAND (t, 1)))
 	    {
 	      tem = negate_expr (TREE_OPERAND (t, 1));
-	      return fold_build2 (MINUS_EXPR, type,
+	      return fold_build2_loc (loc, MINUS_EXPR, type,
 				  tem, TREE_OPERAND (t, 0));
 	    }
 	  /* -(A + B) -> (-A) - B.  */
 	  if (negate_expr_p (TREE_OPERAND (t, 0)))
 	    {
 	      tem = negate_expr (TREE_OPERAND (t, 0));
-	      return fold_build2 (MINUS_EXPR, type,
+	      return fold_build2_loc (loc, MINUS_EXPR, type,
 				  tem, TREE_OPERAND (t, 1));
 	    }
 	}
 break;
 case MINUS_EXPR:
 /* - (A - B) -> B - A  */
 if (!HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (type))
 	  && !HONOR_SIGNED_ZEROS (TYPE_MODE (type))
 	  && reorder_operands_p (TREE_OPERAND (t, 0), TREE_OPERAND (t, 1)))
-	return fold_build2 (MINUS_EXPR, type,
+	return fold_build2_loc (loc, MINUS_EXPR, type,
 			    TREE_OPERAND (t, 1), TREE_OPERAND (t, 0));
 break;
 case MULT_EXPR:
 if (TYPE_UNSIGNED (type))
 case RDIV_EXPR:
 if (! HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (type)))
 	{
 	  tem = TREE_OPERAND (t, 1);
 	  if (negate_expr_p (tem))
-	    return fold_build2 (TREE_CODE (t), type,
+	    return fold_build2_loc (loc, TREE_CODE (t), type,
 				TREE_OPERAND (t, 0), negate_expr (tem));
 	  tem = TREE_OPERAND (t, 0);
 	  if (negate_expr_p (tem))
-	    return fold_build2 (TREE_CODE (t), type,
+	    return fold_build2_loc (loc, TREE_CODE (t), type,
 				negate_expr (tem), TREE_OPERAND (t, 1));
 	}
 break;
 case TRUNC_DIV_EXPR:
 	    {
 	      if (INTEGRAL_TYPE_P (type)
 		  && (TREE_CODE (tem) != INTEGER_CST
 		      || integer_onep (tem)))
 		fold_overflow_warning (warnmsg, WARN_STRICT_OVERFLOW_MISC);
-	      return fold_build2 (TREE_CODE (t), type,
+	      return fold_build2_loc (loc, TREE_CODE (t), type,
 				  TREE_OPERAND (t, 0), negate_expr (tem));
 	    }
 tem = TREE_OPERAND (t, 0);
 if (negate_expr_p (tem))
 	    {
 	      if (INTEGRAL_TYPE_P (type)
 		  && (TREE_CODE (tem) != INTEGER_CST
 		      || tree_int_cst_equal (tem, TYPE_MIN_VALUE (type))))
 		fold_overflow_warning (warnmsg, WARN_STRICT_OVERFLOW_MISC);
-	      return fold_build2 (TREE_CODE (t), type,
+	      return fold_build2_loc (loc, TREE_CODE (t), type,
 				  negate_expr (tem), TREE_OPERAND (t, 1));
 	    }
 }
 break;
 /* Convert -((double)float) into (double)(-float).  */
 if (TREE_CODE (type) == REAL_TYPE)
 	{
 	  tem = strip_float_extensions (t);
 	  if (tem != t && negate_expr_p (tem))
-	    return fold_convert (type, negate_expr (tem));
+	    return fold_convert_loc (loc, type, negate_expr (tem));
 	}
 break;
 case CALL_EXPR:
 /* Negate -f(x) as f(-x).  */
 	{
 	  tree fndecl, arg;
 	  fndecl = get_callee_fndecl (t);
 	  arg = negate_expr (CALL_EXPR_ARG (t, 0));
-	  return build_call_expr (fndecl, 1, arg);
+	  return build_call_expr_loc (loc, fndecl, 1, arg);
 	}
 break;
 case RSHIFT_EXPR:
 /* Optimize -((int)x >> 31) into (unsigned)x >> 31.  */
 		 == TREE_INT_CST_LOW (op1))
 	    {
 	      tree ntype = TYPE_UNSIGNED (type)
 			   ? signed_type_for (type)
 			   : unsigned_type_for (type);
-	      tree temp = fold_convert (ntype, TREE_OPERAND (t, 0));
+	      tree temp = fold_convert_loc (loc, ntype, TREE_OPERAND (t, 0));
-	      temp = fold_build2 (RSHIFT_EXPR, ntype, temp, op1);
+	      temp = fold_build2_loc (loc, RSHIFT_EXPR, ntype, temp, op1);
-	      return fold_convert (type, temp);
+	      return fold_convert_loc (loc, type, temp);
 	    }
 	}
 break;
 default:
 static tree
 negate_expr (tree t)
 {
 tree type, tem;
+location_t loc;
 if (t == NULL_TREE)
 return NULL_TREE;
+loc = EXPR_LOCATION (t);
 type = TREE_TYPE (t);
 STRIP_SIGN_NOPS (t);
-tem = fold_negate_expr (t);
+tem = fold_negate_expr (loc, t);
 if (!tem)
-tem = build1 (NEGATE_EXPR, TREE_TYPE (t), t);
+{
-return fold_convert (type, tem);
+tem = build1 (NEGATE_EXPR, TREE_TYPE (t), t);
+SET_EXPR_LOCATION (tem, loc);
+}
+return fold_convert_loc (loc, type, tem);
 }
 /* Split a tree IN into a constant, literal and variable parts that could be
 combined with CODE to make IN.  "constant" means an expression with
 TREE_CONSTANT but that isn't an actual constant.  CODE must be a
 }
 return var;
 }
-/* Re-associate trees split by the above function.  T1 and T2 are either
+/* Re-associate trees split by the above function.  T1 and T2 are
-expressions to associate or null.  Return the new expression, if any.  If
+either expressions to associate or null.  Return the new
+expression, if any.  LOC is the location of the new expression.  If
 we build an operation, do it in TYPE and with CODE.  */
 static tree
-associate_trees (tree t1, tree t2, enum tree_code code, tree type)
+associate_trees (location_t loc, tree t1, tree t2, enum tree_code code, tree type)
 {
+tree tem;
 if (t1 == 0)
 return t2;
 else if (t2 == 0)
 return t1;
 || TREE_CODE (t1) == MINUS_EXPR || TREE_CODE (t2) == MINUS_EXPR)
 {
 if (code == PLUS_EXPR)
 	{
 	  if (TREE_CODE (t1) == NEGATE_EXPR)
-	    return build2 (MINUS_EXPR, type, fold_convert (type, t2),
+	    tem = build2 (MINUS_EXPR, type, fold_convert_loc (loc, type, t2),
-			   fold_convert (type, TREE_OPERAND (t1, 0)));
+			  fold_convert_loc (loc, type, TREE_OPERAND (t1, 0)));
 	  else if (TREE_CODE (t2) == NEGATE_EXPR)
-	    return build2 (MINUS_EXPR, type, fold_convert (type, t1),
+	    tem = build2 (MINUS_EXPR, type, fold_convert_loc (loc, type, t1),
-			   fold_convert (type, TREE_OPERAND (t2, 0)));
+			  fold_convert_loc (loc, type, TREE_OPERAND (t2, 0)));
 	  else if (integer_zerop (t2))
-	    return fold_convert (type, t1);
+	    return fold_convert_loc (loc, type, t1);
 	}
 else if (code == MINUS_EXPR)
 	{
 	  if (integer_zerop (t2))
-	    return fold_convert (type, t1);
+	    return fold_convert_loc (loc, type, t1);
 	}
-return build2 (code, type, fold_convert (type, t1),
+tem = build2 (code, type, fold_convert_loc (loc, type, t1),
-		     fold_convert (type, t2));
+		    fold_convert_loc (loc, type, t2));
-}
+goto associate_trees_exit;
+}
-return fold_build2 (code, type, fold_convert (type, t1),
-		      fold_convert (type, t2));
+return fold_build2_loc (loc, code, type, fold_convert_loc (loc, type, t1),
+		      fold_convert_loc (loc, type, t2));
+associate_trees_exit:
+protected_set_expr_location (tem, loc);
+return tem;
 }
 /* Check whether TYPE1 and TYPE2 are equivalent integer types, suitable
 for use in int_const_binop, size_binop and size_diffop.  */
 sat_p = TYPE_SATURATING (type);
 overflow_p = fixed_arithmetic (&result, code, &f1, &f2, sat_p);
 t = build_fixed (type, result);
 /* Propagate overflow flags.  */
 if (overflow_p | TREE_OVERFLOW (arg1) | TREE_OVERFLOW (arg2))
-	{
+	TREE_OVERFLOW (t) = 1;
-	  TREE_OVERFLOW (t) = 1;
-	  TREE_CONSTANT_OVERFLOW (t) = 1;
-	}
-else if (TREE_CONSTANT_OVERFLOW (arg1) | TREE_CONSTANT_OVERFLOW (arg2))
-	TREE_CONSTANT_OVERFLOW (t) = 1;
 return t;
 }
 if (TREE_CODE (arg1) == COMPLEX_CST)
 {
 	  real = const_binop (code, r1, r2, notrunc);
 	  imag = const_binop (code, i1, i2, notrunc);
 	  break;
 	case MULT_EXPR:
+	  if (COMPLEX_FLOAT_TYPE_P (type))
+	    return do_mpc_arg2 (arg1, arg2, type,
+				/* do_nonfinite= */ folding_initializer,
+				mpc_mul);
 	  real = const_binop (MINUS_EXPR,
 			      const_binop (MULT_EXPR, r1, r2, notrunc),
 			      const_binop (MULT_EXPR, i1, i2, notrunc),
 			      notrunc);
 	  imag = const_binop (PLUS_EXPR,
 			      const_binop (MULT_EXPR, i1, r2, notrunc),
 			      notrunc);
 	  break;
 	case RDIV_EXPR:
+	  if (COMPLEX_FLOAT_TYPE_P (type))
+	    return do_mpc_arg2 (arg1, arg2, type,
+/* do_nonfinite= */ folding_initializer,
+				mpc_div);
+	  /* Fallthru ... */
+	case TRUNC_DIV_EXPR:
+	case CEIL_DIV_EXPR:
+	case FLOOR_DIV_EXPR:
+	case ROUND_DIV_EXPR:
+	  if (flag_complex_method == 0)
 	  {
+	    /* Keep this algorithm in sync with
+	       tree-complex.c:expand_complex_div_straight().
+	       Expand complex division to scalars, straightforward algorithm.
+	       a / b = ((ar*br + ai*bi)/t) + i((ai*br - ar*bi)/t)
+	       t = br*br + bi*bi
+	    */
 	    tree magsquared
 	      = const_binop (PLUS_EXPR,
 			     const_binop (MULT_EXPR, r2, r2, notrunc),
 			     const_binop (MULT_EXPR, i2, i2, notrunc),
 			     notrunc);
 	      = const_binop (MINUS_EXPR,
 			     const_binop (MULT_EXPR, i1, r2, notrunc),
 			     const_binop (MULT_EXPR, r1, i2, notrunc),
 			     notrunc);
-	    if (INTEGRAL_TYPE_P (TREE_TYPE (r1)))
-	      code = TRUNC_DIV_EXPR;
 	    real = const_binop (code, t1, magsquared, notrunc);
 	    imag = const_binop (code, t2, magsquared, notrunc);
 	  }
+	  else
+	  {
+	    /* Keep this algorithm in sync with
+tree-complex.c:expand_complex_div_wide().
+	       Expand complex division to scalars, modified algorithm to minimize
+	       overflow with wide input ranges.  */
+	    tree compare = fold_build2 (LT_EXPR, boolean_type_node,
+					fold_abs_const (r2, TREE_TYPE (type)),
+					fold_abs_const (i2, TREE_TYPE (type)));
+	    if (integer_nonzerop (compare))
+	      {
+		/* In the TRUE branch, we compute
+		   ratio = br/bi;
+		   div = (br * ratio) + bi;
+		   tr = (ar * ratio) + ai;
+		   ti = (ai * ratio) - ar;
+		   tr = tr / div;
+		   ti = ti / div;  */
+		tree ratio = const_binop (code, r2, i2, notrunc);
+		tree div = const_binop (PLUS_EXPR, i2,
+					const_binop (MULT_EXPR, r2, ratio,
+						     notrunc),
+					notrunc);
+		real = const_binop (MULT_EXPR, r1, ratio, notrunc);
+		real = const_binop (PLUS_EXPR, real, i1, notrunc);
+		real = const_binop (code, real, div, notrunc);
+		imag = const_binop (MULT_EXPR, i1, ratio, notrunc);
+		imag = const_binop (MINUS_EXPR, imag, r1, notrunc);
+		imag = const_binop (code, imag, div, notrunc);
+	      }
+	    else
+	      {
+		/* In the FALSE branch, we compute
+		   ratio = d/c;
+		   divisor = (d * ratio) + c;
+		   tr = (b * ratio) + a;
+		   ti = b - (a * ratio);
+		   tr = tr / div;
+		   ti = ti / div;  */
+		tree ratio = const_binop (code, i2, r2, notrunc);
+		tree div = const_binop (PLUS_EXPR, r2,
+const_binop (MULT_EXPR, i2, ratio,
+						     notrunc),
+					notrunc);
+		real = const_binop (MULT_EXPR, i1, ratio, notrunc);
+		real = const_binop (PLUS_EXPR, real, r1, notrunc);
+		real = const_binop (code, real, div, notrunc);
+		imag = const_binop (MULT_EXPR, r1, ratio, notrunc);
+		imag = const_binop (MINUS_EXPR, i1, imag, notrunc);
+		imag = const_binop (code, imag, div, notrunc);
+	      }
+	  }
 	  break;
 	default:
 	  return NULL_TREE;
 	}
 if (real && imag)
 	return build_complex (type, real, imag);
 }
+if (TREE_CODE (arg1) == VECTOR_CST)
+{
+tree type = TREE_TYPE(arg1);
+int count = TYPE_VECTOR_SUBPARTS (type), i;
+tree elements1, elements2, list = NULL_TREE;
+if(TREE_CODE(arg2) != VECTOR_CST)
+return NULL_TREE;
+elements1 = TREE_VECTOR_CST_ELTS (arg1);
+elements2 = TREE_VECTOR_CST_ELTS (arg2);
+for (i = 0; i < count; i++)
+	{
+tree elem1, elem2, elem;
+/* The trailing elements can be empty and should be treated as 0 */
+if(!elements1)
+elem1 = fold_convert_const (NOP_EXPR, TREE_TYPE (type), integer_zero_node);
+else
+{
+elem1 = TREE_VALUE(elements1);
+elements1 = TREE_CHAIN (elements1);
+}
+if(!elements2)
+elem2 = fold_convert_const (NOP_EXPR, TREE_TYPE (type), integer_zero_node);
+else
+{
+elem2 = TREE_VALUE(elements2);
+elements2 = TREE_CHAIN (elements2);
+}
+elem = const_binop (code, elem1, elem2, notrunc);
+/* It is possible that const_binop cannot handle the given
+code and return NULL_TREE */
+if(elem == NULL_TREE)
+return NULL_TREE;
+list = tree_cons (NULL_TREE, elem, list);
+	}
+return build_vector(type, nreverse(list));
+}
 return NULL_TREE;
 }
 /* Create a size type INT_CST node with NUMBER sign extended.  KIND
 indicates which particular sizetype to create.  */
 is a tree code.  The type of the result is taken from the operands.
 Both must be equivalent integer types, ala int_binop_types_match_p.
 If the operands are constant, so is the result.  */
 tree
-size_binop (enum tree_code code, tree arg0, tree arg1)
+size_binop_loc (location_t loc, enum tree_code code, tree arg0, tree arg1)
 {
 tree type = TREE_TYPE (arg0);
 if (arg0 == error_mark_node || arg1 == error_mark_node)
 return error_mark_node;
 /* Handle general case of two integer constants.  */
 return int_const_binop (code, arg0, arg1, 0);
 }
-return fold_build2 (code, type, arg0, arg1);
+return fold_build2_loc (loc, code, type, arg0, arg1);
 }
 /* Given two values, either both of sizetype or both of bitsizetype,
 compute the difference between the two values.  Return the value
 in signed type corresponding to the type of the operands.  */
 tree
-size_diffop (tree arg0, tree arg1)
+size_diffop_loc (location_t loc, tree arg0, tree arg1)
 {
 tree type = TREE_TYPE (arg0);
 tree ctype;
 gcc_assert (int_binop_types_match_p (MINUS_EXPR, TREE_TYPE (arg0),
 				       TREE_TYPE (arg1)));
 /* If the type is already signed, just do the simple thing.  */
 if (!TYPE_UNSIGNED (type))
-return size_binop (MINUS_EXPR, arg0, arg1);
+return size_binop_loc (loc, MINUS_EXPR, arg0, arg1);
 if (type == sizetype)
 ctype = ssizetype;
 else if (type == bitsizetype)
 ctype = sbitsizetype;
 /* If either operand is not a constant, do the conversions to the signed
 type and subtract.  The hardware will do the right thing with any
 overflow in the subtraction.  */
 if (TREE_CODE (arg0) != INTEGER_CST || TREE_CODE (arg1) != INTEGER_CST)
-return size_binop (MINUS_EXPR, fold_convert (ctype, arg0),
+return size_binop_loc (loc, MINUS_EXPR,
-		       fold_convert (ctype, arg1));
+			   fold_convert_loc (loc, ctype, arg0),
+			   fold_convert_loc (loc, ctype, arg1));
 /* If ARG0 is larger than ARG1, subtract and return the result in CTYPE.
 Otherwise, subtract the other way, convert to CTYPE (we know that can't
 overflow) and negate (which can't either).  Special-case a result
 of zero while we're here.  */
 if (tree_int_cst_equal (arg0, arg1))
 return build_int_cst (ctype, 0);
 else if (tree_int_cst_lt (arg1, arg0))
-return fold_convert (ctype, size_binop (MINUS_EXPR, arg0, arg1));
+return fold_convert_loc (loc, ctype,
+			     size_binop_loc (loc, MINUS_EXPR, arg0, arg1));
 else
-return size_binop (MINUS_EXPR, build_int_cst (ctype, 0),
+return size_binop_loc (loc, MINUS_EXPR, build_int_cst (ctype, 0),
-		       fold_convert (ctype, size_binop (MINUS_EXPR,
+			   fold_convert_loc (loc, ctype,
-							arg1, arg0)));
+					     size_binop_loc (loc,
+							     MINUS_EXPR,
+							     arg1, arg0)));
 }
 /* A subroutine of fold_convert_const handling conversions of an
 INTEGER_CST to another integer type.  */
 tree t;
 real_convert (&value, TYPE_MODE (type), &TREE_REAL_CST (arg1));
 t = build_real (type, value);
-TREE_OVERFLOW (t) = TREE_OVERFLOW (arg1);
+/* If converting an infinity or NAN to a representation that doesn't
+have one, set the overflow bit so that we can produce some kind of
+error message at the appropriate point if necessary.  It's not the
+most user-friendly message, but it's better than nothing.  */
+if (REAL_VALUE_ISINF (TREE_REAL_CST (arg1))
+&& !MODE_HAS_INFINITIES (TYPE_MODE (type)))
+TREE_OVERFLOW (t) = 1;
+else if (REAL_VALUE_ISNAN (TREE_REAL_CST (arg1))
+	   && !MODE_HAS_NANS (TYPE_MODE (type)))
+TREE_OVERFLOW (t) = 1;
+/* Regular overflow, conversion produced an infinity in a mode that
+can't represent them.  */
+else if (!MODE_HAS_INFINITIES (TYPE_MODE (type))
+	   && REAL_VALUE_ISINF (value)
+	   && !REAL_VALUE_ISINF (TREE_REAL_CST (arg1)))
+TREE_OVERFLOW (t) = 1;
+else
+TREE_OVERFLOW (t) = TREE_OVERFLOW (arg1);
 return t;
 }
 /* A subroutine of fold_convert_const handling conversions a FIXED_CST
 to a floating point type.  */
 real_convert_from_fixed (&value, TYPE_MODE (type), &TREE_FIXED_CST (arg1));
 t = build_real (type, value);
 TREE_OVERFLOW (t) = TREE_OVERFLOW (arg1);
-TREE_CONSTANT_OVERFLOW (t)
-= TREE_OVERFLOW (t) | TREE_CONSTANT_OVERFLOW (arg1);
 return t;
 }
 /* A subroutine of fold_convert_const handling conversions a FIXED_CST
 to another fixed-point type.  */
 			      TYPE_SATURATING (type));
 t = build_fixed (type, value);
 /* Propagate overflow flags.  */
 if (overflow_p | TREE_OVERFLOW (arg1))
-{
+TREE_OVERFLOW (t) = 1;
-TREE_OVERFLOW (t) = 1;
-TREE_CONSTANT_OVERFLOW (t) = 1;
-}
-else if (TREE_CONSTANT_OVERFLOW (arg1))
-TREE_CONSTANT_OVERFLOW (t) = 1;
 return t;
 }
 /* A subroutine of fold_convert_const handling conversions an INTEGER_CST
 to a fixed-point type.  */
 				       TYPE_SATURATING (type));
 t = build_fixed (type, value);
 /* Propagate overflow flags.  */
 if (overflow_p | TREE_OVERFLOW (arg1))
-{
+TREE_OVERFLOW (t) = 1;
-TREE_OVERFLOW (t) = 1;
-TREE_CONSTANT_OVERFLOW (t) = 1;
-}
-else if (TREE_CONSTANT_OVERFLOW (arg1))
-TREE_CONSTANT_OVERFLOW (t) = 1;
 return t;
 }
 /* A subroutine of fold_convert_const handling conversions a REAL_CST
 to a fixed-point type.  */
 					TYPE_SATURATING (type));
 t = build_fixed (type, value);
 /* Propagate overflow flags.  */
 if (overflow_p | TREE_OVERFLOW (arg1))
-{
+TREE_OVERFLOW (t) = 1;
-TREE_OVERFLOW (t) = 1;
-TREE_CONSTANT_OVERFLOW (t) = 1;
-}
-else if (TREE_CONSTANT_OVERFLOW (arg1))
-TREE_CONSTANT_OVERFLOW (t) = 1;
 return t;
 }
 /* Attempt to fold type conversion operation CODE of expression ARG1 to
 type TYPE.  If no simplification can be done return NULL_TREE.  */
 tree elem, list;
 int i, units;
 elem = fold_convert_const (NOP_EXPR, TREE_TYPE (type), integer_zero_node);
 units = TYPE_VECTOR_SUBPARTS (type);
 list = NULL_TREE;
 for (i = 0; i < units; i++)
 list = tree_cons (NULL_TREE, elem, list);
 return build_vector (type, list);
 }
 /* Convert expression ARG to type TYPE.  Used by the middle-end for
 simple conversions in preference to calling the front-end's convert.  */
 tree
-fold_convert (tree type, tree arg)
+fold_convert_loc (location_t loc, tree type, tree arg)
 {
 tree orig = TREE_TYPE (arg);
 tree tem;
 if (type == orig)
 || TREE_CODE (type) == ERROR_MARK
 || TREE_CODE (orig) == ERROR_MARK)
 return error_mark_node;
 if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (orig))
-return fold_build1 (NOP_EXPR, type, arg);
+return fold_build1_loc (loc, NOP_EXPR, type, arg);
 switch (TREE_CODE (type))
 {
+case POINTER_TYPE:
+case REFERENCE_TYPE:
+/* Handle conversions between pointers to different address spaces.  */
+if (POINTER_TYPE_P (orig)
+	  && (TYPE_ADDR_SPACE (TREE_TYPE (type))
+	      != TYPE_ADDR_SPACE (TREE_TYPE (orig))))
+	return fold_build1_loc (loc, ADDR_SPACE_CONVERT_EXPR, type, arg);
+/* fall through */
 case INTEGER_TYPE: case ENUMERAL_TYPE: case BOOLEAN_TYPE:
-case POINTER_TYPE: case REFERENCE_TYPE:
 case OFFSET_TYPE:
 if (TREE_CODE (arg) == INTEGER_CST)
 	{
 	  tem = fold_convert_const (NOP_EXPR, type, arg);
 	  if (tem != NULL_TREE)
 	    return tem;
 	}
 if (INTEGRAL_TYPE_P (orig) || POINTER_TYPE_P (orig)
 	  || TREE_CODE (orig) == OFFSET_TYPE)
-return fold_build1 (NOP_EXPR, type, arg);
+	return fold_build1_loc (loc, NOP_EXPR, type, arg);
 if (TREE_CODE (orig) == COMPLEX_TYPE)
-	{
+	return fold_convert_loc (loc, type,
-	  tem = fold_build1 (REALPART_EXPR, TREE_TYPE (orig), arg);
+			     fold_build1_loc (loc, REALPART_EXPR,
-	  return fold_convert (type, tem);
+					  TREE_TYPE (orig), arg));
-	}
 gcc_assert (TREE_CODE (orig) == VECTOR_TYPE
 		  && tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (orig)));
-return fold_build1 (NOP_EXPR, type, arg);
+return fold_build1_loc (loc, NOP_EXPR, type, arg);
 case REAL_TYPE:
 if (TREE_CODE (arg) == INTEGER_CST)
 	{
 	  tem = fold_convert_const (FLOAT_EXPR, type, arg);
 switch (TREE_CODE (orig))
 	{
 	case INTEGER_TYPE:
 	case BOOLEAN_TYPE: case ENUMERAL_TYPE:
 	case POINTER_TYPE: case REFERENCE_TYPE:
-	  return fold_build1 (FLOAT_EXPR, type, arg);
+	  return fold_build1_loc (loc, FLOAT_EXPR, type, arg);
 	case REAL_TYPE:
-	  return fold_build1 (NOP_EXPR, type, arg);
+	  return fold_build1_loc (loc, NOP_EXPR, type, arg);
 	case FIXED_POINT_TYPE:
-	  return fold_build1 (FIXED_CONVERT_EXPR, type, arg);
+	  return fold_build1_loc (loc, FIXED_CONVERT_EXPR, type, arg);
 	case COMPLEX_TYPE:
-	  tem = fold_build1 (REALPART_EXPR, TREE_TYPE (orig), arg);
+	  tem = fold_build1_loc (loc, REALPART_EXPR, TREE_TYPE (orig), arg);
-	  return fold_convert (type, tem);
+	  return fold_convert_loc (loc, type, tem);
 	default:
 	  gcc_unreachable ();
 	}
 if (TREE_CODE (arg) == FIXED_CST || TREE_CODE (arg) == INTEGER_CST
 	  || TREE_CODE (arg) == REAL_CST)
 	{
 	  tem = fold_convert_const (FIXED_CONVERT_EXPR, type, arg);
 	  if (tem != NULL_TREE)
-	    return tem;
+	    goto fold_convert_exit;
 	}
 switch (TREE_CODE (orig))
 	{
 	case FIXED_POINT_TYPE:
 	case INTEGER_TYPE:
 	case ENUMERAL_TYPE:
 	case BOOLEAN_TYPE:
 	case REAL_TYPE:
-	  return fold_build1 (FIXED_CONVERT_EXPR, type, arg);
+	  return fold_build1_loc (loc, FIXED_CONVERT_EXPR, type, arg);
 	case COMPLEX_TYPE:
-	  tem = fold_build1 (REALPART_EXPR, TREE_TYPE (orig), arg);
+	  tem = fold_build1_loc (loc, REALPART_EXPR, TREE_TYPE (orig), arg);
-	  return fold_convert (type, tem);
+	  return fold_convert_loc (loc, type, tem);
 	default:
 	  gcc_unreachable ();
 	}
 	case INTEGER_TYPE:
 	case BOOLEAN_TYPE: case ENUMERAL_TYPE:
 	case POINTER_TYPE: case REFERENCE_TYPE:
 	case REAL_TYPE:
 	case FIXED_POINT_TYPE:
-	  return fold_build2 (COMPLEX_EXPR, type,
+	  return fold_build2_loc (loc, COMPLEX_EXPR, type,
-			      fold_convert (TREE_TYPE (type), arg),
+			      fold_convert_loc (loc, TREE_TYPE (type), arg),
-			      fold_convert (TREE_TYPE (type),
+			      fold_convert_loc (loc, TREE_TYPE (type),
 					    integer_zero_node));
 	case COMPLEX_TYPE:
 	  {
 	    tree rpart, ipart;
 	    if (TREE_CODE (arg) == COMPLEX_EXPR)
 	      {
-		rpart = fold_convert (TREE_TYPE (type), TREE_OPERAND (arg, 0));
+		rpart = fold_convert_loc (loc, TREE_TYPE (type),
-		ipart = fold_convert (TREE_TYPE (type), TREE_OPERAND (arg, 1));
+				      TREE_OPERAND (arg, 0));
-		return fold_build2 (COMPLEX_EXPR, type, rpart, ipart);
+		ipart = fold_convert_loc (loc, TREE_TYPE (type),
+				      TREE_OPERAND (arg, 1));
+		return fold_build2_loc (loc, COMPLEX_EXPR, type, rpart, ipart);
 	      }
 	    arg = save_expr (arg);
-	    rpart = fold_build1 (REALPART_EXPR, TREE_TYPE (orig), arg);
+	    rpart = fold_build1_loc (loc, REALPART_EXPR, TREE_TYPE (orig), arg);
-	    ipart = fold_build1 (IMAGPART_EXPR, TREE_TYPE (orig), arg);
+	    ipart = fold_build1_loc (loc, IMAGPART_EXPR, TREE_TYPE (orig), arg);
-	    rpart = fold_convert (TREE_TYPE (type), rpart);
+	    rpart = fold_convert_loc (loc, TREE_TYPE (type), rpart);
-	    ipart = fold_convert (TREE_TYPE (type), ipart);
+	    ipart = fold_convert_loc (loc, TREE_TYPE (type), ipart);
-	    return fold_build2 (COMPLEX_EXPR, type, rpart, ipart);
+	    return fold_build2_loc (loc, COMPLEX_EXPR, type, rpart, ipart);
 	  }
 	default:
 	  gcc_unreachable ();
 	}
 if (integer_zerop (arg))
 	return build_zero_vector (type);
 gcc_assert (tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (orig)));
 gcc_assert (INTEGRAL_TYPE_P (orig) || POINTER_TYPE_P (orig)
 		  || TREE_CODE (orig) == VECTOR_TYPE);
-return fold_build1 (VIEW_CONVERT_EXPR, type, arg);
+return fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, arg);
 case VOID_TYPE:
 tem = fold_ignored_result (arg);
 if (TREE_CODE (tem) == MODIFY_EXPR)
-	return tem;
+	goto fold_convert_exit;
-return fold_build1 (NOP_EXPR, type, tem);
+return fold_build1_loc (loc, NOP_EXPR, type, tem);
 default:
 gcc_unreachable ();
 }
+fold_convert_exit:
+protected_set_expr_location (tem, loc);
+return tem;
 }
 /* Return false if expr can be assumed not to be an lvalue, true
 otherwise.  */
 case COMPOUND_EXPR:
 case MODIFY_EXPR:
 case TARGET_EXPR:
 case COND_EXPR:
 case BIND_EXPR:
-case MIN_EXPR:
-case MAX_EXPR:
 break;
 default:
 /* Assume the worst for front-end tree codes.  */
 if ((int)TREE_CODE (x) >= NUM_TREE_CODES)
 }
 /* Return an expr equal to X but certainly not valid as an lvalue.  */
 tree
-non_lvalue (tree x)
+non_lvalue_loc (location_t loc, tree x)
 {
 /* While we are in GIMPLE, NON_LVALUE_EXPR doesn't mean anything to
 us.  */
 if (in_gimple_form)
 return x;
 if (! maybe_lvalue_p (x))
 return x;
-return build1 (NON_LVALUE_EXPR, TREE_TYPE (x), x);
+x = build1 (NON_LVALUE_EXPR, TREE_TYPE (x), x);
+SET_EXPR_LOCATION (x, loc);
+return x;
 }
 /* Nonzero means lvalues are limited to those valid in pedantic ANSI C.
 Zero means allow extended lvalues.  */
 /* When pedantic, return an expr equal to X but certainly not valid as a
 pedantic lvalue.  Otherwise, return X.  */
 static tree
-pedantic_non_lvalue (tree x)
+pedantic_non_lvalue_loc (location_t loc, tree x)
 {
 if (pedantic_lvalues)
-return non_lvalue (x);
+return non_lvalue_loc (loc, x);
-else
+protected_set_expr_location (x, loc);
 return x;
 }
 /* Given a tree comparison code, return the code that is the logical inverse
 of the given code.  It is not safe to do this for floating-point
 comparisons, except for NE_EXPR and EQ_EXPR, so we receive a machine mode
 and RCODE on the identical operands LL_ARG and LR_ARG.  Take into account
 the possibility of trapping if the mode has NaNs, and return NULL_TREE
 if this makes the transformation invalid.  */
 tree
-combine_comparisons (enum tree_code code, enum tree_code lcode,
+combine_comparisons (location_t loc,
+		     enum tree_code code, enum tree_code lcode,
 		     enum tree_code rcode, tree truth_type,
 		     tree ll_arg, tree lr_arg)
 {
 bool honor_nans = HONOR_NANS (TYPE_MODE (TREE_TYPE (ll_arg)));
 enum comparison_code lcompcode = comparison_to_compcode (lcode);
 enum comparison_code rcompcode = comparison_to_compcode (rcode);
-enum comparison_code compcode;
+int compcode;
 switch (code)
 {
 case TRUTH_AND_EXPR: case TRUTH_ANDIF_EXPR:
 compcode = lcompcode & rcompcode;
 if (compcode == COMPCODE_TRUE)
 return constant_boolean_node (true, truth_type);
 else if (compcode == COMPCODE_FALSE)
 return constant_boolean_node (false, truth_type);
 else
-return fold_build2 (compcode_to_comparison (compcode),
+{
-			truth_type, ll_arg, lr_arg);
+enum tree_code tcode;
+tcode = compcode_to_comparison ((enum comparison_code) compcode);
+return fold_build2_loc (loc, tcode, truth_type, ll_arg, lr_arg);
+}
 }
 /* Return nonzero if two operands (typically of the same tree node)
 are necessarily equal.  If either argument has side-effects this
 function returns zero.  FLAGS modifies behavior as follows:
 because they may change the signedness of the arguments.  As pointers
 strictly don't have a signedness, require either two pointers or
 two non-pointers as well.  */
 if (TYPE_UNSIGNED (TREE_TYPE (arg0)) != TYPE_UNSIGNED (TREE_TYPE (arg1))
 || POINTER_TYPE_P (TREE_TYPE (arg0)) != POINTER_TYPE_P (TREE_TYPE (arg1)))
+return 0;
+/* We cannot consider pointers to different address space equal.  */
+if (POINTER_TYPE_P (TREE_TYPE (arg0)) && POINTER_TYPE_P (TREE_TYPE (arg1))
+&& (TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (arg0)))
+	  != TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (arg1)))))
 return 0;
 /* If both types don't have the same precision, then it is not safe
 to strip NOPs.  */
 if (TYPE_PRECISION (TREE_TYPE (arg0)) != TYPE_PRECISION (TREE_TYPE (arg1)))
 case REAL_CST:
 	if (REAL_VALUES_IDENTICAL (TREE_REAL_CST (arg0),
 				   TREE_REAL_CST (arg1)))
 	  return 1;
 	if (!HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0))))
 	  {
 	    /* If we do not distinguish between signed and unsigned zero,
 	       consider them equal.  */
 	    if (real_zerop (arg0) && real_zerop (arg1))
 		  && operand_equal_p (TREE_OPERAND (arg0, 1),
 				      TREE_OPERAND (arg1, 0), flags));
 	case COND_EXPR:
 	  return OP_SAME (0) && OP_SAME (1) && OP_SAME (2);
 	default:
 	  return 0;
 	}
 case tcc_vl_exp:
 comparisons.  Evaluate the operations in the tree substituting NEW0 for
 any occurrence of OLD0 as an operand of a comparison and likewise for
 NEW1 and OLD1.  */
 static tree
-eval_subst (tree arg, tree old0, tree new0, tree old1, tree new1)
+eval_subst (location_t loc, tree arg, tree old0, tree new0,
+	    tree old1, tree new1)
 {
 tree type = TREE_TYPE (arg);
 enum tree_code code = TREE_CODE (arg);
 enum tree_code_class tclass = TREE_CODE_CLASS (code);
 tclass = tcc_binary;
 switch (tclass)
 {
 case tcc_unary:
-return fold_build1 (code, type,
+return fold_build1_loc (loc, code, type,
-			  eval_subst (TREE_OPERAND (arg, 0),
+			  eval_subst (loc, TREE_OPERAND (arg, 0),
 				      old0, new0, old1, new1));
 case tcc_binary:
-return fold_build2 (code, type,
+return fold_build2_loc (loc, code, type,
-			  eval_subst (TREE_OPERAND (arg, 0),
+			  eval_subst (loc, TREE_OPERAND (arg, 0),
 				      old0, new0, old1, new1),
-			  eval_subst (TREE_OPERAND (arg, 1),
+			  eval_subst (loc, TREE_OPERAND (arg, 1),
 				      old0, new0, old1, new1));
 case tcc_expression:
 switch (code)
 	{
 	case SAVE_EXPR:
-	  return eval_subst (TREE_OPERAND (arg, 0), old0, new0, old1, new1);
+	  return eval_subst (loc, TREE_OPERAND (arg, 0), old0, new0,
+			     old1, new1);
 	case COMPOUND_EXPR:
-	  return eval_subst (TREE_OPERAND (arg, 1), old0, new0, old1, new1);
+	  return eval_subst (loc, TREE_OPERAND (arg, 1), old0, new0,
+			     old1, new1);
 	case COND_EXPR:
-	  return fold_build3 (code, type,
+	  return fold_build3_loc (loc, code, type,
-			      eval_subst (TREE_OPERAND (arg, 0),
+			      eval_subst (loc, TREE_OPERAND (arg, 0),
 					  old0, new0, old1, new1),
-			      eval_subst (TREE_OPERAND (arg, 1),
+			      eval_subst (loc, TREE_OPERAND (arg, 1),
 					  old0, new0, old1, new1),
-			      eval_subst (TREE_OPERAND (arg, 2),
+			      eval_subst (loc, TREE_OPERAND (arg, 2),
 					  old0, new0, old1, new1));
 	default:
 	  break;
 	}
 /* Fall through - ???  */
 	if (arg1 == old0 || operand_equal_p (arg1, old0, 0))
 	  arg1 = new0;
 	else if (arg1 == old1 || operand_equal_p (arg1, old1, 0))
 	  arg1 = new1;
-	return fold_build2 (code, type, arg0, arg1);
+	return fold_build2_loc (loc, code, type, arg0, arg1);
 }
 default:
 return arg;
 }
 If OMITTED has side effects, we must evaluate it.  Otherwise, just do
 the conversion of RESULT to TYPE.  */
 tree
-omit_one_operand (tree type, tree result, tree omitted)
+omit_one_operand_loc (location_t loc, tree type, tree result, tree omitted)
 {
-tree t = fold_convert (type, result);
+tree t = fold_convert_loc (loc, type, result);
 /* If the resulting operand is an empty statement, just return the omitted
 statement casted to void. */
 if (IS_EMPTY_STMT (t) && TREE_SIDE_EFFECTS (omitted))
-return build1 (NOP_EXPR, void_type_node, fold_ignored_result (omitted));
+{
+t = build1 (NOP_EXPR, void_type_node, fold_ignored_result (omitted));
+goto omit_one_operand_exit;
+}
 if (TREE_SIDE_EFFECTS (omitted))
-return build2 (COMPOUND_EXPR, type, fold_ignored_result (omitted), t);
+{
+t = build2 (COMPOUND_EXPR, type, fold_ignored_result (omitted), t);
-return non_lvalue (t);
+goto omit_one_operand_exit;
+}
+return non_lvalue_loc (loc, t);
+omit_one_operand_exit:
+protected_set_expr_location (t, loc);
+return t;
 }
 /* Similar, but call pedantic_non_lvalue instead of non_lvalue.  */
 static tree
-pedantic_omit_one_operand (tree type, tree result, tree omitted)
+pedantic_omit_one_operand_loc (location_t loc, tree type, tree result,
-{
+			       tree omitted)
-tree t = fold_convert (type, result);
+{
+tree t = fold_convert_loc (loc, type, result);
 /* If the resulting operand is an empty statement, just return the omitted
 statement casted to void. */
 if (IS_EMPTY_STMT (t) && TREE_SIDE_EFFECTS (omitted))
-return build1 (NOP_EXPR, void_type_node, fold_ignored_result (omitted));
+{
+t = build1 (NOP_EXPR, void_type_node, fold_ignored_result (omitted));
+goto pedantic_omit_one_operand_exit;
+}
 if (TREE_SIDE_EFFECTS (omitted))
-return build2 (COMPOUND_EXPR, type, fold_ignored_result (omitted), t);
+{
+t = build2 (COMPOUND_EXPR, type, fold_ignored_result (omitted), t);
-return pedantic_non_lvalue (t);
+goto pedantic_omit_one_operand_exit;
+}
+return pedantic_non_lvalue_loc (loc, t);
+pedantic_omit_one_operand_exit:
+protected_set_expr_location (t, loc);
+return t;
 }
 /* Return a tree for the case when the result of an expression is RESULT
 converted to TYPE and OMITTED1 and OMITTED2 were previously operands
 of the expression but are now not needed.
 If both OMITTED1 and OMITTED2 have side effects, OMITTED1 is
 evaluated before OMITTED2.  Otherwise, if neither has side effects,
 just do the conversion of RESULT to TYPE.  */
 tree
-omit_two_operands (tree type, tree result, tree omitted1, tree omitted2)
+omit_two_operands_loc (location_t loc, tree type, tree result,
-{
+		   tree omitted1, tree omitted2)
-tree t = fold_convert (type, result);
+{
+tree t = fold_convert_loc (loc, type, result);
 if (TREE_SIDE_EFFECTS (omitted2))
-t = build2 (COMPOUND_EXPR, type, omitted2, t);
+{
+t = build2 (COMPOUND_EXPR, type, omitted2, t);
+SET_EXPR_LOCATION (t, loc);
+}
 if (TREE_SIDE_EFFECTS (omitted1))
-t = build2 (COMPOUND_EXPR, type, omitted1, t);
+{
+t = build2 (COMPOUND_EXPR, type, omitted1, t);
-return TREE_CODE (t) != COMPOUND_EXPR ? non_lvalue (t) : t;
+SET_EXPR_LOCATION (t, loc);
+}
+return TREE_CODE (t) != COMPOUND_EXPR ? non_lvalue_loc (loc, t) : t;
 }
 /* Return a simplified tree node for the truth-negation of ARG.  This
 never alters ARG itself.  We assume that ARG is an operation that
 FIXME: one would think we would fold the result, but it causes
 problems with the dominator optimizer.  */
 tree
-fold_truth_not_expr (tree arg)
+fold_truth_not_expr (location_t loc, tree arg)
 {
-tree type = TREE_TYPE (arg);
+tree t, type = TREE_TYPE (arg);
 enum tree_code code = TREE_CODE (arg);
+location_t loc1, loc2;
 /* If this is a comparison, we can simply invert it, except for
 floating-point non-equality comparisons, in which case we just
 enclose a TRUTH_NOT_EXPR around what we have.  */
 if (FLOAT_TYPE_P (op_type)
 	  && flag_trapping_math
 	  && code != ORDERED_EXPR && code != UNORDERED_EXPR
 	  && code != NE_EXPR && code != EQ_EXPR)
 	return NULL_TREE;
-else
-	{
+code = invert_tree_comparison (code, HONOR_NANS (TYPE_MODE (op_type)));
-	  code = invert_tree_comparison (code,
+if (code == ERROR_MARK)
-					 HONOR_NANS (TYPE_MODE (op_type)));
+	return NULL_TREE;
-	  if (code == ERROR_MARK)
-	    return NULL_TREE;
+t = build2 (code, type, TREE_OPERAND (arg, 0), TREE_OPERAND (arg, 1));
-	  else
+SET_EXPR_LOCATION (t, loc);
-	    return build2 (code, type,
+return t;
-			   TREE_OPERAND (arg, 0), TREE_OPERAND (arg, 1));
-	}
 }
 switch (code)
 {
 case INTEGER_CST:
 return constant_boolean_node (integer_zerop (arg), type);
 case TRUTH_AND_EXPR:
-return build2 (TRUTH_OR_EXPR, type,
+loc1 = EXPR_LOCATION (TREE_OPERAND (arg, 0));
-		     invert_truthvalue (TREE_OPERAND (arg, 0)),
+loc2 = EXPR_LOCATION (TREE_OPERAND (arg, 1));
-		     invert_truthvalue (TREE_OPERAND (arg, 1)));
+if (loc1 == UNKNOWN_LOCATION)
+	loc1 = loc;
+if (loc2 == UNKNOWN_LOCATION)
+	loc2 = loc;
+t = build2 (TRUTH_OR_EXPR, type,
+		  invert_truthvalue_loc (loc1, TREE_OPERAND (arg, 0)),
+		  invert_truthvalue_loc (loc2, TREE_OPERAND (arg, 1)));
+break;
 case TRUTH_OR_EXPR:
-return build2 (TRUTH_AND_EXPR, type,
+loc1 = EXPR_LOCATION (TREE_OPERAND (arg, 0));
-		     invert_truthvalue (TREE_OPERAND (arg, 0)),
+loc2 = EXPR_LOCATION (TREE_OPERAND (arg, 1));
-		     invert_truthvalue (TREE_OPERAND (arg, 1)));
+if (loc1 == UNKNOWN_LOCATION)
+	loc1 = loc;
+if (loc2 == UNKNOWN_LOCATION)
+	loc2 = loc;
+t = build2 (TRUTH_AND_EXPR, type,
+		  invert_truthvalue_loc (loc1, TREE_OPERAND (arg, 0)),
+		  invert_truthvalue_loc (loc2, TREE_OPERAND (arg, 1)));
+break;
 case TRUTH_XOR_EXPR:
 /* Here we can invert either operand.  We invert the first operand
 	 unless the second operand is a TRUTH_NOT_EXPR in which case our
 	 result is the XOR of the first operand with the inside of the
 	 negation of the second operand.  */
 if (TREE_CODE (TREE_OPERAND (arg, 1)) == TRUTH_NOT_EXPR)
-	return build2 (TRUTH_XOR_EXPR, type, TREE_OPERAND (arg, 0),
+	t = build2 (TRUTH_XOR_EXPR, type, TREE_OPERAND (arg, 0),
-		       TREE_OPERAND (TREE_OPERAND (arg, 1), 0));
+		    TREE_OPERAND (TREE_OPERAND (arg, 1), 0));
 else
-	return build2 (TRUTH_XOR_EXPR, type,
+	t = build2 (TRUTH_XOR_EXPR, type,
-		       invert_truthvalue (TREE_OPERAND (arg, 0)),
+		    invert_truthvalue_loc (loc, TREE_OPERAND (arg, 0)),
-		       TREE_OPERAND (arg, 1));
+		    TREE_OPERAND (arg, 1));
+break;
 case TRUTH_ANDIF_EXPR:
-return build2 (TRUTH_ORIF_EXPR, type,
+loc1 = EXPR_LOCATION (TREE_OPERAND (arg, 0));
-		     invert_truthvalue (TREE_OPERAND (arg, 0)),
+loc2 = EXPR_LOCATION (TREE_OPERAND (arg, 1));
-		     invert_truthvalue (TREE_OPERAND (arg, 1)));
+if (loc1 == UNKNOWN_LOCATION)
+	loc1 = loc;
+if (loc2 == UNKNOWN_LOCATION)
+	loc2 = loc;
+t = build2 (TRUTH_ORIF_EXPR, type,
+		  invert_truthvalue_loc (loc1, TREE_OPERAND (arg, 0)),
+		  invert_truthvalue_loc (loc2, TREE_OPERAND (arg, 1)));
+break;
 case TRUTH_ORIF_EXPR:
-return build2 (TRUTH_ANDIF_EXPR, type,
+loc1 = EXPR_LOCATION (TREE_OPERAND (arg, 0));
-		     invert_truthvalue (TREE_OPERAND (arg, 0)),
+loc2 = EXPR_LOCATION (TREE_OPERAND (arg, 1));
-		     invert_truthvalue (TREE_OPERAND (arg, 1)));
+if (loc1 == UNKNOWN_LOCATION)
+	loc1 = loc;
+if (loc2 == UNKNOWN_LOCATION)
+	loc2 = loc;
+t = build2 (TRUTH_ANDIF_EXPR, type,
+		  invert_truthvalue_loc (loc1, TREE_OPERAND (arg, 0)),
+		  invert_truthvalue_loc (loc2, TREE_OPERAND (arg, 1)));
+break;
 case TRUTH_NOT_EXPR:
 return TREE_OPERAND (arg, 0);
 case COND_EXPR:
 {
 	tree arg1 = TREE_OPERAND (arg, 1);
 	tree arg2 = TREE_OPERAND (arg, 2);
+	loc1 = EXPR_LOCATION (TREE_OPERAND (arg, 1));
+	loc2 = EXPR_LOCATION (TREE_OPERAND (arg, 2));
+	if (loc1 == UNKNOWN_LOCATION)
+	  loc1 = loc;
+	if (loc2 == UNKNOWN_LOCATION)
+	  loc2 = loc;
 	/* A COND_EXPR may have a throw as one operand, which
 	   then has void type.  Just leave void operands
 	   as they are.  */
-	return build3 (COND_EXPR, type, TREE_OPERAND (arg, 0),
+	t = build3 (COND_EXPR, type, TREE_OPERAND (arg, 0),
-		       VOID_TYPE_P (TREE_TYPE (arg1))
+		    VOID_TYPE_P (TREE_TYPE (arg1))
-		       ? arg1 : invert_truthvalue (arg1),
+		    ? arg1 : invert_truthvalue_loc (loc1, arg1),
-		       VOID_TYPE_P (TREE_TYPE (arg2))
+		    VOID_TYPE_P (TREE_TYPE (arg2))
-		       ? arg2 : invert_truthvalue (arg2));
+		    ? arg2 : invert_truthvalue_loc (loc2, arg2));
+	break;
 }
 case COMPOUND_EXPR:
-return build2 (COMPOUND_EXPR, type, TREE_OPERAND (arg, 0),
+loc1 = EXPR_LOCATION (TREE_OPERAND (arg, 1));
-		     invert_truthvalue (TREE_OPERAND (arg, 1)));
+if (loc1 == UNKNOWN_LOCATION)
+	loc1 = loc;
+t = build2 (COMPOUND_EXPR, type,
+		  TREE_OPERAND (arg, 0),
+		  invert_truthvalue_loc (loc1, TREE_OPERAND (arg, 1)));
+break;
 case NON_LVALUE_EXPR:
-return invert_truthvalue (TREE_OPERAND (arg, 0));
+loc1 = EXPR_LOCATION (TREE_OPERAND (arg, 0));
+if (loc1 == UNKNOWN_LOCATION)
-case NOP_EXPR:
+	loc1 = loc;
+return invert_truthvalue_loc (loc1, TREE_OPERAND (arg, 0));
+CASE_CONVERT:
 if (TREE_CODE (TREE_TYPE (arg)) == BOOLEAN_TYPE)
-	return build1 (TRUTH_NOT_EXPR, type, arg);
+	{
+	  t = build1 (TRUTH_NOT_EXPR, type, arg);
-case CONVERT_EXPR:
+	  break;
+	}
+/* ... fall through ...  */
 case FLOAT_EXPR:
-return build1 (TREE_CODE (arg), type,
+loc1 = EXPR_LOCATION (TREE_OPERAND (arg, 0));
-		     invert_truthvalue (TREE_OPERAND (arg, 0)));
+if (loc1 == UNKNOWN_LOCATION)
+	loc1 = loc;
+t = build1 (TREE_CODE (arg), type,
+		  invert_truthvalue_loc (loc1, TREE_OPERAND (arg, 0)));
+break;
 case BIT_AND_EXPR:
 if (!integer_onep (TREE_OPERAND (arg, 1)))
-	break;
+	return NULL_TREE;
-return build2 (EQ_EXPR, type, arg,
+t = build2 (EQ_EXPR, type, arg, build_int_cst (type, 0));
-		     build_int_cst (type, 0));
+break;
 case SAVE_EXPR:
-return build1 (TRUTH_NOT_EXPR, type, arg);
+t = build1 (TRUTH_NOT_EXPR, type, arg);
+break;
 case CLEANUP_POINT_EXPR:
-return build1 (CLEANUP_POINT_EXPR, type,
+loc1 = EXPR_LOCATION (TREE_OPERAND (arg, 0));
-		     invert_truthvalue (TREE_OPERAND (arg, 0)));
+if (loc1 == UNKNOWN_LOCATION)
+	loc1 = loc;
+t = build1 (CLEANUP_POINT_EXPR, type,
+		  invert_truthvalue_loc (loc1, TREE_OPERAND (arg, 0)));
+break;
 default:
+t = NULL_TREE;
 break;
 }
-return NULL_TREE;
+if (t)
+SET_EXPR_LOCATION (t, loc);
+return t;
 }
 /* Return a simplified tree node for the truth-negation of ARG.  This
 never alters ARG itself.  We assume that ARG is an operation that
 returns a truth value (0 or 1).
 FIXME: one would think we would fold the result, but it causes
 problems with the dominator optimizer.  */
 tree
-invert_truthvalue (tree arg)
+invert_truthvalue_loc (location_t loc, tree arg)
 {
 tree tem;
 if (TREE_CODE (arg) == ERROR_MARK)
 return arg;
-tem = fold_truth_not_expr (arg);
+tem = fold_truth_not_expr (loc, arg);
 if (!tem)
-tem = build1 (TRUTH_NOT_EXPR, TREE_TYPE (arg), arg);
+{
+tem = build1 (TRUTH_NOT_EXPR, TREE_TYPE (arg), arg);
+SET_EXPR_LOCATION (tem, loc);
+}
 return tem;
 }
 /* Given a bit-wise operation CODE applied to ARG0 and ARG1, see if both
 Further simplification will occur if B and C are constants.
 If this optimization cannot be done, 0 will be returned.  */
 static tree
-distribute_bit_expr (enum tree_code code, tree type, tree arg0, tree arg1)
+distribute_bit_expr (location_t loc, enum tree_code code, tree type,
+		     tree arg0, tree arg1)
 {
 tree common;
 tree left, right;
 if (TREE_CODE (arg0) != TREE_CODE (arg1)
 right = TREE_OPERAND (arg1, 0);
 }
 else
 return 0;
-common = fold_convert (type, common);
+common = fold_convert_loc (loc, type, common);
-left = fold_convert (type, left);
+left = fold_convert_loc (loc, type, left);
-right = fold_convert (type, right);
+right = fold_convert_loc (loc, type, right);
-return fold_build2 (TREE_CODE (arg0), type, common,
+return fold_build2_loc (loc, TREE_CODE (arg0), type, common,
-		      fold_build2 (code, type, left, right));
+		      fold_build2_loc (loc, code, type, left, right));
 }
 /* Knowing that ARG0 and ARG1 are both RDIV_EXPRs, simplify a binary operation
 with code CODE.  This optimization is unsafe.  */
 static tree
-distribute_real_division (enum tree_code code, tree type, tree arg0, tree arg1)
+distribute_real_division (location_t loc, enum tree_code code, tree type,
+			  tree arg0, tree arg1)
 {
 bool mul0 = TREE_CODE (arg0) == MULT_EXPR;
 bool mul1 = TREE_CODE (arg1) == MULT_EXPR;
 /* (A / C) +- (B / C) -> (A +- B) / C.  */
 if (mul0 == mul1
 && operand_equal_p (TREE_OPERAND (arg0, 1),
 		       TREE_OPERAND (arg1, 1), 0))
-return fold_build2 (mul0 ? MULT_EXPR : RDIV_EXPR, type,
+return fold_build2_loc (loc, mul0 ? MULT_EXPR : RDIV_EXPR, type,
-			fold_build2 (code, type,
+			fold_build2_loc (loc, code, type,
 				     TREE_OPERAND (arg0, 0),
 				     TREE_OPERAND (arg1, 0)),
 			TREE_OPERAND (arg0, 1));
 /* (A / C1) +- (A / C2) -> A * (1 / C1 +- 1 / C2).  */
 if (!mul0)
 	real_arithmetic (&r0, RDIV_EXPR, &dconst1, &r0);
 if (!mul1)
 real_arithmetic (&r1, RDIV_EXPR, &dconst1, &r1);
 real_arithmetic (&r0, code, &r0, &r1);
-return fold_build2 (MULT_EXPR, type,
+return fold_build2_loc (loc, MULT_EXPR, type,
 			  TREE_OPERAND (arg0, 0),
 			  build_real (type, r0));
 }
 return NULL_TREE;
 /* Return a BIT_FIELD_REF of type TYPE to refer to BITSIZE bits of INNER
 starting at BITPOS.  The field is unsigned if UNSIGNEDP is nonzero.  */
 static tree
-make_bit_field_ref (tree inner, tree type, HOST_WIDE_INT bitsize,
+make_bit_field_ref (location_t loc, tree inner, tree type,
-		    HOST_WIDE_INT bitpos, int unsignedp)
+		    HOST_WIDE_INT bitsize, HOST_WIDE_INT bitpos, int unsignedp)
 {
 tree result, bftype;
 if (bitpos == 0)
 {
 tree size = TYPE_SIZE (TREE_TYPE (inner));
 if ((INTEGRAL_TYPE_P (TREE_TYPE (inner))
 	   || POINTER_TYPE_P (TREE_TYPE (inner)))
 	  && host_integerp (size, 0)
 	  && tree_low_cst (size, 0) == bitsize)
-	return fold_convert (type, inner);
+	return fold_convert_loc (loc, type, inner);
 }
 bftype = type;
 if (TYPE_PRECISION (bftype) != bitsize
 || TYPE_UNSIGNED (bftype) == !unsignedp)
 bftype = build_nonstandard_integer_type (bitsize, 0);
 result = build3 (BIT_FIELD_REF, bftype, inner,
 		   size_int (bitsize), bitsize_int (bitpos));
+SET_EXPR_LOCATION (result, loc);
 if (bftype != type)
-result = fold_convert (type, result);
+result = fold_convert_loc (loc, type, result);
 return result;
 }
 /* Optimize a bit-field compare.
 If the optimization described above can be done, we return the resulting
 tree.  Otherwise we return zero.  */
 static tree
-optimize_bit_field_compare (enum tree_code code, tree compare_type,
+optimize_bit_field_compare (location_t loc, enum tree_code code,
-			    tree lhs, tree rhs)
+			    tree compare_type, tree lhs, tree rhs)
 {
 HOST_WIDE_INT lbitpos, lbitsize, rbitpos, rbitsize, nbitpos, nbitsize;
 tree type = TREE_TYPE (lhs);
 tree signed_type, unsigned_type;
 int const_p = TREE_CODE (rhs) == INTEGER_CST;
 		      size_int (nbitsize - lbitsize - lbitpos), 0);
 if (! const_p)
 /* If not comparing with constant, just rework the comparison
 and return.  */
-return fold_build2 (code, compare_type,
+return fold_build2_loc (loc, code, compare_type,
-			fold_build2 (BIT_AND_EXPR, unsigned_type,
+			fold_build2_loc (loc, BIT_AND_EXPR, unsigned_type,
-				     make_bit_field_ref (linner,
+				     make_bit_field_ref (loc, linner,
 							 unsigned_type,
 							 nbitsize, nbitpos,
 							 1),
 				     mask),
-			fold_build2 (BIT_AND_EXPR, unsigned_type,
+			fold_build2_loc (loc, BIT_AND_EXPR, unsigned_type,
-				     make_bit_field_ref (rinner,
+				     make_bit_field_ref (loc, rinner,
 							 unsigned_type,
 							 nbitsize, nbitpos,
 							 1),
 				     mask));
 the sign bit.  */
 if (lunsignedp)
 {
 if (! integer_zerop (const_binop (RSHIFT_EXPR,
-					fold_convert (unsigned_type, rhs),
+					fold_convert_loc (loc,
+							  unsigned_type, rhs),
 					size_int (lbitsize), 0)))
 	{
 	  warning (0, "comparison is always %d due to width of bit-field",
 		   code == NE_EXPR);
 	  return constant_boolean_node (code == NE_EXPR, compare_type);
 	}
 }
 else
 {
-tree tem = const_binop (RSHIFT_EXPR, fold_convert (signed_type, rhs),
+tree tem = const_binop (RSHIFT_EXPR,
+			      fold_convert_loc (loc, signed_type, rhs),
 			      size_int (lbitsize - 1), 0);
 if (! integer_zerop (tem) && ! integer_all_onesp (tem))
 	{
 	  warning (0, "comparison is always %d due to width of bit-field",
 		   code == NE_EXPR);
 }
 /* Make a new bitfield reference, shift the constant over the
 appropriate number of bits and mask it with the computed mask
 (in case this was a signed field).  If we changed it, make a new one.  */
-lhs = make_bit_field_ref (linner, unsigned_type, nbitsize, nbitpos, 1);
+lhs = make_bit_field_ref (loc, linner, unsigned_type, nbitsize, nbitpos, 1);
 if (lvolatilep)
 {
 TREE_SIDE_EFFECTS (lhs) = 1;
 TREE_THIS_VOLATILE (lhs) = 1;
 }
 rhs = const_binop (BIT_AND_EXPR,
 		     const_binop (LSHIFT_EXPR,
-				  fold_convert (unsigned_type, rhs),
+				  fold_convert_loc (loc, unsigned_type, rhs),
 				  size_int (lbitpos), 0),
 		     mask, 0);
-return build2 (code, compare_type,
+lhs = build2 (code, compare_type,
-		 build2 (BIT_AND_EXPR, unsigned_type, lhs, mask),
+		build2 (BIT_AND_EXPR, unsigned_type, lhs, mask),
-		 rhs);
+		rhs);
+SET_EXPR_LOCATION (lhs, loc);
+return lhs;
 }
 /* Subroutine for fold_truthop: decode a field reference.
 If EXP is a comparison reference, we return the innermost reference.
 Return 0 if this is not a component reference or is one that we can't
 do anything with.  */
 static tree
-decode_field_reference (tree exp, HOST_WIDE_INT *pbitsize,
+decode_field_reference (location_t loc, tree exp, HOST_WIDE_INT *pbitsize,
 			HOST_WIDE_INT *pbitpos, enum machine_mode *pmode,
 			int *punsignedp, int *pvolatilep,
 			tree *pmask, tree *pand_mask)
 {
 tree outer_type = 0;
 mask = const_binop (LSHIFT_EXPR, mask, size_int (precision - *pbitsize), 0);
 mask = const_binop (RSHIFT_EXPR, mask, size_int (precision - *pbitsize), 0);
 /* Merge it with the mask we found in the BIT_AND_EXPR, if any.  */
 if (and_mask != 0)
-mask = fold_build2 (BIT_AND_EXPR, unsigned_type,
+mask = fold_build2_loc (loc, BIT_AND_EXPR, unsigned_type,
-			fold_convert (unsigned_type, and_mask), mask);
+			fold_convert_loc (loc, unsigned_type, and_mask), mask);
 *pmask = mask;
 *pand_mask = and_mask;
 return inner;
 }
 will most likely not be returning a useful value and range.  Set
 *STRICT_OVERFLOW_P to true if the return value is only valid
 because signed overflow is undefined; otherwise, do not change
 *STRICT_OVERFLOW_P.  */
-static tree
+tree
 make_range (tree exp, int *pin_p, tree *plow, tree *phigh,
 	    bool *strict_overflow_p)
 {
 enum tree_code code;
 tree arg0 = NULL_TREE, arg1 = NULL_TREE;
 tree exp_type = NULL_TREE, arg0_type = NULL_TREE;
 int in_p, n_in_p;
 tree low, high, n_low, n_high;
+location_t loc = EXPR_LOCATION (exp);
 /* Start with simply saying "EXP != 0" and then look at the code of EXP
 and see if we can refine the range.  Some of the cases below may not
 happen, but it doesn't seem worth worrying about this.  We "continue"
 the outer loop when we've changed something; otherwise we "break"
 	case BIT_NOT_EXPR:
 	  /* ~ X -> -X - 1  */
 	  exp = build2 (MINUS_EXPR, exp_type, negate_expr (arg0),
 			build_int_cst (exp_type, 1));
+	  SET_EXPR_LOCATION (exp, loc);
 	  continue;
 	case PLUS_EXPR:  case MINUS_EXPR:
 	  if (TREE_CODE (arg1) != INTEGER_CST)
 	    break;
 	    break;
 	  n_low = low, n_high = high;
 	  if (n_low != 0)
-	    n_low = fold_convert (arg0_type, n_low);
+	    n_low = fold_convert_loc (loc, arg0_type, n_low);
 	  if (n_high != 0)
-	    n_high = fold_convert (arg0_type, n_high);
+	    n_high = fold_convert_loc (loc, arg0_type, n_high);
 	  /* If we're converting arg0 from an unsigned type, to exp,
 	     a signed type,  we will be doing the comparison as unsigned.
 	     The tests above have already verified that LOW and HIGH
 	      high_positive
 		= TYPE_MAX_VALUE (equiv_type) ? TYPE_MAX_VALUE (equiv_type)
 		: TYPE_MAX_VALUE (arg0_type);
 	      if (TYPE_PRECISION (exp_type) == TYPE_PRECISION (arg0_type))
-		high_positive = fold_build2 (RSHIFT_EXPR, arg0_type,
+		high_positive = fold_build2_loc (loc, RSHIFT_EXPR, arg0_type,
-					     fold_convert (arg0_type,
+					     fold_convert_loc (loc, arg0_type,
-							   high_positive),
+							       high_positive),
 					     build_int_cst (arg0_type, 1));
 	      /* If the low bound is specified, "and" the range with the
 		 range for which the original unsigned value will be
 		 positive.  */
 	      if (low != 0)
 		{
 		  if (! merge_ranges (&n_in_p, &n_low, &n_high,
 				      1, n_low, n_high, 1,
-				      fold_convert (arg0_type,
+				      fold_convert_loc (loc, arg0_type,
-						    integer_zero_node),
+							integer_zero_node),
 				      high_positive))
 		    break;
 		  in_p = (n_in_p == in_p);
 		}
 		{
 		  /* Otherwise, "or" the range with the range of the input
 		     that will be interpreted as negative.  */
 		  if (! merge_ranges (&n_in_p, &n_low, &n_high,
 				      0, n_low, n_high, 1,
-				      fold_convert (arg0_type,
+				      fold_convert_loc (loc, arg0_type,
-						    integer_zero_node),
+							integer_zero_node),
 				      high_positive))
 		    break;
 		  in_p = (in_p != n_in_p);
 		}
 /* Given a range, LOW, HIGH, and IN_P, an expression, EXP, and a result
 type, TYPE, return an expression to test if EXP is in (or out of, depending
 on IN_P) the range.  Return 0 if the test couldn't be created.  */
-static tree
+tree
-build_range_check (tree type, tree exp, int in_p, tree low, tree high)
+build_range_check (location_t loc, tree type, tree exp, int in_p,
-{
+		   tree low, tree high)
-tree etype = TREE_TYPE (exp);
+{
-tree value;
+tree etype = TREE_TYPE (exp), value;
 #ifdef HAVE_canonicalize_funcptr_for_compare
 /* Disable this optimization for function pointer expressions
 on targets that require function pointer canonicalization.  */
 if (HAVE_canonicalize_funcptr_for_compare
 return NULL_TREE;
 #endif
 if (! in_p)
 {
-value = build_range_check (type, exp, 1, low, high);
+value = build_range_check (loc, type, exp, 1, low, high);
 if (value != 0)
-return invert_truthvalue (value);
+return invert_truthvalue_loc (loc, value);
 return 0;
 }
 if (low == 0 && high == 0)
 return build_int_cst (type, 1);
 if (low == 0)
-return fold_build2 (LE_EXPR, type, exp,
+return fold_build2_loc (loc, LE_EXPR, type, exp,
-			fold_convert (etype, high));
+			fold_convert_loc (loc, etype, high));
 if (high == 0)
-return fold_build2 (GE_EXPR, type, exp,
+return fold_build2_loc (loc, GE_EXPR, type, exp,
-			fold_convert (etype, low));
+			fold_convert_loc (loc, etype, low));
 if (operand_equal_p (low, high, 0))
-return fold_build2 (EQ_EXPR, type, exp,
+return fold_build2_loc (loc, EQ_EXPR, type, exp,
-			fold_convert (etype, low));
+			fold_convert_loc (loc, etype, low));
 if (integer_zerop (low))
 {
 if (! TYPE_UNSIGNED (etype))
 	{
 	  etype = unsigned_type_for (etype);
-	  high = fold_convert (etype, high);
+	  high = fold_convert_loc (loc, etype, high);
-	  exp = fold_convert (etype, exp);
+	  exp = fold_convert_loc (loc, etype, exp);
 	}
-return build_range_check (type, exp, 1, 0, high);
+return build_range_check (loc, type, exp, 1, 0, high);
 }
 /* Optimize (c>=1) && (c<=127) into (signed char)c > 0.  */
 if (integer_onep (low) && TREE_CODE (high) == INTEGER_CST)
 {
 	      if (TYPE_PRECISION (signed_etype) != TYPE_PRECISION (etype))
 		etype
 		  = build_nonstandard_integer_type (TYPE_PRECISION (etype), 0);
 	      else
 		etype = signed_etype;
-	      exp = fold_convert (etype, exp);
+	      exp = fold_convert_loc (loc, etype, exp);
 	    }
-	  return fold_build2 (GT_EXPR, type, exp,
+	  return fold_build2_loc (loc, GT_EXPR, type, exp,
 			      build_int_cst (etype, 0));
 	}
 }
 /* Optimize (c>=low) && (c<=high) into (c-low>=0) && (c-low<=high-low).
-This requires wrap-around arithmetics for the type of the expression.  */
+This requires wrap-around arithmetics for the type of the expression.
-switch (TREE_CODE (etype))
+First make sure that arithmetics in this type is valid, then make sure
-{
+that it wraps around.  */
-case INTEGER_TYPE:
+if (TREE_CODE (etype) == ENUMERAL_TYPE || TREE_CODE (etype) == BOOLEAN_TYPE)
-/* There is no requirement that LOW be within the range of ETYPE
+etype = lang_hooks.types.type_for_size (TYPE_PRECISION (etype),
-	 if the latter is a subtype.  It must, however, be within the base
+					    TYPE_UNSIGNED (etype));
-	 type of ETYPE.  So be sure we do the subtraction in that type.  */
-if (TREE_TYPE (etype))
+if (TREE_CODE (etype) == INTEGER_TYPE && !TYPE_OVERFLOW_WRAPS (etype))
-	etype = TREE_TYPE (etype);
-break;
-case ENUMERAL_TYPE:
-case BOOLEAN_TYPE:
-etype = lang_hooks.types.type_for_size (TYPE_PRECISION (etype),
-					      TYPE_UNSIGNED (etype));
-break;
-default:
-break;
-}
-/* If we don't have wrap-around arithmetics upfront, try to force it.  */
-if (TREE_CODE (etype) == INTEGER_TYPE
-&& !TYPE_OVERFLOW_WRAPS (etype))
 {
 tree utype, minv, maxv;
 /* Check if (unsigned) INT_MAX + 1 == (unsigned) INT_MIN
 	 for the type in question, as we rely on this here.  */
 utype = unsigned_type_for (etype);
-maxv = fold_convert (utype, TYPE_MAX_VALUE (etype));
+maxv = fold_convert_loc (loc, utype, TYPE_MAX_VALUE (etype));
 maxv = range_binop (PLUS_EXPR, NULL_TREE, maxv, 1,
 			  integer_one_node, 1);
-minv = fold_convert (utype, TYPE_MIN_VALUE (etype));
+minv = fold_convert_loc (loc, utype, TYPE_MIN_VALUE (etype));
 if (integer_zerop (range_binop (NE_EXPR, integer_type_node,
 				      minv, 1, maxv, 1)))
 	etype = utype;
 else
 	return 0;
 }
-high = fold_convert (etype, high);
+high = fold_convert_loc (loc, etype, high);
-low = fold_convert (etype, low);
+low = fold_convert_loc (loc, etype, low);
-exp = fold_convert (etype, exp);
+exp = fold_convert_loc (loc, etype, exp);
 value = const_binop (MINUS_EXPR, high, low, 0);
 if (POINTER_TYPE_P (etype))
 {
 if (value != 0 && !TREE_OVERFLOW (value))
 	{
-	  low = fold_convert (sizetype, low);
+	  low = fold_convert_loc (loc, sizetype, low);
-	  low = fold_build1 (NEGATE_EXPR, sizetype, low);
+	  low = fold_build1_loc (loc, NEGATE_EXPR, sizetype, low);
-return build_range_check (type,
+return build_range_check (loc, type,
-			     	    fold_build2 (POINTER_PLUS_EXPR, etype, exp, low),
+			     	    fold_build2_loc (loc, POINTER_PLUS_EXPR,
+						 etype, exp, low),
 			            1, build_int_cst (etype, 0), value);
 	}
 return 0;
 }
 if (value != 0 && !TREE_OVERFLOW (value))
-return build_range_check (type,
+return build_range_check (loc, type,
-			      fold_build2 (MINUS_EXPR, etype, exp, low),
+			      fold_build2_loc (loc, MINUS_EXPR, etype, exp, low),
 			      1, build_int_cst (etype, 0), value);
 return 0;
 }
 }
 /* Given two ranges, see if we can merge them into one.  Return 1 if we
 can, 0 if we can't.  Set the output range into the specified parameters.  */
-static int
+bool
 merge_ranges (int *pin_p, tree *plow, tree *phigh, int in0_p, tree low0,
 	      tree high0, int in1_p, tree low1, tree high1)
 {
 int no_overlap;
 int subset;
 Return a folded expression whose code is not a COND_EXPR
 anymore, or NULL_TREE if no folding opportunity is found.  */
 static tree
-fold_cond_expr_with_comparison (tree type, tree arg0, tree arg1, tree arg2)
+fold_cond_expr_with_comparison (location_t loc, tree type,
+				tree arg0, tree arg1, tree arg2)
 {
 enum tree_code comp_code = TREE_CODE (arg0);
 tree arg00 = TREE_OPERAND (arg0, 0);
 tree arg01 = TREE_OPERAND (arg0, 1);
 tree arg1_type = TREE_TYPE (arg1);
 				  TREE_OPERAND (arg2, 0), 0))))
 switch (comp_code)
 {
 case EQ_EXPR:
 case UNEQ_EXPR:
-	tem = fold_convert (arg1_type, arg1);
+	tem = fold_convert_loc (loc, arg1_type, arg1);
-	return pedantic_non_lvalue (fold_convert (type, negate_expr (tem)));
+	return pedantic_non_lvalue_loc (loc,
+				    fold_convert_loc (loc, type,
+						  negate_expr (tem)));
 case NE_EXPR:
 case LTGT_EXPR:
-	return pedantic_non_lvalue (fold_convert (type, arg1));
+	return pedantic_non_lvalue_loc (loc, fold_convert_loc (loc, type, arg1));
 case UNGE_EXPR:
 case UNGT_EXPR:
 	if (flag_trapping_math)
 	  break;
 	/* Fall through.  */
 case GE_EXPR:
 case GT_EXPR:
 	if (TYPE_UNSIGNED (TREE_TYPE (arg1)))
-	  arg1 = fold_convert (signed_type_for
+	  arg1 = fold_convert_loc (loc, signed_type_for
 			       (TREE_TYPE (arg1)), arg1);
-	tem = fold_build1 (ABS_EXPR, TREE_TYPE (arg1), arg1);
+	tem = fold_build1_loc (loc, ABS_EXPR, TREE_TYPE (arg1), arg1);
-	return pedantic_non_lvalue (fold_convert (type, tem));
+	return pedantic_non_lvalue_loc (loc, fold_convert_loc (loc, type, tem));
 case UNLE_EXPR:
 case UNLT_EXPR:
 	if (flag_trapping_math)
 	  break;
 case LE_EXPR:
 case LT_EXPR:
 	if (TYPE_UNSIGNED (TREE_TYPE (arg1)))
-	  arg1 = fold_convert (signed_type_for
+	  arg1 = fold_convert_loc (loc, signed_type_for
 			       (TREE_TYPE (arg1)), arg1);
-	tem = fold_build1 (ABS_EXPR, TREE_TYPE (arg1), arg1);
+	tem = fold_build1_loc (loc, ABS_EXPR, TREE_TYPE (arg1), arg1);
-	return negate_expr (fold_convert (type, tem));
+	return negate_expr (fold_convert_loc (loc, type, tem));
 default:
 	gcc_assert (TREE_CODE_CLASS (comp_code) == tcc_comparison);
 	break;
 }
 if (!HONOR_SIGNED_ZEROS (TYPE_MODE (type))
 && integer_zerop (arg01) && integer_zerop (arg2))
 {
 if (comp_code == NE_EXPR)
-	return pedantic_non_lvalue (fold_convert (type, arg1));
+	return pedantic_non_lvalue_loc (loc, fold_convert_loc (loc, type, arg1));
 else if (comp_code == EQ_EXPR)
 	return build_int_cst (type, 0);
 }
 /* Try some transformations of A op B ? A : B.
 	}
 switch (comp_code)
 	{
 	case EQ_EXPR:
-	  return pedantic_non_lvalue (fold_convert (type, arg2));
+	  return pedantic_non_lvalue_loc (loc, fold_convert_loc (loc, type, arg2));
 	case NE_EXPR:
-	  return pedantic_non_lvalue (fold_convert (type, arg1));
+	  return pedantic_non_lvalue_loc (loc, fold_convert_loc (loc, type, arg1));
 	case LE_EXPR:
 	case LT_EXPR:
 	case UNLE_EXPR:
 	case UNLT_EXPR:
 	  /* In C++ a ?: expression can be an lvalue, so put the
 	     operand which will be used if they are equal first
 	     so that we can convert this back to the
 	     corresponding COND_EXPR.  */
 	  if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1))))
 	    {
-	      comp_op0 = fold_convert (comp_type, comp_op0);
+	      comp_op0 = fold_convert_loc (loc, comp_type, comp_op0);
-	      comp_op1 = fold_convert (comp_type, comp_op1);
+	      comp_op1 = fold_convert_loc (loc, comp_type, comp_op1);
 	      tem = (comp_code == LE_EXPR || comp_code == UNLE_EXPR)
-		    ? fold_build2 (MIN_EXPR, comp_type, comp_op0, comp_op1)
+		    ? fold_build2_loc (loc, MIN_EXPR, comp_type, comp_op0, comp_op1)
-		    : fold_build2 (MIN_EXPR, comp_type, comp_op1, comp_op0);
+		    : fold_build2_loc (loc, MIN_EXPR, comp_type,
-	      return pedantic_non_lvalue (fold_convert (type, tem));
+				   comp_op1, comp_op0);
+	      return pedantic_non_lvalue_loc (loc,
+					  fold_convert_loc (loc, type, tem));
 	    }
 	  break;
 	case GE_EXPR:
 	case GT_EXPR:
 	case UNGE_EXPR:
 	case UNGT_EXPR:
 	  if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1))))
 	    {
-	      comp_op0 = fold_convert (comp_type, comp_op0);
+	      comp_op0 = fold_convert_loc (loc, comp_type, comp_op0);
-	      comp_op1 = fold_convert (comp_type, comp_op1);
+	      comp_op1 = fold_convert_loc (loc, comp_type, comp_op1);
 	      tem = (comp_code == GE_EXPR || comp_code == UNGE_EXPR)
-		    ? fold_build2 (MAX_EXPR, comp_type, comp_op0, comp_op1)
+		    ? fold_build2_loc (loc, MAX_EXPR, comp_type, comp_op0, comp_op1)
-		    : fold_build2 (MAX_EXPR, comp_type, comp_op1, comp_op0);
+		    : fold_build2_loc (loc, MAX_EXPR, comp_type,
-	      return pedantic_non_lvalue (fold_convert (type, tem));
+				   comp_op1, comp_op0);
+	      return pedantic_non_lvalue_loc (loc,
+					  fold_convert_loc (loc, type, tem));
 	    }
 	  break;
 	case UNEQ_EXPR:
 	  if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1))))
-	    return pedantic_non_lvalue (fold_convert (type, arg2));
+	    return pedantic_non_lvalue_loc (loc,
+					fold_convert_loc (loc, type, arg2));
 	  break;
 	case LTGT_EXPR:
 	  if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1))))
-	    return pedantic_non_lvalue (fold_convert (type, arg1));
+	    return pedantic_non_lvalue_loc (loc,
+					fold_convert_loc (loc, type, arg1));
 	  break;
 	default:
 	  gcc_assert (TREE_CODE_CLASS (comp_code) == tcc_comparison);
 	  break;
 	}
 && TREE_CODE (arg01) == INTEGER_CST
 && TREE_CODE (arg2) == INTEGER_CST)
 switch (comp_code)
 {
 case EQ_EXPR:
+	if (TREE_CODE (arg1) == INTEGER_CST)
+	  break;
 	/* We can replace A with C1 in this case.  */
-	arg1 = fold_convert (type, arg01);
+	arg1 = fold_convert_loc (loc, type, arg01);
-	return fold_build3 (COND_EXPR, type, arg0, arg1, arg2);
+	return fold_build3_loc (loc, COND_EXPR, type, arg0, arg1, arg2);
 case LT_EXPR:
 	/* If C1 is C2 + 1, this is min(A, C2), but use ARG00's type for
 	   MIN_EXPR, to preserve the signedness of the comparison.  */
 	if (! operand_equal_p (arg2, TYPE_MAX_VALUE (type),
 	    && operand_equal_p (arg01,
 				const_binop (PLUS_EXPR, arg2,
 					     build_int_cst (type, 1), 0),
 				OEP_ONLY_CONST))
 	  {
-	    tem = fold_build2 (MIN_EXPR, TREE_TYPE (arg00), arg00,
+	    tem = fold_build2_loc (loc, MIN_EXPR, TREE_TYPE (arg00), arg00,
-			       fold_convert (TREE_TYPE (arg00), arg2));
+				   fold_convert_loc (loc, TREE_TYPE (arg00),
-	    return pedantic_non_lvalue (fold_convert (type, tem));
+						     arg2));
+	    return pedantic_non_lvalue_loc (loc,
+					    fold_convert_loc (loc, type, tem));
 	  }
 	break;
 case LE_EXPR:
 	/* If C1 is C2 - 1, this is min(A, C2), with the same care
 	    && operand_equal_p (arg01,
 				const_binop (MINUS_EXPR, arg2,
 					     build_int_cst (type, 1), 0),
 				OEP_ONLY_CONST))
 	  {
-	    tem = fold_build2 (MIN_EXPR, TREE_TYPE (arg00), arg00,
+	    tem = fold_build2_loc (loc, MIN_EXPR, TREE_TYPE (arg00), arg00,
-			       fold_convert (TREE_TYPE (arg00), arg2));
+				   fold_convert_loc (loc, TREE_TYPE (arg00),
-	    return pedantic_non_lvalue (fold_convert (type, tem));
+						     arg2));
+	    return pedantic_non_lvalue_loc (loc,
+					    fold_convert_loc (loc, type, tem));
 	  }
 	break;
 case GT_EXPR:
 	/* If C1 is C2 - 1, this is max(A, C2), but use ARG00's type for
 	    && operand_equal_p (arg01,
 				const_binop (MINUS_EXPR, arg2,
 					     build_int_cst (type, 1), 0),
 				OEP_ONLY_CONST))
 	  {
-	    tem = fold_build2 (MAX_EXPR, TREE_TYPE (arg00), arg00,
+	    tem = fold_build2_loc (loc, MAX_EXPR, TREE_TYPE (arg00), arg00,
-			       fold_convert (TREE_TYPE (arg00), arg2));
+				   fold_convert_loc (loc, TREE_TYPE (arg00),
-	    return pedantic_non_lvalue (fold_convert (type, tem));
+						     arg2));
+	    return pedantic_non_lvalue_loc (loc, fold_convert_loc (loc, type, tem));
 	  }
 	break;
 case GE_EXPR:
 	/* If C1 is C2 + 1, this is max(A, C2), with the same care as above.  */
 	    && operand_equal_p (arg01,
 				const_binop (PLUS_EXPR, arg2,
 					     build_int_cst (type, 1), 0),
 				OEP_ONLY_CONST))
 	  {
-	    tem = fold_build2 (MAX_EXPR, TREE_TYPE (arg00), arg00,
+	    tem = fold_build2_loc (loc, MAX_EXPR, TREE_TYPE (arg00), arg00,
-			       fold_convert (TREE_TYPE (arg00), arg2));
+				   fold_convert_loc (loc, TREE_TYPE (arg00),
-	    return pedantic_non_lvalue (fold_convert (type, tem));
+						     arg2));
+	    return pedantic_non_lvalue_loc (loc, fold_convert_loc (loc, type, tem));
 	  }
 	break;
 case NE_EXPR:
 	break;
 default:
 /* EXP is some logical combination of boolean tests.  See if we can
 merge it into some range test.  Return the new tree if so.  */
 static tree
-fold_range_test (enum tree_code code, tree type, tree op0, tree op1)
+fold_range_test (location_t loc, enum tree_code code, tree type,
+		 tree op0, tree op1)
 {
 int or_op = (code == TRUTH_ORIF_EXPR
 	       || code == TRUTH_OR_EXPR);
 int in0_p, in1_p, in_p;
 tree low0, low1, low, high0, high1, high;
 ranges is always true or always false, consider it to be the same
 expression as the other.  */
 if ((lhs == 0 || rhs == 0 || operand_equal_p (lhs, rhs, 0))
 && merge_ranges (&in_p, &low, &high, in0_p, low0, high0,
 		       in1_p, low1, high1)
-&& 0 != (tem = (build_range_check (type,
+&& 0 != (tem = (build_range_check (UNKNOWN_LOCATION, type,
 					 lhs != 0 ? lhs
 					 : rhs != 0 ? rhs : integer_zero_node,
 					 in_p, low, high))))
 {
 if (strict_overflow_p)
 	fold_overflow_warning (warnmsg, WARN_STRICT_OVERFLOW_COMPARISON);
-return or_op ? invert_truthvalue (tem) : tem;
+return or_op ? invert_truthvalue_loc (loc, tem) : tem;
 }
 /* On machines where the branch cost is expensive, if this is a
 short-circuited branch and the underlying object on both sides
 is the same, make a non-short-circuit operation.  */
 {
 /* If simple enough, just rewrite.  Otherwise, make a SAVE_EXPR
 	 unless we are at top level or LHS contains a PLACEHOLDER_EXPR, in
 	 which cases we can't do this.  */
 if (simple_operand_p (lhs))
-	return build2 (code == TRUTH_ANDIF_EXPR
+	{
-		       ? TRUTH_AND_EXPR : TRUTH_OR_EXPR,
+	  tem = build2 (code == TRUTH_ANDIF_EXPR
-		       type, op0, op1);
+			? TRUTH_AND_EXPR : TRUTH_OR_EXPR,
+			type, op0, op1);
+	  SET_EXPR_LOCATION (tem, loc);
+	  return tem;
+	}
 else if (lang_hooks.decls.global_bindings_p () == 0
 	       && ! CONTAINS_PLACEHOLDER_P (lhs))
 	{
 	  tree common = save_expr (lhs);
-	  if (0 != (lhs = build_range_check (type, common,
+	  if (0 != (lhs = build_range_check (loc, type, common,
 					     or_op ? ! in0_p : in0_p,
 					     low0, high0))
-	      && (0 != (rhs = build_range_check (type, common,
+	      && (0 != (rhs = build_range_check (loc, type, common,
 						 or_op ? ! in1_p : in1_p,
 						 low1, high1))))
 	    {
 	      if (strict_overflow_p)
 		fold_overflow_warning (warnmsg,
 				       WARN_STRICT_OVERFLOW_COMPARISON);
-	      return build2 (code == TRUTH_ANDIF_EXPR
+	      tem = build2 (code == TRUTH_ANDIF_EXPR
-			     ? TRUTH_AND_EXPR : TRUTH_OR_EXPR,
+			    ? TRUTH_AND_EXPR : TRUTH_OR_EXPR,
-			     type, lhs, rhs);
+			    type, lhs, rhs);
+	      SET_EXPR_LOCATION (tem, loc);
+	      return tem;
 	    }
 	}
 }
 return 0;
 temp = const_binop (LSHIFT_EXPR, temp, size_int (modesize - 1), 0);
 temp = const_binop (RSHIFT_EXPR, temp, size_int (modesize - p - 1), 0);
 if (mask != 0)
 temp = const_binop (BIT_AND_EXPR, temp,
-			fold_convert (TREE_TYPE (c), mask), 0);
+			fold_convert (TREE_TYPE (c), mask),
+			0);
 /* If necessary, convert the type back to match the type of C.  */
 if (TYPE_UNSIGNED (type))
 temp = fold_convert (type, temp);
-return fold_convert (type, const_binop (BIT_XOR_EXPR, c, temp, 0));
+return fold_convert (type,
+		       const_binop (BIT_XOR_EXPR, c, temp, 0));
 }
 /* Find ways of folding logical expressions of LHS and RHS:
 Try to merge two comparisons to the same innermost item.
 Look for range tests like "ch >= '0' && ch <= '9'".
 two operands.
 We return the simplified tree or 0 if no optimization is possible.  */
 static tree
-fold_truthop (enum tree_code code, tree truth_type, tree lhs, tree rhs)
+fold_truthop (location_t loc, enum tree_code code, tree truth_type,
+	      tree lhs, tree rhs)
 {
 /* If this is the "or" of two comparisons, we can do something if
 the comparisons are NE_EXPR.  If this is the "and", we can do something
 if the comparisons are EQ_EXPR.  I.e.,
 	(a->b == 2 && a->c == 4) can become (a->new == NEW).
 {
 tree result;
 if (operand_equal_p (ll_arg, rl_arg, 0)
 && operand_equal_p (lr_arg, rr_arg, 0))
 	{
-result = combine_comparisons (code, lcode, rcode,
+result = combine_comparisons (loc, code, lcode, rcode,
 					truth_type, ll_arg, lr_arg);
 	  if (result)
 	    return result;
 	}
 else if (operand_equal_p (ll_arg, rr_arg, 0)
 && operand_equal_p (lr_arg, rl_arg, 0))
 	{
-result = combine_comparisons (code, lcode,
+result = combine_comparisons (loc, code, lcode,
 					swap_tree_comparison (rcode),
 					truth_type, ll_arg, lr_arg);
 	  if (result)
 	    return result;
 	}
 if (code == TRUTH_OR_EXPR
 	  && lcode == NE_EXPR && integer_zerop (lr_arg)
 	  && rcode == NE_EXPR && integer_zerop (rr_arg)
 	  && TREE_TYPE (ll_arg) == TREE_TYPE (rl_arg)
 	  && INTEGRAL_TYPE_P (TREE_TYPE (ll_arg)))
-	return build2 (NE_EXPR, truth_type,
+	{
-		       build2 (BIT_IOR_EXPR, TREE_TYPE (ll_arg),
+	  result = build2 (NE_EXPR, truth_type,
-			       ll_arg, rl_arg),
+			   build2 (BIT_IOR_EXPR, TREE_TYPE (ll_arg),
-		       build_int_cst (TREE_TYPE (ll_arg), 0));
+				   ll_arg, rl_arg),
+			   build_int_cst (TREE_TYPE (ll_arg), 0));
+	  goto fold_truthop_exit;
+	}
 /* Convert (a == 0) && (b == 0) into (a | b) == 0.  */
 if (code == TRUTH_AND_EXPR
 	  && lcode == EQ_EXPR && integer_zerop (lr_arg)
 	  && rcode == EQ_EXPR && integer_zerop (rr_arg)
 	  && TREE_TYPE (ll_arg) == TREE_TYPE (rl_arg)
 	  && INTEGRAL_TYPE_P (TREE_TYPE (ll_arg)))
-	return build2 (EQ_EXPR, truth_type,
+	{
-		       build2 (BIT_IOR_EXPR, TREE_TYPE (ll_arg),
+	  result = build2 (EQ_EXPR, truth_type,
-			       ll_arg, rl_arg),
+			   build2 (BIT_IOR_EXPR, TREE_TYPE (ll_arg),
-		       build_int_cst (TREE_TYPE (ll_arg), 0));
+				   ll_arg, rl_arg),
+			   build_int_cst (TREE_TYPE (ll_arg), 0));
+	  goto fold_truthop_exit;
+	}
 if (LOGICAL_OP_NON_SHORT_CIRCUIT)
 	{
 	  if (code != orig_code || lhs != orig_lhs || rhs != orig_rhs)
-	    return build2 (code, truth_type, lhs, rhs);
+	    {
+	      result = build2 (code, truth_type, lhs, rhs);
+	      goto fold_truthop_exit;
+	    }
 	  return NULL_TREE;
 	}
 }
 /* See if the comparisons can be merged.  Then get all the parameters for
 if ((lcode != EQ_EXPR && lcode != NE_EXPR)
 || (rcode != EQ_EXPR && rcode != NE_EXPR))
 return 0;
 volatilep = 0;
-ll_inner = decode_field_reference (ll_arg,
+ll_inner = decode_field_reference (loc, ll_arg,
 				     &ll_bitsize, &ll_bitpos, &ll_mode,
 				     &ll_unsignedp, &volatilep, &ll_mask,
 				     &ll_and_mask);
-lr_inner = decode_field_reference (lr_arg,
+lr_inner = decode_field_reference (loc, lr_arg,
 				     &lr_bitsize, &lr_bitpos, &lr_mode,
 				     &lr_unsignedp, &volatilep, &lr_mask,
 				     &lr_and_mask);
-rl_inner = decode_field_reference (rl_arg,
+rl_inner = decode_field_reference (loc, rl_arg,
 				     &rl_bitsize, &rl_bitpos, &rl_mode,
 				     &rl_unsignedp, &volatilep, &rl_mask,
 				     &rl_and_mask);
-rr_inner = decode_field_reference (rr_arg,
+rr_inner = decode_field_reference (loc, rr_arg,
 				     &rr_bitsize, &rr_bitpos, &rr_mode,
 				     &rr_unsignedp, &volatilep, &rr_mask,
 				     &rr_and_mask);
 /* It must be true that the inner operation on the lhs of each
 {
 xll_bitpos = lnbitsize - xll_bitpos - ll_bitsize;
 xrl_bitpos = lnbitsize - xrl_bitpos - rl_bitsize;
 }
-ll_mask = const_binop (LSHIFT_EXPR, fold_convert (lntype, ll_mask),
+ll_mask = const_binop (LSHIFT_EXPR, fold_convert_loc (loc, lntype, ll_mask),
 			 size_int (xll_bitpos), 0);
-rl_mask = const_binop (LSHIFT_EXPR, fold_convert (lntype, rl_mask),
+rl_mask = const_binop (LSHIFT_EXPR, fold_convert_loc (loc, lntype, rl_mask),
 			 size_int (xrl_bitpos), 0);
 if (l_const)
 {
-l_const = fold_convert (lntype, l_const);
+l_const = fold_convert_loc (loc, lntype, l_const);
 l_const = unextend (l_const, ll_bitsize, ll_unsignedp, ll_and_mask);
 l_const = const_binop (LSHIFT_EXPR, l_const, size_int (xll_bitpos), 0);
 if (! integer_zerop (const_binop (BIT_AND_EXPR, l_const,
-					fold_build1 (BIT_NOT_EXPR,
+					fold_build1_loc (loc, BIT_NOT_EXPR,
 						     lntype, ll_mask),
 					0)))
 	{
 	  warning (0, "comparison is always %d", wanted_code == NE_EXPR);
 	  return constant_boolean_node (wanted_code == NE_EXPR, truth_type);
 	}
 }
 if (r_const)
 {
-r_const = fold_convert (lntype, r_const);
+r_const = fold_convert_loc (loc, lntype, r_const);
 r_const = unextend (r_const, rl_bitsize, rl_unsignedp, rl_and_mask);
 r_const = const_binop (LSHIFT_EXPR, r_const, size_int (xrl_bitpos), 0);
 if (! integer_zerop (const_binop (BIT_AND_EXPR, r_const,
-					fold_build1 (BIT_NOT_EXPR,
+					fold_build1_loc (loc, BIT_NOT_EXPR,
 						     lntype, rl_mask),
 					0)))
 	{
 	  warning (0, "comparison is always %d", wanted_code == NE_EXPR);
 	{
 	  xlr_bitpos = rnbitsize - xlr_bitpos - lr_bitsize;
 	  xrr_bitpos = rnbitsize - xrr_bitpos - rr_bitsize;
 	}
-lr_mask = const_binop (LSHIFT_EXPR, fold_convert (rntype, lr_mask),
+lr_mask = const_binop (LSHIFT_EXPR, fold_convert_loc (loc,
+							    rntype, lr_mask),
 			     size_int (xlr_bitpos), 0);
-rr_mask = const_binop (LSHIFT_EXPR, fold_convert (rntype, rr_mask),
+rr_mask = const_binop (LSHIFT_EXPR, fold_convert_loc (loc,
+							    rntype, rr_mask),
 			     size_int (xrr_bitpos), 0);
 /* Make a mask that corresponds to both fields being compared.
 	 Do this for both items being compared.  If the operands are the
 	 same size and the bits being compared are in the same position
 	 results.  */
 ll_mask = const_binop (BIT_IOR_EXPR, ll_mask, rl_mask, 0);
 lr_mask = const_binop (BIT_IOR_EXPR, lr_mask, rr_mask, 0);
 if (lnbitsize == rnbitsize && xll_bitpos == xlr_bitpos)
 	{
-	  lhs = make_bit_field_ref (ll_inner, lntype, lnbitsize, lnbitpos,
+	  lhs = make_bit_field_ref (loc, ll_inner, lntype, lnbitsize, lnbitpos,
 				    ll_unsignedp || rl_unsignedp);
 	  if (! all_ones_mask_p (ll_mask, lnbitsize))
 	    lhs = build2 (BIT_AND_EXPR, lntype, lhs, ll_mask);
-	  rhs = make_bit_field_ref (lr_inner, rntype, rnbitsize, rnbitpos,
+	  rhs = make_bit_field_ref (loc, lr_inner, rntype, rnbitsize, rnbitpos,
 				    lr_unsignedp || rr_unsignedp);
 	  if (! all_ones_mask_p (lr_mask, rnbitsize))
 	    rhs = build2 (BIT_AND_EXPR, rntype, rhs, lr_mask);
-	  return build2 (wanted_code, truth_type, lhs, rhs);
+	  result = build2 (wanted_code, truth_type, lhs, rhs);
+	  goto fold_truthop_exit;
 	}
 /* There is still another way we can do something:  If both pairs of
 	 fields being compared are adjacent, we may be able to make a wider
 	 field containing them both.
 	  || (ll_bitpos == rl_bitpos + rl_bitsize
 	      && lr_bitpos == rr_bitpos + rr_bitsize))
 	{
 	  tree type;
-	  lhs = make_bit_field_ref (ll_inner, lntype, ll_bitsize + rl_bitsize,
+	  lhs = make_bit_field_ref (loc, ll_inner, lntype,
+				    ll_bitsize + rl_bitsize,
 				    MIN (ll_bitpos, rl_bitpos), ll_unsignedp);
-	  rhs = make_bit_field_ref (lr_inner, rntype, lr_bitsize + rr_bitsize,
+	  rhs = make_bit_field_ref (loc, lr_inner, rntype,
+				    lr_bitsize + rr_bitsize,
 				    MIN (lr_bitpos, rr_bitpos), lr_unsignedp);
 	  ll_mask = const_binop (RSHIFT_EXPR, ll_mask,
 				 size_int (MIN (xll_bitpos, xrl_bitpos)), 0);
 	  lr_mask = const_binop (RSHIFT_EXPR, lr_mask,
 	  type = lntype;
 	  if (lntype != rntype)
 	    {
 	      if (lnbitsize > rnbitsize)
 		{
-		  lhs = fold_convert (rntype, lhs);
+		  lhs = fold_convert_loc (loc, rntype, lhs);
-		  ll_mask = fold_convert (rntype, ll_mask);
+		  ll_mask = fold_convert_loc (loc, rntype, ll_mask);
 		  type = rntype;
 		}
 	      else if (lnbitsize < rnbitsize)
 		{
-		  rhs = fold_convert (lntype, rhs);
+		  rhs = fold_convert_loc (loc, lntype, rhs);
-		  lr_mask = fold_convert (lntype, lr_mask);
+		  lr_mask = fold_convert_loc (loc, lntype, lr_mask);
 		  type = lntype;
 		}
 	    }
 	  if (! all_ones_mask_p (ll_mask, ll_bitsize + rl_bitsize))
 	    lhs = build2 (BIT_AND_EXPR, type, lhs, ll_mask);
 	  if (! all_ones_mask_p (lr_mask, lr_bitsize + rr_bitsize))
 	    rhs = build2 (BIT_AND_EXPR, type, rhs, lr_mask);
-	  return build2 (wanted_code, truth_type, lhs, rhs);
+	  result = build2 (wanted_code, truth_type, lhs, rhs);
+	  goto fold_truthop_exit;
 	}
 return 0;
 }
 /* Construct the expression we will return.  First get the component
 reference we will make.  Unless the mask is all ones the width of
 that field, perform the mask operation.  Then compare with the
 merged constant.  */
-result = make_bit_field_ref (ll_inner, lntype, lnbitsize, lnbitpos,
+result = make_bit_field_ref (loc, ll_inner, lntype, lnbitsize, lnbitpos,
 			       ll_unsignedp || rl_unsignedp);
 ll_mask = const_binop (BIT_IOR_EXPR, ll_mask, rl_mask, 0);
 if (! all_ones_mask_p (ll_mask, lnbitsize))
-result = build2 (BIT_AND_EXPR, lntype, result, ll_mask);
+{
+result = build2 (BIT_AND_EXPR, lntype, result, ll_mask);
-return build2 (wanted_code, truth_type, result,
+SET_EXPR_LOCATION (result, loc);
-		 const_binop (BIT_IOR_EXPR, l_const, r_const, 0));
+}
+result = build2 (wanted_code, truth_type, result,
+		   const_binop (BIT_IOR_EXPR, l_const, r_const, 0));
+fold_truthop_exit:
+SET_EXPR_LOCATION (result, loc);
+return result;
 }
 /* Optimize T, which is a comparison of a MIN_EXPR or MAX_EXPR with a
 constant.  */
 static tree
-optimize_minmax_comparison (enum tree_code code, tree type, tree op0, tree op1)
+optimize_minmax_comparison (location_t loc, enum tree_code code, tree type,
+			    tree op0, tree op1)
 {
 tree arg0 = op0;
 enum tree_code op_code;
 tree comp_const;
 tree minmax_const;
 STRIP_SIGN_NOPS (arg0);
 op_code = TREE_CODE (arg0);
 minmax_const = TREE_OPERAND (arg0, 1);
-comp_const = fold_convert (TREE_TYPE (arg0), op1);
+comp_const = fold_convert_loc (loc, TREE_TYPE (arg0), op1);
 consts_equal = tree_int_cst_equal (minmax_const, comp_const);
 consts_lt = tree_int_cst_lt (minmax_const, comp_const);
 inner = TREE_OPERAND (arg0, 0);
 /* If something does not permit us to optimize, return the original tree.  */
 simplifications.  */
 switch (code)
 {
 case NE_EXPR:  case LT_EXPR:  case LE_EXPR:
 {
-	tree tem = optimize_minmax_comparison (invert_tree_comparison (code, false),
+	tree tem
-					  type, op0, op1);
+	  = optimize_minmax_comparison (loc,
+					invert_tree_comparison (code, false),
+					type, op0, op1);
 	if (tem)
-	  return invert_truthvalue (tem);
+	  return invert_truthvalue_loc (loc, tem);
 	return NULL_TREE;
 }
 case GE_EXPR:
 return
-	fold_build2 (TRUTH_ORIF_EXPR, type,
+	fold_build2_loc (loc, TRUTH_ORIF_EXPR, type,
 		     optimize_minmax_comparison
-		     (EQ_EXPR, type, arg0, comp_const),
+		     (loc, EQ_EXPR, type, arg0, comp_const),
 		     optimize_minmax_comparison
-		     (GT_EXPR, type, arg0, comp_const));
+		     (loc, GT_EXPR, type, arg0, comp_const));
 case EQ_EXPR:
 if (op_code == MAX_EXPR && consts_equal)
 	/* MAX (X, 0) == 0  ->  X <= 0  */
-	return fold_build2 (LE_EXPR, type, inner, comp_const);
+	return fold_build2_loc (loc, LE_EXPR, type, inner, comp_const);
 else if (op_code == MAX_EXPR && consts_lt)
 	/* MAX (X, 0) == 5  ->  X == 5   */
-	return fold_build2 (EQ_EXPR, type, inner, comp_const);
+	return fold_build2_loc (loc, EQ_EXPR, type, inner, comp_const);
 else if (op_code == MAX_EXPR)
 	/* MAX (X, 0) == -1  ->  false  */
-	return omit_one_operand (type, integer_zero_node, inner);
+	return omit_one_operand_loc (loc, type, integer_zero_node, inner);
 else if (consts_equal)
 	/* MIN (X, 0) == 0  ->  X >= 0  */
-	return fold_build2 (GE_EXPR, type, inner, comp_const);
+	return fold_build2_loc (loc, GE_EXPR, type, inner, comp_const);
 else if (consts_lt)
 	/* MIN (X, 0) == 5  ->  false  */
-	return omit_one_operand (type, integer_zero_node, inner);
+	return omit_one_operand_loc (loc, type, integer_zero_node, inner);
 else
 	/* MIN (X, 0) == -1  ->  X == -1  */
-	return fold_build2 (EQ_EXPR, type, inner, comp_const);
+	return fold_build2_loc (loc, EQ_EXPR, type, inner, comp_const);
 case GT_EXPR:
 if (op_code == MAX_EXPR && (consts_equal || consts_lt))
 	/* MAX (X, 0) > 0  ->  X > 0
 	   MAX (X, 0) > 5  ->  X > 5  */
-	return fold_build2 (GT_EXPR, type, inner, comp_const);
+	return fold_build2_loc (loc, GT_EXPR, type, inner, comp_const);
 else if (op_code == MAX_EXPR)
 	/* MAX (X, 0) > -1  ->  true  */
-	return omit_one_operand (type, integer_one_node, inner);
+	return omit_one_operand_loc (loc, type, integer_one_node, inner);
 else if (op_code == MIN_EXPR && (consts_equal || consts_lt))
 	/* MIN (X, 0) > 0  ->  false
 	   MIN (X, 0) > 5  ->  false  */
-	return omit_one_operand (type, integer_zero_node, inner);
+	return omit_one_operand_loc (loc, type, integer_zero_node, inner);
 else
 	/* MIN (X, 0) > -1  ->  X > -1  */
-	return fold_build2 (GT_EXPR, type, inner, comp_const);
+	return fold_build2_loc (loc, GT_EXPR, type, inner, comp_const);
 default:
 return NULL_TREE;
 }
 }
 						   size_one_node,
 						   op1, 0)))
 	  && !TREE_OVERFLOW (t1))
 	return extract_muldiv (build2 (tcode == LSHIFT_EXPR
 				       ? MULT_EXPR : FLOOR_DIV_EXPR,
-				       ctype, fold_convert (ctype, op0), t1),
+				       ctype,
+				       fold_convert (ctype, op0),
+				       t1),
 			       c, code, wide_type, strict_overflow_p);
 break;
 case PLUS_EXPR:  case MINUS_EXPR:
 /* See if we can eliminate the operation on both sides.  If we can, we
 	}
 /* If this was a subtraction, negate OP1 and set it to be an addition.
 	 This simplifies the logic below.  */
 if (tcode == MINUS_EXPR)
-	tcode = PLUS_EXPR, op1 = negate_expr (op1);
+	{
+	  tcode = PLUS_EXPR, op1 = negate_expr (op1);
+	  /* If OP1 was not easily negatable, the constant may be OP0.  */
+	  if (TREE_CODE (op0) == INTEGER_CST)
+	    {
+	      tree tem = op0;
+	      op0 = op1;
+	      op1 = tem;
+	      tem = t1;
+	      t1 = t2;
+	      t2 = tem;
+	    }
+	}
 if (TREE_CODE (op1) != INTEGER_CST)
 	break;
 /* If either OP1 or C are negative, this optimization is not safe for
 	return 0;
 /* If these are the same operation types, we can associate them
 	 assuming no overflow.  */
 if (tcode == code
-	  && 0 != (t1 = int_const_binop (MULT_EXPR, fold_convert (ctype, op1),
+	  && 0 != (t1 = int_const_binop (MULT_EXPR,
+					 fold_convert (ctype, op1),
 					 fold_convert (ctype, c), 1))
 	  && 0 != (t1 = force_fit_type_double (ctype, TREE_INT_CST_LOW (t1),
 					       TREE_INT_CST_HIGH (t1),
 					       (TYPE_UNSIGNED (ctype)
 					        && tcode != MULT_EXPR) ? -1 : 1,
 given here), it is the second argument.  TYPE is the type of the
 original expression.  Return NULL_TREE if no simplification is
 possible.  */
 static tree
-fold_binary_op_with_conditional_arg (enum tree_code code,
+fold_binary_op_with_conditional_arg (location_t loc,
+				     enum tree_code code,
 				     tree type, tree op0, tree op1,
 				     tree cond, tree arg, int cond_first_p)
 {
 tree cond_type = cond_first_p ? TREE_TYPE (op0) : TREE_TYPE (op1);
 tree arg_type = cond_first_p ? TREE_TYPE (op1) : TREE_TYPE (op0);
 test = cond;
 true_value = constant_boolean_node (true, testtype);
 false_value = constant_boolean_node (false, testtype);
 }
-arg = fold_convert (arg_type, arg);
+arg = fold_convert_loc (loc, arg_type, arg);
 if (lhs == 0)
 {
-true_value = fold_convert (cond_type, true_value);
+true_value = fold_convert_loc (loc, cond_type, true_value);
 if (cond_first_p)
-	lhs = fold_build2 (code, type, true_value, arg);
+	lhs = fold_build2_loc (loc, code, type, true_value, arg);
 else
-	lhs = fold_build2 (code, type, arg, true_value);
+	lhs = fold_build2_loc (loc, code, type, arg, true_value);
 }
 if (rhs == 0)
 {
-false_value = fold_convert (cond_type, false_value);
+false_value = fold_convert_loc (loc, cond_type, false_value);
 if (cond_first_p)
-	rhs = fold_build2 (code, type, false_value, arg);
+	rhs = fold_build2_loc (loc, code, type, false_value, arg);
 else
-	rhs = fold_build2 (code, type, arg, false_value);
+	rhs = fold_build2_loc (loc, code, type, arg, false_value);
 }
-test = fold_build3 (COND_EXPR, type, test, lhs, rhs);
+test = fold_build3_loc (loc, COND_EXPR, type, test, lhs, rhs);
-return fold_convert (type, test);
+return fold_convert_loc (loc, type, test);
 }
 /* Subroutine of fold() that checks for the addition of +/- 0.0.
 The function returns the constant folded tree if a simplification
 can be made, and NULL_TREE otherwise.  */
 static tree
-fold_mathfn_compare (enum built_in_function fcode, enum tree_code code,
+fold_mathfn_compare (location_t loc,
+		     enum built_in_function fcode, enum tree_code code,
 		     tree type, tree arg0, tree arg1)
 {
 REAL_VALUE_TYPE c;
 if (BUILTIN_SQRT_P (fcode))
 c = TREE_REAL_CST (arg1);
 if (REAL_VALUE_NEGATIVE (c))
 	{
 	  /* sqrt(x) < y is always false, if y is negative.  */
 	  if (code == EQ_EXPR || code == LT_EXPR || code == LE_EXPR)
-	    return omit_one_operand (type, integer_zero_node, arg);
+	    return omit_one_operand_loc (loc, type, integer_zero_node, arg);
 	  /* sqrt(x) > y is always true, if y is negative and we
 	     don't care about NaNs, i.e. negative values of x.  */
 	  if (code == NE_EXPR || !HONOR_NANS (mode))
-	    return omit_one_operand (type, integer_one_node, arg);
+	    return omit_one_operand_loc (loc, type, integer_one_node, arg);
 	  /* sqrt(x) > y is the same as x >= 0, if y is negative.  */
-	  return fold_build2 (GE_EXPR, type, arg,
+	  return fold_build2_loc (loc, GE_EXPR, type, arg,
 			      build_real (TREE_TYPE (arg), dconst0));
 	}
 else if (code == GT_EXPR || code == GE_EXPR)
 	{
 	  REAL_VALUE_TYPE c2;
 	  if (REAL_VALUE_ISINF (c2))
 	    {
 	      /* sqrt(x) > y is x == +Inf, when y is very large.  */
 	      if (HONOR_INFINITIES (mode))
-		return fold_build2 (EQ_EXPR, type, arg,
+		return fold_build2_loc (loc, EQ_EXPR, type, arg,
 				    build_real (TREE_TYPE (arg), c2));
 	      /* sqrt(x) > y is always false, when y is very large
 		 and we don't care about infinities.  */
-	      return omit_one_operand (type, integer_zero_node, arg);
+	      return omit_one_operand_loc (loc, type, integer_zero_node, arg);
 	    }
 	  /* sqrt(x) > c is the same as x > c*c.  */
-	  return fold_build2 (code, type, arg,
+	  return fold_build2_loc (loc, code, type, arg,
 			      build_real (TREE_TYPE (arg), c2));
 	}
 else if (code == LT_EXPR || code == LE_EXPR)
 	{
 	  REAL_VALUE_TYPE c2;
 	  if (REAL_VALUE_ISINF (c2))
 	    {
 	      /* sqrt(x) < y is always true, when y is a very large
 		 value and we don't care about NaNs or Infinities.  */
 	      if (! HONOR_NANS (mode) && ! HONOR_INFINITIES (mode))
-		return omit_one_operand (type, integer_one_node, arg);
+		return omit_one_operand_loc (loc, type, integer_one_node, arg);
 	      /* sqrt(x) < y is x != +Inf when y is very large and we
 		 don't care about NaNs.  */
 	      if (! HONOR_NANS (mode))
-		return fold_build2 (NE_EXPR, type, arg,
+		return fold_build2_loc (loc, NE_EXPR, type, arg,
 				    build_real (TREE_TYPE (arg), c2));
 	      /* sqrt(x) < y is x >= 0 when y is very large and we
 		 don't care about Infinities.  */
 	      if (! HONOR_INFINITIES (mode))
-		return fold_build2 (GE_EXPR, type, arg,
+		return fold_build2_loc (loc, GE_EXPR, type, arg,
 				    build_real (TREE_TYPE (arg), dconst0));
 	      /* sqrt(x) < y is x >= 0 && x != +Inf, when y is large.  */
 	      if (lang_hooks.decls.global_bindings_p () != 0
 		  || CONTAINS_PLACEHOLDER_P (arg))
 		return NULL_TREE;
 	      arg = save_expr (arg);
-	      return fold_build2 (TRUTH_ANDIF_EXPR, type,
+	      return fold_build2_loc (loc, TRUTH_ANDIF_EXPR, type,
-				  fold_build2 (GE_EXPR, type, arg,
+				  fold_build2_loc (loc, GE_EXPR, type, arg,
 					       build_real (TREE_TYPE (arg),
 							   dconst0)),
-				  fold_build2 (NE_EXPR, type, arg,
+				  fold_build2_loc (loc, NE_EXPR, type, arg,
 					       build_real (TREE_TYPE (arg),
 							   c2)));
 	    }
 	  /* sqrt(x) < c is the same as x < c*c, if we ignore NaNs.  */
 	  if (! HONOR_NANS (mode))
-	    return fold_build2 (code, type, arg,
+	    return fold_build2_loc (loc, code, type, arg,
 				build_real (TREE_TYPE (arg), c2));
 	  /* sqrt(x) < c is the same as x >= 0 && x < c*c.  */
 	  if (lang_hooks.decls.global_bindings_p () == 0
 	      && ! CONTAINS_PLACEHOLDER_P (arg))
 	    {
 	      arg = save_expr (arg);
-	      return fold_build2 (TRUTH_ANDIF_EXPR, type,
+	      return fold_build2_loc (loc, TRUTH_ANDIF_EXPR, type,
-				  fold_build2 (GE_EXPR, type, arg,
+				  fold_build2_loc (loc, GE_EXPR, type, arg,
 					       build_real (TREE_TYPE (arg),
 							   dconst0)),
-				  fold_build2 (code, type, arg,
+				  fold_build2_loc (loc, code, type, arg,
 					       build_real (TREE_TYPE (arg),
 							   c2)));
 	    }
 	}
 }
 The function returns the constant folded tree if a simplification
 can be made, and NULL_TREE otherwise.  */
 static tree
-fold_inf_compare (enum tree_code code, tree type, tree arg0, tree arg1)
+fold_inf_compare (location_t loc, enum tree_code code, tree type,
+		  tree arg0, tree arg1)
 {
 enum machine_mode mode;
 REAL_VALUE_TYPE max;
 tree temp;
 bool neg;
 {
 case GT_EXPR:
 /* x > +Inf is always false, if with ignore sNANs.  */
 if (HONOR_SNANS (mode))
 return NULL_TREE;
-return omit_one_operand (type, integer_zero_node, arg0);
+return omit_one_operand_loc (loc, type, integer_zero_node, arg0);
 case LE_EXPR:
 /* x <= +Inf is always true, if we don't case about NaNs.  */
 if (! HONOR_NANS (mode))
-	return omit_one_operand (type, integer_one_node, arg0);
+	return omit_one_operand_loc (loc, type, integer_one_node, arg0);
 /* x <= +Inf is the same as x == x, i.e. isfinite(x).  */
 if (lang_hooks.decls.global_bindings_p () == 0
 	  && ! CONTAINS_PLACEHOLDER_P (arg0))
 	{
 	  arg0 = save_expr (arg0);
-	  return fold_build2 (EQ_EXPR, type, arg0, arg0);
+	  return fold_build2_loc (loc, EQ_EXPR, type, arg0, arg0);
 	}
 break;
 case EQ_EXPR:
 case GE_EXPR:
 /* x == +Inf and x >= +Inf are always equal to x > DBL_MAX.  */
 real_maxval (&max, neg, mode);
-return fold_build2 (neg ? LT_EXPR : GT_EXPR, type,
+return fold_build2_loc (loc, neg ? LT_EXPR : GT_EXPR, type,
 			  arg0, build_real (TREE_TYPE (arg0), max));
 case LT_EXPR:
 /* x < +Inf is always equal to x <= DBL_MAX.  */
 real_maxval (&max, neg, mode);
-return fold_build2 (neg ? GE_EXPR : LE_EXPR, type,
+return fold_build2_loc (loc, neg ? GE_EXPR : LE_EXPR, type,
 			  arg0, build_real (TREE_TYPE (arg0), max));
 case NE_EXPR:
 /* x != +Inf is always equal to !(x > DBL_MAX).  */
 real_maxval (&max, neg, mode);
 if (! HONOR_NANS (mode))
-	return fold_build2 (neg ? GE_EXPR : LE_EXPR, type,
+	return fold_build2_loc (loc, neg ? GE_EXPR : LE_EXPR, type,
 			    arg0, build_real (TREE_TYPE (arg0), max));
-temp = fold_build2 (neg ? LT_EXPR : GT_EXPR, type,
+temp = fold_build2_loc (loc, neg ? LT_EXPR : GT_EXPR, type,
 			  arg0, build_real (TREE_TYPE (arg0), max));
-return fold_build1 (TRUTH_NOT_EXPR, type, temp);
+return fold_build1_loc (loc, TRUTH_NOT_EXPR, type, temp);
 default:
 break;
 }
 The function returns the constant folded tree if a simplification
 can be made, and NULL_TREE otherwise.  */
 static tree
-fold_div_compare (enum tree_code code, tree type, tree arg0, tree arg1)
+fold_div_compare (location_t loc,
+		  enum tree_code code, tree type, tree arg0, tree arg1)
 {
 tree prod, tmp, hi, lo;
 tree arg00 = TREE_OPERAND (arg0, 0);
 tree arg01 = TREE_OPERAND (arg0, 1);
 unsigned HOST_WIDE_INT lpart;
 switch (code)
 {
 case EQ_EXPR:
 if (TREE_OVERFLOW (lo) && TREE_OVERFLOW (hi))
-	return omit_one_operand (type, integer_zero_node, arg00);
+	return omit_one_operand_loc (loc, type, integer_zero_node, arg00);
 if (TREE_OVERFLOW (hi))
-	return fold_build2 (GE_EXPR, type, arg00, lo);
+	return fold_build2_loc (loc, GE_EXPR, type, arg00, lo);
 if (TREE_OVERFLOW (lo))
-	return fold_build2 (LE_EXPR, type, arg00, hi);
+	return fold_build2_loc (loc, LE_EXPR, type, arg00, hi);
-return build_range_check (type, arg00, 1, lo, hi);
+return build_range_check (loc, type, arg00, 1, lo, hi);
 case NE_EXPR:
 if (TREE_OVERFLOW (lo) && TREE_OVERFLOW (hi))
-	return omit_one_operand (type, integer_one_node, arg00);
+	return omit_one_operand_loc (loc, type, integer_one_node, arg00);
 if (TREE_OVERFLOW (hi))
-	return fold_build2 (LT_EXPR, type, arg00, lo);
+	return fold_build2_loc (loc, LT_EXPR, type, arg00, lo);
 if (TREE_OVERFLOW (lo))
-	return fold_build2 (GT_EXPR, type, arg00, hi);
+	return fold_build2_loc (loc, GT_EXPR, type, arg00, hi);
-return build_range_check (type, arg00, 0, lo, hi);
+return build_range_check (loc, type, arg00, 0, lo, hi);
 case LT_EXPR:
 if (TREE_OVERFLOW (lo))
 	{
 	  tmp = neg_overflow ? integer_zero_node : integer_one_node;
-	  return omit_one_operand (type, tmp, arg00);
+	  return omit_one_operand_loc (loc, type, tmp, arg00);
 	}
-return fold_build2 (LT_EXPR, type, arg00, lo);
+return fold_build2_loc (loc, LT_EXPR, type, arg00, lo);
 case LE_EXPR:
 if (TREE_OVERFLOW (hi))
 	{
 	  tmp = neg_overflow ? integer_zero_node : integer_one_node;
-	  return omit_one_operand (type, tmp, arg00);
+	  return omit_one_operand_loc (loc, type, tmp, arg00);
 	}
-return fold_build2 (LE_EXPR, type, arg00, hi);
+return fold_build2_loc (loc, LE_EXPR, type, arg00, hi);
 case GT_EXPR:
 if (TREE_OVERFLOW (hi))
 	{
 	  tmp = neg_overflow ? integer_one_node : integer_zero_node;
-	  return omit_one_operand (type, tmp, arg00);
+	  return omit_one_operand_loc (loc, type, tmp, arg00);
 	}
-return fold_build2 (GT_EXPR, type, arg00, hi);
+return fold_build2_loc (loc, GT_EXPR, type, arg00, hi);
 case GE_EXPR:
 if (TREE_OVERFLOW (lo))
 	{
 	  tmp = neg_overflow ? integer_one_node : integer_zero_node;
-	  return omit_one_operand (type, tmp, arg00);
+	  return omit_one_operand_loc (loc, type, tmp, arg00);
 	}
-return fold_build2 (GE_EXPR, type, arg00, lo);
+return fold_build2_loc (loc, GE_EXPR, type, arg00, lo);
 default:
 break;
 }
 equality/inequality test, then return a simplified form of the test
 using a sign testing.  Otherwise return NULL.  TYPE is the desired
 result type.  */
 static tree
-fold_single_bit_test_into_sign_test (enum tree_code code, tree arg0, tree arg1,
+fold_single_bit_test_into_sign_test (location_t loc,
+				     enum tree_code code, tree arg0, tree arg1,
 				     tree result_type)
 {
 /* If this is testing a single bit, we can optimize the test.  */
 if ((code == NE_EXPR || code == EQ_EXPR)
 && TREE_CODE (arg0) == BIT_AND_EXPR && integer_zerop (arg1)
 	     i.e. when arg00's type is not a partial mode.  */
 	  && TYPE_PRECISION (TREE_TYPE (arg00))
 	     == GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (arg00))))
 	{
 	  tree stype = signed_type_for (TREE_TYPE (arg00));
-	  return fold_build2 (code == EQ_EXPR ? GE_EXPR : LT_EXPR,
+	  return fold_build2_loc (loc, code == EQ_EXPR ? GE_EXPR : LT_EXPR,
-			      result_type, fold_convert (stype, arg00),
+			      result_type,
+			      fold_convert_loc (loc, stype, arg00),
 			      build_int_cst (stype, 0));
 	}
 }
 return NULL_TREE;
 equality/inequality test, then return a simplified form of
 the test using shifts and logical operations.  Otherwise return
 NULL.  TYPE is the desired result type.  */
 tree
-fold_single_bit_test (enum tree_code code, tree arg0, tree arg1,
+fold_single_bit_test (location_t loc, enum tree_code code,
-		      tree result_type)
+		      tree arg0, tree arg1, tree result_type)
 {
 /* If this is testing a single bit, we can optimize the test.  */
 if ((code == NE_EXPR || code == EQ_EXPR)
 && TREE_CODE (arg0) == BIT_AND_EXPR && integer_zerop (arg1)
 && integer_pow2p (TREE_OPERAND (arg0, 1)))
 tree signed_type, unsigned_type, intermediate_type;
 tree tem, one;
 /* First, see if we can fold the single bit test into a sign-bit
 	 test.  */
-tem = fold_single_bit_test_into_sign_test (code, arg0, arg1,
+tem = fold_single_bit_test_into_sign_test (loc, code, arg0, arg1,
 						 result_type);
 if (tem)
 	return tem;
 /* Otherwise we have (A & C) != 0 where C is a single bit,
 /* If we are going to be able to omit the AND below, we must do our
 	 operations as unsigned.  If we must use the AND, we have a choice.
 	 Normally unsigned is faster, but for some machines signed is.  */
 #ifdef LOAD_EXTEND_OP
 ops_unsigned = (LOAD_EXTEND_OP (operand_mode) == SIGN_EXTEND
 		      && !flag_syntax_only) ? 0 : 1;
 #else
 ops_unsigned = 1;
 #endif
 signed_type = lang_hooks.types.type_for_mode (operand_mode, 0);
 unsigned_type = lang_hooks.types.type_for_mode (operand_mode, 1);
 intermediate_type = ops_unsigned ? unsigned_type : signed_type;
-inner = fold_convert (intermediate_type, inner);
+inner = fold_convert_loc (loc, intermediate_type, inner);
 if (bitnum != 0)
 	inner = build2 (RSHIFT_EXPR, intermediate_type,
 			inner, size_int (bitnum));
 one = build_int_cst (intermediate_type, 1);
 if (code == EQ_EXPR)
-	inner = fold_build2 (BIT_XOR_EXPR, intermediate_type, inner, one);
+	inner = fold_build2_loc (loc, BIT_XOR_EXPR, intermediate_type, inner, one);
 /* Put the AND last so it can combine with more things.  */
 inner = build2 (BIT_AND_EXPR, intermediate_type, inner, one);
 /* Make sure to return the proper type.  */
-inner = fold_convert (result_type, inner);
+inner = fold_convert_loc (loc, result_type, inner);
 return inner;
 }
 return NULL_TREE;
 }
 /* Fold comparison ARG0 CODE ARG1 (with result in TYPE), where
 ARG0 is extended to a wider type.  */
 static tree
-fold_widened_comparison (enum tree_code code, tree type, tree arg0, tree arg1)
+fold_widened_comparison (location_t loc, enum tree_code code,
+			 tree type, tree arg0, tree arg1)
 {
 tree arg0_unw = get_unwidened (arg0, NULL_TREE);
 tree arg1_unw;
 tree shorter_type, outer_type;
 tree min, max;
 		  == TYPE_UNSIGNED (TREE_TYPE (arg1_unw))))
 	  || (TREE_CODE (arg1_unw) == INTEGER_CST
 	      && (TREE_CODE (shorter_type) == INTEGER_TYPE
 		  || TREE_CODE (shorter_type) == BOOLEAN_TYPE)
 	      && int_fits_type_p (arg1_unw, shorter_type))))
-return fold_build2 (code, type, arg0_unw,
+return fold_build2_loc (loc, code, type, arg0_unw,
-		       fold_convert (shorter_type, arg1_unw));
+			fold_convert_loc (loc, shorter_type, arg1_unw));
 if (TREE_CODE (arg1_unw) != INTEGER_CST
 || TREE_CODE (shorter_type) != INTEGER_TYPE
 || !int_fits_type_p (arg1_unw, shorter_type))
 return NULL_TREE;
 switch (code)
 {
 case EQ_EXPR:
 if (above || below)
-	return omit_one_operand (type, integer_zero_node, arg0);
+	return omit_one_operand_loc (loc, type, integer_zero_node, arg0);
 break;
 case NE_EXPR:
 if (above || below)
-	return omit_one_operand (type, integer_one_node, arg0);
+	return omit_one_operand_loc (loc, type, integer_one_node, arg0);
 break;
 case LT_EXPR:
 case LE_EXPR:
 if (above)
-	return omit_one_operand (type, integer_one_node, arg0);
+	return omit_one_operand_loc (loc, type, integer_one_node, arg0);
 else if (below)
-	return omit_one_operand (type, integer_zero_node, arg0);
+	return omit_one_operand_loc (loc, type, integer_zero_node, arg0);
 case GT_EXPR:
 case GE_EXPR:
 if (above)
-	return omit_one_operand (type, integer_zero_node, arg0);
+	return omit_one_operand_loc (loc, type, integer_zero_node, arg0);
 else if (below)
-	return omit_one_operand (type, integer_one_node, arg0);
+	return omit_one_operand_loc (loc, type, integer_one_node, arg0);
 default:
 break;
 }
 /* Fold comparison ARG0 CODE ARG1 (with result in TYPE), where for
 ARG0 just the signedness is changed.  */
 static tree
-fold_sign_changed_comparison (enum tree_code code, tree type,
+fold_sign_changed_comparison (location_t loc, enum tree_code code, tree type,
 			      tree arg0, tree arg1)
 {
 tree arg0_inner;
 tree inner_type, outer_type;
 #endif
 if (TYPE_PRECISION (inner_type) != TYPE_PRECISION (outer_type))
 return NULL_TREE;
-/* If the conversion is from an integral subtype to its basetype
-leave it alone.  */
-if (TREE_TYPE (inner_type) == outer_type)
-return NULL_TREE;
 if (TREE_CODE (arg1) != INTEGER_CST
 && !(CONVERT_EXPR_P (arg1)
 	   && TREE_TYPE (TREE_OPERAND (arg1, 0)) == inner_type))
 return NULL_TREE;
 if (TREE_CODE (arg1) == INTEGER_CST)
 arg1 = force_fit_type_double (inner_type, TREE_INT_CST_LOW (arg1),
 				  TREE_INT_CST_HIGH (arg1), 0,
 				  TREE_OVERFLOW (arg1));
 else
-arg1 = fold_convert (inner_type, arg1);
+arg1 = fold_convert_loc (loc, inner_type, arg1);
-return fold_build2 (code, type, arg0_inner, arg1);
+return fold_build2_loc (loc, code, type, arg0_inner, arg1);
 }
 /* Tries to replace &a[idx] p+ s * delta with &a[idx + delta], if s is
-step of the array.  Reconstructs s and delta in the case of s * delta
+step of the array.  Reconstructs s and delta in the case of s *
-being an integer constant (and thus already folded).
+delta being an integer constant (and thus already folded).  ADDR is
-ADDR is the address. MULT is the multiplicative expression.
+the address. MULT is the multiplicative expression.  If the
-If the function succeeds, the new address expression is returned.  Otherwise
+function succeeds, the new address expression is returned.
-NULL_TREE is returned.  */
+Otherwise NULL_TREE is returned.  LOC is the location of the
+resulting expression.  */
 static tree
-try_move_mult_to_index (tree addr, tree op1)
+try_move_mult_to_index (location_t loc, tree addr, tree op1)
 {
 tree s, delta, step;
 tree ref = TREE_OPERAND (addr, 0), pref;
 tree ret, pos;
 tree itype;
 {
 tree arg0 = TREE_OPERAND (op1, 0), arg1 = TREE_OPERAND (op1, 1);
 STRIP_NOPS (arg0);
 STRIP_NOPS (arg1);
 if (TREE_CODE (arg0) == INTEGER_CST)
 {
 s = arg0;
 delta = arg1;
 }
 for (;; ref = TREE_OPERAND (ref, 0))
 {
 if (TREE_CODE (ref) == ARRAY_REF)
 	{
+	  tree domain;
 	  /* Remember if this was a multi-dimensional array.  */
 	  if (TREE_CODE (TREE_OPERAND (ref, 0)) == ARRAY_REF)
 	    mdim = true;
-	  itype = TYPE_DOMAIN (TREE_TYPE (TREE_OPERAND (ref, 0)));
+	  domain = TYPE_DOMAIN (TREE_TYPE (TREE_OPERAND (ref, 0)));
-	  if (! itype)
+	  if (! domain)
 	    continue;
+	  itype = TREE_TYPE (domain);
 	  step = array_ref_element_size (ref);
 	  if (TREE_CODE (step) != INTEGER_CST)
 	    continue;
 	  if (mdim)
 	    {
 	      tree tmp;
 	      if (TREE_CODE (TREE_OPERAND (ref, 1)) != INTEGER_CST
-		  || !INTEGRAL_TYPE_P (itype)
+		  || !TYPE_MAX_VALUE (domain)
-		  || !TYPE_MAX_VALUE (itype)
+		  || TREE_CODE (TYPE_MAX_VALUE (domain)) != INTEGER_CST)
-		  || TREE_CODE (TYPE_MAX_VALUE (itype)) != INTEGER_CST)
 		continue;
-	      tmp = fold_binary (PLUS_EXPR, itype,
+	      tmp = fold_binary_loc (loc, PLUS_EXPR, itype,
-				 fold_convert (itype,
+				     fold_convert_loc (loc, itype,
-					       TREE_OPERAND (ref, 1)),
+						       TREE_OPERAND (ref, 1)),
-				 fold_convert (itype, delta));
+				     fold_convert_loc (loc, itype, delta));
 	      if (!tmp
 		  || TREE_CODE (tmp) != INTEGER_CST
-		  || tree_int_cst_lt (TYPE_MAX_VALUE (itype), tmp))
+		  || tree_int_cst_lt (TYPE_MAX_VALUE (domain), tmp))
 		continue;
 	    }
 	  break;
 	}
 /* We found the suitable array reference.  So copy everything up to it,
 and replace the index.  */
 pref = TREE_OPERAND (addr, 0);
 ret = copy_node (pref);
+SET_EXPR_LOCATION (ret, loc);
 pos = ret;
 while (pref != ref)
 {
 pref = TREE_OPERAND (pref, 0);
 TREE_OPERAND (pos, 0) = copy_node (pref);
 pos = TREE_OPERAND (pos, 0);
 }
-TREE_OPERAND (pos, 1) = fold_build2 (PLUS_EXPR, itype,
+TREE_OPERAND (pos, 1) = fold_build2_loc (loc, PLUS_EXPR, itype,
-				       fold_convert (itype,
+				       fold_convert_loc (loc, itype,
-						     TREE_OPERAND (pos, 1)),
+							 TREE_OPERAND (pos, 1)),
-				       fold_convert (itype, delta));
+				       fold_convert_loc (loc, itype, delta));
-return fold_build1 (ADDR_EXPR, TREE_TYPE (addr), ret);
+return fold_build1_loc (loc, ADDR_EXPR, TREE_TYPE (addr), ret);
 }
 /* Fold A < X && A + 1 > Y to A < X && A >= Y.  Normally A + 1 > Y
 means A >= Y && A != MAX, but in this case we know that
 A < X <= MAX.  INEQ is A + 1 > Y, BOUND is A < X.  */
 static tree
-fold_to_nonsharp_ineq_using_bound (tree ineq, tree bound)
+fold_to_nonsharp_ineq_using_bound (location_t loc, tree ineq, tree bound)
 {
 tree a, typea, type = TREE_TYPE (ineq), a1, diff, y;
 if (TREE_CODE (bound) == LT_EXPR)
 a = TREE_OPERAND (bound, 0);
 return NULL_TREE;
 if (POINTER_TYPE_P (typea))
 {
 /* Convert the pointer types into integer before taking the difference.  */
-tree ta = fold_convert (ssizetype, a);
+tree ta = fold_convert_loc (loc, ssizetype, a);
-tree ta1 = fold_convert (ssizetype, a1);
+tree ta1 = fold_convert_loc (loc, ssizetype, a1);
-diff = fold_binary (MINUS_EXPR, ssizetype, ta1, ta);
+diff = fold_binary_loc (loc, MINUS_EXPR, ssizetype, ta1, ta);
 }
 else
-diff = fold_binary (MINUS_EXPR, typea, a1, a);
+diff = fold_binary_loc (loc, MINUS_EXPR, typea, a1, a);
 if (!diff || !integer_onep (diff))
 return NULL_TREE;
-return fold_build2 (GE_EXPR, type, a, y);
+return fold_build2_loc (loc, GE_EXPR, type, a, y);
 }
 /* Fold a sum or difference of at least one multiplication.
 Returns the folded tree or NULL if no simplification could be made.  */
 static tree
-fold_plusminus_mult_expr (enum tree_code code, tree type, tree arg0, tree arg1)
+fold_plusminus_mult_expr (location_t loc, enum tree_code code, tree type,
+			  tree arg0, tree arg1)
 {
 tree arg00, arg01, arg10, arg11;
 tree alt0 = NULL_TREE, alt1 = NULL_TREE, same;
 /* (A * C) +- (B * C) -> (A+-B) * C.
 	  swap = true;
 	}
 else
 	maybe_same = arg11;
-if (exact_log2 (abs (int11)) > 0 && int01 % int11 == 0)
+if (exact_log2 (abs (int11)) > 0 && int01 % int11 == 0
+	  /* The remainder should not be a constant, otherwise we
+	     end up folding i * 4 + 2 to (i * 2 + 1) * 2 which has
+	     increased the number of multiplications necessary.  */
+	  && TREE_CODE (arg10) != INTEGER_CST)
 {
-	  alt0 = fold_build2 (MULT_EXPR, TREE_TYPE (arg00), arg00,
+	  alt0 = fold_build2_loc (loc, MULT_EXPR, TREE_TYPE (arg00), arg00,
 			      build_int_cst (TREE_TYPE (arg00),
 					     int01 / int11));
 	  alt1 = arg10;
 	  same = maybe_same;
 	  if (swap)
 	    maybe_same = alt0, alt0 = alt1, alt1 = maybe_same;
 	}
 }
 if (same)
-return fold_build2 (MULT_EXPR, type,
+return fold_build2_loc (loc, MULT_EXPR, type,
-			fold_build2 (code, type,
+			fold_build2_loc (loc, code, type,
-				     fold_convert (type, alt0),
+				     fold_convert_loc (loc, type, alt0),
-				     fold_convert (type, alt1)),
+				     fold_convert_loc (loc, type, alt1)),
-			fold_convert (type, same));
+			fold_convert_loc (loc, type, same));
 return NULL_TREE;
 }
 /* Subroutine of native_encode_expr.  Encode the INTEGER_CST
 return native_interpret_expr (type, buffer, len);
 }
 /* Build an expression for the address of T.  Folds away INDIRECT_REF
-to avoid confusing the gimplify process.  When IN_FOLD is true
+to avoid confusing the gimplify process.  */
-avoid modifications of T.  */
+tree
-static tree
+build_fold_addr_expr_with_type_loc (location_t loc, tree t, tree ptrtype)
-build_fold_addr_expr_with_type_1 (tree t, tree ptrtype, bool in_fold)
 {
 /* The size of the object is not relevant when talking about its address.  */
 if (TREE_CODE (t) == WITH_SIZE_EXPR)
 t = TREE_OPERAND (t, 0);
 || TREE_CODE (t) == MISALIGNED_INDIRECT_REF)
 {
 t = TREE_OPERAND (t, 0);
 if (TREE_TYPE (t) != ptrtype)
-	t = build1 (NOP_EXPR, ptrtype, t);
+	{
-}
+	  t = build1 (NOP_EXPR, ptrtype, t);
-else if (!in_fold)
+	  SET_EXPR_LOCATION (t, loc);
-{
+	}
-tree base = t;
+}
+else if (TREE_CODE (t) == VIEW_CONVERT_EXPR)
-while (handled_component_p (base))
+{
-	base = TREE_OPERAND (base, 0);
+t = build_fold_addr_expr_loc (loc, TREE_OPERAND (t, 0));
-if (DECL_P (base))
+if (TREE_TYPE (t) != ptrtype)
-	TREE_ADDRESSABLE (base) = 1;
+	t = fold_convert_loc (loc, ptrtype, t);
+}
+else
+{
 t = build1 (ADDR_EXPR, ptrtype, t);
-}
+SET_EXPR_LOCATION (t, loc);
-else
+}
-t = build1 (ADDR_EXPR, ptrtype, t);
 return t;
 }
-/* Build an expression for the address of T with type PTRTYPE.  This
+/* Build an expression for the address of T.  */
-function modifies the input parameter 'T' by sometimes setting the
-TREE_ADDRESSABLE flag.  */
 tree
-build_fold_addr_expr_with_type (tree t, tree ptrtype)
+build_fold_addr_expr_loc (location_t loc, tree t)
-{
-return build_fold_addr_expr_with_type_1 (t, ptrtype, false);
-}
-/* Build an expression for the address of T.  This function modifies
-the input parameter 'T' by sometimes setting the TREE_ADDRESSABLE
-flag.  When called from fold functions, use fold_addr_expr instead.  */
-tree
-build_fold_addr_expr (tree t)
-{
-return build_fold_addr_expr_with_type_1 (t,
-					   build_pointer_type (TREE_TYPE (t)),
-					   false);
-}
-/* Same as build_fold_addr_expr, builds an expression for the address
-of T, but avoids touching the input node 't'.  Fold functions
-should use this version.  */
-static tree
-fold_addr_expr (tree t)
 {
 tree ptrtype = build_pointer_type (TREE_TYPE (t));
-return build_fold_addr_expr_with_type_1 (t, ptrtype, true);
+return build_fold_addr_expr_with_type_loc (loc, t, ptrtype);
 }
 /* Fold a unary expression of code CODE and type TYPE with operand
 OP0.  Return the folded expression if folding is successful.
 Otherwise, return NULL_TREE.  */
 tree
-fold_unary (enum tree_code code, tree type, tree op0)
+fold_unary_loc (location_t loc, enum tree_code code, tree type, tree op0)
 {
 tree tem;
 tree arg0;
 enum tree_code_class kind = TREE_CODE_CLASS (code);
 if (TREE_CODE_CLASS (code) == tcc_unary)
 {
 if (TREE_CODE (arg0) == COMPOUND_EXPR)
 	return build2 (COMPOUND_EXPR, type, TREE_OPERAND (arg0, 0),
-		       fold_build1 (code, type,
+		       fold_build1_loc (loc, code, type,
-				    fold_convert (TREE_TYPE (op0),
+				    fold_convert_loc (loc, TREE_TYPE (op0),
-						  TREE_OPERAND (arg0, 1))));
+						      TREE_OPERAND (arg0, 1))));
 else if (TREE_CODE (arg0) == COND_EXPR)
 	{
 	  tree arg01 = TREE_OPERAND (arg0, 1);
 	  tree arg02 = TREE_OPERAND (arg0, 2);
 	  if (! VOID_TYPE_P (TREE_TYPE (arg01)))
-	    arg01 = fold_build1 (code, type,
+	    arg01 = fold_build1_loc (loc, code, type,
-				 fold_convert (TREE_TYPE (op0), arg01));
+				 fold_convert_loc (loc,
+						   TREE_TYPE (op0), arg01));
 	  if (! VOID_TYPE_P (TREE_TYPE (arg02)))
-	    arg02 = fold_build1 (code, type,
+	    arg02 = fold_build1_loc (loc, code, type,
-				 fold_convert (TREE_TYPE (op0), arg02));
+				 fold_convert_loc (loc,
-	  tem = fold_build3 (COND_EXPR, type, TREE_OPERAND (arg0, 0),
+						   TREE_TYPE (op0), arg02));
+	  tem = fold_build3_loc (loc, COND_EXPR, type, TREE_OPERAND (arg0, 0),
 			     arg01, arg02);
 	  /* If this was a conversion, and all we did was to move into
 	     inside the COND_EXPR, bring it back out.  But leave it if
 	     it is a conversion from integer to integer and the
 	      && (! (INTEGRAL_TYPE_P (TREE_TYPE (tem))
 		     && (INTEGRAL_TYPE_P
 			 (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (tem, 1), 0))))
 		     && TYPE_PRECISION (TREE_TYPE (tem)) <= BITS_PER_WORD)
 		  || flag_syntax_only))
-	    tem = build1 (code, type,
+	    {
-			  build3 (COND_EXPR,
+	      tem = build1 (code, type,
-				  TREE_TYPE (TREE_OPERAND
+			    build3 (COND_EXPR,
-					     (TREE_OPERAND (tem, 1), 0)),
+				    TREE_TYPE (TREE_OPERAND
-				  TREE_OPERAND (tem, 0),
+					       (TREE_OPERAND (tem, 1), 0)),
-				  TREE_OPERAND (TREE_OPERAND (tem, 1), 0),
+				    TREE_OPERAND (tem, 0),
-				  TREE_OPERAND (TREE_OPERAND (tem, 2), 0)));
+				    TREE_OPERAND (TREE_OPERAND (tem, 1), 0),
+				    TREE_OPERAND (TREE_OPERAND (tem, 2), 0)));
+	      SET_EXPR_LOCATION (tem, loc);
+	    }
 	  return tem;
 	}
 else if (COMPARISON_CLASS_P (arg0))
 	{
 	  if (TREE_CODE (type) == BOOLEAN_TYPE)
 	      arg0 = copy_node (arg0);
 	      TREE_TYPE (arg0) = type;
 	      return arg0;
 	    }
 	  else if (TREE_CODE (type) != INTEGER_TYPE)
-	    return fold_build3 (COND_EXPR, type, arg0,
+	    return fold_build3_loc (loc, COND_EXPR, type, arg0,
-				fold_build1 (code, type,
+				fold_build1_loc (loc, code, type,
 					     integer_one_node),
-				fold_build1 (code, type,
+				fold_build1_loc (loc, code, type,
 					     integer_zero_node));
 	}
 }
 switch (code)
 case PAREN_EXPR:
 /* Re-association barriers around constants and other re-association
 	 barriers can be removed.  */
 if (CONSTANT_CLASS_P (op0)
 	  || TREE_CODE (op0) == PAREN_EXPR)
-	return fold_convert (type, op0);
+	return fold_convert_loc (loc, type, op0);
 return NULL_TREE;
 CASE_CONVERT:
 case FLOAT_EXPR:
 case FIX_TRUNC_EXPR:
 if (TREE_TYPE (op0) == type)
 	return op0;
 /* If we have (type) (a CMP b) and type is an integral type, return
 new expression involving the new type.  */
 if (COMPARISON_CLASS_P (op0) && INTEGRAL_TYPE_P (type))
-	return fold_build2 (TREE_CODE (op0), type, TREE_OPERAND (op0, 0),
+	return fold_build2_loc (loc, TREE_CODE (op0), type, TREE_OPERAND (op0, 0),
 			    TREE_OPERAND (op0, 1));
 /* Handle cases of two conversions in a row.  */
 if (CONVERT_EXPR_P (op0))
 	{
 	     conversion is needed.  */
 	  if (TYPE_MAIN_VARIANT (inside_type) == TYPE_MAIN_VARIANT (type)
 	      && (((inter_int || inter_ptr) && final_int)
 		  || (inter_float && final_float))
 	      && inter_prec >= final_prec)
-	    return fold_build1 (code, type, TREE_OPERAND (op0, 0));
+	    return fold_build1_loc (loc, code, type, TREE_OPERAND (op0, 0));
 	  /* Likewise, if the intermediate and initial types are either both
 	     float or both integer, we don't need the middle conversion if the
 	     former is wider than the latter and doesn't change the signedness
 	     (for integers).  Avoid this if the final type is a pointer since
 		  || inter_unsignedp == inside_unsignedp)
 	      && ! (final_prec != GET_MODE_BITSIZE (TYPE_MODE (type))
 		    && TYPE_MODE (type) == TYPE_MODE (inter_type))
 	      && ! final_ptr
 	      && (! final_vec || inter_prec == inside_prec))
-	    return fold_build1 (code, type, TREE_OPERAND (op0, 0));
+	    return fold_build1_loc (loc, code, type, TREE_OPERAND (op0, 0));
 	  /* If we have a sign-extension of a zero-extended value, we can
 	     replace that by a single zero-extension.  */
 	  if (inside_int && inter_int && final_int
 	      && inside_prec < inter_prec && inter_prec < final_prec
 	      && inside_unsignedp && !inter_unsignedp)
-	    return fold_build1 (code, type, TREE_OPERAND (op0, 0));
+	    return fold_build1_loc (loc, code, type, TREE_OPERAND (op0, 0));
 	  /* Two conversions in a row are not needed unless:
 	     - some conversion is floating-point (overstrict for now), or
 	     - some conversion is a vector (overstrict for now), or
 	     - the intermediate type is narrower than both initial and
 		  == (final_unsignedp && final_prec > inter_prec))
 	      && ! (inside_ptr && inter_prec != final_prec)
 	      && ! (final_ptr && inside_prec != inter_prec)
 	      && ! (final_prec != GET_MODE_BITSIZE (TYPE_MODE (type))
 		    && TYPE_MODE (type) == TYPE_MODE (inter_type)))
-	    return fold_build1 (code, type, TREE_OPERAND (op0, 0));
+	    return fold_build1_loc (loc, code, type, TREE_OPERAND (op0, 0));
 	}
 /* Handle (T *)&A.B.C for A being of type T and B and C
 	 living at offset zero.  This occurs frequently in
 	 C++ upcasting and then accessing the base.  */
 	     the address of the base if it has the same base type
 	     as the result type.  */
 	  if (! offset && bitpos == 0
 	      && TYPE_MAIN_VARIANT (TREE_TYPE (type))
 		  == TYPE_MAIN_VARIANT (TREE_TYPE (base)))
-	    return fold_convert (type, fold_addr_expr (base));
+	    return fold_convert_loc (loc, type,
+				     build_fold_addr_expr_loc (loc, base));
 }
 if (TREE_CODE (op0) == MODIFY_EXPR
 	  && TREE_CONSTANT (TREE_OPERAND (op0, 1))
 	  /* Detect assigning a bitfield.  */
 	       && DECL_BIT_FIELD
 	       (TREE_OPERAND (TREE_OPERAND (op0, 0), 1))))
 	{
 	  /* Don't leave an assignment inside a conversion
 	     unless assigning a bitfield.  */
-	  tem = fold_build1 (code, type, TREE_OPERAND (op0, 1));
+	  tem = fold_build1_loc (loc, code, type, TREE_OPERAND (op0, 1));
 	  /* First do the assignment, then return converted constant.  */
 	  tem = build2 (COMPOUND_EXPR, TREE_TYPE (tem), op0, tem);
 	  TREE_NO_WARNING (tem) = 1;
 	  TREE_USED (tem) = 1;
+	  SET_EXPR_LOCATION (tem, loc);
 	  return tem;
 	}
 /* Convert (T)(x & c) into (T)x & (T)c, if c is an integer
 	 constants (if x has signed type, the sign bit cannot be set
 	 ??? We don't do it for BOOLEAN_TYPE or ENUMERAL_TYPE because they
 	 very likely don't have maximal range for their precision and this
 	 transformation effectively doesn't preserve non-maximal ranges.  */
 if (TREE_CODE (type) == INTEGER_TYPE
 	  && TREE_CODE (op0) == BIT_AND_EXPR
-	  && TREE_CODE (TREE_OPERAND (op0, 1)) == INTEGER_CST
+	  && TREE_CODE (TREE_OPERAND (op0, 1)) == INTEGER_CST)
-	  /* Not if the conversion is to the sub-type.  */
+	{
-	  && TREE_TYPE (type) != TREE_TYPE (op0))
+	  tree and_expr = op0;
-	{
+	  tree and0 = TREE_OPERAND (and_expr, 0);
-	  tree and = op0;
+	  tree and1 = TREE_OPERAND (and_expr, 1);
-	  tree and0 = TREE_OPERAND (and, 0), and1 = TREE_OPERAND (and, 1);
 	  int change = 0;
-	  if (TYPE_UNSIGNED (TREE_TYPE (and))
+	  if (TYPE_UNSIGNED (TREE_TYPE (and_expr))
 	      || (TYPE_PRECISION (type)
-		  <= TYPE_PRECISION (TREE_TYPE (and))))
+		  <= TYPE_PRECISION (TREE_TYPE (and_expr))))
 	    change = 1;
 	  else if (TYPE_PRECISION (TREE_TYPE (and1))
 		   <= HOST_BITS_PER_WIDE_INT
 		   && host_integerp (and1, 1))
 	    {
 		  && !flag_syntax_only
 		  && (LOAD_EXTEND_OP (TYPE_MODE (TREE_TYPE (and0)))
 		      == ZERO_EXTEND))
 		{
 		  tree uns = unsigned_type_for (TREE_TYPE (and0));
-		  and0 = fold_convert (uns, and0);
+		  and0 = fold_convert_loc (loc, uns, and0);
-		  and1 = fold_convert (uns, and1);
+		  and1 = fold_convert_loc (loc, uns, and1);
 		}
 #endif
 	    }
 	  if (change)
 	    {
 	      tem = force_fit_type_double (type, TREE_INT_CST_LOW (and1),
 					   TREE_INT_CST_HIGH (and1), 0,
 					   TREE_OVERFLOW (and1));
-	      return fold_build2 (BIT_AND_EXPR, type,
+	      return fold_build2_loc (loc, BIT_AND_EXPR, type,
-				  fold_convert (type, and0), tem);
+				  fold_convert_loc (loc, type, and0), tem);
 	    }
 	}
 /* Convert (T1)(X p+ Y) into ((T1)X p+ Y), for pointer type,
 when one of the new casts will fold away. Conservatively we assume
 	      || TREE_CODE (TREE_OPERAND (arg0, 1)) == NOP_EXPR))
 	{
 	  tree arg00 = TREE_OPERAND (arg0, 0);
 	  tree arg01 = TREE_OPERAND (arg0, 1);
-	  return fold_build2 (TREE_CODE (arg0), type, fold_convert (type, arg00),
+	  return fold_build2_loc (loc,
-			      fold_convert (sizetype, arg01));
+			      TREE_CODE (arg0), type,
+			      fold_convert_loc (loc, type, arg00),
+			      fold_convert_loc (loc, sizetype, arg01));
 	}
 /* Convert (T1)(~(T2)X) into ~(T1)X if T1 and T2 are integral types
 	 of the same precision, and X is an integer type not narrower than
 	 types T1 or T2, i.e. the cast (T2)X isn't an extension.  */
 	  && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (op0)))
 	{
 	  tem = TREE_OPERAND (TREE_OPERAND (op0, 0), 0);
 	  if (INTEGRAL_TYPE_P (TREE_TYPE (tem))
 	      && TYPE_PRECISION (type) <= TYPE_PRECISION (TREE_TYPE (tem)))
-	    return fold_build1 (BIT_NOT_EXPR, type, fold_convert (type, tem));
+	    return fold_build1_loc (loc, BIT_NOT_EXPR, type,
+				fold_convert_loc (loc, type, tem));
 	}
 /* Convert (T1)(X * Y) into (T1)X * (T1)Y if T1 is narrower than the
 	 type of X and Y (integer types only).  */
 if (INTEGRAL_TYPE_P (type)
 	  else
 	    mult_type = unsigned_type_for (type);
 	  if (TYPE_PRECISION (mult_type) < TYPE_PRECISION (TREE_TYPE (op0)))
 	    {
-	      tem = fold_build2 (MULT_EXPR, mult_type,
+	      tem = fold_build2_loc (loc, MULT_EXPR, mult_type,
-				 fold_convert (mult_type,
+				 fold_convert_loc (loc, mult_type,
-					       TREE_OPERAND (op0, 0)),
+						   TREE_OPERAND (op0, 0)),
-				 fold_convert (mult_type,
+				 fold_convert_loc (loc, mult_type,
-					       TREE_OPERAND (op0, 1)));
+						   TREE_OPERAND (op0, 1)));
-	      return fold_convert (type, tem);
+	      return fold_convert_loc (loc, type, tem);
 	    }
 	}
 tem = fold_convert_const (code, type, op0);
 return tem ? tem : NULL_TREE;
+case ADDR_SPACE_CONVERT_EXPR:
+if (integer_zerop (arg0))
+	return fold_convert_const (code, type, arg0);
+return NULL_TREE;
 case FIXED_CONVERT_EXPR:
 tem = fold_convert_const (code, type, arg0);
 return tem ? tem : NULL_TREE;
 case VIEW_CONVERT_EXPR:
 if (TREE_TYPE (op0) == type)
 	return op0;
 if (TREE_CODE (op0) == VIEW_CONVERT_EXPR)
-	return fold_build1 (VIEW_CONVERT_EXPR, type, TREE_OPERAND (op0, 0));
+	return fold_build1_loc (loc, VIEW_CONVERT_EXPR,
+			    type, TREE_OPERAND (op0, 0));
 /* For integral conversions with the same precision or pointer
 	 conversions use a NOP_EXPR instead.  */
 if ((INTEGRAL_TYPE_P (type)
 	   || POINTER_TYPE_P (type))
 	  && (INTEGRAL_TYPE_P (TREE_TYPE (op0))
 	      || POINTER_TYPE_P (TREE_TYPE (op0)))
-	  && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (op0))
+	  && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (op0)))
-	  /* Do not muck with VIEW_CONVERT_EXPRs that convert from
+	return fold_convert_loc (loc, type, op0);
-	     a sub-type to its base type as generated by the Ada FE.  */
-	  && !(INTEGRAL_TYPE_P (TREE_TYPE (op0))
-	       && TREE_TYPE (TREE_TYPE (op0))))
-	return fold_convert (type, op0);
 /* Strip inner integral conversions that do not change the precision.  */
 if (CONVERT_EXPR_P (op0)
 	  && (INTEGRAL_TYPE_P (TREE_TYPE (op0))
 	      || POINTER_TYPE_P (TREE_TYPE (op0)))
 	  && (INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (op0, 0)))
 	      || POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (op0, 0))))
 	  && (TYPE_PRECISION (TREE_TYPE (op0))
 	      == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op0, 0)))))
-	return fold_build1 (VIEW_CONVERT_EXPR, type, TREE_OPERAND (op0, 0));
+	return fold_build1_loc (loc, VIEW_CONVERT_EXPR,
+			    type, TREE_OPERAND (op0, 0));
 return fold_view_convert_expr (type, op0);
 case NEGATE_EXPR:
-tem = fold_negate_expr (arg0);
+tem = fold_negate_expr (loc, arg0);
 if (tem)
-	return fold_convert (type, tem);
+	return fold_convert_loc (loc, type, tem);
 return NULL_TREE;
 case ABS_EXPR:
 if (TREE_CODE (arg0) == INTEGER_CST || TREE_CODE (arg0) == REAL_CST)
 	return fold_abs_const (arg0, type);
 else if (TREE_CODE (arg0) == NEGATE_EXPR)
-	return fold_build1 (ABS_EXPR, type, TREE_OPERAND (arg0, 0));
+	return fold_build1_loc (loc, ABS_EXPR, type, TREE_OPERAND (arg0, 0));
 /* Convert fabs((double)float) into (double)fabsf(float).  */
 else if (TREE_CODE (arg0) == NOP_EXPR
 	       && TREE_CODE (type) == REAL_TYPE)
 	{
 	  tree targ0 = strip_float_extensions (arg0);
 	  if (targ0 != arg0)
-	    return fold_convert (type, fold_build1 (ABS_EXPR,
+	    return fold_convert_loc (loc, type,
-						    TREE_TYPE (targ0),
+				     fold_build1_loc (loc, ABS_EXPR,
-						    targ0));
+						  TREE_TYPE (targ0),
+						  targ0));
 	}
 /* ABS_EXPR<ABS_EXPR<x>> = ABS_EXPR<x> even if flag_wrapv is on.  */
 else if (TREE_CODE (arg0) == ABS_EXPR)
 	return arg0;
 else if (tree_expr_nonnegative_p (arg0))
 /* Strip sign ops from argument.  */
 if (TREE_CODE (type) == REAL_TYPE)
 	{
 	  tem = fold_strip_sign_ops (arg0);
 	  if (tem)
-	    return fold_build1 (ABS_EXPR, type, fold_convert (type, tem));
+	    return fold_build1_loc (loc, ABS_EXPR, type,
+				fold_convert_loc (loc, type, tem));
 	}
 return NULL_TREE;
 case CONJ_EXPR:
 if (TREE_CODE (TREE_TYPE (arg0)) != COMPLEX_TYPE)
-	return fold_convert (type, arg0);
+	return fold_convert_loc (loc, type, arg0);
 if (TREE_CODE (arg0) == COMPLEX_EXPR)
 	{
 	  tree itype = TREE_TYPE (type);
-	  tree rpart = fold_convert (itype, TREE_OPERAND (arg0, 0));
+	  tree rpart = fold_convert_loc (loc, itype, TREE_OPERAND (arg0, 0));
-	  tree ipart = fold_convert (itype, TREE_OPERAND (arg0, 1));
+	  tree ipart = fold_convert_loc (loc, itype, TREE_OPERAND (arg0, 1));
-	  return fold_build2 (COMPLEX_EXPR, type, rpart, negate_expr (ipart));
+	  return fold_build2_loc (loc, COMPLEX_EXPR, type, rpart,
+			      negate_expr (ipart));
 	}
 if (TREE_CODE (arg0) == COMPLEX_CST)
 	{
 	  tree itype = TREE_TYPE (type);
-	  tree rpart = fold_convert (itype, TREE_REALPART (arg0));
+	  tree rpart = fold_convert_loc (loc, itype, TREE_REALPART (arg0));
-	  tree ipart = fold_convert (itype, TREE_IMAGPART (arg0));
+	  tree ipart = fold_convert_loc (loc, itype, TREE_IMAGPART (arg0));
 	  return build_complex (type, rpart, negate_expr (ipart));
 	}
 if (TREE_CODE (arg0) == CONJ_EXPR)
-	return fold_convert (type, TREE_OPERAND (arg0, 0));
+	return fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0));
 return NULL_TREE;
 case BIT_NOT_EXPR:
 if (TREE_CODE (arg0) == INTEGER_CST)
 return fold_not_const (arg0, type);
 else if (TREE_CODE (arg0) == BIT_NOT_EXPR)
-	return fold_convert (type, TREE_OPERAND (arg0, 0));
+	return fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0));
 /* Convert ~ (-A) to A - 1.  */
 else if (INTEGRAL_TYPE_P (type) && TREE_CODE (arg0) == NEGATE_EXPR)
-	return fold_build2 (MINUS_EXPR, type,
+	return fold_build2_loc (loc, MINUS_EXPR, type,
-			    fold_convert (type, TREE_OPERAND (arg0, 0)),
+			    fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0)),
 			    build_int_cst (type, 1));
 /* Convert ~ (A - 1) or ~ (A + -1) to -A.  */
 else if (INTEGRAL_TYPE_P (type)
 	       && ((TREE_CODE (arg0) == MINUS_EXPR
 		    && integer_onep (TREE_OPERAND (arg0, 1)))
 		   || (TREE_CODE (arg0) == PLUS_EXPR
 		       && integer_all_onesp (TREE_OPERAND (arg0, 1)))))
-	return fold_build1 (NEGATE_EXPR, type,
+	return fold_build1_loc (loc, NEGATE_EXPR, type,
-			    fold_convert (type, TREE_OPERAND (arg0, 0)));
+			    fold_convert_loc (loc, type,
+					      TREE_OPERAND (arg0, 0)));
 /* Convert ~(X ^ Y) to ~X ^ Y or X ^ ~Y if ~X or ~Y simplify.  */
 else if (TREE_CODE (arg0) == BIT_XOR_EXPR
-	       && (tem = fold_unary (BIT_NOT_EXPR, type,
+	       && (tem = fold_unary_loc (loc, BIT_NOT_EXPR, type,
-			       	     fold_convert (type,
+			       	     fold_convert_loc (loc, type,
-					     	   TREE_OPERAND (arg0, 0)))))
+						       TREE_OPERAND (arg0, 0)))))
-	return fold_build2 (BIT_XOR_EXPR, type, tem,
+	return fold_build2_loc (loc, BIT_XOR_EXPR, type, tem,
-			    fold_convert (type, TREE_OPERAND (arg0, 1)));
+			    fold_convert_loc (loc, type,
+					      TREE_OPERAND (arg0, 1)));
 else if (TREE_CODE (arg0) == BIT_XOR_EXPR
-	       && (tem = fold_unary (BIT_NOT_EXPR, type,
+	       && (tem = fold_unary_loc (loc, BIT_NOT_EXPR, type,
-			       	     fold_convert (type,
+			       	     fold_convert_loc (loc, type,
-					     	   TREE_OPERAND (arg0, 1)))))
+						       TREE_OPERAND (arg0, 1)))))
-	return fold_build2 (BIT_XOR_EXPR, type,
+	return fold_build2_loc (loc, BIT_XOR_EXPR, type,
-			    fold_convert (type, TREE_OPERAND (arg0, 0)), tem);
+			    fold_convert_loc (loc, type,
+					      TREE_OPERAND (arg0, 0)), tem);
 /* Perform BIT_NOT_EXPR on each element individually.  */
 else if (TREE_CODE (arg0) == VECTOR_CST)
 	{
 	  tree elements = TREE_VECTOR_CST_ELTS (arg0), elem, list = NULL_TREE;
 	  int count = TYPE_VECTOR_SUBPARTS (type), i;
 	  for (i = 0; i < count; i++)
 	    {
 	      if (elements)
 		{
 		  elem = TREE_VALUE (elements);
-		  elem = fold_unary (BIT_NOT_EXPR, TREE_TYPE (type), elem);
+		  elem = fold_unary_loc (loc, BIT_NOT_EXPR, TREE_TYPE (type), elem);
 		  if (elem == NULL_TREE)
 		    break;
 		  elements = TREE_CHAIN (elements);
 		}
 	      else
 return NULL_TREE;
 case TRUTH_NOT_EXPR:
 /* The argument to invert_truthvalue must have Boolean type.  */
 if (TREE_CODE (TREE_TYPE (arg0)) != BOOLEAN_TYPE)
-arg0 = fold_convert (boolean_type_node, arg0);
+arg0 = fold_convert_loc (loc, boolean_type_node, arg0);
 /* Note that the operand of this must be an int
 	 and its values must be 0 or 1.
 	 ("true" is a fixed value perhaps depending on the language,
 	 but we don't handle values other than 1 correctly yet.)  */
-tem = fold_truth_not_expr (arg0);
+tem = fold_truth_not_expr (loc, arg0);
 if (!tem)
 	return NULL_TREE;
-return fold_convert (type, tem);
+return fold_convert_loc (loc, type, tem);
 case REALPART_EXPR:
 if (TREE_CODE (TREE_TYPE (arg0)) != COMPLEX_TYPE)
-	return fold_convert (type, arg0);
+	return fold_convert_loc (loc, type, arg0);
 if (TREE_CODE (arg0) == COMPLEX_EXPR)
-	return omit_one_operand (type, TREE_OPERAND (arg0, 0),
+	return omit_one_operand_loc (loc, type, TREE_OPERAND (arg0, 0),
 				 TREE_OPERAND (arg0, 1));
 if (TREE_CODE (arg0) == COMPLEX_CST)
-	return fold_convert (type, TREE_REALPART (arg0));
+	return fold_convert_loc (loc, type, TREE_REALPART (arg0));
 if (TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
 	{
 	  tree itype = TREE_TYPE (TREE_TYPE (arg0));
-	  tem = fold_build2 (TREE_CODE (arg0), itype,
+	  tem = fold_build2_loc (loc, TREE_CODE (arg0), itype,
-			     fold_build1 (REALPART_EXPR, itype,
+			     fold_build1_loc (loc, REALPART_EXPR, itype,
 					  TREE_OPERAND (arg0, 0)),
-			     fold_build1 (REALPART_EXPR, itype,
+			     fold_build1_loc (loc, REALPART_EXPR, itype,
 					  TREE_OPERAND (arg0, 1)));
-	  return fold_convert (type, tem);
+	  return fold_convert_loc (loc, type, tem);
 	}
 if (TREE_CODE (arg0) == CONJ_EXPR)
 	{
 	  tree itype = TREE_TYPE (TREE_TYPE (arg0));
-	  tem = fold_build1 (REALPART_EXPR, itype, TREE_OPERAND (arg0, 0));
+	  tem = fold_build1_loc (loc, REALPART_EXPR, itype,
-	  return fold_convert (type, tem);
+			     TREE_OPERAND (arg0, 0));
+	  return fold_convert_loc (loc, type, tem);
 	}
 if (TREE_CODE (arg0) == CALL_EXPR)
 	{
 	  tree fn = get_callee_fndecl (arg0);
 	  if (fn && DECL_BUILT_IN_CLASS (fn) == BUILT_IN_NORMAL)
 	    switch (DECL_FUNCTION_CODE (fn))
 	      {
 	      CASE_FLT_FN (BUILT_IN_CEXPI):
 	        fn = mathfn_built_in (type, BUILT_IN_COS);
 		if (fn)
-	          return build_call_expr (fn, 1, CALL_EXPR_ARG (arg0, 0));
+	          return build_call_expr_loc (loc, fn, 1, CALL_EXPR_ARG (arg0, 0));
 		break;
 	      default:
 		break;
 	      }
 	}
 return NULL_TREE;
 case IMAGPART_EXPR:
 if (TREE_CODE (TREE_TYPE (arg0)) != COMPLEX_TYPE)
-	return fold_convert (type, integer_zero_node);
+	return fold_convert_loc (loc, type, integer_zero_node);
 if (TREE_CODE (arg0) == COMPLEX_EXPR)
-	return omit_one_operand (type, TREE_OPERAND (arg0, 1),
+	return omit_one_operand_loc (loc, type, TREE_OPERAND (arg0, 1),
 				 TREE_OPERAND (arg0, 0));
 if (TREE_CODE (arg0) == COMPLEX_CST)
-	return fold_convert (type, TREE_IMAGPART (arg0));
+	return fold_convert_loc (loc, type, TREE_IMAGPART (arg0));
 if (TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
 	{
 	  tree itype = TREE_TYPE (TREE_TYPE (arg0));
-	  tem = fold_build2 (TREE_CODE (arg0), itype,
+	  tem = fold_build2_loc (loc, TREE_CODE (arg0), itype,
-			     fold_build1 (IMAGPART_EXPR, itype,
+			     fold_build1_loc (loc, IMAGPART_EXPR, itype,
 					  TREE_OPERAND (arg0, 0)),
-			     fold_build1 (IMAGPART_EXPR, itype,
+			     fold_build1_loc (loc, IMAGPART_EXPR, itype,
 					  TREE_OPERAND (arg0, 1)));
-	  return fold_convert (type, tem);
+	  return fold_convert_loc (loc, type, tem);
 	}
 if (TREE_CODE (arg0) == CONJ_EXPR)
 	{
 	  tree itype = TREE_TYPE (TREE_TYPE (arg0));
-	  tem = fold_build1 (IMAGPART_EXPR, itype, TREE_OPERAND (arg0, 0));
+	  tem = fold_build1_loc (loc, IMAGPART_EXPR, itype, TREE_OPERAND (arg0, 0));
-	  return fold_convert (type, negate_expr (tem));
+	  return fold_convert_loc (loc, type, negate_expr (tem));
 	}
 if (TREE_CODE (arg0) == CALL_EXPR)
 	{
 	  tree fn = get_callee_fndecl (arg0);
 	  if (fn && DECL_BUILT_IN_CLASS (fn) == BUILT_IN_NORMAL)
 	    switch (DECL_FUNCTION_CODE (fn))
 	      {
 	      CASE_FLT_FN (BUILT_IN_CEXPI):
 	        fn = mathfn_built_in (type, BUILT_IN_SIN);
 		if (fn)
-	          return build_call_expr (fn, 1, CALL_EXPR_ARG (arg0, 0));
+	          return build_call_expr_loc (loc, fn, 1, CALL_EXPR_ARG (arg0, 0));
 		break;
 	      default:
 		break;
 	      }
 /* If the operation was a conversion do _not_ mark a resulting constant
 with TREE_OVERFLOW if the original constant was not.  These conversions
 have implementation defined behavior and retaining the TREE_OVERFLOW
 flag here would confuse later passes such as VRP.  */
 tree
-fold_unary_ignore_overflow (enum tree_code code, tree type, tree op0)
+fold_unary_ignore_overflow_loc (location_t loc, enum tree_code code,
-{
+				tree type, tree op0)
-tree res = fold_unary (code, type, op0);
+{
+tree res = fold_unary_loc (loc, code, type, op0);
 if (res
 && TREE_CODE (res) == INTEGER_CST
 && TREE_CODE (op0) == INTEGER_CST
 && CONVERT_EXPR_CODE_P (code))
 TREE_OVERFLOW (res) = TREE_OVERFLOW (op0);
 OP0 and OP1, containing either a MIN-MAX or a MAX-MIN combination.
 Return the folded expression if folding is successful.  Otherwise,
 return NULL_TREE.  */
 static tree
-fold_minmax (enum tree_code code, tree type, tree op0, tree op1)
+fold_minmax (location_t loc, enum tree_code code, tree type, tree op0, tree op1)
 {
 enum tree_code compl_code;
 if (code == MIN_EXPR)
 compl_code = MAX_EXPR;
 gcc_unreachable ();
 /* MIN (MAX (a, b), b) == b.  */
 if (TREE_CODE (op0) == compl_code
 && operand_equal_p (TREE_OPERAND (op0, 1), op1, 0))
-return omit_one_operand (type, op1, TREE_OPERAND (op0, 0));
+return omit_one_operand_loc (loc, type, op1, TREE_OPERAND (op0, 0));
 /* MIN (MAX (b, a), b) == b.  */
 if (TREE_CODE (op0) == compl_code
 && operand_equal_p (TREE_OPERAND (op0, 0), op1, 0)
 && reorder_operands_p (TREE_OPERAND (op0, 1), op1))
-return omit_one_operand (type, op1, TREE_OPERAND (op0, 1));
+return omit_one_operand_loc (loc, type, op1, TREE_OPERAND (op0, 1));
 /* MIN (a, MAX (a, b)) == a.  */
 if (TREE_CODE (op1) == compl_code
 && operand_equal_p (op0, TREE_OPERAND (op1, 0), 0)
 && reorder_operands_p (op0, TREE_OPERAND (op1, 1)))
-return omit_one_operand (type, op0, TREE_OPERAND (op1, 1));
+return omit_one_operand_loc (loc, type, op0, TREE_OPERAND (op1, 1));
 /* MIN (a, MAX (b, a)) == a.  */
 if (TREE_CODE (op1) == compl_code
 && operand_equal_p (op0, TREE_OPERAND (op1, 1), 0)
 && reorder_operands_p (op0, TREE_OPERAND (op1, 0)))
-return omit_one_operand (type, op0, TREE_OPERAND (op1, 0));
+return omit_one_operand_loc (loc, type, op0, TREE_OPERAND (op1, 0));
 return NULL_TREE;
 }
 /* Helper that tries to canonicalize the comparison ARG0 CODE ARG1
 possible, otherwise returns NULL_TREE.
 Set *STRICT_OVERFLOW_P to true if the canonicalization is only
 valid if signed overflow is undefined.  */
 static tree
-maybe_canonicalize_comparison_1 (enum tree_code code, tree type,
+maybe_canonicalize_comparison_1 (location_t loc, enum tree_code code, tree type,
 				 tree arg0, tree arg1,
 				 bool *strict_overflow_p)
 {
 enum tree_code code0 = TREE_CODE (arg0);
 tree t, cst0 = NULL_TREE;
 return NULL_TREE;
 t = int_const_binop (sgn0 == -1 ? PLUS_EXPR : MINUS_EXPR,
 		       cst0, build_int_cst (TREE_TYPE (cst0), 1), 0);
 if (code0 != INTEGER_CST)
-t = fold_build2 (code0, TREE_TYPE (arg0), TREE_OPERAND (arg0, 0), t);
+t = fold_build2_loc (loc, code0, TREE_TYPE (arg0), TREE_OPERAND (arg0, 0), t);
 /* If swapping might yield to a more canonical form, do so.  */
 if (swap)
-return fold_build2 (swap_tree_comparison (code), type, arg1, t);
+return fold_build2_loc (loc, swap_tree_comparison (code), type, arg1, t);
 else
-return fold_build2 (code, type, t, arg1);
+return fold_build2_loc (loc, code, type, t, arg1);
 }
 /* Canonicalize the comparison ARG0 CODE ARG1 with type TYPE with undefined
 overflow further.  Try to decrease the magnitude of constants involved
 by changing LE_EXPR and GE_EXPR to LT_EXPR and GT_EXPR or vice versa
 and put sole constants at the second argument position.
 Returns the canonicalized tree if changed, otherwise NULL_TREE.  */
 static tree
-maybe_canonicalize_comparison (enum tree_code code, tree type,
+maybe_canonicalize_comparison (location_t loc, enum tree_code code, tree type,
 			       tree arg0, tree arg1)
 {
 tree t;
 bool strict_overflow_p;
 const char * const warnmsg = G_("assuming signed overflow does not occur "
 				  "when reducing constant in comparison");
 /* Try canonicalization by simplifying arg0.  */
 strict_overflow_p = false;
-t = maybe_canonicalize_comparison_1 (code, type, arg0, arg1,
+t = maybe_canonicalize_comparison_1 (loc, code, type, arg0, arg1,
 				       &strict_overflow_p);
 if (t)
 {
 if (strict_overflow_p)
 	fold_overflow_warning (warnmsg, WARN_STRICT_OVERFLOW_MAGNITUDE);
 /* Try canonicalization by simplifying arg1 using the swapped
 comparison.  */
 code = swap_tree_comparison (code);
 strict_overflow_p = false;
-t = maybe_canonicalize_comparison_1 (code, type, arg1, arg0,
+t = maybe_canonicalize_comparison_1 (loc, code, type, arg1, arg0,
 				       &strict_overflow_p);
 if (t && strict_overflow_p)
 fold_overflow_warning (warnmsg, WARN_STRICT_OVERFLOW_MAGNITUDE);
 return t;
 }
 fold_binary should call fold_binary.  Fold a comparison with
 tree code CODE and type TYPE with operands OP0 and OP1.  Return
 the folded comparison or NULL_TREE.  */
 static tree
-fold_comparison (enum tree_code code, tree type, tree op0, tree op1)
+fold_comparison (location_t loc, enum tree_code code, tree type,
+		 tree op0, tree op1)
 {
 tree arg0, arg1, tem;
 arg0 = op0;
 arg1 = op1;
 if (tem != NULL_TREE)
 return tem;
 /* If one arg is a real or integer constant, put it last.  */
 if (tree_swap_operands_p (arg0, arg1, true))
-return fold_build2 (swap_tree_comparison (code), type, op1, op0);
+return fold_build2_loc (loc, swap_tree_comparison (code), type, op1, op0);
 /* Transform comparisons of the form X +- C1 CMP C2 to X CMP C2 +- C1.  */
 if ((TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
 && (TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
 	  && !TREE_OVERFLOW (TREE_OPERAND (arg0, 1))
 tree variable = TREE_OPERAND (arg0, 0);
 tree lhs;
 int lhs_add;
 lhs_add = TREE_CODE (arg0) != PLUS_EXPR;
-lhs = fold_build2 (lhs_add ? PLUS_EXPR : MINUS_EXPR,
+lhs = fold_build2_loc (loc, lhs_add ? PLUS_EXPR : MINUS_EXPR,
 			 TREE_TYPE (arg1), const2, const1);
 /* If the constant operation overflowed this can be
 	 simplified as a comparison against INT_MAX/INT_MIN.  */
 if (TREE_CODE (lhs) == INTEGER_CST
 	       VARIABLE + 1  CODE2  INT_MIN
 	     and decide on the result.  */
 	  if (code2 == LT_EXPR
 	      || code2 == LE_EXPR
 	      || code2 == EQ_EXPR)
-	    return omit_one_operand (type, boolean_false_node, variable);
+	    return omit_one_operand_loc (loc, type, boolean_false_node, variable);
 	  else if (code2 == NE_EXPR
 		   || code2 == GE_EXPR
 		   || code2 == GT_EXPR)
-	    return omit_one_operand (type, boolean_true_node, variable);
+	    return omit_one_operand_loc (loc, type, boolean_true_node, variable);
 	}
 if (TREE_CODE (lhs) == TREE_CODE (arg1)
 	  && (TREE_CODE (lhs) != INTEGER_CST
 	      || !TREE_OVERFLOW (lhs)))
 	{
 	  fold_overflow_warning (("assuming signed overflow does not occur "
 				  "when changing X +- C1 cmp C2 to "
 				  "X cmp C1 +- C2"),
 				 WARN_STRICT_OVERFLOW_COMPARISON);
-	  return fold_build2 (code, type, variable, lhs);
+	  return fold_build2_loc (loc, code, type, variable, lhs);
 	}
 }
 /* For comparisons of pointers we can decompose it to a compile time
 comparison of the base objects and the offsets into the object.
 	       || (offset0 && offset1
 		   && operand_equal_p (offset0, offset1, 0)))
 	      && (code == EQ_EXPR
 		  || code == NE_EXPR
 		  || POINTER_TYPE_OVERFLOW_UNDEFINED))
 	    {
 	      if (code != EQ_EXPR
 		  && code != NE_EXPR
 		  && bitpos0 != bitpos1
 		  && (pointer_may_wrap_p (base0, offset0, bitpos0)
 	         zero extended from their type in case it is narrower than
 	         size type.  */
 	      if (offset0 == NULL_TREE)
 		offset0 = build_int_cst (signed_size_type_node, 0);
 	      else
-		offset0 = fold_convert (signed_size_type_node, offset0);
+		offset0 = fold_convert_loc (loc, signed_size_type_node,
+					    offset0);
 	      if (offset1 == NULL_TREE)
 		offset1 = build_int_cst (signed_size_type_node, 0);
 	      else
-		offset1 = fold_convert (signed_size_type_node, offset1);
+		offset1 = fold_convert_loc (loc, signed_size_type_node,
+					    offset1);
 	      if (code != EQ_EXPR
 		  && code != NE_EXPR
 		  && (pointer_may_wrap_p (base0, offset0, bitpos0)
 		      || pointer_may_wrap_p (base1, offset1, bitpos1)))
 		fold_overflow_warning (("assuming pointer wraparound does not "
 					"occur when comparing P +- C1 with "
 					"P +- C2"),
 				       WARN_STRICT_OVERFLOW_COMPARISON);
-	      return fold_build2 (code, type, offset0, offset1);
+	      return fold_build2_loc (loc, code, type, offset0, offset1);
 	    }
 	}
 /* For non-equal bases we can simplify if they are addresses
 	 of local binding decls or constants.  */
 else if (indirect_base0 && indirect_base1
 		    && (targetm.binds_local_p (base1)
 			|| CONSTANT_CLASS_P (base0)))
 		   || CONSTANT_CLASS_P (base1)))
 	{
 	  if (code == EQ_EXPR)
-	    return omit_two_operands (type, boolean_false_node, arg0, arg1);
+	    return omit_two_operands_loc (loc, type, boolean_false_node,
+				      arg0, arg1);
 	  else if (code == NE_EXPR)
-	    return omit_two_operands (type, boolean_true_node, arg0, arg1);
+	    return omit_two_operands_loc (loc, type, boolean_true_node,
+				      arg0, arg1);
 	}
 /* For equal offsets we can simplify to a comparison of the
 	 base addresses.  */
 else if (bitpos0 == bitpos1
 	       && (indirect_base0
 	       && ((offset0 == offset1)
 		   || (offset0 && offset1
 		       && operand_equal_p (offset0, offset1, 0))))
 	{
 	  if (indirect_base0)
-	    base0 = fold_addr_expr (base0);
+	    base0 = build_fold_addr_expr_loc (loc, base0);
 	  if (indirect_base1)
-	    base1 = fold_addr_expr (base1);
+	    base1 = build_fold_addr_expr_loc (loc, base1);
-	  return fold_build2 (code, type, base0, base1);
+	  return fold_build2_loc (loc, code, type, base0, base1);
 	}
 }
 /* Transform comparisons of the form X +- C1 CMP Y +- C2 to
 X CMP Y +- C2 +- C1 for signed X, Y.  This is valid if
 			     const2, const1, 0);
 if (!TREE_OVERFLOW (cst)
 	  && tree_int_cst_compare (const2, cst) == tree_int_cst_sgn (const2))
 	{
 	  fold_overflow_warning (warnmsg, WARN_STRICT_OVERFLOW_COMPARISON);
-	  return fold_build2 (code, type,
+	  return fold_build2_loc (loc, code, type,
 			      variable1,
-			      fold_build2 (TREE_CODE (arg1), TREE_TYPE (arg1),
+			      fold_build2_loc (loc,
+					   TREE_CODE (arg1), TREE_TYPE (arg1),
 					   variable2, cst));
 	}
 cst = int_const_binop (TREE_CODE (arg0) == TREE_CODE (arg1)
 			     ? MINUS_EXPR : PLUS_EXPR,
 			     const1, const2, 0);
 if (!TREE_OVERFLOW (cst)
 	  && tree_int_cst_compare (const1, cst) == tree_int_cst_sgn (const1))
 	{
 	  fold_overflow_warning (warnmsg, WARN_STRICT_OVERFLOW_COMPARISON);
-	  return fold_build2 (code, type,
+	  return fold_build2_loc (loc, code, type,
-			      fold_build2 (TREE_CODE (arg0), TREE_TYPE (arg0),
+			      fold_build2_loc (loc, TREE_CODE (arg0), TREE_TYPE (arg0),
 					   variable1, cst),
 			      variable2);
 	}
 }
 /* If const1 is negative we swap the sense of the comparison.  */
 if (tree_int_cst_sgn (const1) < 0)
 cmp_code = swap_tree_comparison (cmp_code);
-return fold_build2 (cmp_code, type, variable1, const2);
+return fold_build2_loc (loc, cmp_code, type, variable1, const2);
 }
-tem = maybe_canonicalize_comparison (code, type, op0, op1);
+tem = maybe_canonicalize_comparison (loc, code, type, op0, op1);
 if (tem)
 return tem;
 if (FLOAT_TYPE_P (TREE_TYPE (arg0)))
 {
 if (TYPE_PRECISION (TREE_TYPE (targ1)) > TYPE_PRECISION (newtype))
 	newtype = TREE_TYPE (targ1);
 /* Fold (double)float1 CMP (double)float2 into float1 CMP float2.  */
 if (TYPE_PRECISION (newtype) < TYPE_PRECISION (TREE_TYPE (arg0)))
-	return fold_build2 (code, type, fold_convert (newtype, targ0),
+	return fold_build2_loc (loc, code, type,
-			    fold_convert (newtype, targ1));
+			    fold_convert_loc (loc, newtype, targ0),
+			    fold_convert_loc (loc, newtype, targ1));
 /* (-a) CMP (-b) -> b CMP a  */
 if (TREE_CODE (arg0) == NEGATE_EXPR
 	  && TREE_CODE (arg1) == NEGATE_EXPR)
-	return fold_build2 (code, type, TREE_OPERAND (arg1, 0),
+	return fold_build2_loc (loc, code, type, TREE_OPERAND (arg1, 0),
 			    TREE_OPERAND (arg0, 0));
 if (TREE_CODE (arg1) == REAL_CST)
 	{
 	  REAL_VALUE_TYPE cst;
 	  cst = TREE_REAL_CST (arg1);
 	  /* (-a) CMP CST -> a swap(CMP) (-CST)  */
 	  if (TREE_CODE (arg0) == NEGATE_EXPR)
-	    return fold_build2 (swap_tree_comparison (code), type,
+	    return fold_build2_loc (loc, swap_tree_comparison (code), type,
 				TREE_OPERAND (arg0, 0),
 				build_real (TREE_TYPE (arg1),
 					    REAL_VALUE_NEGATE (cst)));
 	  /* IEEE doesn't distinguish +0 and -0 in comparisons.  */
 	  /* a CMP (-0) -> a CMP 0  */
 	  if (REAL_VALUE_MINUS_ZERO (cst))
-	    return fold_build2 (code, type, arg0,
+	    return fold_build2_loc (loc, code, type, arg0,
 				build_real (TREE_TYPE (arg1), dconst0));
 	  /* x != NaN is always true, other ops are always false.  */
 	  if (REAL_VALUE_ISNAN (cst)
 	      && ! HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg1))))
 	    {
 	      tem = (code == NE_EXPR) ? integer_one_node : integer_zero_node;
-	      return omit_one_operand (type, tem, arg0);
+	      return omit_one_operand_loc (loc, type, tem, arg0);
 	    }
 	  /* Fold comparisons against infinity.  */
 	  if (REAL_VALUE_ISINF (cst)
 	      && MODE_HAS_INFINITIES (TYPE_MODE (TREE_TYPE (arg1))))
 	    {
-	      tem = fold_inf_compare (code, type, arg0, arg1);
+	      tem = fold_inf_compare (loc, code, type, arg0, arg1);
 	      if (tem != NULL_TREE)
 		return tem;
 	    }
 	}
 	  && TREE_CODE (TREE_OPERAND (arg0, 1)) == REAL_CST
 	  && 0 != (tem = const_binop (TREE_CODE (arg0) == PLUS_EXPR
 				      ? MINUS_EXPR : PLUS_EXPR,
 				      arg1, TREE_OPERAND (arg0, 1), 0))
 	  && !TREE_OVERFLOW (tem))
-	return fold_build2 (code, type, TREE_OPERAND (arg0, 0), tem);
+	return fold_build2_loc (loc, code, type, TREE_OPERAND (arg0, 0), tem);
 /* Likewise, we can simplify a comparison of a real constant with
 a MINUS_EXPR whose first operand is also a real constant, i.e.
 (c1 - x) < c2 becomes x > c1-c2.  Reordering is allowed on
 floating-point types only if -fassociative-math is set.  */
 if (flag_associative_math
 	  && TREE_CODE (arg1) == REAL_CST
 	  && TREE_CODE (arg0) == MINUS_EXPR
 	  && TREE_CODE (TREE_OPERAND (arg0, 0)) == REAL_CST
 	  && 0 != (tem = const_binop (MINUS_EXPR, TREE_OPERAND (arg0, 0),
 				      arg1, 0))
 	  && !TREE_OVERFLOW (tem))
-	return fold_build2 (swap_tree_comparison (code), type,
+	return fold_build2_loc (loc, swap_tree_comparison (code), type,
 			    TREE_OPERAND (arg0, 1), tem);
 /* Fold comparisons against built-in math functions.  */
 if (TREE_CODE (arg1) == REAL_CST
 	  && flag_unsafe_math_optimizations
 	{
 	  enum built_in_function fcode = builtin_mathfn_code (arg0);
 	  if (fcode != END_BUILTINS)
 	    {
-	      tem = fold_mathfn_compare (fcode, code, type, arg0, arg1);
+	      tem = fold_mathfn_compare (loc, fcode, code, type, arg0, arg1);
 	      if (tem != NULL_TREE)
 		return tem;
 	    }
 	}
 }
 && CONVERT_EXPR_P (arg0))
 {
 /* If we are widening one operand of an integer comparison,
 	 see if the other operand is similarly being widened.  Perhaps we
 	 can do the comparison in the narrower type.  */
-tem = fold_widened_comparison (code, type, arg0, arg1);
+tem = fold_widened_comparison (loc, code, type, arg0, arg1);
 if (tem)
 	return tem;
 /* Or if we are changing signedness.  */
-tem = fold_sign_changed_comparison (code, type, arg0, arg1);
+tem = fold_sign_changed_comparison (loc, code, type, arg0, arg1);
 if (tem)
 	return tem;
 }
 /* If this is comparing a constant with a MIN_EXPR or a MAX_EXPR of a
 if (TREE_CODE (arg1) == INTEGER_CST
 && (TREE_CODE (arg0) == MIN_EXPR
 	  || TREE_CODE (arg0) == MAX_EXPR)
 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
 {
-tem = optimize_minmax_comparison (code, type, op0, op1);
+tem = optimize_minmax_comparison (loc, code, type, op0, op1);
 if (tem)
 	return tem;
 }
 /* Simplify comparison of something with itself.  (For IEEE
 	case GE_EXPR:
 	case LE_EXPR:
 	  if (! FLOAT_TYPE_P (TREE_TYPE (arg0))
 	      || ! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0))))
 	    return constant_boolean_node (1, type);
-	  return fold_build2 (EQ_EXPR, type, arg0, arg1);
+	  return fold_build2_loc (loc, EQ_EXPR, type, arg0, arg1);
 	case NE_EXPR:
 	  /* For NE, we can only do this simplification if integer
 	     or we don't honor IEEE floating point NaNs.  */
 	  if (FLOAT_TYPE_P (TREE_TYPE (arg0))
 	  /* We can't just pass T to eval_subst in case cval1 or cval2
 	     was the same as ARG1.  */
 	  tree high_result
-		= fold_build2 (code, type,
+		= fold_build2_loc (loc, code, type,
-			       eval_subst (arg0, cval1, maxval,
+			       eval_subst (loc, arg0, cval1, maxval,
 					   cval2, minval),
 			       arg1);
 	  tree equal_result
-		= fold_build2 (code, type,
+		= fold_build2_loc (loc, code, type,
-			       eval_subst (arg0, cval1, maxval,
+			       eval_subst (loc, arg0, cval1, maxval,
 					   cval2, maxval),
 			       arg1);
 	  tree low_result
-		= fold_build2 (code, type,
+		= fold_build2_loc (loc, code, type,
-			       eval_subst (arg0, cval1, minval,
+			       eval_subst (loc, arg0, cval1, minval,
 					   cval2, maxval),
 			       arg1);
 	  /* All three of these results should be 0 or 1.  Confirm they are.
 	     Then use those values to select the proper code to use.  */
 		      + (integer_onep (equal_result) * 2)
 		      + integer_onep (low_result))
 		{
 		case 0:
 		  /* Always false.  */
-		  return omit_one_operand (type, integer_zero_node, arg0);
+		  return omit_one_operand_loc (loc, type, integer_zero_node, arg0);
 		case 1:
 		  code = LT_EXPR;
 		  break;
 		case 2:
 		  code = EQ_EXPR;
 		case 6:
 		  code = GE_EXPR;
 		  break;
 		case 7:
 		  /* Always true.  */
-		  return omit_one_operand (type, integer_one_node, arg0);
+		  return omit_one_operand_loc (loc, type, integer_one_node, arg0);
 		}
 	      if (save_p)
-		return save_expr (build2 (code, type, cval1, cval2));
+		{
-	      return fold_build2 (code, type, cval1, cval2);
+		  tem = save_expr (build2 (code, type, cval1, cval2));
+		  SET_EXPR_LOCATION (tem, loc);
+		  return tem;
+		}
+	      return fold_build2_loc (loc, code, type, cval1, cval2);
 	    }
 	}
 }
 /* We can fold X/C1 op C2 where C1 and C2 are integer constants
 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
 && !integer_zerop (TREE_OPERAND (arg0, 1))
 && !TREE_OVERFLOW (TREE_OPERAND (arg0, 1))
 && !TREE_OVERFLOW (arg1))
 {
-tem = fold_div_compare (code, type, arg0, arg1);
+tem = fold_div_compare (loc, code, type, arg0, arg1);
 if (tem != NULL_TREE)
 	return tem;
 }
 /* Fold ~X op ~Y as Y op X.  */
 if (TREE_CODE (arg0) == BIT_NOT_EXPR
 && TREE_CODE (arg1) == BIT_NOT_EXPR)
 {
 tree cmp_type = TREE_TYPE (TREE_OPERAND (arg0, 0));
-return fold_build2 (code, type,
+return fold_build2_loc (loc, code, type,
-			  fold_convert (cmp_type, TREE_OPERAND (arg1, 0)),
+			  fold_convert_loc (loc, cmp_type,
+					    TREE_OPERAND (arg1, 0)),
 			  TREE_OPERAND (arg0, 0));
 }
 /* Fold ~X op C as X op' ~C, where op' is the swapped comparison.  */
 if (TREE_CODE (arg0) == BIT_NOT_EXPR
 && TREE_CODE (arg1) == INTEGER_CST)
 {
 tree cmp_type = TREE_TYPE (TREE_OPERAND (arg0, 0));
-return fold_build2 (swap_tree_comparison (code), type,
+return fold_build2_loc (loc, swap_tree_comparison (code), type,
 			  TREE_OPERAND (arg0, 0),
-			  fold_build1 (BIT_NOT_EXPR, cmp_type,
+			  fold_build1_loc (loc, BIT_NOT_EXPR, cmp_type,
-				       fold_convert (cmp_type, arg1)));
+				       fold_convert_loc (loc, cmp_type, arg1)));
 }
 return NULL_TREE;
 }
 /* Subroutine of fold_binary.  Optimize complex multiplications of the
 form z * conj(z), as pow(realpart(z),2) + pow(imagpart(z),2).  The
 argument EXPR represents the expression "z" of type TYPE.  */
 static tree
-fold_mult_zconjz (tree type, tree expr)
+fold_mult_zconjz (location_t loc, tree type, tree expr)
 {
 tree itype = TREE_TYPE (type);
 tree rpart, ipart, tem;
 if (TREE_CODE (expr) == COMPLEX_EXPR)
 ipart = TREE_IMAGPART (expr);
 }
 else
 {
 expr = save_expr (expr);
-rpart = fold_build1 (REALPART_EXPR, itype, expr);
+rpart = fold_build1_loc (loc, REALPART_EXPR, itype, expr);
-ipart = fold_build1 (IMAGPART_EXPR, itype, expr);
+ipart = fold_build1_loc (loc, IMAGPART_EXPR, itype, expr);
 }
 rpart = save_expr (rpart);
 ipart = save_expr (ipart);
-tem = fold_build2 (PLUS_EXPR, itype,
+tem = fold_build2_loc (loc, PLUS_EXPR, itype,
-		     fold_build2 (MULT_EXPR, itype, rpart, rpart),
+		     fold_build2_loc (loc, MULT_EXPR, itype, rpart, rpart),
-		     fold_build2 (MULT_EXPR, itype, ipart, ipart));
+		     fold_build2_loc (loc, MULT_EXPR, itype, ipart, ipart));
-return fold_build2 (COMPLEX_EXPR, type, tem,
+return fold_build2_loc (loc, COMPLEX_EXPR, type, tem,
-		      fold_convert (itype, integer_zero_node));
+		      fold_convert_loc (loc, itype, integer_zero_node));
 }
 /* Subroutine of fold_binary.  If P is the value of EXPR, computes
 power-of-two M and (arbitrary) N such that M divides (P-N).  This condition
 guarantees that P and N have the same least significant log2(M) bits.
 N is not otherwise constrained.  In particular, N is not normalized to
 0 <= N < M as is common.  In general, the precise value of P is unknown.
 M is chosen as large as possible such that constant N can be determined.
-Returns M and sets *RESIDUE to N.  */
+Returns M and sets *RESIDUE to N.
+If ALLOW_FUNC_ALIGN is true, do take functions' DECL_ALIGN_UNIT into
+account.  This is not always possible due to PR 35705.
+*/
 static unsigned HOST_WIDE_INT
-get_pointer_modulus_and_residue (tree expr, unsigned HOST_WIDE_INT *residue)
+get_pointer_modulus_and_residue (tree expr, unsigned HOST_WIDE_INT *residue,
+				 bool allow_func_align)
 {
 enum tree_code code;
 *residue = 0;
 		/* We don't handle more complicated offset expressions.  */
 		return 1;
 	    }
 	}
-if (DECL_P (expr) && TREE_CODE (expr) != FUNCTION_DECL)
+if (DECL_P (expr)
+	  && (allow_func_align || TREE_CODE (expr) != FUNCTION_DECL))
 	return DECL_ALIGN_UNIT (expr);
 }
 else if (code == POINTER_PLUS_EXPR)
 {
 tree op0, op1;
 unsigned HOST_WIDE_INT modulus;
 enum tree_code inner_code;
 op0 = TREE_OPERAND (expr, 0);
 STRIP_NOPS (op0);
-modulus = get_pointer_modulus_and_residue (op0, residue);
+modulus = get_pointer_modulus_and_residue (op0, residue,
+						 allow_func_align);
 op1 = TREE_OPERAND (expr, 1);
 STRIP_NOPS (op1);
 inner_code = TREE_CODE (op1);
 if (inner_code == INTEGER_CST)
 	{
 	  op1 = TREE_OPERAND (op1, 1);
 	  if (TREE_CODE (op1) == INTEGER_CST)
 	    {
 	      unsigned HOST_WIDE_INT align;
 	      /* Compute the greatest power-of-2 divisor of op1.  */
 	      align = TREE_INT_CST_LOW (op1);
 	      align &= -align;
 	      /* If align is non-zero and less than *modulus, replace
 return 1;
 }
 /* Fold a binary expression of code CODE and type TYPE with operands
-OP0 and OP1.  Return the folded expression if folding is
+OP0 and OP1.  LOC is the location of the resulting expression.
-successful.  Otherwise, return NULL_TREE.  */
+Return the folded expression if folding is successful.  Otherwise,
+return NULL_TREE.  */
 tree
-fold_binary (enum tree_code code, tree type, tree op0, tree op1)
+fold_binary_loc (location_t loc,
+	     enum tree_code code, tree type, tree op0, tree op1)
 {
 enum tree_code_class kind = TREE_CODE_CLASS (code);
 tree arg0, arg1, tem;
 tree t1 = NULL_TREE;
 bool strict_overflow_p;
 	tem = NULL_TREE;
 if (tem != NULL_TREE)
 	{
 	  if (TREE_TYPE (tem) != type)
-	    tem = fold_convert (type, tem);
+	    tem = fold_convert_loc (loc, type, tem);
 	  return tem;
 	}
 }
 /* If this is a commutative operation, and ARG0 is a constant, move it
 to ARG1 to reduce the number of tests below.  */
 if (commutative_tree_code (code)
 && tree_swap_operands_p (arg0, arg1, true))
-return fold_build2 (code, type, op1, op0);
+return fold_build2_loc (loc, code, type, op1, op0);
 /* ARG0 is the first operand of EXPR, and ARG1 is the second operand.
 First check for cases where an arithmetic operation is applied to a
 compound, conditional, or comparison operation.  Push the arithmetic
 	  || (truth_value_p (TREE_CODE (arg1))
 	      && (truth_value_p (TREE_CODE (arg0))
 		  || (TREE_CODE (arg0) == BIT_AND_EXPR
 		      && integer_onep (TREE_OPERAND (arg0, 1)))))))
 {
-tem = fold_build2 (code == BIT_AND_EXPR ? TRUTH_AND_EXPR
+tem = fold_build2_loc (loc, code == BIT_AND_EXPR ? TRUTH_AND_EXPR
 			 : code == BIT_IOR_EXPR ? TRUTH_OR_EXPR
 			 : TRUTH_XOR_EXPR,
 			 boolean_type_node,
-			 fold_convert (boolean_type_node, arg0),
+			 fold_convert_loc (loc, boolean_type_node, arg0),
-			 fold_convert (boolean_type_node, arg1));
+			 fold_convert_loc (loc, boolean_type_node, arg1));
 if (code == EQ_EXPR)
-	tem = invert_truthvalue (tem);
+	tem = invert_truthvalue_loc (loc, tem);
-return fold_convert (type, tem);
+return fold_convert_loc (loc, type, tem);
 }
 if (TREE_CODE_CLASS (code) == tcc_binary
 || TREE_CODE_CLASS (code) == tcc_comparison)
 {
 if (TREE_CODE (arg0) == COMPOUND_EXPR)
-	return build2 (COMPOUND_EXPR, type, TREE_OPERAND (arg0, 0),
+	{
-		       fold_build2 (code, type,
+	  tem = fold_build2_loc (loc, code, type,
-				    fold_convert (TREE_TYPE (op0),
+			     fold_convert_loc (loc, TREE_TYPE (op0),
-						  TREE_OPERAND (arg0, 1)),
+					       TREE_OPERAND (arg0, 1)), op1);
-				    op1));
+	  tem = build2 (COMPOUND_EXPR, type, TREE_OPERAND (arg0, 0), tem);
+	  goto fold_binary_exit;
+	}
 if (TREE_CODE (arg1) == COMPOUND_EXPR
 	  && reorder_operands_p (arg0, TREE_OPERAND (arg1, 0)))
-	return build2 (COMPOUND_EXPR, type, TREE_OPERAND (arg1, 0),
+	{
-		       fold_build2 (code, type, op0,
+	  tem = fold_build2_loc (loc, code, type, op0,
-				    fold_convert (TREE_TYPE (op1),
+			     fold_convert_loc (loc, TREE_TYPE (op1),
-						  TREE_OPERAND (arg1, 1))));
+					       TREE_OPERAND (arg1, 1)));
+	  tem = build2 (COMPOUND_EXPR, type, TREE_OPERAND (arg1, 0), tem);
+	  goto fold_binary_exit;
+	}
 if (TREE_CODE (arg0) == COND_EXPR || COMPARISON_CLASS_P (arg0))
 	{
-	  tem = fold_binary_op_with_conditional_arg (code, type, op0, op1,
+	  tem = fold_binary_op_with_conditional_arg (loc, code, type, op0, op1,
 						     arg0, arg1,
 						     /*cond_first_p=*/1);
 	  if (tem != NULL_TREE)
 	    return tem;
 	}
 if (TREE_CODE (arg1) == COND_EXPR || COMPARISON_CLASS_P (arg1))
 	{
-	  tem = fold_binary_op_with_conditional_arg (code, type, op0, op1,
+	  tem = fold_binary_op_with_conditional_arg (loc, code, type, op0, op1,
 						     arg1, arg0,
 					             /*cond_first_p=*/0);
 	  if (tem != NULL_TREE)
 	    return tem;
 	}
 }
 switch (code)
 {
 case POINTER_PLUS_EXPR:
 /* 0 +p index -> (type)index */
 if (integer_zerop (arg0))
-	return non_lvalue (fold_convert (type, arg1));
+	return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg1));
 /* PTR +p 0 -> PTR */
 if (integer_zerop (arg1))
-	return non_lvalue (fold_convert (type, arg0));
+	return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
 /* INT +p INT -> (PTR)(INT + INT).  Stripping types allows for this. */
 if (INTEGRAL_TYPE_P (TREE_TYPE (arg1))
 	   && INTEGRAL_TYPE_P (TREE_TYPE (arg0)))
-return fold_convert (type, fold_build2 (PLUS_EXPR, sizetype,
+return fold_convert_loc (loc, type,
-						fold_convert (sizetype, arg1),
+				 fold_build2_loc (loc, PLUS_EXPR, sizetype,
-						fold_convert (sizetype, arg0)));
+					      fold_convert_loc (loc, sizetype,
+								arg1),
+					      fold_convert_loc (loc, sizetype,
+								arg0)));
 /* index +p PTR -> PTR +p index */
 if (POINTER_TYPE_P (TREE_TYPE (arg1))
 	  && INTEGRAL_TYPE_P (TREE_TYPE (arg0)))
-return fold_build2 (POINTER_PLUS_EXPR, type,
+return fold_build2_loc (loc, POINTER_PLUS_EXPR, type,
-			    fold_convert (type, arg1),
+			    fold_convert_loc (loc, type, arg1),
-			    fold_convert (sizetype, arg0));
+			    fold_convert_loc (loc, sizetype, arg0));
 /* (PTR +p B) +p A -> PTR +p (B + A) */
 if (TREE_CODE (arg0) == POINTER_PLUS_EXPR)
 	{
 	  tree inner;
-	  tree arg01 = fold_convert (sizetype, TREE_OPERAND (arg0, 1));
+	  tree arg01 = fold_convert_loc (loc, sizetype, TREE_OPERAND (arg0, 1));
 	  tree arg00 = TREE_OPERAND (arg0, 0);
-	  inner = fold_build2 (PLUS_EXPR, sizetype,
+	  inner = fold_build2_loc (loc, PLUS_EXPR, sizetype,
-			       arg01, fold_convert (sizetype, arg1));
+			       arg01, fold_convert_loc (loc, sizetype, arg1));
-	  return fold_convert (type,
+	  return fold_convert_loc (loc, type,
-			       fold_build2 (POINTER_PLUS_EXPR,
+				   fold_build2_loc (loc, POINTER_PLUS_EXPR,
-					    TREE_TYPE (arg00), arg00, inner));
+						TREE_TYPE (arg00),
+						arg00, inner));
 	}
 /* PTR_CST +p CST -> CST1 */
 if (TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == INTEGER_CST)
-	return fold_build2 (PLUS_EXPR, type, arg0, fold_convert (type, arg1));
+	return fold_build2_loc (loc, PLUS_EXPR, type, arg0,
+			    fold_convert_loc (loc, type, arg1));
 /* Try replacing &a[i1] +p c * i2 with &a[i1 + i2], if c is step
 	of the array.  Loop optimizer sometimes produce this type of
 	expressions.  */
 if (TREE_CODE (arg0) == ADDR_EXPR)
 	{
-	  tem = try_move_mult_to_index (arg0, fold_convert (sizetype, arg1));
+	  tem = try_move_mult_to_index (loc, arg0,
+					fold_convert_loc (loc, sizetype, arg1));
 	  if (tem)
-	    return fold_convert (type, tem);
+	    return fold_convert_loc (loc, type, tem);
 	}
 return NULL_TREE;
 case PLUS_EXPR:
 /* A + (-B) -> A - B */
 if (TREE_CODE (arg1) == NEGATE_EXPR)
-	return fold_build2 (MINUS_EXPR, type,
+	return fold_build2_loc (loc, MINUS_EXPR, type,
-			    fold_convert (type, arg0),
+			    fold_convert_loc (loc, type, arg0),
-			    fold_convert (type, TREE_OPERAND (arg1, 0)));
+			    fold_convert_loc (loc, type,
+					      TREE_OPERAND (arg1, 0)));
 /* (-A) + B -> B - A */
 if (TREE_CODE (arg0) == NEGATE_EXPR
 	  && reorder_operands_p (TREE_OPERAND (arg0, 0), arg1))
-	return fold_build2 (MINUS_EXPR, type,
+	return fold_build2_loc (loc, MINUS_EXPR, type,
-			    fold_convert (type, arg1),
+			    fold_convert_loc (loc, type, arg1),
-			    fold_convert (type, TREE_OPERAND (arg0, 0)));
+			    fold_convert_loc (loc, type,
+					      TREE_OPERAND (arg0, 0)));
 if (INTEGRAL_TYPE_P (type))
 	{
 	  /* Convert ~A + 1 to -A.  */
 	  if (TREE_CODE (arg0) == BIT_NOT_EXPR
 	      && integer_onep (arg1))
-	    return fold_build1 (NEGATE_EXPR, type,
+	    return fold_build1_loc (loc, NEGATE_EXPR, type,
-				fold_convert (type, TREE_OPERAND (arg0, 0)));
+				fold_convert_loc (loc, type,
+						  TREE_OPERAND (arg0, 0)));
 	  /* ~X + X is -1.  */
 	  if (TREE_CODE (arg0) == BIT_NOT_EXPR
 	      && !TYPE_OVERFLOW_TRAPS (type))
 	    {
 	      STRIP_NOPS (tem);
 	      if (operand_equal_p (tem, arg1, 0))
 		{
 		  t1 = build_int_cst_type (type, -1);
-		  return omit_one_operand (type, t1, arg1);
+		  return omit_one_operand_loc (loc, type, t1, arg1);
 		}
 	    }
 	  /* X + ~X is -1.  */
 	  if (TREE_CODE (arg1) == BIT_NOT_EXPR
 	      STRIP_NOPS (tem);
 	      if (operand_equal_p (arg0, tem, 0))
 		{
 		  t1 = build_int_cst_type (type, -1);
-		  return omit_one_operand (type, t1, arg0);
+		  return omit_one_operand_loc (loc, type, t1, arg0);
 		}
 	    }
 	  /* X + (X / CST) * -CST is X % CST.  */
 	  if (TREE_CODE (arg1) == MULT_EXPR
 	      && operand_equal_p (arg0,
 				  TREE_OPERAND (TREE_OPERAND (arg1, 0), 0), 0))
 	    {
 	      tree cst0 = TREE_OPERAND (TREE_OPERAND (arg1, 0), 1);
 	      tree cst1 = TREE_OPERAND (arg1, 1);
-	      tree sum = fold_binary (PLUS_EXPR, TREE_TYPE (cst1), cst1, cst0);
+	      tree sum = fold_binary_loc (loc, PLUS_EXPR, TREE_TYPE (cst1),
+				      cst1, cst0);
 	      if (sum && integer_zerop (sum))
-		return fold_convert (type,
+		return fold_convert_loc (loc, type,
-				     fold_build2 (TRUNC_MOD_EXPR,
+					 fold_build2_loc (loc, TRUNC_MOD_EXPR,
-						  TREE_TYPE (arg0), arg0, cst0));
+						      TREE_TYPE (arg0), arg0,
+						      cst0));
 	    }
 	}
 /* Handle (A1 * C1) + (A2 * C2) with A1, A2 or C1, C2 being the
 	 same or one.  Make sure type is not saturating.
 if ((TREE_CODE (arg0) == MULT_EXPR
 	   || TREE_CODE (arg1) == MULT_EXPR)
 	  && !TYPE_SATURATING (type)
 	  && (!FLOAT_TYPE_P (type) || flag_associative_math))
 {
-	  tree tem = fold_plusminus_mult_expr (code, type, arg0, arg1);
+	  tree tem = fold_plusminus_mult_expr (loc, code, type, arg0, arg1);
 	  if (tem)
 	    return tem;
 	}
 if (! FLOAT_TYPE_P (type))
 	{
 	  if (integer_zerop (arg1))
-	    return non_lvalue (fold_convert (type, arg0));
+	    return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
 	  /* If we are adding two BIT_AND_EXPR's, both of which are and'ing
 	     with a constant, and the two constants have no bits in common,
 	     we should treat this as a BIT_IOR_EXPR since this may produce more
 	     simplifications.  */
 	      STRIP_NOPS (parg0);
 	      STRIP_NOPS (parg1);
 	      if (TREE_CODE (parg0) == MULT_EXPR
 		  && TREE_CODE (parg1) != MULT_EXPR)
-		return fold_build2 (pcode, type,
+		return fold_build2_loc (loc, pcode, type,
-				    fold_build2 (PLUS_EXPR, type,
+				    fold_build2_loc (loc, PLUS_EXPR, type,
-						 fold_convert (type, parg0),
+						 fold_convert_loc (loc, type,
-						 fold_convert (type, marg)),
+								   parg0),
-				    fold_convert (type, parg1));
+						 fold_convert_loc (loc, type,
+								   marg)),
+				    fold_convert_loc (loc, type, parg1));
 	      if (TREE_CODE (parg0) != MULT_EXPR
 		  && TREE_CODE (parg1) == MULT_EXPR)
-		return fold_build2 (PLUS_EXPR, type,
+		return
-				    fold_convert (type, parg0),
+		  fold_build2_loc (loc, PLUS_EXPR, type,
-				    fold_build2 (pcode, type,
+			       fold_convert_loc (loc, type, parg0),
-						 fold_convert (type, marg),
+			       fold_build2_loc (loc, pcode, type,
-						 fold_convert (type,
+					    fold_convert_loc (loc, type, marg),
-							       parg1)));
+					    fold_convert_loc (loc, type,
+							      parg1)));
 	    }
 	}
 else
 	{
 	  /* See if ARG1 is zero and X + ARG1 reduces to X.  */
 	  if (fold_real_zero_addition_p (TREE_TYPE (arg0), arg1, 0))
-	    return non_lvalue (fold_convert (type, arg0));
+	    return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
 	  /* Likewise if the operands are reversed.  */
 	  if (fold_real_zero_addition_p (TREE_TYPE (arg1), arg0, 0))
-	    return non_lvalue (fold_convert (type, arg1));
+	    return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg1));
 	  /* Convert X + -C into X - C.  */
 	  if (TREE_CODE (arg1) == REAL_CST
 	      && REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg1)))
 	    {
 	      tem = fold_negate_const (arg1, type);
 	      if (!TREE_OVERFLOW (arg1) || !flag_trapping_math)
-		return fold_build2 (MINUS_EXPR, type,
+		return fold_build2_loc (loc, MINUS_EXPR, type,
-				    fold_convert (type, arg0),
+				    fold_convert_loc (loc, type, arg0),
-				    fold_convert (type, tem));
+				    fold_convert_loc (loc, type, tem));
 	    }
 	  /* Fold __complex__ ( x, 0 ) + __complex__ ( 0, y )
 	     to __complex__ ( x, y ).  This is not the same for SNaNs or
 	     if signed zeros are involved.  */
 	  if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
 && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0)))
 	      && COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0)))
 	    {
 	      tree rtype = TREE_TYPE (TREE_TYPE (arg0));
-	      tree arg0r = fold_unary (REALPART_EXPR, rtype, arg0);
+	      tree arg0r = fold_unary_loc (loc, REALPART_EXPR, rtype, arg0);
-	      tree arg0i = fold_unary (IMAGPART_EXPR, rtype, arg0);
+	      tree arg0i = fold_unary_loc (loc, IMAGPART_EXPR, rtype, arg0);
 	      bool arg0rz = false, arg0iz = false;
 	      if ((arg0r && (arg0rz = real_zerop (arg0r)))
 		  || (arg0i && (arg0iz = real_zerop (arg0i))))
 		{
-		  tree arg1r = fold_unary (REALPART_EXPR, rtype, arg1);
+		  tree arg1r = fold_unary_loc (loc, REALPART_EXPR, rtype, arg1);
-		  tree arg1i = fold_unary (IMAGPART_EXPR, rtype, arg1);
+		  tree arg1i = fold_unary_loc (loc, IMAGPART_EXPR, rtype, arg1);
 		  if (arg0rz && arg1i && real_zerop (arg1i))
 		    {
 		      tree rp = arg1r ? arg1r
 				  : build1 (REALPART_EXPR, rtype, arg1);
 		      tree ip = arg0i ? arg0i
 				  : build1 (IMAGPART_EXPR, rtype, arg0);
-		      return fold_build2 (COMPLEX_EXPR, type, rp, ip);
+		      return fold_build2_loc (loc, COMPLEX_EXPR, type, rp, ip);
 		    }
 		  else if (arg0iz && arg1r && real_zerop (arg1r))
 		    {
 		      tree rp = arg0r ? arg0r
 				  : build1 (REALPART_EXPR, rtype, arg0);
 		      tree ip = arg1i ? arg1i
 				  : build1 (IMAGPART_EXPR, rtype, arg1);
-		      return fold_build2 (COMPLEX_EXPR, type, rp, ip);
+		      return fold_build2_loc (loc, COMPLEX_EXPR, type, rp, ip);
 		    }
 		}
 	    }
-if (flag_unsafe_math_optimizations
+	  if (flag_unsafe_math_optimizations
 	      && (TREE_CODE (arg0) == RDIV_EXPR || TREE_CODE (arg0) == MULT_EXPR)
 	      && (TREE_CODE (arg1) == RDIV_EXPR || TREE_CODE (arg1) == MULT_EXPR)
-	      && (tem = distribute_real_division (code, type, arg0, arg1)))
+	      && (tem = distribute_real_division (loc, code, type, arg0, arg1)))
 	    return tem;
 	  /* Convert x+x into x*2.0.  */
 	  if (operand_equal_p (arg0, arg1, 0)
 	      && SCALAR_FLOAT_TYPE_P (type))
-	    return fold_build2 (MULT_EXPR, type, arg0,
+	    return fold_build2_loc (loc, MULT_EXPR, type, arg0,
 				build_real (type, dconst2));
 /* Convert a + (b*c + d*e) into (a + b*c) + d*e.
 We associate floats only if the user has specified
 -fassociative-math.  */
 if (flag_associative_math
 && TREE_CODE (arg1) == PLUS_EXPR
 && TREE_CODE (arg0) != MULT_EXPR)
 tree tree11 = TREE_OPERAND (arg1, 1);
 if (TREE_CODE (tree11) == MULT_EXPR
 		  && TREE_CODE (tree10) == MULT_EXPR)
 {
 tree tree0;
-tree0 = fold_build2 (PLUS_EXPR, type, arg0, tree10);
+tree0 = fold_build2_loc (loc, PLUS_EXPR, type, arg0, tree10);
-return fold_build2 (PLUS_EXPR, type, tree0, tree11);
+return fold_build2_loc (loc, PLUS_EXPR, type, tree0, tree11);
 }
 }
 /* Convert (b*c + d*e) + a into b*c + (d*e +a).
 We associate floats only if the user has specified
 -fassociative-math.  */
 if (flag_associative_math
 && TREE_CODE (arg0) == PLUS_EXPR
 && TREE_CODE (arg1) != MULT_EXPR)
 tree tree01 = TREE_OPERAND (arg0, 1);
 if (TREE_CODE (tree01) == MULT_EXPR
 		  && TREE_CODE (tree00) == MULT_EXPR)
 {
 tree tree0;
-tree0 = fold_build2 (PLUS_EXPR, type, tree01, arg1);
+tree0 = fold_build2_loc (loc, PLUS_EXPR, type, tree01, arg1);
-return fold_build2 (PLUS_EXPR, type, tree00, tree0);
+return fold_build2_loc (loc, PLUS_EXPR, type, tree00, tree0);
 }
 }
 	}
 bit_rotate:
 		&& code11 == INTEGER_CST
 		&& TREE_INT_CST_HIGH (tree01) == 0
 		&& TREE_INT_CST_HIGH (tree11) == 0
 		&& ((TREE_INT_CST_LOW (tree01) + TREE_INT_CST_LOW (tree11))
 		    == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0, 0)))))
-	      return build2 (LROTATE_EXPR, type, TREE_OPERAND (arg0, 0),
+	      {
-			     code0 == LSHIFT_EXPR ? tree01 : tree11);
+		tem = build2 (LROTATE_EXPR,
+			      TREE_TYPE (TREE_OPERAND (arg0, 0)),
+			      TREE_OPERAND (arg0, 0),
+			      code0 == LSHIFT_EXPR
+			      ? tree01 : tree11);
+		SET_EXPR_LOCATION (tem, loc);
+		return fold_convert_loc (loc, type, tem);
+	      }
 	    else if (code11 == MINUS_EXPR)
 	      {
 		tree tree110, tree111;
 		tree110 = TREE_OPERAND (tree11, 0);
 		tree111 = TREE_OPERAND (tree11, 1);
 		    && 0 == compare_tree_int (tree110,
 					      TYPE_PRECISION
 					      (TREE_TYPE (TREE_OPERAND
 							  (arg0, 0))))
 		    && operand_equal_p (tree01, tree111, 0))
-		  return build2 ((code0 == LSHIFT_EXPR
+		  return
-				  ? LROTATE_EXPR
+		    fold_convert_loc (loc, type,
-				  : RROTATE_EXPR),
+				      build2 ((code0 == LSHIFT_EXPR
-				 type, TREE_OPERAND (arg0, 0), tree01);
+					       ? LROTATE_EXPR
+					       : RROTATE_EXPR),
+					      TREE_TYPE (TREE_OPERAND (arg0, 0)),
+					      TREE_OPERAND (arg0, 0), tree01));
 	      }
 	    else if (code01 == MINUS_EXPR)
 	      {
 		tree tree010, tree011;
 		tree010 = TREE_OPERAND (tree01, 0);
 		    && 0 == compare_tree_int (tree010,
 					      TYPE_PRECISION
 					      (TREE_TYPE (TREE_OPERAND
 							  (arg0, 0))))
 		    && operand_equal_p (tree11, tree011, 0))
-		  return build2 ((code0 != LSHIFT_EXPR
+		    return fold_convert_loc
-				  ? LROTATE_EXPR
+		      (loc, type,
-				  : RROTATE_EXPR),
+		       build2 ((code0 != LSHIFT_EXPR
-				 type, TREE_OPERAND (arg0, 0), tree11);
+				? LROTATE_EXPR
+				: RROTATE_EXPR),
+			       TREE_TYPE (TREE_OPERAND (arg0, 0)),
+			       TREE_OPERAND (arg0, 0), tree11));
 	      }
 	  }
 }
 associate:
 	    {
 	      /* Recombine MINUS_EXPR operands by using PLUS_EXPR.  */
 	      if (code == MINUS_EXPR)
 		code = PLUS_EXPR;
-	      var0 = associate_trees (var0, var1, code, type);
+	      var0 = associate_trees (loc, var0, var1, code, type);
-	      con0 = associate_trees (con0, con1, code, type);
+	      con0 = associate_trees (loc, con0, con1, code, type);
-	      lit0 = associate_trees (lit0, lit1, code, type);
+	      lit0 = associate_trees (loc, lit0, lit1, code, type);
-	      minus_lit0 = associate_trees (minus_lit0, minus_lit1, code, type);
+	      minus_lit0 = associate_trees (loc, minus_lit0, minus_lit1, code, type);
 	      /* Preserve the MINUS_EXPR if the negative part of the literal is
 		 greater than the positive part.  Otherwise, the multiplicative
 		 folding code (i.e extract_muldiv) may be fooled in case
 		 unsigned constants are subtracted, like in the following
 		{
 		  if (TREE_CODE (lit0) == INTEGER_CST
 		      && TREE_CODE (minus_lit0) == INTEGER_CST
 		      && tree_int_cst_lt (lit0, minus_lit0))
 		    {
-		      minus_lit0 = associate_trees (minus_lit0, lit0,
+		      minus_lit0 = associate_trees (loc, minus_lit0, lit0,
 						    MINUS_EXPR, type);
 		      lit0 = 0;
 		    }
 		  else
 		    {
-		      lit0 = associate_trees (lit0, minus_lit0,
+		      lit0 = associate_trees (loc, lit0, minus_lit0,
 					      MINUS_EXPR, type);
 		      minus_lit0 = 0;
 		    }
 		}
 	      if (minus_lit0)
 		{
 		  if (con0 == 0)
-		    return fold_convert (type,
+		    return
-					 associate_trees (var0, minus_lit0,
+		      fold_convert_loc (loc, type,
-							  MINUS_EXPR, type));
+					associate_trees (loc, var0, minus_lit0,
+							 MINUS_EXPR, type));
 		  else
 		    {
-		      con0 = associate_trees (con0, minus_lit0,
+		      con0 = associate_trees (loc, con0, minus_lit0,
 					      MINUS_EXPR, type);
-		      return fold_convert (type,
+		      return
-					   associate_trees (var0, con0,
+			fold_convert_loc (loc, type,
-							    PLUS_EXPR, type));
+					  associate_trees (loc, var0, con0,
+							   PLUS_EXPR, type));
 		    }
 		}
-	      con0 = associate_trees (con0, lit0, code, type);
+	      con0 = associate_trees (loc, con0, lit0, code, type);
-	      return fold_convert (type, associate_trees (var0, con0,
+	      return
-							  code, type));
+		fold_convert_loc (loc, type, associate_trees (loc, var0, con0,
+							      code, type));
 	    }
 	}
 return NULL_TREE;
 	{
 	  /* (PTR0 p+ A) - (PTR1 p+ B) -> (PTR0 - PTR1) + (A - B) */
 	  if (TREE_CODE (arg0) == POINTER_PLUS_EXPR
 	      && TREE_CODE (arg1) == POINTER_PLUS_EXPR)
 	    {
-	      tree arg00 = fold_convert (type, TREE_OPERAND (arg0, 0));
+	      tree arg00 = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0));
-	      tree arg01 = fold_convert (type, TREE_OPERAND (arg0, 1));
+	      tree arg01 = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 1));
-	      tree arg10 = fold_convert (type, TREE_OPERAND (arg1, 0));
+	      tree arg10 = fold_convert_loc (loc, type, TREE_OPERAND (arg1, 0));
-	      tree arg11 = fold_convert (type, TREE_OPERAND (arg1, 1));
+	      tree arg11 = fold_convert_loc (loc, type, TREE_OPERAND (arg1, 1));
-	      return fold_build2 (PLUS_EXPR, type,
+	      return fold_build2_loc (loc, PLUS_EXPR, type,
-				  fold_build2 (MINUS_EXPR, type, arg00, arg10),
+				  fold_build2_loc (loc, MINUS_EXPR, type,
-				  fold_build2 (MINUS_EXPR, type, arg01, arg11));
+					       arg00, arg10),
+				  fold_build2_loc (loc, MINUS_EXPR, type,
+					       arg01, arg11));
 	    }
 	  /* (PTR0 p+ A) - PTR1 -> (PTR0 - PTR1) + A, assuming PTR0 - PTR1 simplifies. */
 	  else if (TREE_CODE (arg0) == POINTER_PLUS_EXPR)
 	    {
-	      tree arg00 = fold_convert (type, TREE_OPERAND (arg0, 0));
+	      tree arg00 = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0));
-	      tree arg01 = fold_convert (type, TREE_OPERAND (arg0, 1));
+	      tree arg01 = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 1));
-	      tree tmp = fold_binary (MINUS_EXPR, type, arg00, fold_convert (type, arg1));
+	      tree tmp = fold_binary_loc (loc, MINUS_EXPR, type, arg00,
+				      fold_convert_loc (loc, type, arg1));
 	      if (tmp)
-	        return fold_build2 (PLUS_EXPR, type, tmp, arg01);
+	        return fold_build2_loc (loc, PLUS_EXPR, type, tmp, arg01);
 	    }
 	}
 /* A - (-B) -> A + B */
 if (TREE_CODE (arg1) == NEGATE_EXPR)
-	return fold_build2 (PLUS_EXPR, type, op0,
+	return fold_build2_loc (loc, PLUS_EXPR, type, op0,
-			    fold_convert (type, TREE_OPERAND (arg1, 0)));
+			    fold_convert_loc (loc, type,
+					      TREE_OPERAND (arg1, 0)));
 /* (-A) - B -> (-B) - A  where B is easily negated and we can swap.  */
 if (TREE_CODE (arg0) == NEGATE_EXPR
 	  && (FLOAT_TYPE_P (type)
 	      || INTEGRAL_TYPE_P (type))
 	  && negate_expr_p (arg1)
 	  && reorder_operands_p (arg0, arg1))
-	return fold_build2 (MINUS_EXPR, type,
+	return fold_build2_loc (loc, MINUS_EXPR, type,
-			    fold_convert (type, negate_expr (arg1)),
+			    fold_convert_loc (loc, type,
-			    fold_convert (type, TREE_OPERAND (arg0, 0)));
+					      negate_expr (arg1)),
+			    fold_convert_loc (loc, type,
+					      TREE_OPERAND (arg0, 0)));
 /* Convert -A - 1 to ~A.  */
 if (INTEGRAL_TYPE_P (type)
 	  && TREE_CODE (arg0) == NEGATE_EXPR
 	  && integer_onep (arg1)
 	  && !TYPE_OVERFLOW_TRAPS (type))
-	return fold_build1 (BIT_NOT_EXPR, type,
+	return fold_build1_loc (loc, BIT_NOT_EXPR, type,
-			    fold_convert (type, TREE_OPERAND (arg0, 0)));
+			    fold_convert_loc (loc, type,
+					      TREE_OPERAND (arg0, 0)));
 /* Convert -1 - A to ~A.  */
 if (INTEGRAL_TYPE_P (type)
 	  && integer_all_onesp (arg0))
-	return fold_build1 (BIT_NOT_EXPR, type, op1);
+	return fold_build1_loc (loc, BIT_NOT_EXPR, type, op1);
 /* X - (X / CST) * CST is X % CST.  */
 if (INTEGRAL_TYPE_P (type)
 	  && TREE_CODE (arg1) == MULT_EXPR
 	  && TREE_CODE (TREE_OPERAND (arg1, 0)) == TRUNC_DIV_EXPR
 	  && operand_equal_p (arg0,
 			      TREE_OPERAND (TREE_OPERAND (arg1, 0), 0), 0)
 	  && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg1, 0), 1),
 			      TREE_OPERAND (arg1, 1), 0))
-	return fold_convert (type,
+	return
-			     fold_build2 (TRUNC_MOD_EXPR, TREE_TYPE (arg0),
+	  fold_convert_loc (loc, type,
-					  arg0, TREE_OPERAND (arg1, 1)));
+			    fold_build2_loc (loc, TRUNC_MOD_EXPR, TREE_TYPE (arg0),
+					 arg0, TREE_OPERAND (arg1, 1)));
 if (! FLOAT_TYPE_P (type))
 	{
 	  if (integer_zerop (arg0))
-	    return negate_expr (fold_convert (type, arg1));
+	    return negate_expr (fold_convert_loc (loc, type, arg1));
 	  if (integer_zerop (arg1))
-	    return non_lvalue (fold_convert (type, arg0));
+	    return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
 	  /* Fold A - (A & B) into ~B & A.  */
 	  if (!TREE_SIDE_EFFECTS (arg0)
 	      && TREE_CODE (arg1) == BIT_AND_EXPR)
 	    {
 	      if (operand_equal_p (arg0, TREE_OPERAND (arg1, 1), 0))
 		{
-		  tree arg10 = fold_convert (type, TREE_OPERAND (arg1, 0));
+		  tree arg10 = fold_convert_loc (loc, type,
-		  return fold_build2 (BIT_AND_EXPR, type,
+						 TREE_OPERAND (arg1, 0));
-				      fold_build1 (BIT_NOT_EXPR, type, arg10),
+		  return fold_build2_loc (loc, BIT_AND_EXPR, type,
-				      fold_convert (type, arg0));
+				      fold_build1_loc (loc, BIT_NOT_EXPR,
+						   type, arg10),
+				      fold_convert_loc (loc, type, arg0));
 		}
 	      if (operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
 		{
-		  tree arg11 = fold_convert (type, TREE_OPERAND (arg1, 1));
+		  tree arg11 = fold_convert_loc (loc,
-		  return fold_build2 (BIT_AND_EXPR, type,
+						 type, TREE_OPERAND (arg1, 1));
-				      fold_build1 (BIT_NOT_EXPR, type, arg11),
+		  return fold_build2_loc (loc, BIT_AND_EXPR, type,
-				      fold_convert (type, arg0));
+				      fold_build1_loc (loc, BIT_NOT_EXPR,
+						   type, arg11),
+				      fold_convert_loc (loc, type, arg0));
 		}
 	    }
 	  /* Fold (A & ~B) - (A & B) into (A ^ B) - B, where B is
 	     any power of 2 minus 1.  */
 	      && operand_equal_p (TREE_OPERAND (arg0, 0),
 				  TREE_OPERAND (arg1, 0), 0))
 	    {
 	      tree mask0 = TREE_OPERAND (arg0, 1);
 	      tree mask1 = TREE_OPERAND (arg1, 1);
-	      tree tem = fold_build1 (BIT_NOT_EXPR, type, mask0);
+	      tree tem = fold_build1_loc (loc, BIT_NOT_EXPR, type, mask0);
 	      if (operand_equal_p (tem, mask1, 0))
 		{
-		  tem = fold_build2 (BIT_XOR_EXPR, type,
+		  tem = fold_build2_loc (loc, BIT_XOR_EXPR, type,
 				     TREE_OPERAND (arg0, 0), mask1);
-		  return fold_build2 (MINUS_EXPR, type, tem, mask1);
+		  return fold_build2_loc (loc, MINUS_EXPR, type, tem, mask1);
 		}
 	    }
 	}
 /* See if ARG1 is zero and X - ARG1 reduces to X.  */
 else if (fold_real_zero_addition_p (TREE_TYPE (arg0), arg1, 1))
-	return non_lvalue (fold_convert (type, arg0));
+	return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
 /* (ARG0 - ARG1) is the same as (-ARG1 + ARG0).  So check whether
 	 ARG0 is zero and X + ARG0 reduces to X, since that would mean
 	 (-ARG1 + ARG0) reduces to -ARG1.  */
 else if (fold_real_zero_addition_p (TREE_TYPE (arg1), arg0, 0))
-	return negate_expr (fold_convert (type, arg1));
+	return negate_expr (fold_convert_loc (loc, type, arg1));
 /* Fold __complex__ ( x, 0 ) - __complex__ ( 0, y ) to
 	 __complex__ ( x, -y ).  This is not the same for SNaNs or if
 	 signed zeros are involved.  */
 if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
 	  && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0)))
 	  && COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0)))
 {
 	  tree rtype = TREE_TYPE (TREE_TYPE (arg0));
-	  tree arg0r = fold_unary (REALPART_EXPR, rtype, arg0);
+	  tree arg0r = fold_unary_loc (loc, REALPART_EXPR, rtype, arg0);
-	  tree arg0i = fold_unary (IMAGPART_EXPR, rtype, arg0);
+	  tree arg0i = fold_unary_loc (loc, IMAGPART_EXPR, rtype, arg0);
 	  bool arg0rz = false, arg0iz = false;
 	  if ((arg0r && (arg0rz = real_zerop (arg0r)))
 	      || (arg0i && (arg0iz = real_zerop (arg0i))))
 	    {
-	      tree arg1r = fold_unary (REALPART_EXPR, rtype, arg1);
+	      tree arg1r = fold_unary_loc (loc, REALPART_EXPR, rtype, arg1);
-	      tree arg1i = fold_unary (IMAGPART_EXPR, rtype, arg1);
+	      tree arg1i = fold_unary_loc (loc, IMAGPART_EXPR, rtype, arg1);
 	      if (arg0rz && arg1i && real_zerop (arg1i))
 	        {
-		  tree rp = fold_build1 (NEGATE_EXPR, rtype,
+		  tree rp = fold_build1_loc (loc, NEGATE_EXPR, rtype,
 					 arg1r ? arg1r
 					 : build1 (REALPART_EXPR, rtype, arg1));
 		  tree ip = arg0i ? arg0i
 		    : build1 (IMAGPART_EXPR, rtype, arg0);
-		  return fold_build2 (COMPLEX_EXPR, type, rp, ip);
+		  return fold_build2_loc (loc, COMPLEX_EXPR, type, rp, ip);
 		}
 	      else if (arg0iz && arg1r && real_zerop (arg1r))
 	        {
 		  tree rp = arg0r ? arg0r
 		    : build1 (REALPART_EXPR, rtype, arg0);
-		  tree ip = fold_build1 (NEGATE_EXPR, rtype,
+		  tree ip = fold_build1_loc (loc, NEGATE_EXPR, rtype,
 					 arg1i ? arg1i
 					 : build1 (IMAGPART_EXPR, rtype, arg1));
-		  return fold_build2 (COMPLEX_EXPR, type, rp, ip);
+		  return fold_build2_loc (loc, COMPLEX_EXPR, type, rp, ip);
 		}
 	    }
 	}
 /* Fold &x - &x.  This can happen from &x.foo - &x.
 	 Also note that operand_equal_p is always false if an operand
 	 is volatile.  */
 if ((!FLOAT_TYPE_P (type) || !HONOR_NANS (TYPE_MODE (type)))
 	  && operand_equal_p (arg0, arg1, 0))
-	return fold_convert (type, integer_zero_node);
+	return fold_convert_loc (loc, type, integer_zero_node);
 /* A - B -> A + (-B) if B is easily negatable.  */
 if (negate_expr_p (arg1)
 	  && ((FLOAT_TYPE_P (type)
 /* Avoid this transformation if B is a positive REAL_CST.  */
 	       && (TREE_CODE (arg1) != REAL_CST
 		   ||  REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg1))))
 	      || INTEGRAL_TYPE_P (type)))
-	return fold_build2 (PLUS_EXPR, type,
+	return fold_build2_loc (loc, PLUS_EXPR, type,
-			    fold_convert (type, arg0),
+			    fold_convert_loc (loc, type, arg0),
-			    fold_convert (type, negate_expr (arg1)));
+			    fold_convert_loc (loc, type,
+					      negate_expr (arg1)));
 /* Try folding difference of addresses.  */
 {
 	HOST_WIDE_INT diff;
 	  tree aref0 = TREE_OPERAND (arg0, 0);
 	  tree aref1 = TREE_OPERAND (arg1, 0);
 	  if (operand_equal_p (TREE_OPERAND (aref0, 0),
 			       TREE_OPERAND (aref1, 0), 0))
 	    {
-	      tree op0 = fold_convert (type, TREE_OPERAND (aref0, 1));
+	      tree op0 = fold_convert_loc (loc, type, TREE_OPERAND (aref0, 1));
-	      tree op1 = fold_convert (type, TREE_OPERAND (aref1, 1));
+	      tree op1 = fold_convert_loc (loc, type, TREE_OPERAND (aref1, 1));
 	      tree esz = array_ref_element_size (aref0);
 	      tree diff = build2 (MINUS_EXPR, type, op0, op1);
-	      return fold_build2 (MULT_EXPR, type, diff,
+	      return fold_build2_loc (loc, MULT_EXPR, type, diff,
-			          fold_convert (type, esz));
+			          fold_convert_loc (loc, type, esz));
 	    }
 	}
-if (flag_unsafe_math_optimizations
+if (FLOAT_TYPE_P (type)
+	  && flag_unsafe_math_optimizations
 	  && (TREE_CODE (arg0) == RDIV_EXPR || TREE_CODE (arg0) == MULT_EXPR)
 	  && (TREE_CODE (arg1) == RDIV_EXPR || TREE_CODE (arg1) == MULT_EXPR)
-	  && (tem = distribute_real_division (code, type, arg0, arg1)))
+	  && (tem = distribute_real_division (loc, code, type, arg0, arg1)))
 	return tem;
 /* Handle (A1 * C1) - (A2 * C2) with A1, A2 or C1, C2 being the
 	 same or one.  Make sure type is not saturating.
 	 fold_plusminus_mult_expr will re-associate.  */
 if ((TREE_CODE (arg0) == MULT_EXPR
 	   || TREE_CODE (arg1) == MULT_EXPR)
 	  && !TYPE_SATURATING (type)
 	  && (!FLOAT_TYPE_P (type) || flag_associative_math))
 {
-	  tree tem = fold_plusminus_mult_expr (code, type, arg0, arg1);
+	  tree tem = fold_plusminus_mult_expr (loc, code, type, arg0, arg1);
 	  if (tem)
 	    return tem;
 	}
 goto associate;
 case MULT_EXPR:
 /* (-A) * (-B) -> A * B  */
 if (TREE_CODE (arg0) == NEGATE_EXPR && negate_expr_p (arg1))
-	return fold_build2 (MULT_EXPR, type,
+	return fold_build2_loc (loc, MULT_EXPR, type,
-			    fold_convert (type, TREE_OPERAND (arg0, 0)),
+			    fold_convert_loc (loc, type,
-			    fold_convert (type, negate_expr (arg1)));
+					      TREE_OPERAND (arg0, 0)),
+			    fold_convert_loc (loc, type,
+					      negate_expr (arg1)));
 if (TREE_CODE (arg1) == NEGATE_EXPR && negate_expr_p (arg0))
-	return fold_build2 (MULT_EXPR, type,
+	return fold_build2_loc (loc, MULT_EXPR, type,
-			    fold_convert (type, negate_expr (arg0)),
+			    fold_convert_loc (loc, type,
-			    fold_convert (type, TREE_OPERAND (arg1, 0)));
+					      negate_expr (arg0)),
+			    fold_convert_loc (loc, type,
+					      TREE_OPERAND (arg1, 0)));
 if (! FLOAT_TYPE_P (type))
 	{
 	  if (integer_zerop (arg1))
-	    return omit_one_operand (type, arg1, arg0);
+	    return omit_one_operand_loc (loc, type, arg1, arg0);
 	  if (integer_onep (arg1))
-	    return non_lvalue (fold_convert (type, arg0));
+	    return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
 	  /* Transform x * -1 into -x.  Make sure to do the negation
 	     on the original operand with conversions not stripped
 	     because we can only strip non-sign-changing conversions.  */
 	  if (integer_all_onesp (arg1))
-	    return fold_convert (type, negate_expr (op0));
+	    return fold_convert_loc (loc, type, negate_expr (op0));
 	  /* Transform x * -C into -x * C if x is easily negatable.  */
 	  if (TREE_CODE (arg1) == INTEGER_CST
 	      && tree_int_cst_sgn (arg1) == -1
 	      && negate_expr_p (arg0)
 	      && (tem = negate_expr (arg1)) != arg1
 	      && !TREE_OVERFLOW (tem))
-	    return fold_build2 (MULT_EXPR, type,
+	    return fold_build2_loc (loc, MULT_EXPR, type,
-	    			fold_convert (type, negate_expr (arg0)), tem);
+	    			fold_convert_loc (loc, type,
+						  negate_expr (arg0)),
+				tem);
 	  /* (a * (1 << b)) is (a << b)  */
 	  if (TREE_CODE (arg1) == LSHIFT_EXPR
 	      && integer_onep (TREE_OPERAND (arg1, 0)))
-	    return fold_build2 (LSHIFT_EXPR, type, op0,
+	    return fold_build2_loc (loc, LSHIFT_EXPR, type, op0,
 				TREE_OPERAND (arg1, 1));
 	  if (TREE_CODE (arg0) == LSHIFT_EXPR
 	      && integer_onep (TREE_OPERAND (arg0, 0)))
-	    return fold_build2 (LSHIFT_EXPR, type, op1,
+	    return fold_build2_loc (loc, LSHIFT_EXPR, type, op1,
 				TREE_OPERAND (arg0, 1));
 	  /* (A + A) * C -> A * 2 * C  */
 	  if (TREE_CODE (arg0) == PLUS_EXPR
 	      && TREE_CODE (arg1) == INTEGER_CST
 	      && operand_equal_p (TREE_OPERAND (arg0, 0),
 			          TREE_OPERAND (arg0, 1), 0))
-	    return fold_build2 (MULT_EXPR, type,
+	    return fold_build2_loc (loc, MULT_EXPR, type,
-				omit_one_operand (type, TREE_OPERAND (arg0, 0),
+				omit_one_operand_loc (loc, type,
+						  TREE_OPERAND (arg0, 0),
 						  TREE_OPERAND (arg0, 1)),
-				fold_build2 (MULT_EXPR, type,
+				fold_build2_loc (loc, MULT_EXPR, type,
 					     build_int_cst (type, 2) , arg1));
 	  strict_overflow_p = false;
 	  if (TREE_CODE (arg1) == INTEGER_CST
 	      && 0 != (tem = extract_muldiv (op0, arg1, code, NULL_TREE,
 	      if (strict_overflow_p)
 		fold_overflow_warning (("assuming signed overflow does not "
 					"occur when simplifying "
 					"multiplication"),
 				       WARN_STRICT_OVERFLOW_MISC);
-	      return fold_convert (type, tem);
+	      return fold_convert_loc (loc, type, tem);
 	    }
 	  /* Optimize z * conj(z) for integer complex numbers.  */
 	  if (TREE_CODE (arg0) == CONJ_EXPR
 	      && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
-	    return fold_mult_zconjz (type, arg1);
+	    return fold_mult_zconjz (loc, type, arg1);
 	  if (TREE_CODE (arg1) == CONJ_EXPR
 	      && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
-	    return fold_mult_zconjz (type, arg0);
+	    return fold_mult_zconjz (loc, type, arg0);
 	}
 else
 	{
 	  /* Maybe fold x * 0 to 0.  The expressions aren't the same
 	     when x is NaN, since x * 0 is also NaN.  Nor are they the
 	     same in modes with signed zeros, since multiplying a
 	     negative value by 0 gives -0, not +0.  */
 	  if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0)))
 	      && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0)))
 	      && real_zerop (arg1))
-	    return omit_one_operand (type, arg1, arg0);
+	    return omit_one_operand_loc (loc, type, arg1, arg0);
-	  /* In IEEE floating point, x*1 is not equivalent to x for snans.  */
+	  /* In IEEE floating point, x*1 is not equivalent to x for snans.
+	     Likewise for complex arithmetic with signed zeros.  */
 	  if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
+	      && (!HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0)))
+		  || !COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0)))
 	      && real_onep (arg1))
-	    return non_lvalue (fold_convert (type, arg0));
+	    return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
 	  /* Transform x * -1.0 into -x.  */
 	  if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
+	      && (!HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0)))
+		  || !COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0)))
 	      && real_minus_onep (arg1))
-	    return fold_convert (type, negate_expr (arg0));
+	    return fold_convert_loc (loc, type, negate_expr (arg0));
 	  /* Convert (C1/X)*C2 into (C1*C2)/X.  This transformation may change
 the result for floating point types due to rounding so it is applied
 only if -fassociative-math was specify.  */
 	  if (flag_associative_math
 	      && TREE_CODE (TREE_OPERAND (arg0, 0)) == REAL_CST)
 	    {
 	      tree tem = const_binop (MULT_EXPR, TREE_OPERAND (arg0, 0),
 				      arg1, 0);
 	      if (tem)
-		return fold_build2 (RDIV_EXPR, type, tem,
+		return fold_build2_loc (loc, RDIV_EXPR, type, tem,
 				    TREE_OPERAND (arg0, 1));
 	    }
 /* Strip sign operations from X in X*X, i.e. -Y*-Y -> Y*Y.  */
 	  if (operand_equal_p (arg0, arg1, 0))
 	    {
 	      tree tem = fold_strip_sign_ops (arg0);
 	      if (tem != NULL_TREE)
 		{
-		  tem = fold_convert (type, tem);
+		  tem = fold_convert_loc (loc, type, tem);
-		  return fold_build2 (MULT_EXPR, type, tem, tem);
+		  return fold_build2_loc (loc, MULT_EXPR, type, tem, tem);
 		}
 	    }
 	  /* Fold z * +-I to __complex__ (-+__imag z, +-__real z).
 	     This is not the same for NaNs or if signed zeros are
 	      && TREE_CODE (arg1) == COMPLEX_CST
 	      && real_zerop (TREE_REALPART (arg1)))
 	    {
 	      tree rtype = TREE_TYPE (TREE_TYPE (arg0));
 	      if (real_onep (TREE_IMAGPART (arg1)))
-		return fold_build2 (COMPLEX_EXPR, type,
+		return
-				    negate_expr (fold_build1 (IMAGPART_EXPR,
+		  fold_build2_loc (loc, COMPLEX_EXPR, type,
-							      rtype, arg0)),
+			       negate_expr (fold_build1_loc (loc, IMAGPART_EXPR,
-				    fold_build1 (REALPART_EXPR, rtype, arg0));
+							     rtype, arg0)),
+			       fold_build1_loc (loc, REALPART_EXPR, rtype, arg0));
 	      else if (real_minus_onep (TREE_IMAGPART (arg1)))
-		return fold_build2 (COMPLEX_EXPR, type,
+		return
-				    fold_build1 (IMAGPART_EXPR, rtype, arg0),
+		  fold_build2_loc (loc, COMPLEX_EXPR, type,
-				    negate_expr (fold_build1 (REALPART_EXPR,
+			       fold_build1_loc (loc, IMAGPART_EXPR, rtype, arg0),
-							      rtype, arg0)));
+			       negate_expr (fold_build1_loc (loc, REALPART_EXPR,
+							     rtype, arg0)));
 	    }
 	  /* Optimize z * conj(z) for floating point complex numbers.
 	     Guarded by flag_unsafe_math_optimizations as non-finite
 	     imaginary components don't produce scalar results.  */
 	  if (flag_unsafe_math_optimizations
 	      && TREE_CODE (arg0) == CONJ_EXPR
 	      && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
-	    return fold_mult_zconjz (type, arg1);
+	    return fold_mult_zconjz (loc, type, arg1);
 	  if (flag_unsafe_math_optimizations
 	      && TREE_CODE (arg1) == CONJ_EXPR
 	      && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
-	    return fold_mult_zconjz (type, arg0);
+	    return fold_mult_zconjz (loc, type, arg0);
 	  if (flag_unsafe_math_optimizations)
 	    {
 	      enum built_in_function fcode0 = builtin_mathfn_code (arg0);
 	      enum built_in_function fcode1 = builtin_mathfn_code (arg1);
 		      && ! HONOR_SNANS (TYPE_MODE (type)))
 		    return arg00;
 	          /* Optimize root(x)*root(y) as root(x*y).  */
 		  rootfn = TREE_OPERAND (CALL_EXPR_FN (arg0), 0);
-		  arg = fold_build2 (MULT_EXPR, type, arg00, arg10);
+		  arg = fold_build2_loc (loc, MULT_EXPR, type, arg00, arg10);
-		  return build_call_expr (rootfn, 1, arg);
+		  return build_call_expr_loc (loc, rootfn, 1, arg);
 		}
 	      /* Optimize expN(x)*expN(y) as expN(x+y).  */
 	      if (fcode0 == fcode1 && BUILTIN_EXPONENT_P (fcode0))
 		{
 		  tree expfn = TREE_OPERAND (CALL_EXPR_FN (arg0), 0);
-		  tree arg = fold_build2 (PLUS_EXPR, type,
+		  tree arg = fold_build2_loc (loc, PLUS_EXPR, type,
 					  CALL_EXPR_ARG (arg0, 0),
 					  CALL_EXPR_ARG (arg1, 0));
-		  return build_call_expr (expfn, 1, arg);
+		  return build_call_expr_loc (loc, expfn, 1, arg);
 		}
 	      /* Optimizations of pow(...)*pow(...).  */
 	      if ((fcode0 == BUILT_IN_POW && fcode1 == BUILT_IN_POW)
 		  || (fcode0 == BUILT_IN_POWF && fcode1 == BUILT_IN_POWF)
 		  /* Optimize pow(x,y)*pow(z,y) as pow(x*z,y).  */
 		  if (operand_equal_p (arg01, arg11, 0))
 		    {
 		      tree powfn = TREE_OPERAND (CALL_EXPR_FN (arg0), 0);
-		      tree arg = fold_build2 (MULT_EXPR, type, arg00, arg10);
+		      tree arg = fold_build2_loc (loc, MULT_EXPR, type,
-		      return build_call_expr (powfn, 2, arg, arg01);
+					      arg00, arg10);
+		      return build_call_expr_loc (loc, powfn, 2, arg, arg01);
 		    }
 		  /* Optimize pow(x,y)*pow(x,z) as pow(x,y+z).  */
 		  if (operand_equal_p (arg00, arg10, 0))
 		    {
 		      tree powfn = TREE_OPERAND (CALL_EXPR_FN (arg0), 0);
-		      tree arg = fold_build2 (PLUS_EXPR, type, arg01, arg11);
+		      tree arg = fold_build2_loc (loc, PLUS_EXPR, type,
-		      return build_call_expr (powfn, 2, arg00, arg);
+					      arg01, arg11);
+		      return build_call_expr_loc (loc, powfn, 2, arg00, arg);
 		    }
 		}
 	      /* Optimize tan(x)*cos(x) as sin(x).  */
 	      if (((fcode0 == BUILT_IN_TAN && fcode1 == BUILT_IN_COS)
 				      CALL_EXPR_ARG (arg1, 0), 0))
 		{
 		  tree sinfn = mathfn_built_in (type, BUILT_IN_SIN);
 		  if (sinfn != NULL_TREE)
-		    return build_call_expr (sinfn, 1, CALL_EXPR_ARG (arg0, 0));
+		    return build_call_expr_loc (loc, sinfn, 1,
+					    CALL_EXPR_ARG (arg0, 0));
 		}
 	      /* Optimize x*pow(x,c) as pow(x,c+1).  */
 	      if (fcode1 == BUILT_IN_POW
 		  || fcode1 == BUILT_IN_POWF
 		      tree arg;
 		      c = TREE_REAL_CST (arg11);
 		      real_arithmetic (&c, PLUS_EXPR, &c, &dconst1);
 		      arg = build_real (type, c);
-		      return build_call_expr (powfn, 2, arg0, arg);
+		      return build_call_expr_loc (loc, powfn, 2, arg0, arg);
 		    }
 		}
 	      /* Optimize pow(x,c)*x as pow(x,c+1).  */
 	      if (fcode0 == BUILT_IN_POW
 		      tree arg;
 		      c = TREE_REAL_CST (arg01);
 		      real_arithmetic (&c, PLUS_EXPR, &c, &dconst1);
 		      arg = build_real (type, c);
-		      return build_call_expr (powfn, 2, arg1, arg);
+		      return build_call_expr_loc (loc, powfn, 2, arg1, arg);
 		    }
 		}
 	      /* Optimize x*x as pow(x,2.0), which is expanded as x*x.  */
 	      if (optimize_function_for_speed_p (cfun)
 		  tree powfn = mathfn_built_in (type, BUILT_IN_POW);
 		  if (powfn)
 		    {
 		      tree arg = build_real (type, dconst2);
-		      return build_call_expr (powfn, 2, arg0, arg);
+		      return build_call_expr_loc (loc, powfn, 2, arg0, arg);
 		    }
 		}
 	    }
 	}
 goto associate;
 case BIT_IOR_EXPR:
 bit_ior:
 if (integer_all_onesp (arg1))
-	return omit_one_operand (type, arg1, arg0);
+	return omit_one_operand_loc (loc, type, arg1, arg0);
 if (integer_zerop (arg1))
-	return non_lvalue (fold_convert (type, arg0));
+	return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
 if (operand_equal_p (arg0, arg1, 0))
-	return non_lvalue (fold_convert (type, arg0));
+	return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
 /* ~X | X is -1.  */
 if (TREE_CODE (arg0) == BIT_NOT_EXPR
 	  && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
 	{
-	  t1 = fold_convert (type, integer_zero_node);
+	  t1 = fold_convert_loc (loc, type, integer_zero_node);
-	  t1 = fold_unary (BIT_NOT_EXPR, type, t1);
+	  t1 = fold_unary_loc (loc, BIT_NOT_EXPR, type, t1);
-	  return omit_one_operand (type, t1, arg1);
+	  return omit_one_operand_loc (loc, type, t1, arg1);
 	}
 /* X | ~X is -1.  */
 if (TREE_CODE (arg1) == BIT_NOT_EXPR
 	  && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
 	{
-	  t1 = fold_convert (type, integer_zero_node);
+	  t1 = fold_convert_loc (loc, type, integer_zero_node);
-	  t1 = fold_unary (BIT_NOT_EXPR, type, t1);
+	  t1 = fold_unary_loc (loc, BIT_NOT_EXPR, type, t1);
-	  return omit_one_operand (type, t1, arg0);
+	  return omit_one_operand_loc (loc, type, t1, arg0);
 	}
 /* Canonicalize (X & C1) | C2.  */
 if (TREE_CODE (arg0) == BIT_AND_EXPR
 	  && TREE_CODE (arg1) == INTEGER_CST
 	  hi2 = TREE_INT_CST_HIGH (arg1);
 	  lo2 = TREE_INT_CST_LOW (arg1);
 	  /* If (C1&C2) == C1, then (X&C1)|C2 becomes (X,C2).  */
 	  if ((hi1 & hi2) == hi1 && (lo1 & lo2) == lo1)
-	    return omit_one_operand (type, arg1, TREE_OPERAND (arg0, 0));
+	    return omit_one_operand_loc (loc, type, arg1,
+				     TREE_OPERAND (arg0, 0));
 	  if (width > HOST_BITS_PER_WIDE_INT)
 	    {
 	      mhi = (unsigned HOST_WIDE_INT) -1
 		    >> (2 * HOST_BITS_PER_WIDE_INT - width);
 	      mlo = -1;
 	    }
 	  else
 	    {
 		    >> (HOST_BITS_PER_WIDE_INT - width);
 	    }
 	  /* If (C1|C2) == ~0 then (X&C1)|C2 becomes X|C2.  */
 	  if ((~(hi1 | hi2) & mhi) == 0 && (~(lo1 | lo2) & mlo) == 0)
-	    return fold_build2 (BIT_IOR_EXPR, type,
+	    return fold_build2_loc (loc, BIT_IOR_EXPR, type,
 				TREE_OPERAND (arg0, 0), arg1);
 	  /* Minimize the number of bits set in C1, i.e. C1 := C1 & ~C2,
 	     unless (C1 & ~C2) | (C2 & C3) for some C3 is a mask of some
 	     mode which allows further optimizations.  */
 		  lo3 = mask;
 		  break;
 		}
 	    }
 	  if (hi3 != hi1 || lo3 != lo1)
-	    return fold_build2 (BIT_IOR_EXPR, type,
+	    return fold_build2_loc (loc, BIT_IOR_EXPR, type,
-				fold_build2 (BIT_AND_EXPR, type,
+				fold_build2_loc (loc, BIT_AND_EXPR, type,
 					     TREE_OPERAND (arg0, 0),
 					     build_int_cst_wide (type,
 								 lo3, hi3)),
 				arg1);
 	}
 /* (X & Y) | Y is (X, Y).  */
 if (TREE_CODE (arg0) == BIT_AND_EXPR
 	  && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
-	return omit_one_operand (type, arg1, TREE_OPERAND (arg0, 0));
+	return omit_one_operand_loc (loc, type, arg1, TREE_OPERAND (arg0, 0));
 /* (X & Y) | X is (Y, X).  */
 if (TREE_CODE (arg0) == BIT_AND_EXPR
 	  && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0)
 	  && reorder_operands_p (TREE_OPERAND (arg0, 1), arg1))
-	return omit_one_operand (type, arg1, TREE_OPERAND (arg0, 1));
+	return omit_one_operand_loc (loc, type, arg1, TREE_OPERAND (arg0, 1));
 /* X | (X & Y) is (Y, X).  */
 if (TREE_CODE (arg1) == BIT_AND_EXPR
 	  && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0)
 	  && reorder_operands_p (arg0, TREE_OPERAND (arg1, 1)))
-	return omit_one_operand (type, arg0, TREE_OPERAND (arg1, 1));
+	return omit_one_operand_loc (loc, type, arg0, TREE_OPERAND (arg1, 1));
 /* X | (Y & X) is (Y, X).  */
 if (TREE_CODE (arg1) == BIT_AND_EXPR
 	  && operand_equal_p (arg0, TREE_OPERAND (arg1, 1), 0)
 	  && reorder_operands_p (arg0, TREE_OPERAND (arg1, 0)))
-	return omit_one_operand (type, arg0, TREE_OPERAND (arg1, 0));
+	return omit_one_operand_loc (loc, type, arg0, TREE_OPERAND (arg1, 0));
-t1 = distribute_bit_expr (code, type, arg0, arg1);
+t1 = distribute_bit_expr (loc, code, type, arg0, arg1);
 if (t1 != NULL_TREE)
 	return t1;
 /* Convert (or (not arg0) (not arg1)) to (not (and (arg0) (arg1))).
 	 which will allow use of NAND instructions provided by the
 	 backend if they exist.  */
 if (TREE_CODE (arg0) == BIT_NOT_EXPR
 	  && TREE_CODE (arg1) == BIT_NOT_EXPR)
 	{
-	  return fold_build1 (BIT_NOT_EXPR, type,
+	  return
-			      build2 (BIT_AND_EXPR, type,
+	    fold_build1_loc (loc, BIT_NOT_EXPR, type,
-				      fold_convert (type,
+			 build2 (BIT_AND_EXPR, type,
-						    TREE_OPERAND (arg0, 0)),
+				 fold_convert_loc (loc, type,
-				      fold_convert (type,
+						   TREE_OPERAND (arg0, 0)),
-						    TREE_OPERAND (arg1, 0))));
+				 fold_convert_loc (loc, type,
+						   TREE_OPERAND (arg1, 0))));
 	}
 /* See if this can be simplified into a rotate first.  If that
 	 is unsuccessful continue in the association code.  */
 goto bit_rotate;
 case BIT_XOR_EXPR:
 if (integer_zerop (arg1))
-	return non_lvalue (fold_convert (type, arg0));
+	return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
 if (integer_all_onesp (arg1))
-	return fold_build1 (BIT_NOT_EXPR, type, op0);
+	return fold_build1_loc (loc, BIT_NOT_EXPR, type, op0);
 if (operand_equal_p (arg0, arg1, 0))
-	return omit_one_operand (type, integer_zero_node, arg0);
+	return omit_one_operand_loc (loc, type, integer_zero_node, arg0);
 /* ~X ^ X is -1.  */
 if (TREE_CODE (arg0) == BIT_NOT_EXPR
 	  && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
 	{
-	  t1 = fold_convert (type, integer_zero_node);
+	  t1 = fold_convert_loc (loc, type, integer_zero_node);
-	  t1 = fold_unary (BIT_NOT_EXPR, type, t1);
+	  t1 = fold_unary_loc (loc, BIT_NOT_EXPR, type, t1);
-	  return omit_one_operand (type, t1, arg1);
+	  return omit_one_operand_loc (loc, type, t1, arg1);
 	}
 /* X ^ ~X is -1.  */
 if (TREE_CODE (arg1) == BIT_NOT_EXPR
 	  && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
 	{
-	  t1 = fold_convert (type, integer_zero_node);
+	  t1 = fold_convert_loc (loc, type, integer_zero_node);
-	  t1 = fold_unary (BIT_NOT_EXPR, type, t1);
+	  t1 = fold_unary_loc (loc, BIT_NOT_EXPR, type, t1);
-	  return omit_one_operand (type, t1, arg0);
+	  return omit_one_operand_loc (loc, type, t1, arg0);
 	}
 /* If we are XORing two BIT_AND_EXPR's, both of which are and'ing
 with a constant, and the two constants have no bits in common,
 	 we should treat this as a BIT_IOR_EXPR since this may produce more
 /* (X | Y) ^ X -> Y & ~ X*/
 if (TREE_CODE (arg0) == BIT_IOR_EXPR
 && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
 {
 	  tree t2 = TREE_OPERAND (arg0, 1);
-	  t1 = fold_build1 (BIT_NOT_EXPR, TREE_TYPE (arg1),
+	  t1 = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (arg1),
 			    arg1);
-	  t1 = fold_build2 (BIT_AND_EXPR, type, fold_convert (type, t2),
+	  t1 = fold_build2_loc (loc, BIT_AND_EXPR, type,
-			    fold_convert (type, t1));
+			    fold_convert_loc (loc, type, t2),
+			    fold_convert_loc (loc, type, t1));
 	  return t1;
 	}
 /* (Y | X) ^ X -> Y & ~ X*/
 if (TREE_CODE (arg0) == BIT_IOR_EXPR
 && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
 {
 	  tree t2 = TREE_OPERAND (arg0, 0);
-	  t1 = fold_build1 (BIT_NOT_EXPR, TREE_TYPE (arg1),
+	  t1 = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (arg1),
 			    arg1);
-	  t1 = fold_build2 (BIT_AND_EXPR, type, fold_convert (type, t2),
+	  t1 = fold_build2_loc (loc, BIT_AND_EXPR, type,
-			    fold_convert (type, t1));
+			    fold_convert_loc (loc, type, t2),
+			    fold_convert_loc (loc, type, t1));
 	  return t1;
 	}
 /* X ^ (X | Y) -> Y & ~ X*/
 if (TREE_CODE (arg1) == BIT_IOR_EXPR
 && operand_equal_p (TREE_OPERAND (arg1, 0), arg0, 0))
 {
 	  tree t2 = TREE_OPERAND (arg1, 1);
-	  t1 = fold_build1 (BIT_NOT_EXPR, TREE_TYPE (arg0),
+	  t1 = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (arg0),
 			    arg0);
-	  t1 = fold_build2 (BIT_AND_EXPR, type, fold_convert (type, t2),
+	  t1 = fold_build2_loc (loc, BIT_AND_EXPR, type,
-			    fold_convert (type, t1));
+			    fold_convert_loc (loc, type, t2),
+			    fold_convert_loc (loc, type, t1));
 	  return t1;
 	}
 /* X ^ (Y | X) -> Y & ~ X*/
 if (TREE_CODE (arg1) == BIT_IOR_EXPR
 && operand_equal_p (TREE_OPERAND (arg1, 1), arg0, 0))
 {
 	  tree t2 = TREE_OPERAND (arg1, 0);
-	  t1 = fold_build1 (BIT_NOT_EXPR, TREE_TYPE (arg0),
+	  t1 = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (arg0),
 			    arg0);
-	  t1 = fold_build2 (BIT_AND_EXPR, type, fold_convert (type, t2),
+	  t1 = fold_build2_loc (loc, BIT_AND_EXPR, type,
-			    fold_convert (type, t1));
+			    fold_convert_loc (loc, type, t2),
+			    fold_convert_loc (loc, type, t1));
 	  return t1;
 	}
 /* Convert ~X ^ ~Y to X ^ Y.  */
 if (TREE_CODE (arg0) == BIT_NOT_EXPR
 	  && TREE_CODE (arg1) == BIT_NOT_EXPR)
-	return fold_build2 (code, type,
+	return fold_build2_loc (loc, code, type,
-			    fold_convert (type, TREE_OPERAND (arg0, 0)),
+			    fold_convert_loc (loc, type,
-			    fold_convert (type, TREE_OPERAND (arg1, 0)));
+					      TREE_OPERAND (arg0, 0)),
+			    fold_convert_loc (loc, type,
+					      TREE_OPERAND (arg1, 0)));
 /* Convert ~X ^ C to X ^ ~C.  */
 if (TREE_CODE (arg0) == BIT_NOT_EXPR
 	  && TREE_CODE (arg1) == INTEGER_CST)
-	return fold_build2 (code, type,
+	return fold_build2_loc (loc, code, type,
-			    fold_convert (type, TREE_OPERAND (arg0, 0)),
+			    fold_convert_loc (loc, type,
-			    fold_build1 (BIT_NOT_EXPR, type, arg1));
+					      TREE_OPERAND (arg0, 0)),
+			    fold_build1_loc (loc, BIT_NOT_EXPR, type, arg1));
 /* Fold (X & 1) ^ 1 as (X & 1) == 0.  */
 if (TREE_CODE (arg0) == BIT_AND_EXPR
 	  && integer_onep (TREE_OPERAND (arg0, 1))
 	  && integer_onep (arg1))
-	return fold_build2 (EQ_EXPR, type, arg0,
+	return fold_build2_loc (loc, EQ_EXPR, type, arg0,
 			    build_int_cst (TREE_TYPE (arg0), 0));
 /* Fold (X & Y) ^ Y as ~X & Y.  */
 if (TREE_CODE (arg0) == BIT_AND_EXPR
 	  && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
 	{
-	  tem = fold_convert (type, TREE_OPERAND (arg0, 0));
+	  tem = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0));
-	  return fold_build2 (BIT_AND_EXPR, type,
+	  return fold_build2_loc (loc, BIT_AND_EXPR, type,
-			      fold_build1 (BIT_NOT_EXPR, type, tem),
+			      fold_build1_loc (loc, BIT_NOT_EXPR, type, tem),
-			      fold_convert (type, arg1));
+			      fold_convert_loc (loc, type, arg1));
 	}
 /* Fold (X & Y) ^ X as ~Y & X.  */
 if (TREE_CODE (arg0) == BIT_AND_EXPR
 	  && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0)
 	  && reorder_operands_p (TREE_OPERAND (arg0, 1), arg1))
 	{
-	  tem = fold_convert (type, TREE_OPERAND (arg0, 1));
+	  tem = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 1));
-	  return fold_build2 (BIT_AND_EXPR, type,
+	  return fold_build2_loc (loc, BIT_AND_EXPR, type,
-			      fold_build1 (BIT_NOT_EXPR, type, tem),
+			      fold_build1_loc (loc, BIT_NOT_EXPR, type, tem),
-			      fold_convert (type, arg1));
+			      fold_convert_loc (loc, type, arg1));
 	}
 /* Fold X ^ (X & Y) as X & ~Y.  */
 if (TREE_CODE (arg1) == BIT_AND_EXPR
 	  && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
 	{
-	  tem = fold_convert (type, TREE_OPERAND (arg1, 1));
+	  tem = fold_convert_loc (loc, type, TREE_OPERAND (arg1, 1));
-	  return fold_build2 (BIT_AND_EXPR, type,
+	  return fold_build2_loc (loc, BIT_AND_EXPR, type,
-			      fold_convert (type, arg0),
+			      fold_convert_loc (loc, type, arg0),
-			      fold_build1 (BIT_NOT_EXPR, type, tem));
+			      fold_build1_loc (loc, BIT_NOT_EXPR, type, tem));
 	}
 /* Fold X ^ (Y & X) as ~Y & X.  */
 if (TREE_CODE (arg1) == BIT_AND_EXPR
 	  && operand_equal_p (arg0, TREE_OPERAND (arg1, 1), 0)
 	  && reorder_operands_p (arg0, TREE_OPERAND (arg1, 0)))
 	{
-	  tem = fold_convert (type, TREE_OPERAND (arg1, 0));
+	  tem = fold_convert_loc (loc, type, TREE_OPERAND (arg1, 0));
-	  return fold_build2 (BIT_AND_EXPR, type,
+	  return fold_build2_loc (loc, BIT_AND_EXPR, type,
-			      fold_build1 (BIT_NOT_EXPR, type, tem),
+			      fold_build1_loc (loc, BIT_NOT_EXPR, type, tem),
-			      fold_convert (type, arg0));
+			      fold_convert_loc (loc, type, arg0));
 	}
 /* See if this can be simplified into a rotate first.  If that
 	 is unsuccessful continue in the association code.  */
 goto bit_rotate;
 case BIT_AND_EXPR:
 if (integer_all_onesp (arg1))
-	return non_lvalue (fold_convert (type, arg0));
+	return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
 if (integer_zerop (arg1))
-	return omit_one_operand (type, arg1, arg0);
+	return omit_one_operand_loc (loc, type, arg1, arg0);
 if (operand_equal_p (arg0, arg1, 0))
-	return non_lvalue (fold_convert (type, arg0));
+	return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
 /* ~X & X is always zero.  */
 if (TREE_CODE (arg0) == BIT_NOT_EXPR
 	  && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
-	return omit_one_operand (type, integer_zero_node, arg1);
+	return omit_one_operand_loc (loc, type, integer_zero_node, arg1);
 /* X & ~X is always zero.  */
 if (TREE_CODE (arg1) == BIT_NOT_EXPR
 	  && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
-	return omit_one_operand (type, integer_zero_node, arg0);
+	return omit_one_operand_loc (loc, type, integer_zero_node, arg0);
 /* Canonicalize (X | C1) & C2 as (X & C2) | (C1 & C2).  */
 if (TREE_CODE (arg0) == BIT_IOR_EXPR
 	  && TREE_CODE (arg1) == INTEGER_CST
 	  && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
 	{
-	  tree tmp1 = fold_convert (type, arg1);
+	  tree tmp1 = fold_convert_loc (loc, type, arg1);
-	  tree tmp2 = fold_convert (type, TREE_OPERAND (arg0, 0));
+	  tree tmp2 = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0));
-	  tree tmp3 = fold_convert (type, TREE_OPERAND (arg0, 1));
+	  tree tmp3 = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 1));
-	  tmp2 = fold_build2 (BIT_AND_EXPR, type, tmp2, tmp1);
+	  tmp2 = fold_build2_loc (loc, BIT_AND_EXPR, type, tmp2, tmp1);
-	  tmp3 = fold_build2 (BIT_AND_EXPR, type, tmp3, tmp1);
+	  tmp3 = fold_build2_loc (loc, BIT_AND_EXPR, type, tmp3, tmp1);
-	  return fold_convert (type,
+	  return
-			       fold_build2 (BIT_IOR_EXPR, type, tmp2, tmp3));
+	    fold_convert_loc (loc, type,
+			      fold_build2_loc (loc, BIT_IOR_EXPR,
+					   type, tmp2, tmp3));
 	}
 /* (X | Y) & Y is (X, Y).  */
 if (TREE_CODE (arg0) == BIT_IOR_EXPR
 	  && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
-	return omit_one_operand (type, arg1, TREE_OPERAND (arg0, 0));
+	return omit_one_operand_loc (loc, type, arg1, TREE_OPERAND (arg0, 0));
 /* (X | Y) & X is (Y, X).  */
 if (TREE_CODE (arg0) == BIT_IOR_EXPR
 	  && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0)
 	  && reorder_operands_p (TREE_OPERAND (arg0, 1), arg1))
-	return omit_one_operand (type, arg1, TREE_OPERAND (arg0, 1));
+	return omit_one_operand_loc (loc, type, arg1, TREE_OPERAND (arg0, 1));
 /* X & (X | Y) is (Y, X).  */
 if (TREE_CODE (arg1) == BIT_IOR_EXPR
 	  && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0)
 	  && reorder_operands_p (arg0, TREE_OPERAND (arg1, 1)))
-	return omit_one_operand (type, arg0, TREE_OPERAND (arg1, 1));
+	return omit_one_operand_loc (loc, type, arg0, TREE_OPERAND (arg1, 1));
 /* X & (Y | X) is (Y, X).  */
 if (TREE_CODE (arg1) == BIT_IOR_EXPR
 	  && operand_equal_p (arg0, TREE_OPERAND (arg1, 1), 0)
 	  && reorder_operands_p (arg0, TREE_OPERAND (arg1, 0)))
-	return omit_one_operand (type, arg0, TREE_OPERAND (arg1, 0));
+	return omit_one_operand_loc (loc, type, arg0, TREE_OPERAND (arg1, 0));
 /* Fold (X ^ 1) & 1 as (X & 1) == 0.  */
 if (TREE_CODE (arg0) == BIT_XOR_EXPR
 	  && integer_onep (TREE_OPERAND (arg0, 1))
 	  && integer_onep (arg1))
 	{
 	  tem = TREE_OPERAND (arg0, 0);
-	  return fold_build2 (EQ_EXPR, type,
+	  return fold_build2_loc (loc, EQ_EXPR, type,
-			      fold_build2 (BIT_AND_EXPR, TREE_TYPE (tem), tem,
+			      fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (tem), tem,
 					   build_int_cst (TREE_TYPE (tem), 1)),
 			      build_int_cst (TREE_TYPE (tem), 0));
 	}
 /* Fold ~X & 1 as (X & 1) == 0.  */
 if (TREE_CODE (arg0) == BIT_NOT_EXPR
 	  && integer_onep (arg1))
 	{
 	  tem = TREE_OPERAND (arg0, 0);
-	  return fold_build2 (EQ_EXPR, type,
+	  return fold_build2_loc (loc, EQ_EXPR, type,
-			      fold_build2 (BIT_AND_EXPR, TREE_TYPE (tem), tem,
+			      fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (tem), tem,
 					   build_int_cst (TREE_TYPE (tem), 1)),
 			      build_int_cst (TREE_TYPE (tem), 0));
 	}
 /* Fold (X ^ Y) & Y as ~X & Y.  */
 if (TREE_CODE (arg0) == BIT_XOR_EXPR
 	  && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
 	{
-	  tem = fold_convert (type, TREE_OPERAND (arg0, 0));
+	  tem = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0));
-	  return fold_build2 (BIT_AND_EXPR, type,
+	  return fold_build2_loc (loc, BIT_AND_EXPR, type,
-			      fold_build1 (BIT_NOT_EXPR, type, tem),
+			      fold_build1_loc (loc, BIT_NOT_EXPR, type, tem),
-			      fold_convert (type, arg1));
+			      fold_convert_loc (loc, type, arg1));
 	}
 /* Fold (X ^ Y) & X as ~Y & X.  */
 if (TREE_CODE (arg0) == BIT_XOR_EXPR
 	  && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0)
 	  && reorder_operands_p (TREE_OPERAND (arg0, 1), arg1))
 	{
-	  tem = fold_convert (type, TREE_OPERAND (arg0, 1));
+	  tem = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 1));
-	  return fold_build2 (BIT_AND_EXPR, type,
+	  return fold_build2_loc (loc, BIT_AND_EXPR, type,
-			      fold_build1 (BIT_NOT_EXPR, type, tem),
+			      fold_build1_loc (loc, BIT_NOT_EXPR, type, tem),
-			      fold_convert (type, arg1));
+			      fold_convert_loc (loc, type, arg1));
 	}
 /* Fold X & (X ^ Y) as X & ~Y.  */
 if (TREE_CODE (arg1) == BIT_XOR_EXPR
 	  && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
 	{
-	  tem = fold_convert (type, TREE_OPERAND (arg1, 1));
+	  tem = fold_convert_loc (loc, type, TREE_OPERAND (arg1, 1));
-	  return fold_build2 (BIT_AND_EXPR, type,
+	  return fold_build2_loc (loc, BIT_AND_EXPR, type,
-			      fold_convert (type, arg0),
+			      fold_convert_loc (loc, type, arg0),
-			      fold_build1 (BIT_NOT_EXPR, type, tem));
+			      fold_build1_loc (loc, BIT_NOT_EXPR, type, tem));
 	}
 /* Fold X & (Y ^ X) as ~Y & X.  */
 if (TREE_CODE (arg1) == BIT_XOR_EXPR
 	  && operand_equal_p (arg0, TREE_OPERAND (arg1, 1), 0)
 	  && reorder_operands_p (arg0, TREE_OPERAND (arg1, 0)))
 	{
-	  tem = fold_convert (type, TREE_OPERAND (arg1, 0));
+	  tem = fold_convert_loc (loc, type, TREE_OPERAND (arg1, 0));
-	  return fold_build2 (BIT_AND_EXPR, type,
+	  return fold_build2_loc (loc, BIT_AND_EXPR, type,
-			      fold_build1 (BIT_NOT_EXPR, type, tem),
+			      fold_build1_loc (loc, BIT_NOT_EXPR, type, tem),
-			      fold_convert (type, arg0));
+			      fold_convert_loc (loc, type, arg0));
 	}
-t1 = distribute_bit_expr (code, type, arg0, arg1);
+t1 = distribute_bit_expr (loc, code, type, arg0, arg1);
 if (t1 != NULL_TREE)
 	return t1;
 /* Simplify ((int)c & 0377) into (int)c, if c is unsigned char.  */
 if (TREE_CODE (arg1) == INTEGER_CST && TREE_CODE (arg0) == NOP_EXPR
 	  && TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg0, 0))))
 	    = TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0, 0)));
 	  if (prec < BITS_PER_WORD && prec < HOST_BITS_PER_WIDE_INT
 	      && (~TREE_INT_CST_LOW (arg1)
 		  & (((HOST_WIDE_INT) 1 << prec) - 1)) == 0)
-	    return fold_convert (type, TREE_OPERAND (arg0, 0));
+	    return
+	      fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0));
 	}
 /* Convert (and (not arg0) (not arg1)) to (not (or (arg0) (arg1))).
 	 This results in more efficient code for machines without a NOR
 	 which will allow use of NOR instructions provided by the
 	 backend if they exist.  */
 if (TREE_CODE (arg0) == BIT_NOT_EXPR
 	  && TREE_CODE (arg1) == BIT_NOT_EXPR)
 	{
-	  return fold_build1 (BIT_NOT_EXPR, type,
+	  return fold_build1_loc (loc, BIT_NOT_EXPR, type,
 			      build2 (BIT_IOR_EXPR, type,
-				      fold_convert (type,
+				      fold_convert_loc (loc, type,
-						    TREE_OPERAND (arg0, 0)),
+							TREE_OPERAND (arg0, 0)),
-				      fold_convert (type,
+				      fold_convert_loc (loc, type,
-						    TREE_OPERAND (arg1, 0))));
+							TREE_OPERAND (arg1, 0))));
 	}
 /* If arg0 is derived from the address of an object or function, we may
 	 be able to fold this expression using the object or function's
 	 alignment.  */
 if (POINTER_TYPE_P (TREE_TYPE (arg0)) && host_integerp (arg1, 1))
 	{
 	  unsigned HOST_WIDE_INT modulus, residue;
 	  unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (arg1);
-	  modulus = get_pointer_modulus_and_residue (arg0, &residue);
+	  modulus = get_pointer_modulus_and_residue (arg0, &residue,
+						     integer_onep (arg1));
 	  /* This works because modulus is a power of 2.  If this weren't the
 	     case, we'd have to replace it by its greatest power-of-2
 	     divisor: modulus & -modulus.  */
 	  if (low < modulus)
 		}
 	    }
 	  /* ((X << 16) & 0xff00) is (X, 0).  */
 	  if ((mask & zerobits) == mask)
-	    return omit_one_operand (type, build_int_cst (type, 0), arg0);
+	    return omit_one_operand_loc (loc, type,
+				     build_int_cst (type, 0), arg0);
 	  newmask = mask | zerobits;
 	  if (newmask != mask && (newmask & (newmask + 1)) == 0)
 	    {
 	      unsigned int prec;
 		{
 		  tree newmaskt;
 		  if (shift_type != TREE_TYPE (arg0))
 		    {
-		      tem = fold_build2 (TREE_CODE (arg0), shift_type,
+		      tem = fold_build2_loc (loc, TREE_CODE (arg0), shift_type,
-					 fold_convert (shift_type,
+					 fold_convert_loc (loc, shift_type,
-						       TREE_OPERAND (arg0, 0)),
+							   TREE_OPERAND (arg0, 0)),
 					 TREE_OPERAND (arg0, 1));
-		      tem = fold_convert (type, tem);
+		      tem = fold_convert_loc (loc, type, tem);
 		    }
 		  else
 		    tem = op0;
 		  newmaskt = build_int_cst_type (TREE_TYPE (op1), newmask);
 		  if (!tree_int_cst_equal (newmaskt, arg1))
-		    return fold_build2 (BIT_AND_EXPR, type, tem, newmaskt);
+		    return fold_build2_loc (loc, BIT_AND_EXPR, type, tem, newmaskt);
 		}
 	    }
 	}
 goto associate;
 	  && ! HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (arg0)))
 	  && operand_equal_p (arg0, arg1, 0))
 	{
 	  tree r = build_real (TREE_TYPE (arg0), dconst1);
-	  return omit_two_operands (type, r, arg0, arg1);
+	  return omit_two_operands_loc (loc, type, r, arg0, arg1);
 	}
 /* The complex version of the above A / A optimization.  */
 if (COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0))
 	  && operand_equal_p (arg0, arg1, 0))
 	  if (! HONOR_NANS (TYPE_MODE (elem_type))
 	      && ! HONOR_INFINITIES (TYPE_MODE (elem_type)))
 	    {
 	      tree r = build_real (elem_type, dconst1);
 	      /* omit_two_operands will call fold_convert for us.  */
-	      return omit_two_operands (type, r, arg0, arg1);
+	      return omit_two_operands_loc (loc, type, r, arg0, arg1);
 	    }
 	}
 /* (-A) / (-B) -> A / B  */
 if (TREE_CODE (arg0) == NEGATE_EXPR && negate_expr_p (arg1))
-	return fold_build2 (RDIV_EXPR, type,
+	return fold_build2_loc (loc, RDIV_EXPR, type,
 			    TREE_OPERAND (arg0, 0),
 			    negate_expr (arg1));
 if (TREE_CODE (arg1) == NEGATE_EXPR && negate_expr_p (arg0))
-	return fold_build2 (RDIV_EXPR, type,
+	return fold_build2_loc (loc, RDIV_EXPR, type,
 			    negate_expr (arg0),
 			    TREE_OPERAND (arg1, 0));
 /* In IEEE floating point, x/1 is not equivalent to x for snans.  */
 if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
 	  && real_onep (arg1))
-	return non_lvalue (fold_convert (type, arg0));
+	return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
 /* In IEEE floating point, x/-1 is not equivalent to -x for snans.  */
 if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
 	  && real_minus_onep (arg1))
-	return non_lvalue (fold_convert (type, negate_expr (arg0)));
+	return non_lvalue_loc (loc, fold_convert_loc (loc, type,
+						  negate_expr (arg0)));
 /* If ARG1 is a constant, we can convert this to a multiply by the
 	 reciprocal.  This does not have the same rounding properties,
 	 so only do this if -freciprocal-math.  We can actually
 	 always safely do it if ARG1 is a power of two, but it's hard to
 if (TREE_CODE (arg1) == REAL_CST)
 	{
 	  if (flag_reciprocal_math
 	      && 0 != (tem = const_binop (code, build_real (type, dconst1),
 					  arg1, 0)))
-	    return fold_build2 (MULT_EXPR, type, arg0, tem);
+	    return fold_build2_loc (loc, MULT_EXPR, type, arg0, tem);
 	  /* Find the reciprocal if optimizing and the result is exact.  */
 	  if (optimize)
 	    {
 	      REAL_VALUE_TYPE r;
 	      r = TREE_REAL_CST (arg1);
 	      if (exact_real_inverse (TYPE_MODE(TREE_TYPE(arg0)), &r))
 		{
 		  tem = build_real (type, r);
-		  return fold_build2 (MULT_EXPR, type,
+		  return fold_build2_loc (loc, MULT_EXPR, type,
-				      fold_convert (type, arg0), tem);
+				      fold_convert_loc (loc, type, arg0), tem);
 		}
 	    }
 	}
 /* Convert A/B/C to A/(B*C).  */
 if (flag_reciprocal_math
 	  && TREE_CODE (arg0) == RDIV_EXPR)
-	return fold_build2 (RDIV_EXPR, type, TREE_OPERAND (arg0, 0),
+	return fold_build2_loc (loc, RDIV_EXPR, type, TREE_OPERAND (arg0, 0),
-			    fold_build2 (MULT_EXPR, type,
+			    fold_build2_loc (loc, MULT_EXPR, type,
 					 TREE_OPERAND (arg0, 1), arg1));
 /* Convert A/(B/C) to (A/B)*C.  */
 if (flag_reciprocal_math
 	  && TREE_CODE (arg1) == RDIV_EXPR)
-	return fold_build2 (MULT_EXPR, type,
+	return fold_build2_loc (loc, MULT_EXPR, type,
-			    fold_build2 (RDIV_EXPR, type, arg0,
+			    fold_build2_loc (loc, RDIV_EXPR, type, arg0,
 					 TREE_OPERAND (arg1, 0)),
 			    TREE_OPERAND (arg1, 1));
 /* Convert C1/(X*C2) into (C1/C2)/X.  */
 if (flag_reciprocal_math
 	  && TREE_CODE (TREE_OPERAND (arg1, 1)) == REAL_CST)
 	{
 	  tree tem = const_binop (RDIV_EXPR, arg0,
 				  TREE_OPERAND (arg1, 1), 0);
 	  if (tem)
-	    return fold_build2 (RDIV_EXPR, type, tem,
+	    return fold_build2_loc (loc, RDIV_EXPR, type, tem,
 				TREE_OPERAND (arg1, 0));
 	}
 if (flag_unsafe_math_optimizations)
 	{
 				  CALL_EXPR_ARG (arg1, 0), 0))
 	    {
 	      tree tanfn = mathfn_built_in (type, BUILT_IN_TAN);
 	      if (tanfn != NULL_TREE)
-		return build_call_expr (tanfn, 1, CALL_EXPR_ARG (arg0, 0));
+		return build_call_expr_loc (loc, tanfn, 1, CALL_EXPR_ARG (arg0, 0));
 	    }
 	  /* Optimize cos(x)/sin(x) as 1.0/tan(x).  */
 	  if (((fcode0 == BUILT_IN_COS && fcode1 == BUILT_IN_SIN)
 	       || (fcode0 == BUILT_IN_COSF && fcode1 == BUILT_IN_SINF)
 	    {
 	      tree tanfn = mathfn_built_in (type, BUILT_IN_TAN);
 	      if (tanfn != NULL_TREE)
 		{
-		  tree tmp = build_call_expr (tanfn, 1, CALL_EXPR_ARG (arg0, 0));
+		  tree tmp = build_call_expr_loc (loc, tanfn, 1,
-		  return fold_build2 (RDIV_EXPR, type,
+					      CALL_EXPR_ARG (arg0, 0));
+		  return fold_build2_loc (loc, RDIV_EXPR, type,
 				      build_real (type, dconst1), tmp);
 		}
 	    }
 	  /* Optimize sin(x)/tan(x) as cos(x) if we don't care about
 		  && operand_equal_p (arg00, arg01, 0))
 		{
 		  tree cosfn = mathfn_built_in (type, BUILT_IN_COS);
 		  if (cosfn != NULL_TREE)
-		    return build_call_expr (cosfn, 1, arg00);
+		    return build_call_expr_loc (loc, cosfn, 1, arg00);
 		}
 	    }
 	  /* Optimize tan(x)/sin(x) as 1.0/cos(x) if we don't care about
 	     NaNs or Infinities.  */
 		{
 		  tree cosfn = mathfn_built_in (type, BUILT_IN_COS);
 		  if (cosfn != NULL_TREE)
 		    {
-		      tree tmp = build_call_expr (cosfn, 1, arg00);
+		      tree tmp = build_call_expr_loc (loc, cosfn, 1, arg00);
-		      return fold_build2 (RDIV_EXPR, type,
+		      return fold_build2_loc (loc, RDIV_EXPR, type,
 					  build_real (type, dconst1),
 					  tmp);
 		    }
 		}
 	    }
 		  tree arg;
 		  c = TREE_REAL_CST (arg01);
 		  real_arithmetic (&c, MINUS_EXPR, &c, &dconst1);
 		  arg = build_real (type, c);
-		  return build_call_expr (powfn, 2, arg1, arg);
+		  return build_call_expr_loc (loc, powfn, 2, arg1, arg);
 		}
 	    }
 	  /* Optimize a/root(b/c) into a*root(c/b).  */
 	  if (BUILTIN_ROOT_P (fcode1))
 		{
 		  tree rootfn = TREE_OPERAND (CALL_EXPR_FN (arg1), 0);
 		  tree b = TREE_OPERAND (rootarg, 0);
 		  tree c = TREE_OPERAND (rootarg, 1);
-		  tree tmp = fold_build2 (RDIV_EXPR, type, c, b);
+		  tree tmp = fold_build2_loc (loc, RDIV_EXPR, type, c, b);
-		  tmp = build_call_expr (rootfn, 1, tmp);
+		  tmp = build_call_expr_loc (loc, rootfn, 1, tmp);
-		  return fold_build2 (MULT_EXPR, type, arg0, tmp);
+		  return fold_build2_loc (loc, MULT_EXPR, type, arg0, tmp);
 		}
 	    }
 	  /* Optimize x/expN(y) into x*expN(-y).  */
 	  if (BUILTIN_EXPONENT_P (fcode1))
 	    {
 	      tree expfn = TREE_OPERAND (CALL_EXPR_FN (arg1), 0);
 	      tree arg = negate_expr (CALL_EXPR_ARG (arg1, 0));
-	      arg1 = build_call_expr (expfn, 1, fold_convert (type, arg));
+	      arg1 = build_call_expr_loc (loc,
-	      return fold_build2 (MULT_EXPR, type, arg0, arg1);
+				      expfn, 1,
+				      fold_convert_loc (loc, type, arg));
+	      return fold_build2_loc (loc, MULT_EXPR, type, arg0, arg1);
 	    }
 	  /* Optimize x/pow(y,z) into x*pow(y,-z).  */
 	  if (fcode1 == BUILT_IN_POW
 	      || fcode1 == BUILT_IN_POWF
 	      || fcode1 == BUILT_IN_POWL)
 	    {
 	      tree powfn = TREE_OPERAND (CALL_EXPR_FN (arg1), 0);
 	      tree arg10 = CALL_EXPR_ARG (arg1, 0);
 	      tree arg11 = CALL_EXPR_ARG (arg1, 1);
-	      tree neg11 = fold_convert (type, negate_expr (arg11));
+	      tree neg11 = fold_convert_loc (loc, type,
-	      arg1 = build_call_expr (powfn, 2, arg10, neg11);
+					     negate_expr (arg11));
-	      return fold_build2 (MULT_EXPR, type, arg0, arg1);
+	      arg1 = build_call_expr_loc (loc, powfn, 2, arg10, neg11);
+	      return fold_build2_loc (loc, MULT_EXPR, type, arg0, arg1);
 	    }
 	}
 return NULL_TREE;
 case TRUNC_DIV_EXPR:
 	      if (strict_overflow_p)
 		fold_overflow_warning (("assuming signed overflow does not "
 					"occur when simplifying A / (B << N)"),
 				       WARN_STRICT_OVERFLOW_MISC);
-	      sh_cnt = fold_build2 (PLUS_EXPR, TREE_TYPE (sh_cnt),
+	      sh_cnt = fold_build2_loc (loc, PLUS_EXPR, TREE_TYPE (sh_cnt),
 				    sh_cnt, build_int_cst (NULL_TREE, pow2));
-	      return fold_build2 (RSHIFT_EXPR, type,
+	      return fold_build2_loc (loc, RSHIFT_EXPR, type,
-				  fold_convert (type, arg0), sh_cnt);
+				  fold_convert_loc (loc, type, arg0), sh_cnt);
 	    }
 	}
 /* For unsigned integral types, FLOOR_DIV_EXPR is the same as
 	 TRUNC_DIV_EXPR.  Rewrite into the latter in this case.  */
 if (INTEGRAL_TYPE_P (type)
 	  && TYPE_UNSIGNED (type)
 	  && code == FLOOR_DIV_EXPR)
-	return fold_build2 (TRUNC_DIV_EXPR, type, op0, op1);
+	return fold_build2_loc (loc, TRUNC_DIV_EXPR, type, op0, op1);
 /* Fall thru */
 case ROUND_DIV_EXPR:
 case CEIL_DIV_EXPR:
 case EXACT_DIV_EXPR:
 if (integer_onep (arg1))
-	return non_lvalue (fold_convert (type, arg0));
+	return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
 if (integer_zerop (arg1))
 	return NULL_TREE;
 /* X / -1 is -X.  */
 if (!TYPE_UNSIGNED (type)
 	  && TREE_CODE (arg1) == INTEGER_CST
 	  && TREE_INT_CST_LOW (arg1) == (unsigned HOST_WIDE_INT) -1
 	  && TREE_INT_CST_HIGH (arg1) == -1)
-	return fold_convert (type, negate_expr (arg0));
+	return fold_convert_loc (loc, type, negate_expr (arg0));
 /* Convert -A / -B to A / B when the type is signed and overflow is
 	 undefined.  */
 if ((!INTEGRAL_TYPE_P (type) || TYPE_OVERFLOW_UNDEFINED (type))
 	  && TREE_CODE (arg0) == NEGATE_EXPR
 	  if (INTEGRAL_TYPE_P (type))
 	    fold_overflow_warning (("assuming signed overflow does not occur "
 				    "when distributing negation across "
 				    "division"),
 				   WARN_STRICT_OVERFLOW_MISC);
-	  return fold_build2 (code, type,
+	  return fold_build2_loc (loc, code, type,
-			      fold_convert (type, TREE_OPERAND (arg0, 0)),
+			      fold_convert_loc (loc, type,
-			      fold_convert (type, negate_expr (arg1)));
+						TREE_OPERAND (arg0, 0)),
+			      fold_convert_loc (loc, type,
+						negate_expr (arg1)));
 	}
 if ((!INTEGRAL_TYPE_P (type) || TYPE_OVERFLOW_UNDEFINED (type))
 	  && TREE_CODE (arg1) == NEGATE_EXPR
 	  && negate_expr_p (arg0))
 	{
 	  if (INTEGRAL_TYPE_P (type))
 	    fold_overflow_warning (("assuming signed overflow does not occur "
 				    "when distributing negation across "
 				    "division"),
 				   WARN_STRICT_OVERFLOW_MISC);
-	  return fold_build2 (code, type,
+	  return fold_build2_loc (loc, code, type,
-			      fold_convert (type, negate_expr (arg0)),
+			      fold_convert_loc (loc, type,
-			      fold_convert (type, TREE_OPERAND (arg1, 0)));
+						negate_expr (arg0)),
+			      fold_convert_loc (loc, type,
+						TREE_OPERAND (arg1, 0)));
 	}
 /* If arg0 is a multiple of arg1, then rewrite to the fastest div
 	 operation, EXACT_DIV_EXPR.
 	 Note that only CEIL_DIV_EXPR and FLOOR_DIV_EXPR are rewritten now.
 	 At one time others generated faster code, it's not clear if they do
 	 after the last round to changes to the DIV code in expmed.c.  */
 if ((code == CEIL_DIV_EXPR || code == FLOOR_DIV_EXPR)
 	  && multiple_of_p (type, arg0, arg1))
-	return fold_build2 (EXACT_DIV_EXPR, type, arg0, arg1);
+	return fold_build2_loc (loc, EXACT_DIV_EXPR, type, arg0, arg1);
 strict_overflow_p = false;
 if (TREE_CODE (arg1) == INTEGER_CST
 	  && 0 != (tem = extract_muldiv (op0, arg1, code, NULL_TREE,
 					 &strict_overflow_p)))
 	{
 	  if (strict_overflow_p)
 	    fold_overflow_warning (("assuming signed overflow does not occur "
 				    "when simplifying division"),
 				   WARN_STRICT_OVERFLOW_MISC);
-	  return fold_convert (type, tem);
+	  return fold_convert_loc (loc, type, tem);
 	}
 return NULL_TREE;
 case CEIL_MOD_EXPR:
 case ROUND_MOD_EXPR:
 case TRUNC_MOD_EXPR:
 /* X % 1 is always zero, but be sure to preserve any side
 	 effects in X.  */
 if (integer_onep (arg1))
-	return omit_one_operand (type, integer_zero_node, arg0);
+	return omit_one_operand_loc (loc, type, integer_zero_node, arg0);
 /* X % 0, return X % 0 unchanged so that we can get the
 	 proper warnings and errors.  */
 if (integer_zerop (arg1))
 	return NULL_TREE;
 /* 0 % X is always zero, but be sure to preserve any side
 	 effects in X.  Place this after checking for X == 0.  */
 if (integer_zerop (arg0))
-	return omit_one_operand (type, integer_zero_node, arg1);
+	return omit_one_operand_loc (loc, type, integer_zero_node, arg1);
 /* X % -1 is zero.  */
 if (!TYPE_UNSIGNED (type)
 	  && TREE_CODE (arg1) == INTEGER_CST
 	  && TREE_INT_CST_LOW (arg1) == (unsigned HOST_WIDE_INT) -1
 	  && TREE_INT_CST_HIGH (arg1) == -1)
-	return omit_one_operand (type, integer_zero_node, arg0);
+	return omit_one_operand_loc (loc, type, integer_zero_node, arg0);
 /* Optimize TRUNC_MOD_EXPR by a power of two into a BIT_AND_EXPR,
 i.e. "X % C" into "X & (C - 1)", if X and C are positive.  */
 strict_overflow_p = false;
 if ((code == TRUNC_MOD_EXPR || code == FLOOR_MOD_EXPR)
 	  if (TREE_CODE (arg1) == LSHIFT_EXPR)
 	    c = TREE_OPERAND (arg1, 0);
 	  if (integer_pow2p (c) && tree_int_cst_sgn (c) > 0)
 	    {
-	      tree mask = fold_build2 (MINUS_EXPR, TREE_TYPE (arg1), arg1,
+	      tree mask = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (arg1), arg1,
 				       build_int_cst (TREE_TYPE (arg1), 1));
 	      if (strict_overflow_p)
 		fold_overflow_warning (("assuming signed overflow does not "
 					"occur when simplifying "
 					"X % (power of two)"),
 				       WARN_STRICT_OVERFLOW_MISC);
-	      return fold_build2 (BIT_AND_EXPR, type,
+	      return fold_build2_loc (loc, BIT_AND_EXPR, type,
-				  fold_convert (type, arg0),
+				  fold_convert_loc (loc, type, arg0),
-				  fold_convert (type, mask));
+				  fold_convert_loc (loc, type, mask));
 	    }
 	}
 /* X % -C is the same as X % C.  */
 if (code == TRUNC_MOD_EXPR
 	  && !TREE_OVERFLOW (arg1)
 	  && TREE_INT_CST_HIGH (arg1) < 0
 	  && !TYPE_OVERFLOW_TRAPS (type)
 	  /* Avoid this transformation if C is INT_MIN, i.e. C == -C.  */
 	  && !sign_bit_p (arg1, arg1))
-	return fold_build2 (code, type, fold_convert (type, arg0),
+	return fold_build2_loc (loc, code, type,
-			    fold_convert (type, negate_expr (arg1)));
+			    fold_convert_loc (loc, type, arg0),
+			    fold_convert_loc (loc, type,
+					      negate_expr (arg1)));
 /* X % -Y is the same as X % Y.  */
 if (code == TRUNC_MOD_EXPR
 	  && !TYPE_UNSIGNED (type)
 	  && TREE_CODE (arg1) == NEGATE_EXPR
 	  && !TYPE_OVERFLOW_TRAPS (type))
-	return fold_build2 (code, type, fold_convert (type, arg0),
+	return fold_build2_loc (loc, code, type, fold_convert_loc (loc, type, arg0),
-			    fold_convert (type, TREE_OPERAND (arg1, 0)));
+			    fold_convert_loc (loc, type,
+					      TREE_OPERAND (arg1, 0)));
 if (TREE_CODE (arg1) == INTEGER_CST
 	  && 0 != (tem = extract_muldiv (op0, arg1, code, NULL_TREE,
 					 &strict_overflow_p)))
 	{
 	  if (strict_overflow_p)
 	    fold_overflow_warning (("assuming signed overflow does not occur "
 				    "when simplifying modulus"),
 				   WARN_STRICT_OVERFLOW_MISC);
-	  return fold_convert (type, tem);
+	  return fold_convert_loc (loc, type, tem);
 	}
 return NULL_TREE;
 case LROTATE_EXPR:
 case RROTATE_EXPR:
 if (integer_all_onesp (arg0))
-	return omit_one_operand (type, arg0, arg1);
+	return omit_one_operand_loc (loc, type, arg0, arg1);
 goto shift;
 case RSHIFT_EXPR:
 /* Optimize -1 >> x for arithmetic right shifts.  */
 if (integer_all_onesp (arg0) && !TYPE_UNSIGNED (type)
 	  && tree_expr_nonnegative_p (arg1))
-	return omit_one_operand (type, arg0, arg1);
+	return omit_one_operand_loc (loc, type, arg0, arg1);
 /* ... fall through ...  */
 case LSHIFT_EXPR:
 shift:
 if (integer_zerop (arg1))
-	return non_lvalue (fold_convert (type, arg0));
+	return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
 if (integer_zerop (arg0))
-	return omit_one_operand (type, arg0, arg1);
+	return omit_one_operand_loc (loc, type, arg0, arg1);
 /* Since negative shift count is not well-defined,
 	 don't try to compute it in the compiler.  */
 if (TREE_CODE (arg1) == INTEGER_CST && tree_int_cst_sgn (arg1) < 0)
 	return NULL_TREE;
 	  if (low >= TYPE_PRECISION (type))
 	    {
 	      if (code == LROTATE_EXPR || code == RROTATE_EXPR)
 	        low = low % TYPE_PRECISION (type);
 	      else if (TYPE_UNSIGNED (type) || code == LSHIFT_EXPR)
-		return omit_one_operand (type, build_int_cst (type, 0),
+		return omit_one_operand_loc (loc, type, build_int_cst (type, 0),
 					 TREE_OPERAND (arg0, 0));
 	      else
 		low = TYPE_PRECISION (type) - 1;
 	    }
-	  return fold_build2 (code, type, TREE_OPERAND (arg0, 0),
+	  return fold_build2_loc (loc, code, type, TREE_OPERAND (arg0, 0),
 			      build_int_cst (type, low));
 	}
 /* Transform (x >> c) << c into x & (-1<<c), or transform (x << c) >> c
 into x & ((unsigned)-1 >> c) for unsigned types.  */
 	  tree lshift;
 	  tree arg00;
 	  if (low0 == low1)
 	    {
-	      arg00 = fold_convert (type, TREE_OPERAND (arg0, 0));
+	      arg00 = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0));
 	      lshift = build_int_cst (type, -1);
 	      lshift = int_const_binop (code, lshift, arg1, 0);
-	      return fold_build2 (BIT_AND_EXPR, type, arg00, lshift);
+	      return fold_build2_loc (loc, BIT_AND_EXPR, type, arg00, lshift);
 	    }
 	}
 /* Rewrite an LROTATE_EXPR by a constant into an
 	 RROTATE_EXPR by a new constant.  */
 if (code == LROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST)
 	{
 	  tree tem = build_int_cst (TREE_TYPE (arg1),
 				    TYPE_PRECISION (type));
 	  tem = const_binop (MINUS_EXPR, tem, arg1, 0);
-	  return fold_build2 (RROTATE_EXPR, type, op0, tem);
+	  return fold_build2_loc (loc, RROTATE_EXPR, type, op0, tem);
 	}
 /* If we have a rotate of a bit operation with the rotate count and
 	 the second operand of the bit operation both constant,
 	 permute the two operations.  */
 if (code == RROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST
 	  && (TREE_CODE (arg0) == BIT_AND_EXPR
 	      || TREE_CODE (arg0) == BIT_IOR_EXPR
 	      || TREE_CODE (arg0) == BIT_XOR_EXPR)
 	  && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
-	return fold_build2 (TREE_CODE (arg0), type,
+	return fold_build2_loc (loc, TREE_CODE (arg0), type,
-			    fold_build2 (code, type,
+			    fold_build2_loc (loc, code, type,
 					 TREE_OPERAND (arg0, 0), arg1),
-			    fold_build2 (code, type,
+			    fold_build2_loc (loc, code, type,
 					 TREE_OPERAND (arg0, 1), arg1));
 /* Two consecutive rotates adding up to the precision of the
 	 type can be ignored.  */
 if (code == RROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST
 if ((code == LSHIFT_EXPR || code == RSHIFT_EXPR)
 	  && TREE_CODE (arg0) == BIT_AND_EXPR
 	  && TREE_CODE (arg1) == INTEGER_CST
 	  && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
 	{
-	  tree mask = fold_build2 (code, type,
+	  tree mask = fold_build2_loc (loc, code, type,
-				   fold_convert (type, TREE_OPERAND (arg0, 1)),
+				   fold_convert_loc (loc, type,
+						     TREE_OPERAND (arg0, 1)),
 				   arg1);
-	  tree shift = fold_build2 (code, type,
+	  tree shift = fold_build2_loc (loc, code, type,
-				    fold_convert (type, TREE_OPERAND (arg0, 0)),
+				    fold_convert_loc (loc, type,
+						      TREE_OPERAND (arg0, 0)),
 				    arg1);
-	  tem = fold_binary (BIT_AND_EXPR, type, shift, mask);
+	  tem = fold_binary_loc (loc, BIT_AND_EXPR, type, shift, mask);
 	  if (tem)
 	    return tem;
 	}
 return NULL_TREE;
 case MIN_EXPR:
 if (operand_equal_p (arg0, arg1, 0))
-	return omit_one_operand (type, arg0, arg1);
+	return omit_one_operand_loc (loc, type, arg0, arg1);
 if (INTEGRAL_TYPE_P (type)
 	  && operand_equal_p (arg1, TYPE_MIN_VALUE (type), OEP_ONLY_CONST))
-	return omit_one_operand (type, arg1, arg0);
+	return omit_one_operand_loc (loc, type, arg1, arg0);
-tem = fold_minmax (MIN_EXPR, type, arg0, arg1);
+tem = fold_minmax (loc, MIN_EXPR, type, arg0, arg1);
 if (tem)
 	return tem;
 goto associate;
 case MAX_EXPR:
 if (operand_equal_p (arg0, arg1, 0))
-	return omit_one_operand (type, arg0, arg1);
+	return omit_one_operand_loc (loc, type, arg0, arg1);
 if (INTEGRAL_TYPE_P (type)
 	  && TYPE_MAX_VALUE (type)
 	  && operand_equal_p (arg1, TYPE_MAX_VALUE (type), OEP_ONLY_CONST))
-	return omit_one_operand (type, arg1, arg0);
+	return omit_one_operand_loc (loc, type, arg1, arg0);
-tem = fold_minmax (MAX_EXPR, type, arg0, arg1);
+tem = fold_minmax (loc, MAX_EXPR, type, arg0, arg1);
 if (tem)
 	return tem;
 goto associate;
 case TRUTH_ANDIF_EXPR:
 /* Note that the operands of this must be ints
 	 and their values must be 0 or 1.
 	 ("true" is a fixed value perhaps depending on the language.)  */
 /* If first arg is constant zero, return it.  */
 if (integer_zerop (arg0))
-	return fold_convert (type, arg0);
+	return fold_convert_loc (loc, type, arg0);
 case TRUTH_AND_EXPR:
 /* If either arg is constant true, drop it.  */
 if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
-	return non_lvalue (fold_convert (type, arg1));
+	return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg1));
 if (TREE_CODE (arg1) == INTEGER_CST && ! integer_zerop (arg1)
 	  /* Preserve sequence points.  */
 	  && (code != TRUTH_ANDIF_EXPR || ! TREE_SIDE_EFFECTS (arg0)))
-	return non_lvalue (fold_convert (type, arg0));
+	return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
 /* If second arg is constant zero, result is zero, but first arg
 	 must be evaluated.  */
 if (integer_zerop (arg1))
-	return omit_one_operand (type, arg1, arg0);
+	return omit_one_operand_loc (loc, type, arg1, arg0);
 /* Likewise for first arg, but note that only the TRUTH_AND_EXPR
 	 case will be handled here.  */
 if (integer_zerop (arg0))
-	return omit_one_operand (type, arg0, arg1);
+	return omit_one_operand_loc (loc, type, arg0, arg1);
 /* !X && X is always false.  */
 if (TREE_CODE (arg0) == TRUTH_NOT_EXPR
 	  && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
-	return omit_one_operand (type, integer_zero_node, arg1);
+	return omit_one_operand_loc (loc, type, integer_zero_node, arg1);
 /* X && !X is always false.  */
 if (TREE_CODE (arg1) == TRUTH_NOT_EXPR
 	  && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
-	return omit_one_operand (type, integer_zero_node, arg0);
+	return omit_one_operand_loc (loc, type, integer_zero_node, arg0);
 /* A < X && A + 1 > Y ==> A < X && A >= Y.  Normally A + 1 > Y
 	 means A >= Y && A != MAX, but in this case we know that
 	 A < X <= MAX.  */
 if (!TREE_SIDE_EFFECTS (arg0)
 	  && !TREE_SIDE_EFFECTS (arg1))
 	{
-	  tem = fold_to_nonsharp_ineq_using_bound (arg0, arg1);
+	  tem = fold_to_nonsharp_ineq_using_bound (loc, arg0, arg1);
 	  if (tem && !operand_equal_p (tem, arg0, 0))
-	    return fold_build2 (code, type, tem, arg1);
+	    return fold_build2_loc (loc, code, type, tem, arg1);
-	  tem = fold_to_nonsharp_ineq_using_bound (arg1, arg0);
+	  tem = fold_to_nonsharp_ineq_using_bound (loc, arg1, arg0);
 	  if (tem && !operand_equal_p (tem, arg1, 0))
-	    return fold_build2 (code, type, arg0, tem);
+	    return fold_build2_loc (loc, code, type, arg0, tem);
 	}
 truth_andor:
 /* We only do these simplifications if we are optimizing.  */
 if (!optimize)
 			      || TREE_CODE (arg0) == TRUTH_AND_EXPR)
 			     && (code == TRUTH_AND_EXPR
 				 || code == TRUTH_OR_EXPR));
 	  if (operand_equal_p (a00, a10, 0))
-	    return fold_build2 (TREE_CODE (arg0), type, a00,
+	    return fold_build2_loc (loc, TREE_CODE (arg0), type, a00,
-				fold_build2 (code, type, a01, a11));
+				fold_build2_loc (loc, code, type, a01, a11));
 	  else if (commutative && operand_equal_p (a00, a11, 0))
-	    return fold_build2 (TREE_CODE (arg0), type, a00,
+	    return fold_build2_loc (loc, TREE_CODE (arg0), type, a00,
-				fold_build2 (code, type, a01, a10));
+				fold_build2_loc (loc, code, type, a01, a10));
 	  else if (commutative && operand_equal_p (a01, a10, 0))
-	    return fold_build2 (TREE_CODE (arg0), type, a01,
+	    return fold_build2_loc (loc, TREE_CODE (arg0), type, a01,
-				fold_build2 (code, type, a00, a11));
+				fold_build2_loc (loc, code, type, a00, a11));
 	  /* This case if tricky because we must either have commutative
 	     operators or else A10 must not have side-effects.  */
 	  else if ((commutative || ! TREE_SIDE_EFFECTS (a10))
 		   && operand_equal_p (a01, a11, 0))
-	    return fold_build2 (TREE_CODE (arg0), type,
+	    return fold_build2_loc (loc, TREE_CODE (arg0), type,
-				fold_build2 (code, type, a00, a10),
+				fold_build2_loc (loc, code, type, a00, a10),
 				a01);
 	}
 /* See if we can build a range comparison.  */
-if (0 != (tem = fold_range_test (code, type, op0, op1)))
+if (0 != (tem = fold_range_test (loc, code, type, op0, op1)))
 	return tem;
 /* Check for the possibility of merging component references.  If our
 	 lhs is another similar operation, try to merge its rhs with our
 	 rhs.  Then try to merge our lhs and rhs.  */
 if (TREE_CODE (arg0) == code
-	  && 0 != (tem = fold_truthop (code, type,
+	  && 0 != (tem = fold_truthop (loc, code, type,
 				       TREE_OPERAND (arg0, 1), arg1)))
-	return fold_build2 (code, type, TREE_OPERAND (arg0, 0), tem);
+	return fold_build2_loc (loc, code, type, TREE_OPERAND (arg0, 0), tem);
-if ((tem = fold_truthop (code, type, arg0, arg1)) != 0)
+if ((tem = fold_truthop (loc, code, type, arg0, arg1)) != 0)
 	return tem;
 return NULL_TREE;
 case TRUTH_ORIF_EXPR:
 /* Note that the operands of this must be ints
 	 and their values must be 0 or true.
 	 ("true" is a fixed value perhaps depending on the language.)  */
 /* If first arg is constant true, return it.  */
 if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
-	return fold_convert (type, arg0);
+	return fold_convert_loc (loc, type, arg0);
 case TRUTH_OR_EXPR:
 /* If either arg is constant zero, drop it.  */
 if (TREE_CODE (arg0) == INTEGER_CST && integer_zerop (arg0))
-	return non_lvalue (fold_convert (type, arg1));
+	return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg1));
 if (TREE_CODE (arg1) == INTEGER_CST && integer_zerop (arg1)
 	  /* Preserve sequence points.  */
 	  && (code != TRUTH_ORIF_EXPR || ! TREE_SIDE_EFFECTS (arg0)))
-	return non_lvalue (fold_convert (type, arg0));
+	return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
 /* If second arg is constant true, result is true, but we must
 	 evaluate first arg.  */
 if (TREE_CODE (arg1) == INTEGER_CST && ! integer_zerop (arg1))
-	return omit_one_operand (type, arg1, arg0);
+	return omit_one_operand_loc (loc, type, arg1, arg0);
 /* Likewise for first arg, but note this only occurs here for
 	 TRUTH_OR_EXPR.  */
 if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
-	return omit_one_operand (type, arg0, arg1);
+	return omit_one_operand_loc (loc, type, arg0, arg1);
 /* !X || X is always true.  */
 if (TREE_CODE (arg0) == TRUTH_NOT_EXPR
 	  && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
-	return omit_one_operand (type, integer_one_node, arg1);
+	return omit_one_operand_loc (loc, type, integer_one_node, arg1);
 /* X || !X is always true.  */
 if (TREE_CODE (arg1) == TRUTH_NOT_EXPR
 	  && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
-	return omit_one_operand (type, integer_one_node, arg0);
+	return omit_one_operand_loc (loc, type, integer_one_node, arg0);
 goto truth_andor;
 case TRUTH_XOR_EXPR:
 /* If the second arg is constant zero, drop it.  */
 if (integer_zerop (arg1))
-	return non_lvalue (fold_convert (type, arg0));
+	return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
 /* If the second arg is constant true, this is a logical inversion.  */
 if (integer_onep (arg1))
 	{
 	  /* Only call invert_truthvalue if operand is a truth value.  */
 	  if (TREE_CODE (TREE_TYPE (arg0)) != BOOLEAN_TYPE)
-	    tem = fold_build1 (TRUTH_NOT_EXPR, TREE_TYPE (arg0), arg0);
+	    tem = fold_build1_loc (loc, TRUTH_NOT_EXPR, TREE_TYPE (arg0), arg0);
 	  else
-	    tem = invert_truthvalue (arg0);
+	    tem = invert_truthvalue_loc (loc, arg0);
-	  return non_lvalue (fold_convert (type, tem));
+	  return non_lvalue_loc (loc, fold_convert_loc (loc, type, tem));
 	}
 /* Identical arguments cancel to zero.  */
 if (operand_equal_p (arg0, arg1, 0))
-	return omit_one_operand (type, integer_zero_node, arg0);
+	return omit_one_operand_loc (loc, type, integer_zero_node, arg0);
 /* !X ^ X is always true.  */
 if (TREE_CODE (arg0) == TRUTH_NOT_EXPR
 	  && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
-	return omit_one_operand (type, integer_one_node, arg1);
+	return omit_one_operand_loc (loc, type, integer_one_node, arg1);
 /* X ^ !X is always true.  */
 if (TREE_CODE (arg1) == TRUTH_NOT_EXPR
 	  && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
-	return omit_one_operand (type, integer_one_node, arg0);
+	return omit_one_operand_loc (loc, type, integer_one_node, arg0);
 return NULL_TREE;
 case EQ_EXPR:
 case NE_EXPR:
-tem = fold_comparison (code, type, op0, op1);
+tem = fold_comparison (loc, code, type, op0, op1);
 if (tem != NULL_TREE)
 	return tem;
 /* bool_var != 0 becomes bool_var. */
 if (TREE_CODE (TREE_TYPE (arg0)) == BOOLEAN_TYPE && integer_zerop (arg1)
 && code == NE_EXPR)
-return non_lvalue (fold_convert (type, arg0));
+return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
 /* bool_var == 1 becomes bool_var. */
 if (TREE_CODE (TREE_TYPE (arg0)) == BOOLEAN_TYPE && integer_onep (arg1)
 && code == EQ_EXPR)
-return non_lvalue (fold_convert (type, arg0));
+return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
 /* bool_var != 1 becomes !bool_var. */
 if (TREE_CODE (TREE_TYPE (arg0)) == BOOLEAN_TYPE && integer_onep (arg1)
 && code == NE_EXPR)
-return fold_build1 (TRUTH_NOT_EXPR, type, fold_convert (type, arg0));
+return fold_build1_loc (loc, TRUTH_NOT_EXPR, type,
+			    fold_convert_loc (loc, type, arg0));
 /* bool_var == 0 becomes !bool_var. */
 if (TREE_CODE (TREE_TYPE (arg0)) == BOOLEAN_TYPE && integer_zerop (arg1)
 && code == EQ_EXPR)
-return fold_build1 (TRUTH_NOT_EXPR, type, fold_convert (type, arg0));
+return fold_build1_loc (loc, TRUTH_NOT_EXPR, type,
+			    fold_convert_loc (loc, type, arg0));
+/* !exp != 0 becomes !exp */
+if (TREE_CODE (arg0) == TRUTH_NOT_EXPR && integer_zerop (arg1)
+	  && code == NE_EXPR)
+return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
 /* If this is an equality comparison of the address of two non-weak,
 	 unaliased symbols neither of which are extern (since we do not
 	 have access to attributes for externs), then we know the result.  */
 if (TREE_CODE (arg0) == ADDR_EXPR
 	  && (TREE_CODE (arg0) == PLUS_EXPR
 	      || TREE_CODE (arg0) == MINUS_EXPR)
 	  && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
 	  && 0 != (tem = const_binop (TREE_CODE (arg0) == PLUS_EXPR
 				      ? MINUS_EXPR : PLUS_EXPR,
-				      fold_convert (TREE_TYPE (arg0), arg1),
+				      fold_convert_loc (loc, TREE_TYPE (arg0),
+							arg1),
 				      TREE_OPERAND (arg0, 1), 0))
 	  && !TREE_OVERFLOW (tem))
-	return fold_build2 (code, type, TREE_OPERAND (arg0, 0), tem);
+	return fold_build2_loc (loc, code, type, TREE_OPERAND (arg0, 0), tem);
 /* Similarly for a NEGATE_EXPR.  */
 if (TREE_CODE (arg0) == NEGATE_EXPR
 	  && TREE_CODE (arg1) == INTEGER_CST
 	  && 0 != (tem = negate_expr (arg1))
 	  && TREE_CODE (tem) == INTEGER_CST
 	  && !TREE_OVERFLOW (tem))
-	return fold_build2 (code, type, TREE_OPERAND (arg0, 0), tem);
+	return fold_build2_loc (loc, code, type, TREE_OPERAND (arg0, 0), tem);
 /* Similarly for a BIT_XOR_EXPR;  X ^ C1 == C2 is X == (C1 ^ C2).  */
 if (TREE_CODE (arg0) == BIT_XOR_EXPR
 	  && TREE_CODE (arg1) == INTEGER_CST
 	  && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
-	return fold_build2 (code, type, TREE_OPERAND (arg0, 0),
+	return fold_build2_loc (loc, code, type, TREE_OPERAND (arg0, 0),
-			    fold_build2 (BIT_XOR_EXPR, TREE_TYPE (arg0),
+			    fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (arg0),
-					 fold_convert (TREE_TYPE (arg0), arg1),
+					 fold_convert_loc (loc,
+							   TREE_TYPE (arg0),
+							   arg1),
 					 TREE_OPERAND (arg0, 1)));
-/* Transform comparisons of the form X +- C CMP X.  */
+/* Transform comparisons of the form X +- Y CMP X to Y CMP 0.  */
-if ((TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
+if ((TREE_CODE (arg0) == PLUS_EXPR
+	   || TREE_CODE (arg0) == POINTER_PLUS_EXPR
+	   || TREE_CODE (arg0) == MINUS_EXPR)
 	  && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0)
-	  && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
 	  && (INTEGRAL_TYPE_P (TREE_TYPE (arg0))
 	      || POINTER_TYPE_P (TREE_TYPE (arg0))))
 	{
-	  tree cst = TREE_OPERAND (arg0, 1);
+	  tree val = TREE_OPERAND (arg0, 1);
+	  return omit_two_operands_loc (loc, type,
-	  if (code == EQ_EXPR
+				    fold_build2_loc (loc, code, type,
-	      && !integer_zerop (cst))
+						 val,
-	    return omit_two_operands (type, boolean_false_node,
+						 build_int_cst (TREE_TYPE (val),
-				      TREE_OPERAND (arg0, 0), arg1);
+								0)),
-	  else
+				    TREE_OPERAND (arg0, 0), arg1);
-	    return omit_two_operands (type, boolean_true_node,
+	}
-				      TREE_OPERAND (arg0, 0), arg1);
+/* Transform comparisons of the form C - X CMP X if C % 2 == 1.  */
+if (TREE_CODE (arg0) == MINUS_EXPR
+	  && TREE_CODE (TREE_OPERAND (arg0, 0)) == INTEGER_CST
+	  && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0)
+	  && (TREE_INT_CST_LOW (TREE_OPERAND (arg0, 0)) & 1) == 1)
+	{
+	  return omit_two_operands_loc (loc, type,
+				    code == NE_EXPR
+				    ? boolean_true_node : boolean_false_node,
+				    TREE_OPERAND (arg0, 1), arg1);
 	}
 /* If we have X - Y == 0, we can convert that to X == Y and similarly
 	 for !=.  Don't do this for ordered comparisons due to overflow.  */
 if (TREE_CODE (arg0) == MINUS_EXPR
 	  && integer_zerop (arg1))
-	return fold_build2 (code, type,
+	return fold_build2_loc (loc, code, type,
 			    TREE_OPERAND (arg0, 0), TREE_OPERAND (arg0, 1));
 /* Convert ABS_EXPR<x> == 0 or ABS_EXPR<x> != 0 to x == 0 or x != 0.  */
 if (TREE_CODE (arg0) == ABS_EXPR
 	  && (integer_zerop (arg1) || real_zerop (arg1)))
-	return fold_build2 (code, type, TREE_OPERAND (arg0, 0), arg1);
+	return fold_build2_loc (loc, code, type, TREE_OPERAND (arg0, 0), arg1);
 /* If this is an EQ or NE comparison with zero and ARG0 is
 	 (1 << foo) & bar, convert it to (bar >> foo) & 1.  Both require
 	 two operations, but the latter can be done in one less insn
 	 on machines that have only two-operand insns or on which a
 	  tree arg00 = TREE_OPERAND (arg0, 0);
 	  tree arg01 = TREE_OPERAND (arg0, 1);
 	  if (TREE_CODE (arg00) == LSHIFT_EXPR
 	      && integer_onep (TREE_OPERAND (arg00, 0)))
 	    {
-	      tree tem = fold_build2 (RSHIFT_EXPR, TREE_TYPE (arg00),
+	      tree tem = fold_build2_loc (loc, RSHIFT_EXPR, TREE_TYPE (arg00),
 				      arg01, TREE_OPERAND (arg00, 1));
-	      tem = fold_build2 (BIT_AND_EXPR, TREE_TYPE (arg0), tem,
+	      tem = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (arg0), tem,
 				 build_int_cst (TREE_TYPE (arg0), 1));
-	      return fold_build2 (code, type,
+	      return fold_build2_loc (loc, code, type,
-				  fold_convert (TREE_TYPE (arg1), tem), arg1);
+				  fold_convert_loc (loc, TREE_TYPE (arg1), tem),
+				  arg1);
 	    }
 	  else if (TREE_CODE (arg01) == LSHIFT_EXPR
 		   && integer_onep (TREE_OPERAND (arg01, 0)))
 	    {
-	      tree tem = fold_build2 (RSHIFT_EXPR, TREE_TYPE (arg01),
+	      tree tem = fold_build2_loc (loc, RSHIFT_EXPR, TREE_TYPE (arg01),
 				      arg00, TREE_OPERAND (arg01, 1));
-	      tem = fold_build2 (BIT_AND_EXPR, TREE_TYPE (arg0), tem,
+	      tem = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (arg0), tem,
 				 build_int_cst (TREE_TYPE (arg0), 1));
-	      return fold_build2 (code, type,
+	      return fold_build2_loc (loc, code, type,
-				  fold_convert (TREE_TYPE (arg1), tem), arg1);
+				  fold_convert_loc (loc, TREE_TYPE (arg1), tem),
+				  arg1);
 	    }
 	}
 /* If this is an NE or EQ comparison of zero against the result of a
 	 signed MOD operation whose second operand is a power of 2, make
 	      || TREE_CODE (arg0) == FLOOR_MOD_EXPR
 	      || TREE_CODE (arg0) == ROUND_MOD_EXPR)
 	  && integer_pow2p (TREE_OPERAND (arg0, 1)))
 	{
 	  tree newtype = unsigned_type_for (TREE_TYPE (arg0));
-	  tree newmod = fold_build2 (TREE_CODE (arg0), newtype,
+	  tree newmod = fold_build2_loc (loc, TREE_CODE (arg0), newtype,
-				     fold_convert (newtype,
+				     fold_convert_loc (loc, newtype,
-						   TREE_OPERAND (arg0, 0)),
+						       TREE_OPERAND (arg0, 0)),
-				     fold_convert (newtype,
+				     fold_convert_loc (loc, newtype,
-						   TREE_OPERAND (arg0, 1)));
+						       TREE_OPERAND (arg0, 1)));
-	  return fold_build2 (code, type, newmod,
+	  return fold_build2_loc (loc, code, type, newmod,
-			      fold_convert (newtype, arg1));
+			      fold_convert_loc (loc, newtype, arg1));
 	}
 /* Fold ((X >> C1) & C2) == 0 and ((X >> C1) & C2) != 0 where
 	 C1 is a valid shift constant, and C2 is a power of two, i.e.
 	 a single bit.  */
 	      unsigned HOST_WIDE_INT log2 = tree_log2 (arg01);
 	      /* If (C2 << C1) doesn't overflow, then ((X >> C1) & C2) != 0
 		 can be rewritten as (X & (C2 << C1)) != 0.  */
 	      if ((log2 + TREE_INT_CST_LOW (arg001)) < prec)
 		{
-		  tem = fold_build2 (LSHIFT_EXPR, itype, arg01, arg001);
+		  tem = fold_build2_loc (loc, LSHIFT_EXPR, itype, arg01, arg001);
-		  tem = fold_build2 (BIT_AND_EXPR, itype, arg000, tem);
+		  tem = fold_build2_loc (loc, BIT_AND_EXPR, itype, arg000, tem);
-		  return fold_build2 (code, type, tem, arg1);
+		  return fold_build2_loc (loc, code, type, tem, arg1);
 		}
 	      /* Otherwise, for signed (arithmetic) shifts,
 		 ((X >> C1) & C2) != 0 is rewritten as X < 0, and
 		 ((X >> C1) & C2) == 0 is rewritten as X >= 0.  */
 	      else if (!TYPE_UNSIGNED (itype))
-		return fold_build2 (code == EQ_EXPR ? GE_EXPR : LT_EXPR, type,
+		return fold_build2_loc (loc, code == EQ_EXPR ? GE_EXPR : LT_EXPR, type,
 				    arg000, build_int_cst (itype, 0));
 	      /* Otherwise, of unsigned (logical) shifts,
 		 ((X >> C1) & C2) != 0 is rewritten as (X,false), and
 		 ((X >> C1) & C2) == 0 is rewritten as (X,true).  */
 	      else
-		return omit_one_operand (type,
+		return omit_one_operand_loc (loc, type,
 					 code == EQ_EXPR ? integer_one_node
 							 : integer_zero_node,
 					 arg000);
 	    }
 	}
 	 comparison since the AND will give the correct value.  */
 if (code == NE_EXPR
 	  && integer_zerop (arg1)
 	  && TREE_CODE (arg0) == BIT_AND_EXPR
 	  && integer_onep (TREE_OPERAND (arg0, 1)))
-	return fold_convert (type, arg0);
+	return fold_convert_loc (loc, type, arg0);
 /* If we have (A & C) == C where C is a power of 2, convert this into
 	 (A & C) != 0.  Similarly for NE_EXPR.  */
 if (TREE_CODE (arg0) == BIT_AND_EXPR
 	  && integer_pow2p (TREE_OPERAND (arg0, 1))
 	  && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
-	return fold_build2 (code == EQ_EXPR ? NE_EXPR : EQ_EXPR, type,
+	return fold_build2_loc (loc, code == EQ_EXPR ? NE_EXPR : EQ_EXPR, type,
-			    arg0, fold_convert (TREE_TYPE (arg0),
+			    arg0, fold_convert_loc (loc, TREE_TYPE (arg0),
-						integer_zero_node));
+						    integer_zero_node));
 /* If we have (A & C) != 0 or (A & C) == 0 and C is the sign
 	 bit, then fold the expression into A < 0 or A >= 0.  */
-tem = fold_single_bit_test_into_sign_test (code, arg0, arg1, type);
+tem = fold_single_bit_test_into_sign_test (loc, code, arg0, arg1, type);
 if (tem)
 	return tem;
 /* If we have (A & C) == D where D & ~C != 0, convert this into 0.
 	 Similarly for NE_EXPR.  */
 if (TREE_CODE (arg0) == BIT_AND_EXPR
 	  && TREE_CODE (arg1) == INTEGER_CST
 	  && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
 	{
-	  tree notc = fold_build1 (BIT_NOT_EXPR,
+	  tree notc = fold_build1_loc (loc, BIT_NOT_EXPR,
 				   TREE_TYPE (TREE_OPERAND (arg0, 1)),
 				   TREE_OPERAND (arg0, 1));
-	  tree dandnotc = fold_build2 (BIT_AND_EXPR, TREE_TYPE (arg0),
+	  tree dandnotc = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (arg0),
 				       arg1, notc);
 	  tree rslt = code == EQ_EXPR ? integer_zero_node : integer_one_node;
 	  if (integer_nonzerop (dandnotc))
-	    return omit_one_operand (type, rslt, arg0);
+	    return omit_one_operand_loc (loc, type, rslt, arg0);
 	}
 /* If we have (A | C) == D where C & ~D != 0, convert this into 0.
 	 Similarly for NE_EXPR.  */
 if (TREE_CODE (arg0) == BIT_IOR_EXPR
 	  && TREE_CODE (arg1) == INTEGER_CST
 	  && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
 	{
-	  tree notd = fold_build1 (BIT_NOT_EXPR, TREE_TYPE (arg1), arg1);
+	  tree notd = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (arg1), arg1);
-	  tree candnotd = fold_build2 (BIT_AND_EXPR, TREE_TYPE (arg0),
+	  tree candnotd = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (arg0),
 				       TREE_OPERAND (arg0, 1), notd);
 	  tree rslt = code == EQ_EXPR ? integer_zero_node : integer_one_node;
 	  if (integer_nonzerop (candnotd))
-	    return omit_one_operand (type, rslt, arg0);
+	    return omit_one_operand_loc (loc, type, rslt, arg0);
 	}
 /* If this is a comparison of a field, we may be able to simplify it.  */
 if ((TREE_CODE (arg0) == COMPONENT_REF
 	   || TREE_CODE (arg0) == BIT_FIELD_REF)
 	  /* Handle the constant case even without -O
 	     to make sure the warnings are given.  */
 	  && (optimize || TREE_CODE (arg1) == INTEGER_CST))
 	{
-	  t1 = optimize_bit_field_compare (code, type, arg0, arg1);
+	  t1 = optimize_bit_field_compare (loc, code, type, arg0, arg1);
 	  if (t1)
 	    return t1;
 	}
 /* Optimize comparisons of strlen vs zero to a compare of the
 	      && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
 	      && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_STRLEN
 	      && call_expr_nargs (arg0) == 1
 	      && TREE_CODE (TREE_TYPE (CALL_EXPR_ARG (arg0, 0))) == POINTER_TYPE)
 	    {
-	      tree iref = build_fold_indirect_ref (CALL_EXPR_ARG (arg0, 0));
+	      tree iref = build_fold_indirect_ref_loc (loc,
-	      return fold_build2 (code, type, iref,
+						   CALL_EXPR_ARG (arg0, 0));
+	      return fold_build2_loc (loc, code, type, iref,
 				  build_int_cst (TREE_TYPE (iref), 0));
 	    }
 	}
 /* Fold (X >> C) != 0 into X < 0 if C is one less than the width
 		 == (unsigned HOST_WIDE_INT) (TYPE_PRECISION (itype) - 1))
 	    {
 	      if (TYPE_UNSIGNED (itype))
 		{
 		  itype = signed_type_for (itype);
-		  arg00 = fold_convert (itype, arg00);
+		  arg00 = fold_convert_loc (loc, itype, arg00);
 		}
-	      return fold_build2 (code == EQ_EXPR ? GE_EXPR : LT_EXPR,
+	      return fold_build2_loc (loc, code == EQ_EXPR ? GE_EXPR : LT_EXPR,
 				  type, arg00, build_int_cst (itype, 0));
 	    }
 	}
 /* (X ^ Y) == 0 becomes X == Y, and (X ^ Y) != 0 becomes X != Y.  */
 if (integer_zerop (arg1)
 	  && TREE_CODE (arg0) == BIT_XOR_EXPR)
-	return fold_build2 (code, type, TREE_OPERAND (arg0, 0),
+	return fold_build2_loc (loc, code, type, TREE_OPERAND (arg0, 0),
 			    TREE_OPERAND (arg0, 1));
 /* (X ^ Y) == Y becomes X == 0.  We know that Y has no side-effects.  */
 if (TREE_CODE (arg0) == BIT_XOR_EXPR
 	  && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
-	return fold_build2 (code, type, TREE_OPERAND (arg0, 0),
+	return fold_build2_loc (loc, code, type, TREE_OPERAND (arg0, 0),
 			    build_int_cst (TREE_TYPE (arg1), 0));
 /* Likewise (X ^ Y) == X becomes Y == 0.  X has no side-effects.  */
 if (TREE_CODE (arg0) == BIT_XOR_EXPR
 	  && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0)
 	  && reorder_operands_p (TREE_OPERAND (arg0, 1), arg1))
-	return fold_build2 (code, type, TREE_OPERAND (arg0, 1),
+	return fold_build2_loc (loc, code, type, TREE_OPERAND (arg0, 1),
 			    build_int_cst (TREE_TYPE (arg1), 0));
 /* (X ^ C1) op C2 can be rewritten as X op (C1 ^ C2).  */
 if (TREE_CODE (arg0) == BIT_XOR_EXPR
 	  && TREE_CODE (arg1) == INTEGER_CST
 	  && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
-	return fold_build2 (code, type, TREE_OPERAND (arg0, 0),
+	return fold_build2_loc (loc, code, type, TREE_OPERAND (arg0, 0),
-			    fold_build2 (BIT_XOR_EXPR, TREE_TYPE (arg1),
+			    fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (arg1),
 					 TREE_OPERAND (arg0, 1), arg1));
 /* Fold (~X & C) == 0 into (X & C) != 0 and (~X & C) != 0 into
 	 (X & C) == 0 when C is a single bit.  */
 if (TREE_CODE (arg0) == BIT_AND_EXPR
 	  && TREE_CODE (TREE_OPERAND (arg0, 0)) == BIT_NOT_EXPR
 	  && integer_zerop (arg1)
 	  && integer_pow2p (TREE_OPERAND (arg0, 1)))
 	{
-	  tem = fold_build2 (BIT_AND_EXPR, TREE_TYPE (arg0),
+	  tem = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (arg0),
 			     TREE_OPERAND (TREE_OPERAND (arg0, 0), 0),
 			     TREE_OPERAND (arg0, 1));
-	  return fold_build2 (code == EQ_EXPR ? NE_EXPR : EQ_EXPR,
+	  return fold_build2_loc (loc, code == EQ_EXPR ? NE_EXPR : EQ_EXPR,
 			      type, tem, arg1);
 	}
 /* Fold ((X & C) ^ C) eq/ne 0 into (X & C) ne/eq 0, when the
 	 constant C is a power of two, i.e. a single bit.  */
 	  && integer_pow2p (TREE_OPERAND (arg0, 1))
 	  && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0, 0), 1),
 			      TREE_OPERAND (arg0, 1), OEP_ONLY_CONST))
 	{
 	  tree arg00 = TREE_OPERAND (arg0, 0);
-	  return fold_build2 (code == EQ_EXPR ? NE_EXPR : EQ_EXPR, type,
+	  return fold_build2_loc (loc, code == EQ_EXPR ? NE_EXPR : EQ_EXPR, type,
 			      arg00, build_int_cst (TREE_TYPE (arg00), 0));
 	}
 /* Likewise, fold ((X ^ C) & C) eq/ne 0 into (X & C) ne/eq 0,
 	 when is C is a power of two, i.e. a single bit.  */
 	  && integer_pow2p (TREE_OPERAND (arg0, 1))
 	  && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0, 0), 1),
 			      TREE_OPERAND (arg0, 1), OEP_ONLY_CONST))
 	{
 	  tree arg000 = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
-	  tem = fold_build2 (BIT_AND_EXPR, TREE_TYPE (arg000),
+	  tem = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (arg000),
 			     arg000, TREE_OPERAND (arg0, 1));
-	  return fold_build2 (code == EQ_EXPR ? NE_EXPR : EQ_EXPR, type,
+	  return fold_build2_loc (loc, code == EQ_EXPR ? NE_EXPR : EQ_EXPR, type,
 			      tem, build_int_cst (TREE_TYPE (tem), 0));
 	}
 if (integer_zerop (arg1)
 	  && tree_expr_nonzero_p (arg0))
 {
 	  tree res = constant_boolean_node (code==NE_EXPR, type);
-	  return omit_one_operand (type, res, arg0);
+	  return omit_one_operand_loc (loc, type, res, arg0);
 	}
 /* Fold -X op -Y as X op Y, where op is eq/ne.  */
 if (TREE_CODE (arg0) == NEGATE_EXPR
 && TREE_CODE (arg1) == NEGATE_EXPR)
-	return fold_build2 (code, type,
+	return fold_build2_loc (loc, code, type,
 			    TREE_OPERAND (arg0, 0),
 			    TREE_OPERAND (arg1, 0));
 /* Fold (X & C) op (Y & C) as (X ^ Y) & C op 0", and symmetries.  */
 if (TREE_CODE (arg0) == BIT_AND_EXPR
 	  tree arg10 = TREE_OPERAND (arg1, 0);
 	  tree arg11 = TREE_OPERAND (arg1, 1);
 	  tree itype = TREE_TYPE (arg0);
 	  if (operand_equal_p (arg01, arg11, 0))
-	    return fold_build2 (code, type,
+	    return fold_build2_loc (loc, code, type,
-				fold_build2 (BIT_AND_EXPR, itype,
+				fold_build2_loc (loc, BIT_AND_EXPR, itype,
-					     fold_build2 (BIT_XOR_EXPR, itype,
+					     fold_build2_loc (loc,
+							  BIT_XOR_EXPR, itype,
 							  arg00, arg10),
 					     arg01),
 				build_int_cst (itype, 0));
 	  if (operand_equal_p (arg01, arg10, 0))
-	    return fold_build2 (code, type,
+	    return fold_build2_loc (loc, code, type,
-				fold_build2 (BIT_AND_EXPR, itype,
+				fold_build2_loc (loc, BIT_AND_EXPR, itype,
-					     fold_build2 (BIT_XOR_EXPR, itype,
+					     fold_build2_loc (loc,
+							  BIT_XOR_EXPR, itype,
 							  arg00, arg11),
 					     arg01),
 				build_int_cst (itype, 0));
 	  if (operand_equal_p (arg00, arg11, 0))
-	    return fold_build2 (code, type,
+	    return fold_build2_loc (loc, code, type,
-				fold_build2 (BIT_AND_EXPR, itype,
+				fold_build2_loc (loc, BIT_AND_EXPR, itype,
-					     fold_build2 (BIT_XOR_EXPR, itype,
+					     fold_build2_loc (loc,
+							  BIT_XOR_EXPR, itype,
 							  arg01, arg10),
 					     arg00),
 				build_int_cst (itype, 0));
 	  if (operand_equal_p (arg00, arg10, 0))
-	    return fold_build2 (code, type,
+	    return fold_build2_loc (loc, code, type,
-				fold_build2 (BIT_AND_EXPR, itype,
+				fold_build2_loc (loc, BIT_AND_EXPR, itype,
-					     fold_build2 (BIT_XOR_EXPR, itype,
+					     fold_build2_loc (loc,
+							  BIT_XOR_EXPR, itype,
 							  arg01, arg11),
 					     arg00),
 				build_int_cst (itype, 0));
 	}
 	  /* Optimize (X ^ Z) op (Y ^ Z) as X op Y, and symmetries.
 	     operand_equal_p guarantees no side-effects so we don't need
 	     to use omit_one_operand on Z.  */
 	  if (operand_equal_p (arg01, arg11, 0))
-	    return fold_build2 (code, type, arg00, arg10);
+	    return fold_build2_loc (loc, code, type, arg00, arg10);
 	  if (operand_equal_p (arg01, arg10, 0))
-	    return fold_build2 (code, type, arg00, arg11);
+	    return fold_build2_loc (loc, code, type, arg00, arg11);
 	  if (operand_equal_p (arg00, arg11, 0))
-	    return fold_build2 (code, type, arg01, arg10);
+	    return fold_build2_loc (loc, code, type, arg01, arg10);
 	  if (operand_equal_p (arg00, arg10, 0))
-	    return fold_build2 (code, type, arg01, arg11);
+	    return fold_build2_loc (loc, code, type, arg01, arg11);
 	  /* Optimize (X ^ C1) op (Y ^ C2) as (X ^ (C1 ^ C2)) op Y.  */
 	  if (TREE_CODE (arg01) == INTEGER_CST
 	      && TREE_CODE (arg11) == INTEGER_CST)
-	    return fold_build2 (code, type,
+	    return fold_build2_loc (loc, code, type,
-				fold_build2 (BIT_XOR_EXPR, itype, arg00,
+				fold_build2_loc (loc, BIT_XOR_EXPR, itype, arg00,
-					     fold_build2 (BIT_XOR_EXPR, itype,
+					     fold_build2_loc (loc,
+							  BIT_XOR_EXPR, itype,
 							  arg01, arg11)),
 				arg10);
 	}
 /* Attempt to simplify equality/inequality comparisons of complex
 	    {
 	      real1 = TREE_REALPART (arg1);
 	      imag1 = TREE_IMAGPART (arg1);
 	    }
-	  rcond = fold_binary (code, type, real0, real1);
+	  rcond = fold_binary_loc (loc, code, type, real0, real1);
 	  if (rcond && TREE_CODE (rcond) == INTEGER_CST)
 	    {
 	      if (integer_zerop (rcond))
 		{
 		  if (code == EQ_EXPR)
-		    return omit_two_operands (type, boolean_false_node,
+		    return omit_two_operands_loc (loc, type, boolean_false_node,
 					      imag0, imag1);
-		  return fold_build2 (NE_EXPR, type, imag0, imag1);
+		  return fold_build2_loc (loc, NE_EXPR, type, imag0, imag1);
 		}
 	      else
 		{
 		  if (code == NE_EXPR)
-		    return omit_two_operands (type, boolean_true_node,
+		    return omit_two_operands_loc (loc, type, boolean_true_node,
 					      imag0, imag1);
-		  return fold_build2 (EQ_EXPR, type, imag0, imag1);
+		  return fold_build2_loc (loc, EQ_EXPR, type, imag0, imag1);
 		}
 	    }
-	  icond = fold_binary (code, type, imag0, imag1);
+	  icond = fold_binary_loc (loc, code, type, imag0, imag1);
 	  if (icond && TREE_CODE (icond) == INTEGER_CST)
 	    {
 	      if (integer_zerop (icond))
 		{
 		  if (code == EQ_EXPR)
-		    return omit_two_operands (type, boolean_false_node,
+		    return omit_two_operands_loc (loc, type, boolean_false_node,
 					      real0, real1);
-		  return fold_build2 (NE_EXPR, type, real0, real1);
+		  return fold_build2_loc (loc, NE_EXPR, type, real0, real1);
 		}
 	      else
 		{
 		  if (code == NE_EXPR)
-		    return omit_two_operands (type, boolean_true_node,
+		    return omit_two_operands_loc (loc, type, boolean_true_node,
 					      real0, real1);
-		  return fold_build2 (EQ_EXPR, type, real0, real1);
+		  return fold_build2_loc (loc, EQ_EXPR, type, real0, real1);
 		}
 	    }
 	}
 return NULL_TREE;
 case LT_EXPR:
 case GT_EXPR:
 case LE_EXPR:
 case GE_EXPR:
-tem = fold_comparison (code, type, op0, op1);
+tem = fold_comparison (loc, code, type, op0, op1);
 if (tem != NULL_TREE)
 	return tem;
 /* Transform comparisons of the form X +- C CMP X.  */
 if ((TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
 	    if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (arg1) == max_hi
 		&& TREE_INT_CST_LOW (arg1) == max_lo)
 	      switch (code)
 		{
 		case GT_EXPR:
-		  return omit_one_operand (type, integer_zero_node, arg0);
+		  return omit_one_operand_loc (loc, type, integer_zero_node, arg0);
 		case GE_EXPR:
-		  return fold_build2 (EQ_EXPR, type, op0, op1);
+		  return fold_build2_loc (loc, EQ_EXPR, type, op0, op1);
 		case LE_EXPR:
-		  return omit_one_operand (type, integer_one_node, arg0);
+		  return omit_one_operand_loc (loc, type, integer_one_node, arg0);
 		case LT_EXPR:
-		  return fold_build2 (NE_EXPR, type, op0, op1);
+		  return fold_build2_loc (loc, NE_EXPR, type, op0, op1);
 		/* The GE_EXPR and LT_EXPR cases above are not normally
 		   reached because of previous transformations.  */
 		default:
 	      switch (code)
 		{
 		case GT_EXPR:
 		  arg1 = const_binop (PLUS_EXPR, arg1,
 				      build_int_cst (TREE_TYPE (arg1), 1), 0);
-		  return fold_build2 (EQ_EXPR, type,
+		  return fold_build2_loc (loc, EQ_EXPR, type,
-				      fold_convert (TREE_TYPE (arg1), arg0),
+				      fold_convert_loc (loc,
+							TREE_TYPE (arg1), arg0),
 				      arg1);
 		case LE_EXPR:
 		  arg1 = const_binop (PLUS_EXPR, arg1,
 				      build_int_cst (TREE_TYPE (arg1), 1), 0);
-		  return fold_build2 (NE_EXPR, type,
+		  return fold_build2_loc (loc, NE_EXPR, type,
-				      fold_convert (TREE_TYPE (arg1), arg0),
+				      fold_convert_loc (loc, TREE_TYPE (arg1),
+							arg0),
 				      arg1);
 		default:
 		  break;
 		}
 	    else if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (arg1)
 		     == min_hi
 		     && TREE_INT_CST_LOW (arg1) == min_lo)
 	      switch (code)
 		{
 		case LT_EXPR:
-		  return omit_one_operand (type, integer_zero_node, arg0);
+		  return omit_one_operand_loc (loc, type, integer_zero_node, arg0);
 		case LE_EXPR:
-		  return fold_build2 (EQ_EXPR, type, op0, op1);
+		  return fold_build2_loc (loc, EQ_EXPR, type, op0, op1);
 		case GE_EXPR:
-		  return omit_one_operand (type, integer_one_node, arg0);
+		  return omit_one_operand_loc (loc, type, integer_one_node, arg0);
 		case GT_EXPR:
-		  return fold_build2 (NE_EXPR, type, op0, op1);
+		  return fold_build2_loc (loc, NE_EXPR, type, op0, op1);
 		default:
 		  break;
 		}
 	    else if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (arg1)
 		     && TREE_INT_CST_LOW (arg1) == min_lo + 1)
 	      switch (code)
 		{
 		case GE_EXPR:
 		  arg1 = const_binop (MINUS_EXPR, arg1, integer_one_node, 0);
-		  return fold_build2 (NE_EXPR, type,
+		  return fold_build2_loc (loc, NE_EXPR, type,
-				      fold_convert (TREE_TYPE (arg1), arg0),
+				      fold_convert_loc (loc,
+							TREE_TYPE (arg1), arg0),
 				      arg1);
 		case LT_EXPR:
 		  arg1 = const_binop (MINUS_EXPR, arg1, integer_one_node, 0);
-		  return fold_build2 (EQ_EXPR, type,
+		  return fold_build2_loc (loc, EQ_EXPR, type,
-				      fold_convert (TREE_TYPE (arg1), arg0),
+				      fold_convert_loc (loc, TREE_TYPE (arg1),
+							arg0),
 				      arg1);
 		default:
 		  break;
 		}
 		   and X >= signed_max+1 because previous transformations.  */
 		if (code == LE_EXPR || code == GT_EXPR)
 		  {
 		    tree st;
 		    st = signed_type_for (TREE_TYPE (arg1));
-		    return fold_build2 (code == LE_EXPR ? GE_EXPR : LT_EXPR,
+		    return fold_build2_loc (loc,
-					type, fold_convert (st, arg0),
+					code == LE_EXPR ? GE_EXPR : LT_EXPR,
+					type, fold_convert_loc (loc, st, arg0),
 					build_int_cst (st, 0));
 		  }
 	      }
 	  }
 }
 	  && TREE_CODE (arg0) == ABS_EXPR
 	  && ! TREE_SIDE_EFFECTS (arg0)
 	  && (0 != (tem = negate_expr (arg1)))
 	  && TREE_CODE (tem) == INTEGER_CST
 	  && !TREE_OVERFLOW (tem))
-	return fold_build2 (TRUTH_ANDIF_EXPR, type,
+	return fold_build2_loc (loc, TRUTH_ANDIF_EXPR, type,
 			    build2 (GE_EXPR, type,
 				    TREE_OPERAND (arg0, 0), tem),
 			    build2 (LE_EXPR, type,
 				    TREE_OPERAND (arg0, 0), arg1));
 	  if (strict_overflow_p)
 	    fold_overflow_warning (("assuming signed overflow does not occur "
 				    "when simplifying comparison of "
 				    "absolute value and zero"),
 				   WARN_STRICT_OVERFLOW_CONDITIONAL);
-	  return omit_one_operand (type, integer_one_node, arg0);
+	  return omit_one_operand_loc (loc, type, integer_one_node, arg0);
 	}
 /* Convert ABS_EXPR<x> < 0 to false.  */
 strict_overflow_p = false;
 if (code == LT_EXPR
 	  if (strict_overflow_p)
 	    fold_overflow_warning (("assuming signed overflow does not occur "
 				    "when simplifying comparison of "
 				    "absolute value and zero"),
 				   WARN_STRICT_OVERFLOW_CONDITIONAL);
-	  return omit_one_operand (type, integer_zero_node, arg0);
+	  return omit_one_operand_loc (loc, type, integer_zero_node, arg0);
 	}
 /* If X is unsigned, convert X < (1 << Y) into X >> Y == 0
 	 and similarly for >= into !=.  */
 if ((code == LT_EXPR || code == GE_EXPR)
 	  && TYPE_UNSIGNED (TREE_TYPE (arg0))
 	  && TREE_CODE (arg1) == LSHIFT_EXPR
 	  && integer_onep (TREE_OPERAND (arg1, 0)))
-	return build2 (code == LT_EXPR ? EQ_EXPR : NE_EXPR, type,
+	{
-		       build2 (RSHIFT_EXPR, TREE_TYPE (arg0), arg0,
+	  tem = build2 (code == LT_EXPR ? EQ_EXPR : NE_EXPR, type,
-			       TREE_OPERAND (arg1, 1)),
+			build2 (RSHIFT_EXPR, TREE_TYPE (arg0), arg0,
-		       build_int_cst (TREE_TYPE (arg0), 0));
+				TREE_OPERAND (arg1, 1)),
+			build_int_cst (TREE_TYPE (arg0), 0));
+	  goto fold_binary_exit;
+	}
 if ((code == LT_EXPR || code == GE_EXPR)
 	  && TYPE_UNSIGNED (TREE_TYPE (arg0))
 	  && CONVERT_EXPR_P (arg1)
 	  && TREE_CODE (TREE_OPERAND (arg1, 0)) == LSHIFT_EXPR
 	  && integer_onep (TREE_OPERAND (TREE_OPERAND (arg1, 0), 0)))
-	return
+	{
-	  build2 (code == LT_EXPR ? EQ_EXPR : NE_EXPR, type,
+	  tem = build2 (code == LT_EXPR ? EQ_EXPR : NE_EXPR, type,
-		  fold_convert (TREE_TYPE (arg0),
+			fold_convert_loc (loc, TREE_TYPE (arg0),
-				build2 (RSHIFT_EXPR, TREE_TYPE (arg0), arg0,
+					  build2 (RSHIFT_EXPR,
-					TREE_OPERAND (TREE_OPERAND (arg1, 0),
+						  TREE_TYPE (arg0), arg0,
-						      1))),
+						  TREE_OPERAND (TREE_OPERAND (arg1, 0),
-		  build_int_cst (TREE_TYPE (arg0), 0));
+								1))),
+			build_int_cst (TREE_TYPE (arg0), 0));
+	  goto fold_binary_exit;
+	}
 return NULL_TREE;
 case UNORDERED_EXPR:
 case ORDERED_EXPR:
 	  && (code != LTGT_EXPR || ! flag_trapping_math))
 	{
 	  t1 = (code == ORDERED_EXPR || code == LTGT_EXPR)
 	       ? integer_zero_node
 	       : integer_one_node;
-	  return omit_one_operand (type, t1, arg1);
+	  return omit_one_operand_loc (loc, type, t1, arg1);
 	}
 /* If the second operand is NaN, the result is constant.  */
 if (TREE_CODE (arg1) == REAL_CST
 	  && REAL_VALUE_ISNAN (TREE_REAL_CST (arg1))
 	  && (code != LTGT_EXPR || ! flag_trapping_math))
 	{
 	  t1 = (code == ORDERED_EXPR || code == LTGT_EXPR)
 	       ? integer_zero_node
 	       : integer_one_node;
-	  return omit_one_operand (type, t1, arg0);
+	  return omit_one_operand_loc (loc, type, t1, arg0);
 	}
 /* Simplify unordered comparison of something with itself.  */
 if ((code == UNLE_EXPR || code == UNGE_EXPR || code == UNEQ_EXPR)
 	  && operand_equal_p (arg0, arg1, 0))
 	if (TYPE_PRECISION (TREE_TYPE (targ1)) > TYPE_PRECISION (newtype))
 	  newtype = TREE_TYPE (targ1);
 	if (TYPE_PRECISION (newtype) < TYPE_PRECISION (TREE_TYPE (arg0)))
-	  return fold_build2 (code, type, fold_convert (newtype, targ0),
+	  return fold_build2_loc (loc, code, type,
-			      fold_convert (newtype, targ1));
+			      fold_convert_loc (loc, newtype, targ0),
+			      fold_convert_loc (loc, newtype, targ1));
 }
 return NULL_TREE;
 case COMPOUND_EXPR:
 	 nor an integer constant expression.  */
 if (TREE_SIDE_EFFECTS (arg0) || TREE_CONSTANT (arg1))
 	return NULL_TREE;
 /* Don't let (0, 0) be null pointer constant.  */
 tem = integer_zerop (arg1) ? build1 (NOP_EXPR, type, arg1)
-				 : fold_convert (type, arg1);
+				 : fold_convert_loc (loc, type, arg1);
-return pedantic_non_lvalue (tem);
+return pedantic_non_lvalue_loc (loc, tem);
 case COMPLEX_EXPR:
 if ((TREE_CODE (arg0) == REAL_CST
 	   && TREE_CODE (arg1) == REAL_CST)
 	  || (TREE_CODE (arg0) == INTEGER_CST
 gcc_unreachable ();
 default:
 return NULL_TREE;
 } /* switch (code) */
-}
+fold_binary_exit:
+protected_set_expr_location (tem, loc);
-/* Callback for walk_tree, looking for LABEL_EXPR.
+return tem;
-Returns tree TP if it is LABEL_EXPR. Otherwise it returns NULL_TREE.
+}
-Do not check the sub-tree of GOTO_EXPR.  */
+/* Callback for walk_tree, looking for LABEL_EXPR.  Return *TP if it is
+a LABEL_EXPR; otherwise return NULL_TREE.  Do not check the subtrees
+of GOTO_EXPR.  */
 static tree
-contains_label_1 (tree *tp,
+contains_label_1 (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
-int *walk_subtrees,
-void *data ATTRIBUTE_UNUSED)
 {
 switch (TREE_CODE (*tp))
 {
 case LABEL_EXPR:
 return *tp;
 case GOTO_EXPR:
 *walk_subtrees = 0;
-/* no break */
+/* ... fall through ...  */
 default:
 return NULL_TREE;
 }
 }
-/* Checks whether the sub-tree ST contains a label LABEL_EXPR which is
+/* Return whether the sub-tree ST contains a label which is accessible from
-accessible from outside the sub-tree. Returns NULL_TREE if no
+outside the sub-tree.  */
-addressable label is found.  */
 static bool
 contains_label_p (tree st)
 {
-return (walk_tree (&st, contains_label_1 , NULL, NULL) != NULL_TREE);
+return
+(walk_tree_without_duplicates (&st, contains_label_1 , NULL) != NULL_TREE);
 }
 /* Fold a ternary expression of code CODE and type TYPE with operands
 OP0, OP1, and OP2.  Return the folded expression if folding is
 successful.  Otherwise, return NULL_TREE.  */
 tree
-fold_ternary (enum tree_code code, tree type, tree op0, tree op1, tree op2)
+fold_ternary_loc (location_t loc, enum tree_code code, tree type,
+	      tree op0, tree op1, tree op2)
 {
 tree tem;
 tree arg0 = NULL_TREE, arg1 = NULL_TREE;
 enum tree_code_class kind = TREE_CODE_CLASS (code);
 Avoid throwing away that operand which contains label.  */
 if ((!TREE_SIDE_EFFECTS (unused_op)
 || !contains_label_p (unused_op))
 && (! VOID_TYPE_P (TREE_TYPE (tem))
 || VOID_TYPE_P (type)))
-	    return pedantic_non_lvalue (tem);
+	    return pedantic_non_lvalue_loc (loc, tem);
 	  return NULL_TREE;
 	}
 if (operand_equal_p (arg1, op2, 0))
-	return pedantic_omit_one_operand (type, arg1, arg0);
+	return pedantic_omit_one_operand_loc (loc, type, arg1, arg0);
 /* If we have A op B ? A : C, we may be able to convert this to a
 	 simpler expression, depending on the operation and the values
 	 of B and C.  Signed zeros prevent all of these transformations,
 	 for reasons given above each one.
 if (COMPARISON_CLASS_P (arg0)
 	  && operand_equal_for_comparison_p (TREE_OPERAND (arg0, 0),
 					     arg1, TREE_OPERAND (arg0, 1))
 	  && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg1))))
 	{
-	  tem = fold_cond_expr_with_comparison (type, arg0, op1, op2);
+	  tem = fold_cond_expr_with_comparison (loc, type, arg0, op1, op2);
 	  if (tem)
 	    return tem;
 	}
 if (COMPARISON_CLASS_P (arg0)
 	  && operand_equal_for_comparison_p (TREE_OPERAND (arg0, 0),
 					     op2,
 					     TREE_OPERAND (arg0, 1))
 	  && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (op2))))
 	{
-	  tem = fold_truth_not_expr (arg0);
+	  tem = fold_truth_not_expr (loc, arg0);
 	  if (tem && COMPARISON_CLASS_P (tem))
 	    {
-	      tem = fold_cond_expr_with_comparison (type, tem, op2, op1);
+	      tem = fold_cond_expr_with_comparison (loc, type, tem, op2, op1);
 	      if (tem)
 		return tem;
 	    }
 	}
 	  && tree_swap_operands_p (op1, op2, false))
 	{
 	  /* See if this can be inverted.  If it can't, possibly because
 	     it was a floating-point inequality comparison, don't do
 	     anything.  */
-	  tem = fold_truth_not_expr (arg0);
+	  tem = fold_truth_not_expr (loc, arg0);
 	  if (tem)
-	    return fold_build3 (code, type, tem, op2, op1);
+	    return fold_build3_loc (loc, code, type, tem, op2, op1);
 	}
 /* Convert A ? 1 : 0 to simply A.  */
 if (integer_onep (op1)
 	  && integer_zerop (op2)
 	  /* If we try to convert OP0 to our type, the
 	     call to fold will try to move the conversion inside
 	     a COND, which will recurse.  In that case, the COND_EXPR
 	     is probably the best choice, so leave it alone.  */
 	  && type == TREE_TYPE (arg0))
-	return pedantic_non_lvalue (arg0);
+	return pedantic_non_lvalue_loc (loc, arg0);
 /* Convert A ? 0 : 1 to !A.  This prefers the use of NOT_EXPR
 	 over COND_EXPR in cases such as floating point comparisons.  */
 if (integer_zerop (op1)
 	  && integer_onep (op2)
 	  && truth_value_p (TREE_CODE (arg0)))
-	return pedantic_non_lvalue (fold_convert (type,
+	return pedantic_non_lvalue_loc (loc,
-						  invert_truthvalue (arg0)));
+				    fold_convert_loc (loc, type,
+					      invert_truthvalue_loc (loc,
+								     arg0)));
 /* A < 0 ? <sign bit of A> : 0 is simply (A & <sign bit of A>).  */
 if (TREE_CODE (arg0) == LT_EXPR
 	  && integer_zerop (TREE_OPERAND (arg0, 1))
 	  && integer_zerop (op2)
 	      if ((TREE_INT_CST_HIGH (arg1) & mask_hi) == mask_hi
 		  && (TREE_INT_CST_LOW (arg1) & mask_lo) == mask_lo)
 		{
 		  tem_type = signed_type_for (TREE_TYPE (tem));
-		  tem = fold_convert (tem_type, tem);
+		  tem = fold_convert_loc (loc, tem_type, tem);
 		}
 	      else if ((TREE_INT_CST_HIGH (arg1) & mask_hi) == 0
 		       && (TREE_INT_CST_LOW (arg1) & mask_lo) == 0)
 		{
 		  tem_type = unsigned_type_for (TREE_TYPE (tem));
-		  tem = fold_convert (tem_type, tem);
+		  tem = fold_convert_loc (loc, tem_type, tem);
 		}
 	      else
 		tem = NULL;
 	    }
 	  if (tem)
-	    return fold_convert (type,
+	    return
-				 fold_build2 (BIT_AND_EXPR,
+	      fold_convert_loc (loc, type,
-					      TREE_TYPE (tem), tem,
+				fold_build2_loc (loc, BIT_AND_EXPR,
-					      fold_convert (TREE_TYPE (tem),
+					     TREE_TYPE (tem), tem,
-							    arg1)));
+					     fold_convert_loc (loc,
+							       TREE_TYPE (tem),
+							       arg1)));
 	}
 /* (A >> N) & 1 ? (1 << N) : 0 is simply A & (1 << N).  A & 1 was
 	 already handled above.  */
 if (TREE_CODE (arg0) == BIT_AND_EXPR
 	  STRIP_NOPS (tem);
 	  if (TREE_CODE (tem) == RSHIFT_EXPR
 && TREE_CODE (TREE_OPERAND (tem, 1)) == INTEGER_CST
 && (unsigned HOST_WIDE_INT) tree_log2 (arg1) ==
 	         TREE_INT_CST_LOW (TREE_OPERAND (tem, 1)))
-	    return fold_build2 (BIT_AND_EXPR, type,
+	    return fold_build2_loc (loc, BIT_AND_EXPR, type,
 				TREE_OPERAND (tem, 0), arg1);
 	}
 /* A & N ? N : 0 is simply A & N if N is a power of two.  This
 	 is probably obsolete because the first operand should be a
 	  && integer_zerop (TREE_OPERAND (arg0, 1))
 	  && integer_pow2p (arg1)
 	  && TREE_CODE (TREE_OPERAND (arg0, 0)) == BIT_AND_EXPR
 	  && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0, 0), 1),
 			      arg1, OEP_ONLY_CONST))
-	return pedantic_non_lvalue (fold_convert (type,
+	return pedantic_non_lvalue_loc (loc,
-						  TREE_OPERAND (arg0, 0)));
+				    fold_convert_loc (loc, type,
+						      TREE_OPERAND (arg0, 0)));
 /* Convert A ? B : 0 into A && B if A and B are truth values.  */
 if (integer_zerop (op2)
 	  && truth_value_p (TREE_CODE (arg0))
 	  && truth_value_p (TREE_CODE (arg1)))
-	return fold_build2 (TRUTH_ANDIF_EXPR, type,
+	return fold_build2_loc (loc, TRUTH_ANDIF_EXPR, type,
-			    fold_convert (type, arg0),
+			    fold_convert_loc (loc, type, arg0),
 			    arg1);
 /* Convert A ? B : 1 into !A || B if A and B are truth values.  */
 if (integer_onep (op2)
 	  && truth_value_p (TREE_CODE (arg0))
 	  && truth_value_p (TREE_CODE (arg1)))
 	{
 	  /* Only perform transformation if ARG0 is easily inverted.  */
-	  tem = fold_truth_not_expr (arg0);
+	  tem = fold_truth_not_expr (loc, arg0);
 	  if (tem)
-	    return fold_build2 (TRUTH_ORIF_EXPR, type,
+	    return fold_build2_loc (loc, TRUTH_ORIF_EXPR, type,
-				fold_convert (type, tem),
+				fold_convert_loc (loc, type, tem),
 				arg1);
 	}
 /* Convert A ? 0 : B into !A && B if A and B are truth values.  */
 if (integer_zerop (arg1)
 	  && truth_value_p (TREE_CODE (arg0))
 	  && truth_value_p (TREE_CODE (op2)))
 	{
 	  /* Only perform transformation if ARG0 is easily inverted.  */
-	  tem = fold_truth_not_expr (arg0);
+	  tem = fold_truth_not_expr (loc, arg0);
 	  if (tem)
-	    return fold_build2 (TRUTH_ANDIF_EXPR, type,
+	    return fold_build2_loc (loc, TRUTH_ANDIF_EXPR, type,
-				fold_convert (type, tem),
+				fold_convert_loc (loc, type, tem),
 				op2);
 	}
 /* Convert A ? 1 : B into A || B if A and B are truth values.  */
 if (integer_onep (arg1)
 	  && truth_value_p (TREE_CODE (arg0))
 	  && truth_value_p (TREE_CODE (op2)))
-	return fold_build2 (TRUTH_ORIF_EXPR, type,
+	return fold_build2_loc (loc, TRUTH_ORIF_EXPR, type,
-			    fold_convert (type, arg0),
+			    fold_convert_loc (loc, type, arg0),
 			    op2);
 return NULL_TREE;
 case CALL_EXPR:
 	      while (idx-- > 0 && elements)
 		elements = TREE_CHAIN (elements);
 	      if (elements)
 		return TREE_VALUE (elements);
 	      else
-		return fold_convert (type, integer_zero_node);
+		return fold_convert_loc (loc, type, integer_zero_node);
 	    }
 	}
 /* A bit-field-ref that referenced the full argument can be stripped.  */
 if (INTEGRAL_TYPE_P (TREE_TYPE (arg0))
 	  && TYPE_PRECISION (TREE_TYPE (arg0)) == tree_low_cst (arg1, 1)
 	  && integer_zerop (op2))
-	return fold_convert (type, arg0);
+	return fold_convert_loc (loc, type, arg0);
 return NULL_TREE;
 default:
 return NULL_TREE;
 {
 const tree t = expr;
 enum tree_code code = TREE_CODE (t);
 enum tree_code_class kind = TREE_CODE_CLASS (code);
 tree tem;
+location_t loc = EXPR_LOCATION (expr);
 /* Return right away if a constant.  */
 if (kind == tcc_constant)
 return t;
 treated specially.  */
 if (kind == tcc_vl_exp)
 {
 if (code == CALL_EXPR)
 	{
-	  tem = fold_call_expr (expr, false);
+	  tem = fold_call_expr (loc, expr, false);
 	  return tem ? tem : expr;
 	}
 return expr;
 }
 switch (TREE_CODE_LENGTH (code))
 	{
 	case 1:
 	  op0 = TREE_OPERAND (t, 0);
-	  tem = fold_unary (code, type, op0);
+	  tem = fold_unary_loc (loc, code, type, op0);
 	  return tem ? tem : expr;
 	case 2:
 	  op0 = TREE_OPERAND (t, 0);
 	  op1 = TREE_OPERAND (t, 1);
-	  tem = fold_binary (code, type, op0, op1);
+	  tem = fold_binary_loc (loc, code, type, op0, op1);
 	  return tem ? tem : expr;
 	case 3:
 	  op0 = TREE_OPERAND (t, 0);
 	  op1 = TREE_OPERAND (t, 1);
 	  op2 = TREE_OPERAND (t, 2);
-	  tem = fold_ternary (code, type, op0, op1, op2);
+	  tem = fold_ternary_loc (loc, code, type, op0, op1, op2);
 	  return tem ? tem : expr;
 	default:
 	  break;
 	}
 }
 {
 const void **slot;
 enum tree_code code;
 union tree_node buf;
 int i, len;
 recursive_label:
 gcc_assert ((sizeof (struct tree_exp) + 5 * sizeof (tree)
 	       <= sizeof (struct tree_function_decl))
 	      && sizeof (struct tree_type) <= sizeof (struct tree_function_decl));
 	  fold_checksum_tree (DECL_ABSTRACT_ORIGIN (expr), ctx, ht);
 	  fold_checksum_tree (DECL_ATTRIBUTES (expr), ctx, ht);
 	}
 if (CODE_CONTAINS_STRUCT (TREE_CODE (expr), TS_DECL_WITH_VIS))
 	fold_checksum_tree (DECL_SECTION_NAME (expr), ctx, ht);
 if (CODE_CONTAINS_STRUCT (TREE_CODE (expr), TS_DECL_NON_COMMON))
 	{
 	  fold_checksum_tree (DECL_VINDEX (expr), ctx, ht);
 	  fold_checksum_tree (DECL_RESULT_FLD (expr), ctx, ht);
 	  fold_checksum_tree (DECL_ARGUMENT_FLD (expr), ctx, ht);
 {
 int i;
 unsigned char checksum[16];
 struct md5_ctx ctx;
 htab_t ht = htab_create (32, htab_hash_pointer, htab_eq_pointer, NULL);
 md5_init_ctx (&ctx);
 fold_checksum_tree (t, &ctx, ht);
 md5_finish_ctx (&ctx, checksum);
 htab_empty (ht);
 }
 #endif
 /* Fold a unary tree expression with code CODE of type TYPE with an
-operand OP0.  Return a folded expression if successful.  Otherwise,
+operand OP0.  LOC is the location of the resulting expression.
-return a tree expression with code CODE of type TYPE with an
+Return a folded expression if successful.  Otherwise, return a tree
-operand OP0.  */
+expression with code CODE of type TYPE with an operand OP0.  */
 tree
-fold_build1_stat (enum tree_code code, tree type, tree op0 MEM_STAT_DECL)
+fold_build1_stat_loc (location_t loc,
+		      enum tree_code code, tree type, tree op0 MEM_STAT_DECL)
 {
 tree tem;
 #ifdef ENABLE_FOLD_CHECKING
 unsigned char checksum_before[16], checksum_after[16];
 struct md5_ctx ctx;
 md5_init_ctx (&ctx);
 fold_checksum_tree (op0, &ctx, ht);
 md5_finish_ctx (&ctx, checksum_before);
 htab_empty (ht);
 #endif
-tem = fold_unary (code, type, op0);
+tem = fold_unary_loc (loc, code, type, op0);
 if (!tem)
-tem = build1_stat (code, type, op0 PASS_MEM_STAT);
+{
+tem = build1_stat (code, type, op0 PASS_MEM_STAT);
+SET_EXPR_LOCATION (tem, loc);
+}
 #ifdef ENABLE_FOLD_CHECKING
 md5_init_ctx (&ctx);
 fold_checksum_tree (op0, &ctx, ht);
 md5_finish_ctx (&ctx, checksum_after);
 htab_delete (ht);
 #endif
 return tem;
 }
 /* Fold a binary tree expression with code CODE of type TYPE with
-operands OP0 and OP1.  Return a folded expression if successful.
+operands OP0 and OP1.  LOC is the location of the resulting
-Otherwise, return a tree expression with code CODE of type TYPE
+expression.  Return a folded expression if successful.  Otherwise,
-with operands OP0 and OP1.  */
+return a tree expression with code CODE of type TYPE with operands
+OP0 and OP1.  */
 tree
-fold_build2_stat (enum tree_code code, tree type, tree op0, tree op1
+fold_build2_stat_loc (location_t loc,
-		  MEM_STAT_DECL)
+		      enum tree_code code, tree type, tree op0, tree op1
+		      MEM_STAT_DECL)
 {
 tree tem;
 #ifdef ENABLE_FOLD_CHECKING
 unsigned char checksum_before_op0[16],
 checksum_before_op1[16],
 fold_checksum_tree (op1, &ctx, ht);
 md5_finish_ctx (&ctx, checksum_before_op1);
 htab_empty (ht);
 #endif
-tem = fold_binary (code, type, op0, op1);
+tem = fold_binary_loc (loc, code, type, op0, op1);
 if (!tem)
-tem = build2_stat (code, type, op0, op1 PASS_MEM_STAT);
+{
+tem = build2_stat (code, type, op0, op1 PASS_MEM_STAT);
+SET_EXPR_LOCATION (tem, loc);
+}
 #ifdef ENABLE_FOLD_CHECKING
 md5_init_ctx (&ctx);
 fold_checksum_tree (op0, &ctx, ht);
 md5_finish_ctx (&ctx, checksum_after_op0);
 htab_empty (ht);
 if (memcmp (checksum_before_op0, checksum_after_op0, 16))
 fold_check_failed (op0, tem);
 md5_init_ctx (&ctx);
 fold_checksum_tree (op1, &ctx, ht);
 md5_finish_ctx (&ctx, checksum_after_op1);
 htab_delete (ht);
 operands OP0, OP1, and OP2.  Return a folded expression if
 successful.  Otherwise, return a tree expression with code CODE of
 type TYPE with operands OP0, OP1, and OP2.  */
 tree
-fold_build3_stat (enum tree_code code, tree type, tree op0, tree op1, tree op2
+fold_build3_stat_loc (location_t loc, enum tree_code code, tree type,
-	     MEM_STAT_DECL)
+		      tree op0, tree op1, tree op2 MEM_STAT_DECL)
 {
 tree tem;
 #ifdef ENABLE_FOLD_CHECKING
 unsigned char checksum_before_op0[16],
 checksum_before_op1[16],
 md5_finish_ctx (&ctx, checksum_before_op2);
 htab_empty (ht);
 #endif
 gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
-tem = fold_ternary (code, type, op0, op1, op2);
+tem = fold_ternary_loc (loc, code, type, op0, op1, op2);
 if (!tem)
-tem =  build3_stat (code, type, op0, op1, op2 PASS_MEM_STAT);
+{
+tem =  build3_stat (code, type, op0, op1, op2 PASS_MEM_STAT);
+SET_EXPR_LOCATION (tem, loc);
+}
 #ifdef ENABLE_FOLD_CHECKING
 md5_init_ctx (&ctx);
 fold_checksum_tree (op0, &ctx, ht);
 md5_finish_ctx (&ctx, checksum_after_op0);
 htab_empty (ht);
 if (memcmp (checksum_before_op0, checksum_after_op0, 16))
 fold_check_failed (op0, tem);
 md5_init_ctx (&ctx);
 fold_checksum_tree (op1, &ctx, ht);
 md5_finish_ctx (&ctx, checksum_after_op1);
 htab_empty (ht);
 if (memcmp (checksum_before_op1, checksum_after_op1, 16))
 fold_check_failed (op1, tem);
 md5_init_ctx (&ctx);
 fold_checksum_tree (op2, &ctx, ht);
 md5_finish_ctx (&ctx, checksum_after_op2);
 htab_delete (ht);
 arguments in ARGARRAY, and a null static chain.
 Return a folded expression if successful.  Otherwise, return a CALL_EXPR
 of type TYPE from the given operands as constructed by build_call_array.  */
 tree
-fold_build_call_array (tree type, tree fn, int nargs, tree *argarray)
+fold_build_call_array_loc (location_t loc, tree type, tree fn,
+			   int nargs, tree *argarray)
 {
 tree tem;
 #ifdef ENABLE_FOLD_CHECKING
 unsigned char checksum_before_fn[16],
 checksum_before_arglist[16],
 fold_checksum_tree (argarray[i], &ctx, ht);
 md5_finish_ctx (&ctx, checksum_before_arglist);
 htab_empty (ht);
 #endif
-tem = fold_builtin_call_array (type, fn, nargs, argarray);
+tem = fold_builtin_call_array (loc, type, fn, nargs, argarray);
 #ifdef ENABLE_FOLD_CHECKING
 md5_init_ctx (&ctx);
 fold_checksum_tree (fn, &ctx, ht);
 md5_finish_ctx (&ctx, checksum_after_fn);
 htab_empty (ht);
 if (memcmp (checksum_before_fn, checksum_after_fn, 16))
 fold_check_failed (fn, tem);
 md5_init_ctx (&ctx);
 for (i = 0; i < nargs; i++)
 fold_checksum_tree (argarray[i], &ctx, ht);
 md5_finish_ctx (&ctx, checksum_after_arglist);
 htab_delete (ht);
 flag_rounding_math = saved_rounding_math;\
 flag_trapv = saved_trapv;\
 folding_initializer = saved_folding_initializer;
 tree
-fold_build1_initializer (enum tree_code code, tree type, tree op)
+fold_build1_initializer_loc (location_t loc, enum tree_code code,
+			     tree type, tree op)
 {
 tree result;
 START_FOLD_INIT;
-result = fold_build1 (code, type, op);
+result = fold_build1_loc (loc, code, type, op);
 END_FOLD_INIT;
 return result;
 }
 tree
-fold_build2_initializer (enum tree_code code, tree type, tree op0, tree op1)
+fold_build2_initializer_loc (location_t loc, enum tree_code code,
+			     tree type, tree op0, tree op1)
 {
 tree result;
 START_FOLD_INIT;
-result = fold_build2 (code, type, op0, op1);
+result = fold_build2_loc (loc, code, type, op0, op1);
 END_FOLD_INIT;
 return result;
 }
 tree
-fold_build3_initializer (enum tree_code code, tree type, tree op0, tree op1,
+fold_build3_initializer_loc (location_t loc, enum tree_code code,
-			 tree op2)
+			     tree type, tree op0, tree op1, tree op2)
 {
 tree result;
 START_FOLD_INIT;
-result = fold_build3 (code, type, op0, op1, op2);
+result = fold_build3_loc (loc, code, type, op0, op1, op2);
 END_FOLD_INIT;
 return result;
 }
 tree
-fold_build_call_array_initializer (tree type, tree fn,
+fold_build_call_array_initializer_loc (location_t loc, tree type, tree fn,
-				   int nargs, tree *argarray)
+				       int nargs, tree *argarray)
 {
 tree result;
 START_FOLD_INIT;
-result = fold_build_call_array (type, fn, nargs, argarray);
+result = fold_build_call_array_loc (loc, type, fn, nargs, argarray);
 END_FOLD_INIT;
 return result;
 }
 	 both unsigned and their total bits is shorter than the result.  */
 if (TREE_CODE (type) == INTEGER_TYPE
 	  && (TREE_CODE (op0) == NOP_EXPR || TREE_CODE (op0) == INTEGER_CST)
 	  && (TREE_CODE (op1) == NOP_EXPR || TREE_CODE (op1) == INTEGER_CST))
 	{
 	  tree inner0 = (TREE_CODE (op0) == NOP_EXPR)
 	    ? TREE_TYPE (TREE_OPERAND (op0, 0))
 	    : TREE_TYPE (op0);
 	  tree inner1 = (TREE_CODE (op1) == NOP_EXPR)
 	    ? TREE_TYPE (TREE_OPERAND (op1, 0))
 	    : TREE_TYPE (op1);
 	  bool unsigned0 = TYPE_UNSIGNED (inner0);
 	  bool unsigned1 = TYPE_UNSIGNED (inner1);
 case CONSTRUCTOR:
 case OBJ_TYPE_REF:
 case ASSERT_EXPR:
 case ADDR_EXPR:
 case WITH_SIZE_EXPR:
-case EXC_PTR_EXPR:
 case SSA_NAME:
-case FILTER_EXPR:
 return tree_single_nonnegative_warnv_p (t, strict_overflow_p);
 default:
 return tree_invalid_nonnegative_warnv_p (t, strict_overflow_p);
 }
 	tree base = get_base_address (TREE_OPERAND (t, 0));
 	if (!base)
 	  return false;
-	/* Weak declarations may link to NULL.  */
+	/* Weak declarations may link to NULL.  Other things may also be NULL
-	if (VAR_OR_FUNCTION_DECL_P (base))
+	   so protect with -fdelete-null-pointer-checks; but not variables
-	  return !DECL_WEAK (base);
+	   allocated on the stack.  */
+	if (DECL_P (base)
+	    && (flag_delete_null_pointer_checks
+		|| (TREE_CODE (base) == VAR_DECL && !TREE_STATIC (base))))
+	  return !VAR_OR_FUNCTION_DECL_P (base) || !DECL_WEAK (base);
 	/* Constants are never weak.  */
 	if (CONSTANT_CLASS_P (base))
 	  return true;
 case CONSTRUCTOR:
 case OBJ_TYPE_REF:
 case ASSERT_EXPR:
 case ADDR_EXPR:
 case WITH_SIZE_EXPR:
-case EXC_PTR_EXPR:
 case SSA_NAME:
-case FILTER_EXPR:
 return tree_single_nonzero_warnv_p (t, strict_overflow_p);
 case COMPOUND_EXPR:
 case MODIFY_EXPR:
 case BIND_EXPR:
 && TREE_CODE (TREE_TYPE (exp)) == INTEGER_TYPE)
 {
 tree exp1 = TREE_OPERAND (exp, 0);
 tree index;
 tree string;
+location_t loc = EXPR_LOCATION (exp);
 if (TREE_CODE (exp) == INDIRECT_REF)
 	string = string_constant (exp1, &index);
 else
 	{
 	  tree low_bound = array_ref_low_bound (exp);
-	  index = fold_convert (sizetype, TREE_OPERAND (exp, 1));
+	  index = fold_convert_loc (loc, sizetype, TREE_OPERAND (exp, 1));
 	  /* Optimize the special-case of a zero lower bound.
 	     We convert the low_bound to sizetype to avoid some problems
 	     with constant folding.  (E.g. suppose the lower bound is 1,
 	     and its mode is QI.  Without the conversion,l (ARRAY
 	     +(INDEX-(unsigned char)1)) becomes ((ARRAY+(-(unsigned char)1))
 	     +INDEX), which becomes (ARRAY+255+INDEX).  Oops!)  */
 	  if (! integer_zerop (low_bound))
-	    index = size_diffop (index, fold_convert (sizetype, low_bound));
+	    index = size_diffop_loc (loc, index,
+				 fold_convert_loc (loc, sizetype, low_bound));
 	  string = exp1;
 	}
 if (string
 					    &(TREE_FIXED_CST (arg0)), NULL,
 					    TYPE_SATURATING (type));
 	t = build_fixed (type, f);
 	/* Propagate overflow flags.  */
 	if (overflow_p | TREE_OVERFLOW (arg0))
-	  {
+	  TREE_OVERFLOW (t) = 1;
-	    TREE_OVERFLOW (t) = 1;
-	    TREE_CONSTANT_OVERFLOW (t) = 1;
-	  }
-	else if (TREE_CONSTANT_OVERFLOW (arg0))
-	  TREE_CONSTANT_OVERFLOW (t) = 1;
 	break;
 }
 default:
 gcc_unreachable ();
 return expr;
 op = TREE_OPERAND (op, 1);
 if (!TREE_SIDE_EFFECTS (op))
 return expr;
 }
 return build1 (CLEANUP_POINT_EXPR, type, expr);
 }
 /* Given a pointer value OP0 and a type TYPE, return a simplified version
 of an indirection through OP0, or NULL_TREE if no simplification is
 possible.  */
 tree
-fold_indirect_ref_1 (tree type, tree op0)
+fold_indirect_ref_1 (location_t loc, tree type, tree op0)
 {
 tree sub = op0;
 tree subtype;
 STRIP_NOPS (sub);
 	{
 	  tree type_domain = TYPE_DOMAIN (optype);
 	  tree min_val = size_zero_node;
 	  if (type_domain && TYPE_MIN_VALUE (type_domain))
 	    min_val = TYPE_MIN_VALUE (type_domain);
-	  return build4 (ARRAY_REF, type, op, min_val, NULL_TREE, NULL_TREE);
+	  op0 = build4 (ARRAY_REF, type, op, min_val, NULL_TREE, NULL_TREE);
+	  SET_EXPR_LOCATION (op0, loc);
+	  return op0;
 	}
 /* *(foo *)&complexfoo => __real__ complexfoo */
 else if (TREE_CODE (optype) == COMPLEX_TYPE
 	       && type == TREE_TYPE (optype))
-	return fold_build1 (REALPART_EXPR, type, op);
+	return fold_build1_loc (loc, REALPART_EXPR, type, op);
 /* *(foo *)&vectorfoo => BIT_FIELD_REF<vectorfoo,...> */
 else if (TREE_CODE (optype) == VECTOR_TYPE
 	       && type == TREE_TYPE (optype))
 	{
 	  tree part_width = TYPE_SIZE (type);
 	  tree index = bitsize_int (0);
-	  return fold_build3 (BIT_FIELD_REF, type, op, part_width, index);
+	  return fold_build3_loc (loc, BIT_FIELD_REF, type, op, part_width, index);
 	}
 }
 /* ((foo*)&vectorfoo)[1] => BIT_FIELD_REF<vectorfoo,...> */
 if (TREE_CODE (sub) == POINTER_PLUS_EXPR
 && TREE_CODE (TREE_OPERAND (sub, 1)) == INTEGER_CST)
 {
 tree op00 = TREE_OPERAND (sub, 0);
 tree op01 = TREE_OPERAND (sub, 1);
 tree op00type;
 STRIP_NOPS (op00);
 op00type = TREE_TYPE (op00);
 if (TREE_CODE (op00) == ADDR_EXPR
 && TREE_CODE (TREE_TYPE (op00type)) == VECTOR_TYPE
 && type == TREE_TYPE (TREE_TYPE (op00type)))
 	{
 	  HOST_WIDE_INT offset = tree_low_cst (op01, 0);
 	  tree part_width = TYPE_SIZE (type);
 	  unsigned HOST_WIDE_INT part_widthi = tree_low_cst (part_width, 0)/BITS_PER_UNIT;
 	  unsigned HOST_WIDE_INT indexi = offset * BITS_PER_UNIT;
 	  tree index = bitsize_int (indexi);
 	  if (offset/part_widthi <= TYPE_VECTOR_SUBPARTS (TREE_TYPE (op00type)))
-	    return fold_build3 (BIT_FIELD_REF, type, TREE_OPERAND (op00, 0),
+	    return fold_build3_loc (loc,
+				BIT_FIELD_REF, type, TREE_OPERAND (op00, 0),
 				part_width, index);
 	}
 }
 /* ((foo*)&complexfoo)[1] => __imag__ complexfoo */
 	  && TREE_CODE (TREE_TYPE (op00type)) == COMPLEX_TYPE
 	  && type == TREE_TYPE (TREE_TYPE (op00type)))
 	{
 	  tree size = TYPE_SIZE_UNIT (type);
 	  if (tree_int_cst_equal (size, op01))
-	    return fold_build1 (IMAGPART_EXPR, type, TREE_OPERAND (op00, 0));
+	    return fold_build1_loc (loc, IMAGPART_EXPR, type,
-	}
+				TREE_OPERAND (op00, 0));
-}
+	}
+}
 /* *(foo *)fooarrptr => (*fooarrptr)[0] */
 if (TREE_CODE (TREE_TYPE (subtype)) == ARRAY_TYPE
 && type == TREE_TYPE (TREE_TYPE (subtype)))
 {
 tree type_domain;
 tree min_val = size_zero_node;
-sub = build_fold_indirect_ref (sub);
+sub = build_fold_indirect_ref_loc (loc, sub);
 type_domain = TYPE_DOMAIN (TREE_TYPE (sub));
 if (type_domain && TYPE_MIN_VALUE (type_domain))
 	min_val = TYPE_MIN_VALUE (type_domain);
-return build4 (ARRAY_REF, type, sub, min_val, NULL_TREE, NULL_TREE);
+op0 = build4 (ARRAY_REF, type, sub, min_val, NULL_TREE, NULL_TREE);
+SET_EXPR_LOCATION (op0, loc);
+return op0;
 }
 return NULL_TREE;
 }
 /* Builds an expression for an indirection through T, simplifying some
 cases.  */
 tree
-build_fold_indirect_ref (tree t)
+build_fold_indirect_ref_loc (location_t loc, tree t)
 {
 tree type = TREE_TYPE (TREE_TYPE (t));
-tree sub = fold_indirect_ref_1 (type, t);
+tree sub = fold_indirect_ref_1 (loc, type, t);
 if (sub)
 return sub;
-else
-return build1 (INDIRECT_REF, type, t);
+t = build1 (INDIRECT_REF, type, t);
+SET_EXPR_LOCATION (t, loc);
+return t;
 }
 /* Given an INDIRECT_REF T, return either T or a simplified version.  */
 tree
-fold_indirect_ref (tree t)
+fold_indirect_ref_loc (location_t loc, tree t)
 {
-tree sub = fold_indirect_ref_1 (TREE_TYPE (t), TREE_OPERAND (t, 0));
+tree sub = fold_indirect_ref_1 (loc, TREE_TYPE (t), TREE_OPERAND (t, 0));
 if (sub)
 return sub;
 else
 return t;
 /* Return the value of VALUE, rounded up to a multiple of DIVISOR.
 This can only be applied to objects of a sizetype.  */
 tree
-round_up (tree value, int divisor)
+round_up_loc (location_t loc, tree value, int divisor)
 {
 tree div = NULL_TREE;
 gcc_assert (divisor > 0);
 if (divisor == 1)
 else
 	{
 	  tree t;
 	  t = build_int_cst (TREE_TYPE (value), divisor - 1);
-	  value = size_binop (PLUS_EXPR, value, t);
+	  value = size_binop_loc (loc, PLUS_EXPR, value, t);
 	  t = build_int_cst (TREE_TYPE (value), -divisor);
-	  value = size_binop (BIT_AND_EXPR, value, t);
+	  value = size_binop_loc (loc, BIT_AND_EXPR, value, t);
 	}
 }
 else
 {
 if (!div)
 	div = build_int_cst (TREE_TYPE (value), divisor);
-value = size_binop (CEIL_DIV_EXPR, value, div);
+value = size_binop_loc (loc, CEIL_DIV_EXPR, value, div);
-value = size_binop (MULT_EXPR, value, div);
+value = size_binop_loc (loc, MULT_EXPR, value, div);
 }
 return value;
 }
 /* Likewise, but round down.  */
 tree
-round_down (tree value, int divisor)
+round_down_loc (location_t loc, tree value, int divisor)
 {
 tree div = NULL_TREE;
 gcc_assert (divisor > 0);
 if (divisor == 1)
 if (divisor == (divisor & -divisor))
 {
 tree t;
 t = build_int_cst (TREE_TYPE (value), -divisor);
-value = size_binop (BIT_AND_EXPR, value, t);
+value = size_binop_loc (loc, BIT_AND_EXPR, value, t);
 }
 else
 {
 if (!div)
 	div = build_int_cst (TREE_TYPE (value), divisor);
-value = size_binop (FLOOR_DIV_EXPR, value, div);
+value = size_binop_loc (loc, FLOOR_DIV_EXPR, value, div);
-value = size_binop (MULT_EXPR, value, div);
+value = size_binop_loc (loc, MULT_EXPR, value, div);
 }
 return value;
 }
 {
 tree core;
 enum machine_mode mode;
 int unsignedp, volatilep;
 HOST_WIDE_INT bitsize;
+location_t loc = EXPR_LOCATION (exp);
 if (TREE_CODE (exp) == ADDR_EXPR)
 {
 core = get_inner_reference (TREE_OPERAND (exp, 0), &bitsize, pbitpos,
 				  poffset, &mode, &unsignedp, &volatilep,
 				  false);
-core = fold_addr_expr (core);
+core = build_fold_addr_expr_loc (loc, core);
 }
 else
 {
 core = exp;
 *pbitpos = 0;
 tree
 fold_strip_sign_ops (tree exp)
 {
 tree arg0, arg1;
+location_t loc = EXPR_LOCATION (exp);
 switch (TREE_CODE (exp))
 {
 case ABS_EXPR:
 case NEGATE_EXPR:
 if (HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (TREE_TYPE (exp))))
 	return NULL_TREE;
 arg0 = fold_strip_sign_ops (TREE_OPERAND (exp, 0));
 arg1 = fold_strip_sign_ops (TREE_OPERAND (exp, 1));
 if (arg0 != NULL_TREE || arg1 != NULL_TREE)
-	return fold_build2 (TREE_CODE (exp), TREE_TYPE (exp),
+	return fold_build2_loc (loc, TREE_CODE (exp), TREE_TYPE (exp),
 			    arg0 ? arg0 : TREE_OPERAND (exp, 0),
 			    arg1 ? arg1 : TREE_OPERAND (exp, 1));
 break;
 case COMPOUND_EXPR:
 arg0 = TREE_OPERAND (exp, 0);
 arg1 = fold_strip_sign_ops (TREE_OPERAND (exp, 1));
 if (arg1)
-	return fold_build2 (COMPOUND_EXPR, TREE_TYPE (exp), arg0, arg1);
+	return fold_build2_loc (loc, COMPOUND_EXPR, TREE_TYPE (exp), arg0, arg1);
 break;
 case COND_EXPR:
 arg0 = fold_strip_sign_ops (TREE_OPERAND (exp, 1));
 arg1 = fold_strip_sign_ops (TREE_OPERAND (exp, 2));
 if (arg0 || arg1)
-	return fold_build3 (COND_EXPR, TREE_TYPE (exp), TREE_OPERAND (exp, 0),
+	return fold_build3_loc (loc,
+			    COND_EXPR, TREE_TYPE (exp), TREE_OPERAND (exp, 0),
 			    arg0 ? arg0 : TREE_OPERAND (exp, 1),
 			    arg1 ? arg1 : TREE_OPERAND (exp, 2));
 break;
 case CALL_EXPR:
 {
 	const enum built_in_function fcode = builtin_mathfn_code (exp);
 	switch (fcode)
 	{
 	CASE_FLT_FN (BUILT_IN_COPYSIGN):
 	  /* Strip copysign function call, return the 1st argument. */
 	  arg0 = CALL_EXPR_ARG (exp, 0);
 	  arg1 = CALL_EXPR_ARG (exp, 1);
-	  return omit_one_operand (TREE_TYPE (exp), arg0, arg1);
+	  return omit_one_operand_loc (loc, TREE_TYPE (exp), arg0, arg1);
 	default:
 	  /* Strip sign ops from the argument of "odd" math functions.  */
 	  if (negate_mathfn_p (fcode))
 {
 	      arg0 = fold_strip_sign_ops (CALL_EXPR_ARG (exp, 0));
 	      if (arg0)
-		return build_call_expr (get_callee_fndecl (exp), 1, arg0);
+		return build_call_expr_loc (loc, get_callee_fndecl (exp), 1, arg0);
 	    }
 	  break;
 	}
 }
 break;

Mercurial > hg > CbC > CbC_gcc

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