OSDN Git Service

2009-07-17 Aldy Hernandez <aldyh@redhat.com>
authormanu <manu@138bc75d-0d04-0410-961f-82ee72b054a4>
Thu, 16 Jul 2009 22:29:52 +0000 (22:29 +0000)
committermanu <manu@138bc75d-0d04-0410-961f-82ee72b054a4>
Thu, 16 Jul 2009 22:29:52 +0000 (22:29 +0000)
    Manuel López-Ibáñez  <manu@gcc.gnu.org>

PR 40435
* tree-complex.c, tree-loop-distribution.c,
tree.c, tree.h, builtins.c, fold-const.c, omp-low.c,
cgraphunit.c, tree-ssa-ccp.c, tree-ssa-dom.c,
gimple-low.c, expr.c, tree-ssa-ifcombine.c, c-decl.c,
stor-layout.c, tree-if-conv.c, c-typeck.c,
gimplify.c, calls.c, tree-sra.c, tree-mudflap.c,
tree-ssa-copy.c, tree-ssa-forwprop.c, c-convert.c, c-omp.c,
varasm.c, tree-inline.c, c-common.c,
c-common.h, gimple.c, tree-switch-conversion.c, gimple.h,
tree-cfg.c, c-parser.c, convert.c: Add location
argument to fold_{unary,binary,ternary}, fold_build[123],
build_call_expr, build_size_arg, build_fold_addr_expr,
build_call_array, non_lvalue, size_diffop,
fold_build1_initializer, fold_build2_initializer,
fold_build3_initializer, fold_build_call_array,
fold_build_call_array_initializer, fold_single_bit_test,
omit_one_operand, omit_two_operands, invert_truthvalue,
fold_truth_not_expr, build_fold_indirect_ref, fold_indirect_ref,
combine_comparisons, fold_builtin_*, fold_call_expr,
build_range_check, maybe_fold_offset_to_address, round_up,
round_down.
objc/
* objc-act.c: Add location argument to all calls to
build_fold_addr_expr.
testsuite/
* gcc.dg/pr36902.c: Add column info.
* g++.dg/gcov/gcov-2.C: Change count for definition.
cp/
* typeck.c, init.c, class.c, method.c, rtti.c, except.c, error.c,
tree.c, cp-gimplify.c, cxx-pretty-print.c, pt.c, semantics.c,
call.c, cvt.c, mangle.c: Add location argument to
fold_{unary,binary,ternary}, fold_build[123], build_call_expr,
build_size_arg, build_fold_addr_expr, build_call_array,
non_lvalue, size_diffop, fold_build1_initializer,
fold_build2_initializer, fold_build3_initializer,
fold_build_call_array, fold_build_call_array_initializer,
fold_single_bit_test, omit_one_operand, omit_two_operands,
invert_truthvalue, fold_truth_not_expr, build_fold_indirect_ref,
fold_indirect_ref, combine_comparisons, fold_builtin_*,
fold_call_expr, build_range_check, maybe_fold_offset_to_address,
round_up, round_down.
fortran/
* trans-expr.c, trans-array.c, trans-openmp.c, trans-stmt.c,
trans.c, trans-io.c, trans-decl.c, trans-intrinsic.c: Add location
argument to fold_{unary,binary,ternary}, fold_build[123],
build_call_expr, build_size_arg, build_fold_addr_expr,
build_call_array, non_lvalue, size_diffop,
fold_build1_initializer, fold_build2_initializer,
fold_build3_initializer, fold_build_call_array,
fold_build_call_array_initializer, fold_single_bit_test,
omit_one_operand, omit_two_operands, invert_truthvalue,
fold_truth_not_expr, build_fold_indirect_ref, fold_indirect_ref,
combine_comparisons, fold_builtin_*, fold_call_expr,
build_range_check, maybe_fold_offset_to_address, round_up,
round_down.

git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@149722 138bc75d-0d04-0410-961f-82ee72b054a4

66 files changed:
gcc/ChangeLog
gcc/builtins.c
gcc/c-common.c
gcc/c-common.h
gcc/c-convert.c
gcc/c-decl.c
gcc/c-omp.c
gcc/c-parser.c
gcc/c-typeck.c
gcc/calls.c
gcc/cgraphunit.c
gcc/convert.c
gcc/cp/ChangeLog
gcc/cp/call.c
gcc/cp/class.c
gcc/cp/cp-gimplify.c
gcc/cp/cvt.c
gcc/cp/cxx-pretty-print.c
gcc/cp/error.c
gcc/cp/except.c
gcc/cp/init.c
gcc/cp/mangle.c
gcc/cp/method.c
gcc/cp/pt.c
gcc/cp/rtti.c
gcc/cp/semantics.c
gcc/cp/tree.c
gcc/cp/typeck.c
gcc/expr.c
gcc/fold-const.c
gcc/fortran/ChangeLog
gcc/fortran/trans-array.c
gcc/fortran/trans-decl.c
gcc/fortran/trans-expr.c
gcc/fortran/trans-intrinsic.c
gcc/fortran/trans-io.c
gcc/fortran/trans-openmp.c
gcc/fortran/trans-stmt.c
gcc/fortran/trans.c
gcc/gimple-low.c
gcc/gimple.c
gcc/gimple.h
gcc/gimplify.c
gcc/objc/ChangeLog
gcc/objc/objc-act.c
gcc/omp-low.c
gcc/stor-layout.c
gcc/testsuite/ChangeLog
gcc/testsuite/g++.dg/gcov/gcov-2.C
gcc/testsuite/gcc.dg/pr36902.c
gcc/tree-cfg.c
gcc/tree-complex.c
gcc/tree-if-conv.c
gcc/tree-inline.c
gcc/tree-loop-distribution.c
gcc/tree-mudflap.c
gcc/tree-sra.c
gcc/tree-ssa-ccp.c
gcc/tree-ssa-copy.c
gcc/tree-ssa-dom.c
gcc/tree-ssa-forwprop.c
gcc/tree-ssa-ifcombine.c
gcc/tree-switch-conversion.c
gcc/tree.c
gcc/tree.h
gcc/varasm.c

index 28ff163..c6eb42a 100644 (file)
@@ -1,3 +1,27 @@
+2009-07-17  Aldy Hernandez  <aldyh@redhat.com>
+           Manuel López-Ibáñez  <manu@gcc.gnu.org>
+
+       PR 40435 
+       * tree-complex.c, tree-loop-distribution.c, tree.c, tree.h,
+       builtins.c, fold-const.c, omp-low.c, cgraphunit.c, tree-ssa-ccp.c,
+       tree-ssa-dom.c, gimple-low.c, expr.c, tree-ssa-ifcombine.c,
+       c-decl.c, stor-layout.c, tree-if-conv.c, c-typeck.c, gimplify.c,
+       calls.c, tree-sra.c, tree-mudflap.c, tree-ssa-copy.c,
+       tree-ssa-forwprop.c, c-convert.c, c-omp.c, varasm.c,
+       tree-inline.c, c-common.c, c-common.h, gimple.c,
+       tree-switch-conversion.c, gimple.h, tree-cfg.c, c-parser.c,
+       convert.c: Add location argument to fold_{unary,binary,ternary},
+       fold_build[123], build_call_expr, build_size_arg,
+       build_fold_addr_expr, build_call_array, non_lvalue, size_diffop,
+       fold_build1_initializer, fold_build2_initializer,
+       fold_build3_initializer, fold_build_call_array,
+       fold_build_call_array_initializer, fold_single_bit_test,
+       omit_one_operand, omit_two_operands, invert_truthvalue,
+       fold_truth_not_expr, build_fold_indirect_ref, fold_indirect_ref,
+       combine_comparisons, fold_builtin_*, fold_call_expr,
+       build_range_check, maybe_fold_offset_to_address, round_up,
+       round_down.
+
 2009-07-16  Jason Merrill  <jason@redhat.com>
 
        PR libstdc++/37907
index a94a379..5a474cd 100644 (file)
@@ -152,65 +152,65 @@ static rtx expand_builtin_fputs (tree, rtx, bool);
 static rtx expand_builtin_printf (tree, rtx, enum machine_mode, bool);
 static rtx expand_builtin_fprintf (tree, rtx, enum machine_mode, bool);
 static rtx expand_builtin_sprintf (tree, rtx, enum machine_mode);
-static tree stabilize_va_list (tree, int);
+static tree stabilize_va_list_loc (location_t, tree, int);
 static rtx expand_builtin_expect (tree, rtx);
 static tree fold_builtin_constant_p (tree);
-static tree fold_builtin_expect (tree, tree);
+static tree fold_builtin_expect (location_t, tree, tree);
 static tree fold_builtin_classify_type (tree);
-static tree fold_builtin_strlen (tree);
-static tree fold_builtin_inf (tree, int);
+static tree fold_builtin_strlen (location_t, tree);
+static tree fold_builtin_inf (location_t, tree, int);
 static tree fold_builtin_nan (tree, tree, int);
-static tree rewrite_call_expr (tree, int, tree, int, ...);
+static tree rewrite_call_expr (location_t, tree, int, tree, int, ...);
 static bool validate_arg (const_tree, enum tree_code code);
 static bool integer_valued_real_p (tree);
-static tree fold_trunc_transparent_mathfn (tree, tree);
+static tree fold_trunc_transparent_mathfn (location_t, tree, tree);
 static bool readonly_data_expr (tree);
 static rtx expand_builtin_fabs (tree, rtx, rtx);
 static rtx expand_builtin_signbit (tree, rtx);
-static tree fold_builtin_sqrt (tree, tree);
-static tree fold_builtin_cbrt (tree, tree);
-static tree fold_builtin_pow (tree, tree, tree, tree);
-static tree fold_builtin_powi (tree, tree, tree, tree);
-static tree fold_builtin_cos (tree, tree, tree);
-static tree fold_builtin_cosh (tree, tree, tree);
+static tree fold_builtin_sqrt (location_t, tree, tree);
+static tree fold_builtin_cbrt (location_t, tree, tree);
+static tree fold_builtin_pow (location_t, tree, tree, tree, tree);
+static tree fold_builtin_powi (location_t, tree, tree, tree, tree);
+static tree fold_builtin_cos (location_t, tree, tree, tree);
+static tree fold_builtin_cosh (location_t, tree, tree, tree);
 static tree fold_builtin_tan (tree, tree);
-static tree fold_builtin_trunc (tree, tree);
-static tree fold_builtin_floor (tree, tree);
-static tree fold_builtin_ceil (tree, tree);
-static tree fold_builtin_round (tree, tree);
-static tree fold_builtin_int_roundingfn (tree, tree);
+static tree fold_builtin_trunc (location_t, tree, tree);
+static tree fold_builtin_floor (location_t, tree, tree);
+static tree fold_builtin_ceil (location_t, tree, tree);
+static tree fold_builtin_round (location_t, tree, tree);
+static tree fold_builtin_int_roundingfn (location_t, tree, tree);
 static tree fold_builtin_bitop (tree, tree);
-static tree fold_builtin_memory_op (tree, tree, tree, tree, bool, int);
-static tree fold_builtin_strchr (tree, tree, tree);
-static tree fold_builtin_memchr (tree, tree, tree, tree);
-static tree fold_builtin_memcmp (tree, tree, tree);
-static tree fold_builtin_strcmp (tree, tree);
-static tree fold_builtin_strncmp (tree, tree, tree);
-static tree fold_builtin_signbit (tree, tree);
-static tree fold_builtin_copysign (tree, tree, tree, tree);
-static tree fold_builtin_isascii (tree);
-static tree fold_builtin_toascii (tree);
-static tree fold_builtin_isdigit (tree);
-static tree fold_builtin_fabs (tree, tree);
-static tree fold_builtin_abs (tree, tree);
-static tree fold_builtin_unordered_cmp (tree, tree, tree, enum tree_code,
+static tree fold_builtin_memory_op (location_t, tree, tree, tree, tree, bool, int);
+static tree fold_builtin_strchr (location_t, tree, tree, tree);
+static tree fold_builtin_memchr (location_t, tree, tree, tree, tree);
+static tree fold_builtin_memcmp (location_t, tree, tree, tree);
+static tree fold_builtin_strcmp (location_t, tree, tree);
+static tree fold_builtin_strncmp (location_t, tree, tree, tree);
+static tree fold_builtin_signbit (location_t, tree, tree);
+static tree fold_builtin_copysign (location_t, tree, tree, tree, tree);
+static tree fold_builtin_isascii (location_t, tree);
+static tree fold_builtin_toascii (location_t, tree);
+static tree fold_builtin_isdigit (location_t, tree);
+static tree fold_builtin_fabs (location_t, tree, tree);
+static tree fold_builtin_abs (location_t, tree, tree);
+static tree fold_builtin_unordered_cmp (location_t, tree, tree, tree, enum tree_code,
                                        enum tree_code);
-static tree fold_builtin_n (tree, tree *, int, bool);
-static tree fold_builtin_0 (tree, bool);
-static tree fold_builtin_1 (tree, tree, bool);
-static tree fold_builtin_2 (tree, tree, tree, bool);
-static tree fold_builtin_3 (tree, tree, tree, tree, bool);
-static tree fold_builtin_4 (tree, tree, tree, tree, tree, bool);
-static tree fold_builtin_varargs (tree, tree, bool);
-
-static tree fold_builtin_strpbrk (tree, tree, tree);
-static tree fold_builtin_strstr (tree, tree, tree);
-static tree fold_builtin_strrchr (tree, tree, tree);
-static tree fold_builtin_strcat (tree, tree);
-static tree fold_builtin_strncat (tree, tree, tree);
-static tree fold_builtin_strspn (tree, tree);
-static tree fold_builtin_strcspn (tree, tree);
-static tree fold_builtin_sprintf (tree, tree, tree, int);
+static tree fold_builtin_n (location_t, tree, tree *, int, bool);
+static tree fold_builtin_0 (location_t, tree, bool);
+static tree fold_builtin_1 (location_t, tree, tree, bool);
+static tree fold_builtin_2 (location_t, tree, tree, tree, bool);
+static tree fold_builtin_3 (location_t, tree, tree, tree, tree, bool);
+static tree fold_builtin_4 (location_t, tree, tree, tree, tree, tree, bool);
+static tree fold_builtin_varargs (location_t, tree, tree, bool);
+
+static tree fold_builtin_strpbrk (location_t, tree, tree, tree);
+static tree fold_builtin_strstr (location_t, tree, tree, tree);
+static tree fold_builtin_strrchr (location_t, tree, tree, tree);
+static tree fold_builtin_strcat (location_t, tree, tree);
+static tree fold_builtin_strncat (location_t, tree, tree, tree);
+static tree fold_builtin_strspn (location_t, tree, tree);
+static tree fold_builtin_strcspn (location_t, tree, tree);
+static tree fold_builtin_sprintf (location_t, tree, tree, tree, int);
 
 static rtx expand_builtin_object_size (tree);
 static rtx expand_builtin_memory_chk (tree, rtx, enum machine_mode,
@@ -219,11 +219,11 @@ static void maybe_emit_chk_warning (tree, enum built_in_function);
 static void maybe_emit_sprintf_chk_warning (tree, enum built_in_function);
 static void maybe_emit_free_warning (tree);
 static tree fold_builtin_object_size (tree, tree);
-static tree fold_builtin_strcat_chk (tree, tree, tree, tree);
-static tree fold_builtin_strncat_chk (tree, tree, tree, tree, tree);
-static tree fold_builtin_sprintf_chk (tree, enum built_in_function);
-static tree fold_builtin_printf (tree, tree, tree, bool, enum built_in_function);
-static tree fold_builtin_fprintf (tree, tree, tree, tree, bool,
+static tree fold_builtin_strcat_chk (location_t, tree, tree, tree, tree);
+static tree fold_builtin_strncat_chk (location_t, tree, tree, tree, tree, tree);
+static tree fold_builtin_sprintf_chk (location_t, tree, enum built_in_function);
+static tree fold_builtin_printf (location_t, tree, tree, tree, bool, enum built_in_function);
+static tree fold_builtin_fprintf (location_t, tree, tree, tree, tree, bool,
                                  enum built_in_function);
 static bool init_target_chars (void);
 
@@ -482,7 +482,7 @@ c_strlen (tree src, int only_value)
         and return that.  This would perhaps not be valid if we were dealing
         with named arrays in addition to literal string constants.  */
 
-      return size_diffop (size_int (max), offset_node);
+      return size_diffop_loc (input_location, size_int (max), offset_node);
     }
 
   /* We have a known offset into the string.  Start searching there for
@@ -2268,6 +2268,7 @@ expand_builtin_interclass_mathfn (tree exp, rtx target, rtx subtarget)
   enum machine_mode mode;
   bool errno_set = false;
   tree arg;
+  location_t loc = EXPR_LOCATION (exp);
 
   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
     return NULL_RTX;
@@ -2342,7 +2343,7 @@ expand_builtin_interclass_mathfn (tree exp, rtx target, rtx subtarget)
        get_max_float (REAL_MODE_FORMAT (mode), buf, sizeof (buf));
        real_from_string (&r, buf);
        result = build_call_expr (isgr_fn, 2,
-                                 fold_build1 (ABS_EXPR, type, arg),
+                                 fold_build1_loc (loc, ABS_EXPR, type, arg),
                                  build_real (type, r));
        return expand_expr (result, target, VOIDmode, EXPAND_NORMAL);
       }
@@ -2358,7 +2359,7 @@ expand_builtin_interclass_mathfn (tree exp, rtx target, rtx subtarget)
        get_max_float (REAL_MODE_FORMAT (mode), buf, sizeof (buf));
        real_from_string (&r, buf);
        result = build_call_expr (isle_fn, 2,
-                                 fold_build1 (ABS_EXPR, type, arg),
+                                 fold_build1_loc (loc, ABS_EXPR, type, arg),
                                  build_real (type, r));
        return expand_expr (result, target, VOIDmode, EXPAND_NORMAL);
       }
@@ -2376,7 +2377,7 @@ expand_builtin_interclass_mathfn (tree exp, rtx target, rtx subtarget)
        real_from_string (&rmax, buf);
        sprintf (buf, "0x1p%d", REAL_MODE_FORMAT (mode)->emin - 1);
        real_from_string (&rmin, buf);
-       arg = builtin_save_expr (fold_build1 (ABS_EXPR, type, arg));
+       arg = builtin_save_expr (fold_build1_loc (loc, ABS_EXPR, type, arg));
        result = build_call_expr (isle_fn, 2, arg,
                                  build_real (type, rmax));
        result = fold_build2 (BIT_AND_EXPR, integer_type_node, result,
@@ -2405,6 +2406,7 @@ expand_builtin_sincos (tree exp)
   enum machine_mode mode;
   tree arg, sinp, cosp;
   int result;
+  location_t loc = EXPR_LOCATION (exp);
 
   if (!validate_arglist (exp, REAL_TYPE,
                         POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
@@ -2425,8 +2427,8 @@ expand_builtin_sincos (tree exp)
   target2 = gen_reg_rtx (mode);
 
   op0 = expand_normal (arg);
-  op1 = expand_normal (build_fold_indirect_ref (sinp));
-  op2 = expand_normal (build_fold_indirect_ref (cosp));
+  op1 = expand_normal (build_fold_indirect_ref_loc (loc, sinp));
+  op2 = expand_normal (build_fold_indirect_ref_loc (loc, cosp));
 
   /* Compute into target1 and target2.
      Set TARGET to wherever the result comes back.  */
@@ -2453,6 +2455,7 @@ expand_builtin_cexpi (tree exp, rtx target, rtx subtarget)
   tree arg, type;
   enum machine_mode mode;
   rtx op0, op1, op2;
+  location_t loc = EXPR_LOCATION (exp);
 
   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
     return NULL_RTX;
@@ -2534,7 +2537,7 @@ expand_builtin_cexpi (tree exp, rtx target, rtx subtarget)
          fn = build_fn_decl (name, fntype);
        }
 
-      narg = fold_build2 (COMPLEX_EXPR, ctype,
+      narg = fold_build2_loc (loc, COMPLEX_EXPR, ctype,
                          build_real (type, dconst0), arg);
 
       /* Make sure not to fold the cexp call again.  */
@@ -3269,7 +3272,8 @@ expand_builtin_strstr (tree exp, rtx target, enum machine_mode mode)
   if (validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
     {
       tree type = TREE_TYPE (exp);
-      tree result = fold_builtin_strstr (CALL_EXPR_ARG (exp, 0),
+      tree result = fold_builtin_strstr (EXPR_LOCATION (exp),
+                                        CALL_EXPR_ARG (exp, 0),
                                         CALL_EXPR_ARG (exp, 1), type);
       if (result)
        return expand_expr (result, target, mode, EXPAND_NORMAL);
@@ -3287,7 +3291,8 @@ expand_builtin_strchr (tree exp, rtx target, enum machine_mode mode)
   if (validate_arglist (exp, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
     {
       tree type = TREE_TYPE (exp);
-      tree result = fold_builtin_strchr (CALL_EXPR_ARG (exp, 0),
+      tree result = fold_builtin_strchr (EXPR_LOCATION (exp),
+                                        CALL_EXPR_ARG (exp, 0),
                                         CALL_EXPR_ARG (exp, 1), type);
       if (result)
        return expand_expr (result, target, mode, EXPAND_NORMAL);
@@ -3307,7 +3312,8 @@ expand_builtin_strrchr (tree exp, rtx target, enum machine_mode mode)
   if (validate_arglist (exp, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
     {
       tree type = TREE_TYPE (exp);
-      tree result = fold_builtin_strrchr (CALL_EXPR_ARG (exp, 0),
+      tree result = fold_builtin_strrchr (EXPR_LOCATION (exp),
+                                         CALL_EXPR_ARG (exp, 0),
                                          CALL_EXPR_ARG (exp, 1), type);
       if (result)
        return expand_expr (result, target, mode, EXPAND_NORMAL);
@@ -3325,7 +3331,8 @@ expand_builtin_strpbrk (tree exp, rtx target, enum machine_mode mode)
   if (validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
     {
       tree type = TREE_TYPE (exp);
-      tree result = fold_builtin_strpbrk (CALL_EXPR_ARG (exp, 0),
+      tree result = fold_builtin_strpbrk (EXPR_LOCATION (exp),
+                                         CALL_EXPR_ARG (exp, 0),
                                          CALL_EXPR_ARG (exp, 1), type);
       if (result)
        return expand_expr (result, target, mode, EXPAND_NORMAL);
@@ -3373,7 +3380,8 @@ expand_builtin_memcpy (tree exp, rtx target, enum machine_mode mode)
       unsigned int dest_align
        = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
       rtx dest_mem, src_mem, dest_addr, len_rtx;
-      tree result = fold_builtin_memory_op (dest, src, len, 
+      tree result = fold_builtin_memory_op (EXPR_LOCATION (exp),
+                                           dest, src, len, 
                                            TREE_TYPE (TREE_TYPE (fndecl)),
                                            false, /*endp=*/0);
       HOST_WIDE_INT expected_size = -1;
@@ -3504,7 +3512,8 @@ expand_builtin_mempcpy_args (tree dest, tree src, tree len, tree type,
       unsigned int dest_align
        = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
       rtx dest_mem, src_mem, len_rtx;
-      tree result = fold_builtin_memory_op (dest, src, len, type, false, endp);
+      tree result = fold_builtin_memory_op (UNKNOWN_LOCATION,
+                                           dest, src, len, type, false, endp);
 
       if (result)
        {
@@ -3599,7 +3608,8 @@ expand_builtin_memmove_args (tree dest, tree src, tree len,
                             tree type, rtx target, enum machine_mode mode, 
                              int ignore)
 {
-  tree result = fold_builtin_memory_op (dest, src, len, type, ignore, /*endp=*/3);
+  tree result = fold_builtin_memory_op (UNKNOWN_LOCATION,
+                                       dest, src, len, type, ignore, /*endp=*/3);
 
   if (result)
     {
@@ -3625,6 +3635,7 @@ expand_builtin_bcopy (tree exp, int ignore)
 {
   tree type = TREE_TYPE (exp);
   tree src, dest, size;
+  location_t loc = EXPR_LOCATION (exp);
 
   if (!validate_arglist (exp,
                         POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
@@ -3638,7 +3649,7 @@ expand_builtin_bcopy (tree exp, int ignore)
      This is done this way so that if it isn't expanded inline, we fall
      back to calling bcopy instead of memmove.  */
   return expand_builtin_memmove_args (dest, src,
-                                     fold_convert (sizetype, size),
+                                     fold_convert_loc (loc, sizetype, size),
                                      type, const0_rtx, VOIDmode, 
                                      ignore);
 }
@@ -3737,7 +3748,8 @@ static rtx
 expand_builtin_strcpy_args (tree fndecl, tree dest, tree src,
                            rtx target, enum machine_mode mode)
 {
-  tree result = fold_builtin_strcpy (fndecl, dest, src, 0);
+  tree result = fold_builtin_strcpy (UNKNOWN_LOCATION,
+                                    fndecl, dest, src, 0);
   if (result)
     return expand_expr (result, target, mode, EXPAND_NORMAL);
   return expand_movstr (dest, src, target, /*endp=*/0);
@@ -3753,6 +3765,7 @@ static rtx
 expand_builtin_stpcpy (tree exp, rtx target, enum machine_mode mode)
 {
   tree dst, src;
+  location_t loc = EXPR_LOCATION (exp);
 
   if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
     return NULL_RTX;
@@ -3787,7 +3800,7 @@ expand_builtin_stpcpy (tree exp, rtx target, enum machine_mode mode)
       if (! c_getstr (src) || ! (len = c_strlen (src, 0)))
        return expand_movstr (dst, src, target, /*endp=*/2);
 
-      lenp1 = size_binop (PLUS_EXPR, len, ssize_int (1));
+      lenp1 = size_binop_loc (loc, PLUS_EXPR, len, ssize_int (1));
       ret = expand_builtin_mempcpy_args (dst, src, lenp1, TREE_TYPE (exp),
                                         target, mode, /*endp=*/2);
 
@@ -3851,6 +3864,7 @@ static rtx
 expand_builtin_strncpy (tree exp, rtx target, enum machine_mode mode)
 {
   tree fndecl = get_callee_fndecl (exp);
+  location_t loc = EXPR_LOCATION (exp);
 
   if (validate_arglist (exp,
                        POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
@@ -3859,7 +3873,8 @@ expand_builtin_strncpy (tree exp, rtx target, enum machine_mode mode)
       tree src = CALL_EXPR_ARG (exp, 1);
       tree len = CALL_EXPR_ARG (exp, 2);
       tree slen = c_strlen (src, 1);
-      tree result = fold_builtin_strncpy (fndecl, dest, src, len, slen);
+      tree result = fold_builtin_strncpy (EXPR_LOCATION (exp),
+                                         fndecl, dest, src, len, slen);
 
       if (result)
        {
@@ -3876,7 +3891,7 @@ expand_builtin_strncpy (tree exp, rtx target, enum machine_mode mode)
       if (!host_integerp (len, 1) || !slen || !host_integerp (slen, 1))
        return NULL_RTX;
 
-      slen = size_binop (PLUS_EXPR, slen, ssize_int (1));
+      slen = size_binop_loc (loc, PLUS_EXPR, slen, ssize_int (1));
 
       /* We're required to pad with trailing zeros if the requested
         len is greater than strlen(s2)+1.  In that case try to
@@ -4106,6 +4121,7 @@ static rtx
 expand_builtin_bzero (tree exp)
 {
   tree dest, size;
+  location_t loc = EXPR_LOCATION (exp);
 
   if (!validate_arglist (exp, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
     return NULL_RTX;
@@ -4119,7 +4135,7 @@ expand_builtin_bzero (tree exp)
      calling bzero instead of memset.  */
 
   return expand_builtin_memset_args (dest, integer_zero_node,
-                                    fold_convert (sizetype, size),
+                                    fold_convert_loc (loc, sizetype, size),
                                     const0_rtx, VOIDmode, exp);
 }
 
@@ -4134,7 +4150,8 @@ expand_builtin_memchr (tree exp, rtx target, enum machine_mode mode)
                        INTEGER_TYPE, VOID_TYPE))
     {
       tree type = TREE_TYPE (exp);
-      tree result = fold_builtin_memchr (CALL_EXPR_ARG (exp, 0),
+      tree result = fold_builtin_memchr (EXPR_LOCATION (exp),
+                                        CALL_EXPR_ARG (exp, 0),
                                         CALL_EXPR_ARG (exp, 1),
                                         CALL_EXPR_ARG (exp, 2), type);
       if (result)
@@ -4151,12 +4168,15 @@ expand_builtin_memchr (tree exp, rtx target, enum machine_mode mode)
 static rtx
 expand_builtin_memcmp (tree exp, rtx target, enum machine_mode mode)
 {
+  location_t loc = EXPR_LOCATION (exp);
+
   if (!validate_arglist (exp,
                         POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
     return NULL_RTX;
   else
     {
-      tree result = fold_builtin_memcmp (CALL_EXPR_ARG (exp, 0),
+      tree result = fold_builtin_memcmp (EXPR_LOCATION (exp),
+                                        CALL_EXPR_ARG (exp, 0),
                                         CALL_EXPR_ARG (exp, 1),
                                         CALL_EXPR_ARG (exp, 2));
       if (result)
@@ -4203,7 +4223,7 @@ expand_builtin_memcmp (tree exp, rtx target, enum machine_mode mode)
 
     arg1_rtx = get_memory_rtx (arg1, len);
     arg2_rtx = get_memory_rtx (arg2, len);
-    arg3_rtx = expand_normal (fold_convert (sizetype, len));
+    arg3_rtx = expand_normal (fold_convert_loc (loc, sizetype, len));
 
     /* Set MEM_SIZE as appropriate.  */
     if (CONST_INT_P (arg3_rtx))
@@ -4261,11 +4281,14 @@ expand_builtin_memcmp (tree exp, rtx target, enum machine_mode mode)
 static rtx
 expand_builtin_strcmp (tree exp, rtx target, enum machine_mode mode)
 {
+  location_t loc = EXPR_LOCATION (exp);
+
   if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
     return NULL_RTX;
   else
     {
-      tree result = fold_builtin_strcmp (CALL_EXPR_ARG (exp, 0),
+      tree result = fold_builtin_strcmp (loc,
+                                        CALL_EXPR_ARG (exp, 0),
                                         CALL_EXPR_ARG (exp, 1));
       if (result)
        return expand_expr (result, target, mode, EXPAND_NORMAL);
@@ -4410,12 +4433,15 @@ expand_builtin_strcmp (tree exp, rtx target, enum machine_mode mode)
 static rtx
 expand_builtin_strncmp (tree exp, rtx target, enum machine_mode mode)
 {
+  location_t loc = EXPR_LOCATION (exp);
+
   if (!validate_arglist (exp,
                         POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
     return NULL_RTX;
   else
     {
-      tree result = fold_builtin_strncmp (CALL_EXPR_ARG (exp, 0),
+      tree result = fold_builtin_strncmp (EXPR_LOCATION (exp),
+                                         CALL_EXPR_ARG (exp, 0),
                                          CALL_EXPR_ARG (exp, 1),
                                          CALL_EXPR_ARG (exp, 2));
       if (result)
@@ -4447,9 +4473,9 @@ expand_builtin_strncmp (tree exp, rtx target, enum machine_mode mode)
     len2 = c_strlen (arg2, 1);
 
     if (len1)
-      len1 = size_binop (PLUS_EXPR, ssize_int (1), len1);
+      len1 = size_binop_loc (loc, PLUS_EXPR, ssize_int (1), len1);
     if (len2)
-      len2 = size_binop (PLUS_EXPR, ssize_int (1), len2);
+      len2 = size_binop_loc (loc, PLUS_EXPR, ssize_int (1), len2);
 
     /* If we don't have a constant length for the first, use the length
        of the second, if we know it.  We don't require a constant for
@@ -4480,8 +4506,8 @@ expand_builtin_strncmp (tree exp, rtx target, enum machine_mode mode)
       return NULL_RTX;
 
     /* The actual new length parameter is MIN(len,arg3).  */
-    len = fold_build2 (MIN_EXPR, TREE_TYPE (len), len,
-                      fold_convert (TREE_TYPE (len), arg3));
+    len = fold_build2_loc (loc, MIN_EXPR, TREE_TYPE (len), len,
+                      fold_convert_loc (loc, TREE_TYPE (len), arg3));
 
     /* If we don't have POINTER_TYPE, call the function.  */
     if (arg1_align == 0 || arg2_align == 0)
@@ -4537,6 +4563,8 @@ expand_builtin_strncmp (tree exp, rtx target, enum machine_mode mode)
 static rtx
 expand_builtin_strcat (tree fndecl, tree exp, rtx target, enum machine_mode mode)
 {
+  location_t loc = EXPR_LOCATION (exp);
+
   if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
     return NULL_RTX;
   else
@@ -4566,7 +4594,8 @@ expand_builtin_strcat (tree fndecl, tree exp, rtx target, enum machine_mode mode
          newdst = build_call_expr (strlen_fn, 1, dst);
          /* Create (dst p+ strlen (dst)).  */
 
-         newdst = fold_build2 (POINTER_PLUS_EXPR, TREE_TYPE (dst), dst, newdst);
+         newdst = fold_build2_loc (loc, POINTER_PLUS_EXPR,
+                               TREE_TYPE (dst), dst, newdst);
          newdst = builtin_save_expr (newdst);
 
          if (!expand_builtin_strcpy_args (fndecl, newdst, newsrc, target, mode))
@@ -4597,7 +4626,8 @@ expand_builtin_strncat (tree exp, rtx target, enum machine_mode mode)
   if (validate_arglist (exp,
                        POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
     {
-      tree result = fold_builtin_strncat (CALL_EXPR_ARG (exp, 0),
+      tree result = fold_builtin_strncat (EXPR_LOCATION (exp),
+                                         CALL_EXPR_ARG (exp, 0),
                                          CALL_EXPR_ARG (exp, 1),
                                          CALL_EXPR_ARG (exp, 2));
       if (result)
@@ -4615,7 +4645,8 @@ expand_builtin_strspn (tree exp, rtx target, enum machine_mode mode)
 {
   if (validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
     {
-      tree result = fold_builtin_strspn (CALL_EXPR_ARG (exp, 0),
+      tree result = fold_builtin_strspn (EXPR_LOCATION (exp),
+                                        CALL_EXPR_ARG (exp, 0),
                                         CALL_EXPR_ARG (exp, 1));
       if (result)
        return expand_expr (result, target, mode, EXPAND_NORMAL);
@@ -4632,7 +4663,8 @@ expand_builtin_strcspn (tree exp, rtx target, enum machine_mode mode)
 {
   if (validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
     {
-      tree result = fold_builtin_strcspn (CALL_EXPR_ARG (exp, 0),
+      tree result = fold_builtin_strcspn (EXPR_LOCATION (exp),
+                                         CALL_EXPR_ARG (exp, 0),
                                          CALL_EXPR_ARG (exp, 1));
       if (result)
        return expand_expr (result, target, mode, EXPAND_NORMAL);
@@ -4726,7 +4758,7 @@ expand_builtin_next_arg (void)
    from multiple evaluations.  */
 
 static tree
-stabilize_va_list (tree valist, int needs_lvalue)
+stabilize_va_list_loc (location_t loc, tree valist, int needs_lvalue)
 {
   tree vatype = targetm.canonical_va_list_type (TREE_TYPE (valist));
 
@@ -4744,7 +4776,7 @@ stabilize_va_list (tree valist, int needs_lvalue)
       if (TREE_CODE (TREE_TYPE (valist)) == ARRAY_TYPE)
        {
          tree p1 = build_pointer_type (TREE_TYPE (vatype));
-         valist = build_fold_addr_expr_with_type (valist, p1);
+         valist = build_fold_addr_expr_with_type_loc (loc, valist, p1);
        }
     }
   else
@@ -4757,13 +4789,13 @@ stabilize_va_list (tree valist, int needs_lvalue)
            return valist;
 
          pt = build_pointer_type (vatype);
-         valist = fold_build1 (ADDR_EXPR, pt, valist);
+         valist = fold_build1_loc (loc, ADDR_EXPR, pt, valist);
          TREE_SIDE_EFFECTS (valist) = 1;
        }
 
       if (TREE_SIDE_EFFECTS (valist))
        valist = save_expr (valist);
-      valist = build_fold_indirect_ref (valist);
+      valist = build_fold_indirect_ref_loc (loc, valist);
     }
 
   return valist;
@@ -4837,10 +4869,11 @@ expand_builtin_va_start (tree exp)
 {
   rtx nextarg;
   tree valist;
+  location_t loc = EXPR_LOCATION (exp);
 
   if (call_expr_nargs (exp) < 2)
     {
-      error ("too few arguments to function %<va_start%>");
+      error_at (loc, "too few arguments to function %<va_start%>");
       return const0_rtx;
     }
 
@@ -4848,7 +4881,7 @@ expand_builtin_va_start (tree exp)
     return const0_rtx;
 
   nextarg = expand_builtin_next_arg ();
-  valist = stabilize_va_list (CALL_EXPR_ARG (exp, 0), 1);
+  valist = stabilize_va_list_loc (loc, CALL_EXPR_ARG (exp, 0), 1);
 
   if (targetm.expand_builtin_va_start)
     targetm.expand_builtin_va_start (valist, nextarg);
@@ -4901,7 +4934,8 @@ std_gimplify_va_arg_expr (tree valist, tree type, gimple_seq *pre_p,
       && !integer_zerop (TYPE_SIZE (type)))
     {
       t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist_tmp,
-                 fold_build2 (POINTER_PLUS_EXPR, TREE_TYPE (valist),
+                 fold_build2 (POINTER_PLUS_EXPR,
+                              TREE_TYPE (valist),
                               valist_tmp, size_int (boundary - 1)));
       gimplify_and_add (t, pre_p);
 
@@ -4937,10 +4971,12 @@ std_gimplify_va_arg_expr (tree valist, tree type, gimple_seq *pre_p,
   if (PAD_VARARGS_DOWN && !integer_zerop (rounded_size))
     {
       /* Small args are padded downward.  */
-      t = fold_build2 (GT_EXPR, sizetype, rounded_size, size_int (align));
+      t = fold_build2_loc (input_location, GT_EXPR, sizetype,
+                      rounded_size, size_int (align));
       t = fold_build3 (COND_EXPR, sizetype, t, size_zero_node,
                       size_binop (MINUS_EXPR, rounded_size, type_size));
-      addr = fold_build2 (POINTER_PLUS_EXPR, TREE_TYPE (addr), addr, t);
+      addr = fold_build2 (POINTER_PLUS_EXPR,
+                         TREE_TYPE (addr), addr, t);
     }
 
   /* Compute new value for AP.  */
@@ -4961,7 +4997,7 @@ std_gimplify_va_arg_expr (tree valist, tree type, gimple_seq *pre_p,
 tree
 build_va_arg_indirect_ref (tree addr)
 {
-  addr = build_fold_indirect_ref (addr);
+  addr = build_fold_indirect_ref_loc (EXPR_LOCATION (addr), addr);
 
   if (flag_mudflap) /* Don't instrument va_arg INDIRECT_REF.  */
     mf_mark (addr);
@@ -4989,8 +5025,7 @@ gimplify_va_arg_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)
   tree valist = TREE_OPERAND (*expr_p, 0);
   tree type = TREE_TYPE (*expr_p);
   tree t;
-  location_t loc = EXPR_HAS_LOCATION (*expr_p) ? EXPR_LOCATION (*expr_p) :
-    UNKNOWN_LOCATION;
+  location_t loc = EXPR_LOCATION (*expr_p);
 
   /* Verify that valist is of the proper type.  */
   have_va_type = TREE_TYPE (valist);
@@ -5032,7 +5067,8 @@ gimplify_va_arg_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)
       /* Before the abort, allow the evaluation of the va_list
         expression to exit or longjmp.  */
       gimplify_and_add (valist, pre_p);
-      t = build_call_expr (implicit_built_in_decls[BUILT_IN_TRAP], 0);
+      t = build_call_expr_loc (loc,
+                              implicit_built_in_decls[BUILT_IN_TRAP], 0);
       gimplify_and_add (t, pre_p);
 
       /* This is dead code, but go ahead and finish so that the
@@ -5053,7 +5089,8 @@ gimplify_va_arg_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)
          if (TREE_CODE (TREE_TYPE (valist)) == ARRAY_TYPE)
            {
              tree p1 = build_pointer_type (TREE_TYPE (have_va_type));
-             valist = fold_convert (p1, build_fold_addr_expr (valist));
+             valist = fold_convert_loc (loc, p1,
+                                        build_fold_addr_expr_loc (loc, valist));
            }
 
          gimplify_expr (&valist, pre_p, post_p, is_gimple_val, fb_rvalue);
@@ -5067,6 +5104,7 @@ gimplify_va_arg_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)
        return GS_ALL_DONE;
 
       *expr_p = targetm.gimplify_va_arg_expr (valist, type, pre_p, post_p);
+      SET_EXPR_LOCATION (*expr_p, loc);
       return GS_OK;
     }
 }
@@ -5094,12 +5132,13 @@ static rtx
 expand_builtin_va_copy (tree exp)
 {
   tree dst, src, t;
+  location_t loc = EXPR_LOCATION (exp);
 
   dst = CALL_EXPR_ARG (exp, 0);
   src = CALL_EXPR_ARG (exp, 1);
 
-  dst = stabilize_va_list (dst, 1);
-  src = stabilize_va_list (src, 0);
+  dst = stabilize_va_list_loc (loc, dst, 1);
+  src = stabilize_va_list_loc (loc, src, 0);
 
   gcc_assert (cfun != NULL && cfun->decl != NULL_TREE);
 
@@ -5270,7 +5309,8 @@ expand_builtin_fputs (tree exp, rtx target, bool unlocked)
   /* Verify the arguments in the original call.  */
   if (validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
     {
-      tree result = fold_builtin_fputs (CALL_EXPR_ARG (exp, 0),
+      tree result = fold_builtin_fputs (EXPR_LOCATION (exp),
+                                       CALL_EXPR_ARG (exp, 0),
                                        CALL_EXPR_ARG (exp, 1),
                                        (target == const0_rtx),
                                        unlocked, NULL_TREE);
@@ -5846,6 +5886,7 @@ expand_builtin_signbit (tree exp, rtx target)
   int word, bitpos;
   enum insn_code icode;
   rtx temp;
+  location_t loc = EXPR_LOCATION (exp);
 
   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
     return NULL_RTX;
@@ -5879,7 +5920,7 @@ expand_builtin_signbit (tree exp, rtx target)
     if (fmt->has_signed_zero && HONOR_SIGNED_ZEROS (fmode))
       return NULL_RTX;
 
-    arg = fold_build2 (LT_EXPR, TREE_TYPE (exp), arg,
+    arg = fold_build2_loc (loc, LT_EXPR, TREE_TYPE (exp), arg,
                       build_real (TREE_TYPE (arg), dconst0));
     return expand_expr (arg, target, VOIDmode, EXPAND_NORMAL);
   }
@@ -6007,7 +6048,7 @@ expand_builtin_fork_or_exec (tree fn, tree exp, rtx target, int ignore)
   TREE_NOTHROW (decl) = 1;
   DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
   DECL_VISIBILITY_SPECIFIED (decl) = 1;
-  call = rewrite_call_expr (exp, 0, decl, 0);
+  call = rewrite_call_expr (EXPR_LOCATION (exp), exp, 0, decl, 0);
   return expand_call (call, target, ignore);
  }
   
@@ -7292,7 +7333,7 @@ fold_builtin_constant_p (tree arg)
    return it as a truthvalue.  */
 
 static tree
-build_builtin_expect_predicate (tree pred, tree expected)
+build_builtin_expect_predicate (location_t loc, tree pred, tree expected)
 {
   tree fn, arg_types, pred_type, expected_type, call_expr, ret_type;
 
@@ -7302,9 +7343,9 @@ build_builtin_expect_predicate (tree pred, tree expected)
   pred_type = TREE_VALUE (arg_types);
   expected_type = TREE_VALUE (TREE_CHAIN (arg_types));
 
-  pred = fold_convert (pred_type, pred);
-  expected = fold_convert (expected_type, expected);
-  call_expr = build_call_expr (fn, 2, pred, expected);
+  pred = fold_convert_loc (loc, pred_type, pred);
+  expected = fold_convert_loc (loc, expected_type, expected);
+  call_expr = build_call_expr_loc (loc, fn, 2, pred, expected);
 
   return build2 (NE_EXPR, TREE_TYPE (pred), call_expr,
                 build_int_cst (ret_type, 0));
@@ -7314,7 +7355,7 @@ build_builtin_expect_predicate (tree pred, tree expected)
    NULL_TREE if no simplification is possible.  */
 
 static tree
-fold_builtin_expect (tree arg0, tree arg1)
+fold_builtin_expect (location_t loc, tree arg0, tree arg1)
 {
   tree inner, fndecl;
   enum tree_code code;
@@ -7347,11 +7388,11 @@ fold_builtin_expect (tree arg0, tree arg1)
       tree op0 = TREE_OPERAND (inner, 0);
       tree op1 = TREE_OPERAND (inner, 1);
 
-      op0 = build_builtin_expect_predicate (op0, arg1);
-      op1 = build_builtin_expect_predicate (op1, arg1);
+      op0 = build_builtin_expect_predicate (loc, op0, arg1);
+      op1 = build_builtin_expect_predicate (loc, op1, arg1);
       inner = build2 (code, TREE_TYPE (inner), op0, op1);
 
-      return fold_convert (TREE_TYPE (arg0), inner);
+      return fold_convert_loc (loc, TREE_TYPE (arg0), inner);
     }
 
   /* If the argument isn't invariant then there's nothing else we can do.  */
@@ -7395,7 +7436,7 @@ fold_builtin_classify_type (tree arg)
 /* Fold a call to __builtin_strlen with argument ARG.  */
 
 static tree
-fold_builtin_strlen (tree arg)
+fold_builtin_strlen (location_t loc, tree arg)
 {
   if (!validate_arg (arg, POINTER_TYPE))
     return NULL_TREE;
@@ -7407,7 +7448,7 @@ fold_builtin_strlen (tree arg)
        {
          /* Convert from the internal "sizetype" type to "size_t".  */
          if (size_type_node)
-           len = fold_convert (size_type_node, len);
+           len = fold_convert_loc (loc, size_type_node, len);
          return len;
        }
 
@@ -7418,7 +7459,7 @@ fold_builtin_strlen (tree arg)
 /* Fold a call to __builtin_inf or __builtin_huge_val.  */
 
 static tree
-fold_builtin_inf (tree type, int warn)
+fold_builtin_inf (location_t loc, tree type, int warn)
 {
   REAL_VALUE_TYPE real;
 
@@ -7430,7 +7471,7 @@ fold_builtin_inf (tree type, int warn)
      Thus we pedwarn to ensure this constraint violation is
      diagnosed.  */
   if (!MODE_HAS_INFINITIES (TYPE_MODE (type)) && warn)
-    pedwarn (input_location, 0, "target format does not support infinity");
+    pedwarn (loc, 0, "target format does not support infinity");
 
   real_inf (&real);
   return build_real (type, real);
@@ -7533,7 +7574,7 @@ integer_valued_real_p (tree t)
    Do the transformation for a call with argument ARG.  */
 
 static tree
-fold_trunc_transparent_mathfn (tree fndecl, tree arg)
+fold_trunc_transparent_mathfn (location_t loc, tree fndecl, tree arg)
 {
   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
 
@@ -7558,9 +7599,11 @@ fold_trunc_transparent_mathfn (tree fndecl, tree arg)
 
       if (TYPE_PRECISION (newtype) < TYPE_PRECISION (ftype)
          && (decl = mathfn_built_in (newtype, fcode)))
-       return fold_convert (ftype,
-                            build_call_expr (decl, 1,
-                                             fold_convert (newtype, arg0)));
+       return fold_convert_loc (loc, ftype,
+                                build_call_expr_loc (loc, decl, 1,
+                                                 fold_convert_loc (loc,
+                                                                   newtype,
+                                                                   arg0)));
     }
   return NULL_TREE;
 }
@@ -7570,7 +7613,7 @@ fold_trunc_transparent_mathfn (tree fndecl, tree arg)
    Do the transformation for a call with argument ARG.  */
 
 static tree
-fold_fixed_mathfn (tree fndecl, tree arg)
+fold_fixed_mathfn (location_t loc, tree fndecl, tree arg)
 {
   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
 
@@ -7580,7 +7623,8 @@ fold_fixed_mathfn (tree fndecl, tree arg)
   /* If argument is already integer valued, and we don't need to worry
      about setting errno, there's no need to perform rounding.  */
   if (! flag_errno_math && integer_valued_real_p (arg))
-    return fold_build1 (FIX_TRUNC_EXPR, TREE_TYPE (TREE_TYPE (fndecl)), arg);
+    return fold_build1_loc (loc, FIX_TRUNC_EXPR,
+                       TREE_TYPE (TREE_TYPE (fndecl)), arg);
 
   if (optimize)
     {
@@ -7591,7 +7635,8 @@ fold_fixed_mathfn (tree fndecl, tree arg)
 
       if (TYPE_PRECISION (newtype) < TYPE_PRECISION (ftype)
          && (decl = mathfn_built_in (newtype, fcode)))
-       return build_call_expr (decl, 1, fold_convert (newtype, arg0));
+       return build_call_expr_loc (loc, decl, 1,
+                               fold_convert_loc (loc, newtype, arg0));
     }
 
   /* Canonicalize llround (x) to lround (x) on LP64 targets where
@@ -7624,8 +7669,9 @@ fold_fixed_mathfn (tree fndecl, tree arg)
 
       if (newfn)
        {
-         tree newcall = build_call_expr(newfn, 1, arg);
-         return fold_convert (TREE_TYPE (TREE_TYPE (fndecl)), newcall);
+         tree newcall = build_call_expr_loc (loc, newfn, 1, arg);
+         return fold_convert_loc (loc,
+                                  TREE_TYPE (TREE_TYPE (fndecl)), newcall);
        }
     }
 
@@ -7636,7 +7682,7 @@ fold_fixed_mathfn (tree fndecl, tree arg)
    return type.  Return NULL_TREE if no simplification can be made.  */
 
 static tree
-fold_builtin_cabs (tree arg, tree type, tree fndecl)
+fold_builtin_cabs (location_t loc, tree arg, tree type, tree fndecl)
 {
   tree res;
 
@@ -7657,9 +7703,9 @@ fold_builtin_cabs (tree arg, tree type, tree fndecl)
       
       /* If either part is zero, cabs is fabs of the other.  */
       if (real_zerop (real))
-       return fold_build1 (ABS_EXPR, type, imag);
+       return fold_build1_loc (loc, ABS_EXPR, type, imag);
       if (real_zerop (imag))
-       return fold_build1 (ABS_EXPR, type, real);
+       return fold_build1_loc (loc, ABS_EXPR, type, real);
 
       /* cabs(x+xi) -> fabs(x)*sqrt(2).  */
       if (flag_unsafe_math_optimizations
@@ -7668,8 +7714,8 @@ fold_builtin_cabs (tree arg, tree type, tree fndecl)
          const REAL_VALUE_TYPE sqrt2_trunc
            = real_value_truncate (TYPE_MODE (type), dconst_sqrt2 ());
          STRIP_NOPS (real);
-         return fold_build2 (MULT_EXPR, type,
-                             fold_build1 (ABS_EXPR, type, real),
+         return fold_build2_loc (loc, MULT_EXPR, type,
+                             fold_build1_loc (loc, ABS_EXPR, type, real),
                              build_real (type, sqrt2_trunc));
        }
     }
@@ -7677,7 +7723,7 @@ fold_builtin_cabs (tree arg, tree type, tree fndecl)
   /* Optimize cabs(-z) and cabs(conj(z)) as cabs(z).  */
   if (TREE_CODE (arg) == NEGATE_EXPR
       || TREE_CODE (arg) == CONJ_EXPR)
-    return build_call_expr (fndecl, 1, TREE_OPERAND (arg, 0));
+    return build_call_expr_loc (loc, fndecl, 1, TREE_OPERAND (arg, 0));
 
   /* Don't do this when optimizing for size.  */
   if (flag_unsafe_math_optimizations
@@ -7691,19 +7737,19 @@ fold_builtin_cabs (tree arg, tree type, tree fndecl)
 
          arg = builtin_save_expr (arg);
 
-         rpart = fold_build1 (REALPART_EXPR, type, arg);
-         ipart = fold_build1 (IMAGPART_EXPR, type, arg);
+         rpart = fold_build1_loc (loc, REALPART_EXPR, type, arg);
+         ipart = fold_build1_loc (loc, IMAGPART_EXPR, type, arg);
 
          rpart = builtin_save_expr (rpart);
          ipart = builtin_save_expr (ipart);
 
-         result = fold_build2 (PLUS_EXPR, type,
-                               fold_build2 (MULT_EXPR, type,
+         result = fold_build2_loc (loc, PLUS_EXPR, type,
+                               fold_build2_loc (loc, MULT_EXPR, type,
                                             rpart, rpart),
-                               fold_build2 (MULT_EXPR, type,
+                               fold_build2_loc (loc, MULT_EXPR, type,
                                             ipart, ipart));
 
-         return build_call_expr (sqrtfn, 1, result);
+         return build_call_expr_loc (loc, sqrtfn, 1, result);
        }
     }
 
@@ -7714,7 +7760,7 @@ fold_builtin_cabs (tree arg, tree type, tree fndecl)
    Return NULL_TREE if no simplification can be made.  */
 
 static tree
-fold_builtin_sqrt (tree arg, tree type)
+fold_builtin_sqrt (location_t loc, tree arg, tree type)
 {
 
   enum built_in_function fcode;
@@ -7732,10 +7778,10 @@ fold_builtin_sqrt (tree arg, tree type)
   if (flag_unsafe_math_optimizations && BUILTIN_EXPONENT_P (fcode))
     {
       tree expfn = TREE_OPERAND (CALL_EXPR_FN (arg), 0);
-      arg = fold_build2 (MULT_EXPR, type,
+      arg = fold_build2_loc (loc, MULT_EXPR, type,
                         CALL_EXPR_ARG (arg, 0),
                         build_real (type, dconsthalf));
-      return build_call_expr (expfn, 1, arg);
+      return build_call_expr_loc (loc, expfn, 1, arg);
     }
 
   /* Optimize sqrt(Nroot(x)) -> pow(x,1/(2*N)).  */
@@ -7760,7 +7806,7 @@ fold_builtin_sqrt (tree arg, tree type)
          SET_REAL_EXP (&dconstroot, REAL_EXP (&dconstroot) - 1);
          dconstroot = real_value_truncate (TYPE_MODE (type), dconstroot);
          tree_root = build_real (type, dconstroot);
-         return build_call_expr (powfn, 2, arg0, tree_root);
+         return build_call_expr_loc (loc, powfn, 2, arg0, tree_root);
        }
     }
 
@@ -7776,9 +7822,9 @@ fold_builtin_sqrt (tree arg, tree type)
       tree narg1;
       if (!tree_expr_nonnegative_p (arg0))
        arg0 = build1 (ABS_EXPR, type, arg0);
-      narg1 = fold_build2 (MULT_EXPR, type, arg1,
+      narg1 = fold_build2_loc (loc, MULT_EXPR, type, arg1,
                           build_real (type, dconsthalf));
-      return build_call_expr (powfn, 2, arg0, narg1);
+      return build_call_expr_loc (loc, powfn, 2, arg0, narg1);
     }
 
   return NULL_TREE;
@@ -7788,7 +7834,7 @@ fold_builtin_sqrt (tree arg, tree type)
    Return NULL_TREE if no simplification can be made.  */
 
 static tree
-fold_builtin_cbrt (tree arg, tree type)
+fold_builtin_cbrt (location_t loc, tree arg, tree type)
 {
   const enum built_in_function fcode = builtin_mathfn_code (arg);
   tree res;
@@ -7808,10 +7854,10 @@ fold_builtin_cbrt (tree arg, tree type)
          tree expfn = TREE_OPERAND (CALL_EXPR_FN (arg), 0);
          const REAL_VALUE_TYPE third_trunc =
            real_value_truncate (TYPE_MODE (type), dconst_third ());
-         arg = fold_build2 (MULT_EXPR, type,
+         arg = fold_build2_loc (loc, MULT_EXPR, type,
                             CALL_EXPR_ARG (arg, 0),
                             build_real (type, third_trunc));
-         return build_call_expr (expfn, 1, arg);
+         return build_call_expr_loc (loc, expfn, 1, arg);
        }
 
       /* Optimize cbrt(sqrt(x)) -> pow(x,1/6).  */
@@ -7828,7 +7874,7 @@ fold_builtin_cbrt (tree arg, tree type)
              SET_REAL_EXP (&dconstroot, REAL_EXP (&dconstroot) - 1);
              dconstroot = real_value_truncate (TYPE_MODE (type), dconstroot);
              tree_root = build_real (type, dconstroot);
-             return build_call_expr (powfn, 2, arg0, tree_root);
+             return build_call_expr_loc (loc, powfn, 2, arg0, tree_root);
            }
        }
 
@@ -7849,7 +7895,7 @@ fold_builtin_cbrt (tree arg, tree type)
                                    dconst_third_ptr (), dconst_third_ptr ());
                  dconstroot = real_value_truncate (TYPE_MODE (type), dconstroot);
                  tree_root = build_real (type, dconstroot);
-                 return build_call_expr (powfn, 2, arg0, tree_root);
+                 return build_call_expr_loc (loc, powfn, 2, arg0, tree_root);
                }
            }
        }
@@ -7866,9 +7912,9 @@ fold_builtin_cbrt (tree arg, tree type)
              tree powfn = TREE_OPERAND (CALL_EXPR_FN (arg), 0);
              const REAL_VALUE_TYPE dconstroot
                = real_value_truncate (TYPE_MODE (type), dconst_third ());
-             tree narg01 = fold_build2 (MULT_EXPR, type, arg01,
+             tree narg01 = fold_build2_loc (loc, MULT_EXPR, type, arg01,
                                         build_real (type, dconstroot));
-             return build_call_expr (powfn, 2, arg00, narg01);
+             return build_call_expr_loc (loc, powfn, 2, arg00, narg01);
            }
        }
     }
@@ -7880,7 +7926,8 @@ fold_builtin_cbrt (tree arg, tree type)
    simplification can be made.  */
 
 static tree
-fold_builtin_cos (tree arg, tree type, tree fndecl)
+fold_builtin_cos (location_t loc,
+                 tree arg, tree type, tree fndecl)
 {
   tree res, narg;
 
@@ -7893,7 +7940,7 @@ fold_builtin_cos (tree arg, tree type, tree fndecl)
   
   /* Optimize cos(-x) into cos (x).  */
   if ((narg = fold_strip_sign_ops (arg)))
-    return build_call_expr (fndecl, 1, narg);
+    return build_call_expr_loc (loc, fndecl, 1, narg);
 
   return NULL_TREE;
 }
@@ -7902,7 +7949,7 @@ fold_builtin_cos (tree arg, tree type, tree fndecl)
    Return NULL_TREE if no simplification can be made.  */
 
 static tree
-fold_builtin_cosh (tree arg, tree type, tree fndecl)
+fold_builtin_cosh (location_t loc, tree arg, tree type, tree fndecl)
 {
   if (validate_arg (arg, REAL_TYPE))
     {
@@ -7914,7 +7961,7 @@ fold_builtin_cosh (tree arg, tree type, tree fndecl)
   
       /* Optimize cosh(-x) into cosh (x).  */
       if ((narg = fold_strip_sign_ops (arg)))
-       return build_call_expr (fndecl, 1, narg);
+       return build_call_expr_loc (loc, fndecl, 1, narg);
     }
   
   return NULL_TREE;
@@ -7925,7 +7972,8 @@ fold_builtin_cosh (tree arg, tree type, tree fndecl)
    NULL_TREE if no simplification can be made.  */
 
 static tree
-fold_builtin_ccos (tree arg, tree type ATTRIBUTE_UNUSED, tree fndecl,
+fold_builtin_ccos (location_t loc,
+                  tree arg, tree type ATTRIBUTE_UNUSED, tree fndecl,
                   bool hyper ATTRIBUTE_UNUSED)
 {
   if (validate_arg (arg, COMPLEX_TYPE)
@@ -7941,7 +7989,7 @@ fold_builtin_ccos (tree arg, tree type ATTRIBUTE_UNUSED, tree fndecl,
   
       /* Optimize fn(-x) into fn(x).  */
       if ((tmp = fold_strip_sign_ops (arg)))
-       return build_call_expr (fndecl, 1, tmp);
+       return build_call_expr_loc (loc, fndecl, 1, tmp);
     }
 
   return NULL_TREE;
@@ -7978,7 +8026,8 @@ fold_builtin_tan (tree arg, tree type)
    NULL_TREE if no simplification can be made.  */
 
 static tree
-fold_builtin_sincos (tree arg0, tree arg1, tree arg2)
+fold_builtin_sincos (location_t loc,
+                    tree arg0, tree arg1, tree arg2)
 {
   tree type;
   tree res, fn, call;
@@ -8001,15 +8050,15 @@ fold_builtin_sincos (tree arg0, tree arg1, tree arg2)
   if (!fn)
     return NULL_TREE;
 
-  call = build_call_expr (fn, 1, arg0);
+  call = build_call_expr_loc (loc, fn, 1, arg0);
   call = builtin_save_expr (call);
 
   return build2 (COMPOUND_EXPR, void_type_node,
                 build2 (MODIFY_EXPR, void_type_node,
-                        build_fold_indirect_ref (arg1),
+                        build_fold_indirect_ref_loc (loc, arg1),
                         build1 (IMAGPART_EXPR, type, call)),
                 build2 (MODIFY_EXPR, void_type_node,
-                        build_fold_indirect_ref (arg2),
+                        build_fold_indirect_ref_loc (loc, arg2),
                         build1 (REALPART_EXPR, type, call)));
 }
 
@@ -8017,7 +8066,7 @@ fold_builtin_sincos (tree arg0, tree arg1, tree arg2)
    NULL_TREE if no simplification can be made.  */
 
 static tree
-fold_builtin_cexp (tree arg0, tree type)
+fold_builtin_cexp (location_t loc, tree arg0, tree type)
 {
   tree rtype;
   tree realp, imagp, ifn;
@@ -8045,11 +8094,11 @@ fold_builtin_cexp (tree arg0, tree type)
   if (!ifn)
     return NULL_TREE;
 
-  if ((realp = fold_unary (REALPART_EXPR, rtype, arg0))
+  if ((realp = fold_unary_loc (loc, REALPART_EXPR, rtype, arg0))
       && real_zerop (realp))
     {
-      tree narg = fold_build1 (IMAGPART_EXPR, rtype, arg0);
-      return build_call_expr (ifn, 1, narg);
+      tree narg = fold_build1_loc (loc, IMAGPART_EXPR, rtype, arg0);
+      return build_call_expr_loc (loc, ifn, 1, narg);
     }
 
   /* In case we can easily decompose real and imaginary parts split cexp
@@ -8063,21 +8112,23 @@ fold_builtin_cexp (tree arg0, tree type)
       if (!rfn)
        return NULL_TREE;
 
-      imagp = fold_unary (IMAGPART_EXPR, rtype, arg0);
+      imagp = fold_unary_loc (loc, IMAGPART_EXPR, rtype, arg0);
       if (!imagp)
        return NULL_TREE;
 
-      icall = build_call_expr (ifn, 1, imagp);
+      icall = build_call_expr_loc (loc, ifn, 1, imagp);
       icall = builtin_save_expr (icall);
-      rcall = build_call_expr (rfn, 1, realp);
+      rcall = build_call_expr_loc (loc, rfn, 1, realp);
       rcall = builtin_save_expr (rcall);
-      return fold_build2 (COMPLEX_EXPR, type,
-                         fold_build2 (MULT_EXPR, rtype,
+      return fold_build2_loc (loc, COMPLEX_EXPR, type,
+                         fold_build2_loc (loc, MULT_EXPR, rtype,
                                       rcall,
-                                      fold_build1 (REALPART_EXPR, rtype, icall)),
-                         fold_build2 (MULT_EXPR, rtype,
+                                      fold_build1_loc (loc, REALPART_EXPR,
+                                                   rtype, icall)),
+                         fold_build2_loc (loc, MULT_EXPR, rtype,
                                       rcall,
-                                      fold_build1 (IMAGPART_EXPR, rtype, icall)));
+                                      fold_build1_loc (loc, IMAGPART_EXPR,
+                                                   rtype, icall)));
     }
 
   return NULL_TREE;
@@ -8087,7 +8138,7 @@ fold_builtin_cexp (tree arg0, tree type)
    Return NULL_TREE if no simplification can be made.  */
 
 static tree
-fold_builtin_trunc (tree fndecl, tree arg)
+fold_builtin_trunc (location_t loc, tree fndecl, tree arg)
 {
   if (!validate_arg (arg, REAL_TYPE))
     return NULL_TREE;
@@ -8103,14 +8154,14 @@ fold_builtin_trunc (tree fndecl, tree arg)
       return build_real (type, r);
     }
 
-  return fold_trunc_transparent_mathfn (fndecl, arg);
+  return fold_trunc_transparent_mathfn (loc, fndecl, arg);
 }
 
 /* Fold function call to builtin floor, floorf or floorl with argument ARG.
    Return NULL_TREE if no simplification can be made.  */
 
 static tree
-fold_builtin_floor (tree fndecl, tree arg)
+fold_builtin_floor (location_t loc, tree fndecl, tree arg)
 {
   if (!validate_arg (arg, REAL_TYPE))
     return NULL_TREE;
@@ -8136,17 +8187,17 @@ fold_builtin_floor (tree fndecl, tree arg)
     {
       tree truncfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_TRUNC);
       if (truncfn)
-       return build_call_expr (truncfn, 1, arg);
+       return build_call_expr_loc (loc, truncfn, 1, arg);
     }
 
-  return fold_trunc_transparent_mathfn (fndecl, arg);
+  return fold_trunc_transparent_mathfn (loc, fndecl, arg);
 }
 
 /* Fold function call to builtin ceil, ceilf or ceill with argument ARG.
    Return NULL_TREE if no simplification can be made.  */
 
 static tree
-fold_builtin_ceil (tree fndecl, tree arg)
+fold_builtin_ceil (location_t loc, tree fndecl, tree arg)
 {
   if (!validate_arg (arg, REAL_TYPE))
     return NULL_TREE;
@@ -8167,14 +8218,14 @@ fold_builtin_ceil (tree fndecl, tree arg)
        }
     }
 
-  return fold_trunc_transparent_mathfn (fndecl, arg);
+  return fold_trunc_transparent_mathfn (loc, fndecl, arg);
 }
 
 /* Fold function call to builtin round, roundf or roundl with argument ARG.
    Return NULL_TREE if no simplification can be made.  */
 
 static tree
-fold_builtin_round (tree fndecl, tree arg)
+fold_builtin_round (location_t loc, tree fndecl, tree arg)
 {
   if (!validate_arg (arg, REAL_TYPE))
     return NULL_TREE;
@@ -8195,7 +8246,7 @@ fold_builtin_round (tree fndecl, tree arg)
        }
     }
 
-  return fold_trunc_transparent_mathfn (fndecl, arg);
+  return fold_trunc_transparent_mathfn (loc, fndecl, arg);
 }
 
 /* Fold function call to builtin lround, lroundf or lroundl (or the
@@ -8204,7 +8255,7 @@ fold_builtin_round (tree fndecl, tree arg)
    can be made.  */
 
 static tree
-fold_builtin_int_roundingfn (tree fndecl, tree arg)
+fold_builtin_int_roundingfn (location_t loc, tree fndecl, tree arg)
 {
   if (!validate_arg (arg, REAL_TYPE))
     return NULL_TREE;
@@ -8255,13 +8306,13 @@ fold_builtin_int_roundingfn (tree fndecl, tree arg)
     CASE_FLT_FN (BUILT_IN_LLFLOOR):
       /* Fold lfloor (x) where x is nonnegative to FIX_TRUNC (x).  */
       if (tree_expr_nonnegative_p (arg))
-       return fold_build1 (FIX_TRUNC_EXPR, TREE_TYPE (TREE_TYPE (fndecl)),
-                           arg);
+       return fold_build1_loc (loc, FIX_TRUNC_EXPR,
+                           TREE_TYPE (TREE_TYPE (fndecl)), arg);
       break;
     default:;
     }
 
-  return fold_fixed_mathfn (fndecl, arg);
+  return fold_fixed_mathfn (loc, fndecl, arg);
 }
 
 /* Fold function call to builtin ffs, clz, ctz, popcount and parity
@@ -8420,7 +8471,7 @@ fold_builtin_bswap (tree fndecl, tree arg)
    FUNC is the corresponding MPFR logarithm function.  */
 
 static tree
-fold_builtin_logarithm (tree fndecl, tree arg,
+fold_builtin_logarithm (location_t loc, tree fndecl, tree arg,
                        int (*func)(mpfr_ptr, mpfr_srcptr, mp_rnd_t))
 {
   if (validate_arg (arg, REAL_TYPE))
@@ -8444,7 +8495,7 @@ fold_builtin_logarithm (tree fndecl, tree arg,
                      || fcode == BUILT_IN_EXP2F
                      || fcode == BUILT_IN_EXP2L))
              || (func == mpfr_log10 && (BUILTIN_EXP10_P (fcode)))))
-       return fold_convert (type, CALL_EXPR_ARG (arg, 0));
+       return fold_convert_loc (loc, type, CALL_EXPR_ARG (arg, 0));
 
       /* Optimize logN(func()) for various exponential functions.  We
         want to determine the value "x" and the power "exponent" in
@@ -8499,8 +8550,8 @@ fold_builtin_logarithm (tree fndecl, tree arg,
          /* Now perform the optimization.  */
          if (x && exponent)
            {
-             tree logfn = build_call_expr (fndecl, 1, x);
-             return fold_build2 (MULT_EXPR, type, exponent, logfn);
+             tree logfn = build_call_expr_loc (loc, fndecl, 1, x);
+             return fold_build2_loc (loc, MULT_EXPR, type, exponent, logfn);
            }
        }
     }
@@ -8512,7 +8563,8 @@ fold_builtin_logarithm (tree fndecl, tree arg,
    NULL_TREE if no simplification can be made.  */
 
 static tree
-fold_builtin_hypot (tree fndecl, tree arg0, tree arg1, tree type)
+fold_builtin_hypot (location_t loc, tree fndecl,
+                   tree arg0, tree arg1, tree type)
 {
   tree res, narg0, narg1;
 
@@ -8530,15 +8582,15 @@ fold_builtin_hypot (tree fndecl, tree arg0, tree arg1, tree type)
   narg1 = fold_strip_sign_ops (arg1);
   if (narg0 || narg1)
     {
-      return build_call_expr (fndecl, 2, narg0 ? narg0 : arg0, 
+      return build_call_expr_loc (loc, fndecl, 2, narg0 ? narg0 : arg0, 
                              narg1 ? narg1 : arg1);
     }
   
   /* If either argument is zero, hypot is fabs of the other.  */
   if (real_zerop (arg0))
-    return fold_build1 (ABS_EXPR, type, arg1);
+    return fold_build1_loc (loc, ABS_EXPR, type, arg1);
   else if (real_zerop (arg1))
-    return fold_build1 (ABS_EXPR, type, arg0);
+    return fold_build1_loc (loc, ABS_EXPR, type, arg0);
       
   /* hypot(x,x) -> fabs(x)*sqrt(2).  */
   if (flag_unsafe_math_optimizations
@@ -8546,8 +8598,8 @@ fold_builtin_hypot (tree fndecl, tree arg0, tree arg1, tree type)
     {
       const REAL_VALUE_TYPE sqrt2_trunc
        = real_value_truncate (TYPE_MODE (type), dconst_sqrt2 ());
-      return fold_build2 (MULT_EXPR, type,
-                         fold_build1 (ABS_EXPR, type, arg0),
+      return fold_build2_loc (loc, MULT_EXPR, type,
+                         fold_build1_loc (loc, ABS_EXPR, type, arg0),
                          build_real (type, sqrt2_trunc));
     }
 
@@ -8558,7 +8610,7 @@ fold_builtin_hypot (tree fndecl, tree arg0, tree arg1, tree type)
 /* Fold a builtin function call to pow, powf, or powl.  Return
    NULL_TREE if no simplification can be made.  */
 static tree
-fold_builtin_pow (tree fndecl, tree arg0, tree arg1, tree type)
+fold_builtin_pow (location_t loc, tree fndecl, tree arg0, tree arg1, tree type)
 {
   tree res;
 
@@ -8572,7 +8624,7 @@ fold_builtin_pow (tree fndecl, tree arg0, tree arg1, tree type)
 
   /* Optimize pow(1.0,y) = 1.0.  */
   if (real_onep (arg0))
-    return omit_one_operand (type, build_real (type, dconst1), arg1);
+    return omit_one_operand_loc (loc, type, build_real (type, dconst1), arg1);
 
   if (TREE_CODE (arg1) == REAL_CST
       && !TREE_OVERFLOW (arg1))
@@ -8585,7 +8637,7 @@ fold_builtin_pow (tree fndecl, tree arg0, tree arg1, tree type)
 
       /* Optimize pow(x,0.0) = 1.0.  */
       if (REAL_VALUES_EQUAL (c, dconst0))
-       return omit_one_operand (type, build_real (type, dconst1),
+       return omit_one_operand_loc (loc, type, build_real (type, dconst1),
                                 arg0);
 
       /* Optimize pow(x,1.0) = x.  */
@@ -8594,7 +8646,7 @@ fold_builtin_pow (tree fndecl, tree arg0, tree arg1, tree type)
 
       /* Optimize pow(x,-1.0) = 1.0/x.  */
       if (REAL_VALUES_EQUAL (c, dconstm1))
-       return fold_build2 (RDIV_EXPR, type,
+       return fold_build2_loc (loc, RDIV_EXPR, type,
                            build_real (type, dconst1), arg0);
 
       /* Optimize pow(x,0.5) = sqrt(x).  */
@@ -8604,7 +8656,7 @@ fold_builtin_pow (tree fndecl, tree arg0, tree arg1, tree type)
          tree sqrtfn = mathfn_built_in (type, BUILT_IN_SQRT);
 
          if (sqrtfn != NULL_TREE)
-           return build_call_expr (sqrtfn, 1, arg0);
+           return build_call_expr_loc (loc, sqrtfn, 1, arg0);
        }
 
       /* Optimize pow(x,1.0/3.0) = cbrt(x).  */
@@ -8617,7 +8669,7 @@ fold_builtin_pow (tree fndecl, tree arg0, tree arg1, tree type)
            {
              tree cbrtfn = mathfn_built_in (type, BUILT_IN_CBRT);
              if (cbrtfn != NULL_TREE)
-                 return build_call_expr (cbrtfn, 1, arg0);
+               return build_call_expr_loc (loc, cbrtfn, 1, arg0);
            }
        }
 
@@ -8648,7 +8700,7 @@ fold_builtin_pow (tree fndecl, tree arg0, tree arg1, tree type)
            {
              tree narg0 = fold_strip_sign_ops (arg0);
              if (narg0)
-               return build_call_expr (fndecl, 2, narg0, arg1);
+               return build_call_expr_loc (loc, fndecl, 2, narg0, arg1);
            }
        }
     }
@@ -8662,17 +8714,17 @@ fold_builtin_pow (tree fndecl, tree arg0, tree arg1, tree type)
        {
          tree expfn = TREE_OPERAND (CALL_EXPR_FN (arg0), 0);
          tree arg = CALL_EXPR_ARG (arg0, 0);
-         arg = fold_build2 (MULT_EXPR, type, arg, arg1);
-         return build_call_expr (expfn, 1, arg);
+         arg = fold_build2_loc (loc, MULT_EXPR, type, arg, arg1);
+         return build_call_expr_loc (loc, expfn, 1, arg);
        }
 
       /* Optimize pow(sqrt(x),y) = pow(x,y*0.5).  */
       if (BUILTIN_SQRT_P (fcode))
        {
          tree narg0 = CALL_EXPR_ARG (arg0, 0);
-         tree narg1 = fold_build2 (MULT_EXPR, type, arg1,
+         tree narg1 = fold_build2_loc (loc, MULT_EXPR, type, arg1,
                                    build_real (type, dconsthalf));
-         return build_call_expr (fndecl, 2, narg0, narg1);
+         return build_call_expr_loc (loc, fndecl, 2, narg0, narg1);
        }
 
       /* Optimize pow(cbrt(x),y) = pow(x,y/3) iff x is nonnegative.  */
@@ -8683,9 +8735,9 @@ fold_builtin_pow (tree fndecl, tree arg0, tree arg1, tree type)
            {
              const REAL_VALUE_TYPE dconstroot
                = real_value_truncate (TYPE_MODE (type), dconst_third ());
-             tree narg1 = fold_build2 (MULT_EXPR, type, arg1,
+             tree narg1 = fold_build2_loc (loc, MULT_EXPR, type, arg1,
                                        build_real (type, dconstroot));
-             return build_call_expr (fndecl, 2, arg, narg1);
+             return build_call_expr_loc (loc, fndecl, 2, arg, narg1);
            }
        }
 
@@ -8696,8 +8748,8 @@ fold_builtin_pow (tree fndecl, tree arg0, tree arg1, tree type)
        {
          tree arg00 = CALL_EXPR_ARG (arg0, 0);
          tree arg01 = CALL_EXPR_ARG (arg0, 1);
-         tree narg1 = fold_build2 (MULT_EXPR, type, arg01, arg1);
-         return build_call_expr (fndecl, 2, arg00, narg1);
+         tree narg1 = fold_build2_loc (loc, MULT_EXPR, type, arg01, arg1);
+         return build_call_expr_loc (loc, fndecl, 2, arg00, narg1);
        }
     }
 
@@ -8707,7 +8759,7 @@ fold_builtin_pow (tree fndecl, tree arg0, tree arg1, tree type)
 /* Fold a builtin function call to powi, powif, or powil with argument ARG.
    Return NULL_TREE if no simplification can be made.  */
 static tree
-fold_builtin_powi (tree fndecl ATTRIBUTE_UNUSED,
+fold_builtin_powi (location_t loc, tree fndecl ATTRIBUTE_UNUSED,
                   tree arg0, tree arg1, tree type)
 {
   if (!validate_arg (arg0, REAL_TYPE)
@@ -8716,7 +8768,7 @@ fold_builtin_powi (tree fndecl ATTRIBUTE_UNUSED,
 
   /* Optimize pow(1.0,y) = 1.0.  */
   if (real_onep (arg0))
-    return omit_one_operand (type, build_real (type, dconst1), arg1);
+    return omit_one_operand_loc (loc, type, build_real (type, dconst1), arg1);
 
   if (host_integerp (arg1, 0))
     {
@@ -8734,7 +8786,7 @@ fold_builtin_powi (tree fndecl ATTRIBUTE_UNUSED,
 
       /* Optimize pow(x,0) = 1.0.  */
       if (c == 0)
-       return omit_one_operand (type, build_real (type, dconst1),
+       return omit_one_operand_loc (loc, type, build_real (type, dconst1),
                                 arg0);
 
       /* Optimize pow(x,1) = x.  */
@@ -8743,7 +8795,7 @@ fold_builtin_powi (tree fndecl ATTRIBUTE_UNUSED,
 
       /* Optimize pow(x,-1) = 1.0/x.  */
       if (c == -1)
-       return fold_build2 (RDIV_EXPR, type,
+       return fold_build2_loc (loc, RDIV_EXPR, type,
                           build_real (type, dconst1), arg0);
     }
 
@@ -8755,7 +8807,7 @@ fold_builtin_powi (tree fndecl ATTRIBUTE_UNUSED,
    FUNC is the corresponding MPFR exponent function.  */
 
 static tree
-fold_builtin_exponent (tree fndecl, tree arg,
+fold_builtin_exponent (location_t loc, tree fndecl, tree arg,
                       int (*func)(mpfr_ptr, mpfr_srcptr, mp_rnd_t))
 {
   if (validate_arg (arg, REAL_TYPE))
@@ -8784,7 +8836,7 @@ fold_builtin_exponent (tree fndecl, tree arg,
                  && (fcode == BUILT_IN_LOG10
                      || fcode == BUILT_IN_LOG10F
                      || fcode == BUILT_IN_LOG10L)))
-           return fold_convert (type, CALL_EXPR_ARG (arg, 0));
+           return fold_convert_loc (loc, type, CALL_EXPR_ARG (arg, 0));
        }
     }
 
@@ -8806,7 +8858,8 @@ var_decl_component_p (tree var)
    NULL_TREE if no simplification can be made.  */
 
 static tree
-fold_builtin_memset (tree dest, tree c, tree len, tree type, bool ignore)
+fold_builtin_memset (location_t loc, tree dest, tree c, tree len,
+                    tree type, bool ignore)
 {
   tree var, ret, etype;
   unsigned HOST_WIDE_INT length, cval;
@@ -8821,7 +8874,7 @@ fold_builtin_memset (tree dest, tree c, tree len, tree type, bool ignore)
 
   /* If the LEN parameter is zero, return DEST.  */
   if (integer_zerop (len))
-    return omit_one_operand (type, dest, c);
+    return omit_one_operand_loc (loc, type, dest, c);
 
   if (! host_integerp (c, 1) || TREE_SIDE_EFFECTS (dest))
     return NULL_TREE;
@@ -8870,20 +8923,22 @@ fold_builtin_memset (tree dest, tree c, tree len, tree type, bool ignore)
     }
 
   ret = build_int_cst_type (etype, cval);
-  var = build_fold_indirect_ref (fold_convert (build_pointer_type (etype),
-                                              dest));
+  var = build_fold_indirect_ref_loc (loc,
+                                fold_convert_loc (loc,
+                                                  build_pointer_type (etype),
+                                                  dest));
   ret = build2 (MODIFY_EXPR, etype, var, ret);
   if (ignore)
     return ret;
 
-  return omit_one_operand (type, dest, ret);
+  return omit_one_operand_loc (loc, type, dest, ret);
 }
 
 /* Fold function call to builtin memset.  Return
    NULL_TREE if no simplification can be made.  */
 
 static tree
-fold_builtin_bzero (tree dest, tree size, bool ignore)
+fold_builtin_bzero (location_t loc, tree dest, tree size, bool ignore)
 {
   if (! validate_arg (dest, POINTER_TYPE)
       || ! validate_arg (size, INTEGER_TYPE))
@@ -8897,8 +8952,8 @@ fold_builtin_bzero (tree dest, tree size, bool ignore)
      so that if it isn't expanded inline, we fallback to
      calling bzero instead of memset.  */
 
-  return fold_builtin_memset (dest, integer_zero_node,
-                             fold_convert (sizetype, size),
+  return fold_builtin_memset (loc, dest, integer_zero_node,
+                             fold_convert_loc (loc, sizetype, size),
                              void_type_node, ignore);
 }
 
@@ -8911,7 +8966,8 @@ fold_builtin_bzero (tree dest, tree size, bool ignore)
    (memmove).   */
 
 static tree
-fold_builtin_memory_op (tree dest, tree src, tree len, tree type, bool ignore, int endp)
+fold_builtin_memory_op (location_t loc, tree dest, tree src,
+                       tree len, tree type, bool ignore, int endp)
 {
   tree destvar, srcvar, expr;
 
@@ -8922,7 +8978,7 @@ fold_builtin_memory_op (tree dest, tree src, tree len, tree type, bool ignore, i
 
   /* If the LEN parameter is zero, return DEST.  */
   if (integer_zerop (len))
-    return omit_one_operand (type, dest, src);
+    return omit_one_operand_loc (loc, type, dest, src);
 
   /* If SRC and DEST are the same (and not volatile), return
      DEST{,+LEN,+LEN-1}.  */
@@ -8953,12 +9009,12 @@ fold_builtin_memory_op (tree dest, tree src, tree len, tree type, bool ignore, i
              tree fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
              if (!fn)
                return NULL_TREE;
-              return build_call_expr (fn, 3, dest, src, len);
+              return build_call_expr_loc (loc, fn, 3, dest, src, len);
            }
 
          /* If *src and *dest can't overlap, optimize into memcpy as well.  */
-         srcvar = build_fold_indirect_ref (src);
-         destvar = build_fold_indirect_ref (dest);
+         srcvar = build_fold_indirect_ref_loc (loc, src);
+         destvar = build_fold_indirect_ref_loc (loc, dest);
          if (srcvar
              && !TREE_THIS_VOLATILE (srcvar)
              && destvar
@@ -9011,7 +9067,7 @@ fold_builtin_memory_op (tree dest, tree src, tree len, tree type, bool ignore, i
              fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
              if (!fn)
                return NULL_TREE;
-             return build_call_expr (fn, 3, dest, src, len);
+             return build_call_expr_loc (loc, fn, 3, dest, src, len);
            }
          return NULL_TREE;
        }
@@ -9078,7 +9134,7 @@ fold_builtin_memory_op (tree dest, tree src, tree len, tree type, bool ignore, i
       srcvar = NULL_TREE;
       if (tree_int_cst_equal (TYPE_SIZE_UNIT (srctype), len))
        {
-         srcvar = build_fold_indirect_ref (src);
+         srcvar = build_fold_indirect_ref_loc (loc, src);
          if (TREE_THIS_VOLATILE (srcvar))
            return NULL_TREE;
          else if (!tree_int_cst_equal (lang_hooks.expr_size (srcvar), len))
@@ -9096,7 +9152,7 @@ fold_builtin_memory_op (tree dest, tree src, tree len, tree type, bool ignore, i
       destvar = NULL_TREE;
       if (tree_int_cst_equal (TYPE_SIZE_UNIT (desttype), len))
        {
-         destvar = build_fold_indirect_ref (dest);
+         destvar = build_fold_indirect_ref_loc (loc, dest);
          if (TREE_THIS_VOLATILE (destvar))
            return NULL_TREE;
          else if (!tree_int_cst_equal (lang_hooks.expr_size (destvar), len))
@@ -9127,8 +9183,8 @@ fold_builtin_memory_op (tree dest, tree src, tree len, tree type, bool ignore, i
              TYPE_PACKED (srctype) = 1;
            }
          srcptype = build_pointer_type_for_mode (srctype, ptr_mode, true);
-         src = fold_convert (srcptype, src);
-         srcvar = build_fold_indirect_ref (src);
+         src = fold_convert_loc (loc, srcptype, src);
+         srcvar = build_fold_indirect_ref_loc (loc, src);
        }
       else if (destvar == NULL_TREE)
        {
@@ -9149,8 +9205,8 @@ fold_builtin_memory_op (tree dest, tree src, tree len, tree type, bool ignore, i
              TYPE_PACKED (desttype) = 1;
            }
          destptype = build_pointer_type_for_mode (desttype, ptr_mode, true);
-         dest = fold_convert (destptype, dest);
-         destvar = build_fold_indirect_ref (dest);
+         dest = fold_convert_loc (loc, destptype, dest);
+         destvar = build_fold_indirect_ref_loc (loc, dest);
        }
 
       if (srctype == desttype
@@ -9161,9 +9217,10 @@ fold_builtin_memory_op (tree dest, tree src, tree len, tree type, bool ignore, i
           || POINTER_TYPE_P (TREE_TYPE (srcvar)))
          && (INTEGRAL_TYPE_P (TREE_TYPE (destvar))
              || POINTER_TYPE_P (TREE_TYPE (destvar))))
-       expr = fold_convert (TREE_TYPE (destvar), srcvar);
+       expr = fold_convert_loc (loc, TREE_TYPE (destvar), srcvar);
       else
-       expr = fold_build1 (VIEW_CONVERT_EXPR, TREE_TYPE (destvar), srcvar);
+       expr = fold_build1_loc (loc, VIEW_CONVERT_EXPR,
+                           TREE_TYPE (destvar), srcvar);
       expr = build2 (MODIFY_EXPR, TREE_TYPE (destvar), destvar, expr);
     }
 
@@ -9171,20 +9228,20 @@ fold_builtin_memory_op (tree dest, tree src, tree len, tree type, bool ignore, i
     return expr;
 
   if (endp == 0 || endp == 3)
-    return omit_one_operand (type, dest, expr);
+    return omit_one_operand_loc (loc, type, dest, expr);
 
   if (expr == len)
     expr = NULL_TREE;
 
   if (endp == 2)
-    len = fold_build2 (MINUS_EXPR, TREE_TYPE (len), len,
+    len = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (len), len,
                       ssize_int (1));
 
-  len = fold_convert (sizetype, len);
-  dest = fold_build2 (POINTER_PLUS_EXPR, TREE_TYPE (dest), dest, len);
-  dest = fold_convert (type, dest);
+  len = fold_convert_loc (loc, sizetype, len);
+  dest = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (dest), dest, len);
+  dest = fold_convert_loc (loc, type, dest);
   if (expr)
-    dest = omit_one_operand (type, dest, expr);
+    dest = omit_one_operand_loc (loc, type, dest, expr);
   return dest;
 }
 
@@ -9193,7 +9250,7 @@ fold_builtin_memory_op (tree dest, tree src, tree len, tree type, bool ignore, i
    copied.  Return NULL_TREE if no simplification can be made.  */
 
 tree
-fold_builtin_strcpy (tree fndecl, tree dest, tree src, tree len)
+fold_builtin_strcpy (location_t loc, tree fndecl, tree dest, tree src, tree len)
 {
   tree fn;
 
@@ -9203,7 +9260,7 @@ fold_builtin_strcpy (tree fndecl, tree dest, tree src, tree len)
 
   /* If SRC and DEST are the same (and not volatile), return DEST.  */
   if (operand_equal_p (src, dest, 0))
-    return fold_convert (TREE_TYPE (TREE_TYPE (fndecl)), dest);
+    return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), dest);
 
   if (optimize_function_for_size_p (cfun))
     return NULL_TREE;
@@ -9219,9 +9276,9 @@ fold_builtin_strcpy (tree fndecl, tree dest, tree src, tree len)
        return NULL_TREE;
     }
 
-  len = size_binop (PLUS_EXPR, len, ssize_int (1));
-  return fold_convert (TREE_TYPE (TREE_TYPE (fndecl)),
-                      build_call_expr (fn, 3, dest, src, len));
+  len = size_binop_loc (loc, PLUS_EXPR, len, ssize_int (1));
+  return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)),
+                          build_call_expr_loc (loc, fn, 3, dest, src, len));
 }
 
 /* Fold function call to builtin strncpy with arguments DEST, SRC, and LEN.
@@ -9229,7 +9286,8 @@ fold_builtin_strcpy (tree fndecl, tree dest, tree src, tree len)
    Return NULL_TREE if no simplification can be made.  */
 
 tree
-fold_builtin_strncpy (tree fndecl, tree dest, tree src, tree len, tree slen)
+fold_builtin_strncpy (location_t loc, tree fndecl, tree dest,
+                     tree src, tree len, tree slen)
 {
   tree fn;
 
@@ -9240,7 +9298,7 @@ fold_builtin_strncpy (tree fndecl, tree dest, tree src, tree len, tree slen)
 
   /* If the LEN parameter is zero, return DEST.  */
   if (integer_zerop (len))
-    return omit_one_operand (TREE_TYPE (TREE_TYPE (fndecl)), dest, src);
+    return omit_one_operand_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), dest, src);
 
   /* We can't compare slen with len as constants below if len is not a
      constant.  */
@@ -9254,7 +9312,7 @@ fold_builtin_strncpy (tree fndecl, tree dest, tree src, tree len, tree slen)
   if (slen == 0 || TREE_CODE (slen) != INTEGER_CST)
     return NULL_TREE;
 
-  slen = size_binop (PLUS_EXPR, slen, ssize_int (1));
+  slen = size_binop_loc (loc, PLUS_EXPR, slen, ssize_int (1));
 
   /* We do not support simplification of this case, though we do
      support it when expanding trees into RTL.  */
@@ -9266,8 +9324,8 @@ fold_builtin_strncpy (tree fndecl, tree dest, tree src, tree len, tree slen)
   fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
   if (!fn)
     return NULL_TREE;
-  return fold_convert (TREE_TYPE (TREE_TYPE (fndecl)),
-                      build_call_expr (fn, 3, dest, src, len));
+  return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)),
+                          build_call_expr_loc (loc, fn, 3, dest, src, len));
 }
 
 /* Fold function call to builtin memchr.  ARG1, ARG2 and LEN are the
@@ -9275,7 +9333,7 @@ fold_builtin_strncpy (tree fndecl, tree dest, tree src, tree len, tree slen)
    Return NULL_TREE if no simplification can be made.  */
 
 static tree
-fold_builtin_memchr (tree arg1, tree arg2, tree len, tree type)
+fold_builtin_memchr (location_t loc, tree arg1, tree arg2, tree len, tree type)
 {
   if (!validate_arg (arg1, POINTER_TYPE)
       || !validate_arg (arg2, INTEGER_TYPE)
@@ -9304,9 +9362,9 @@ fold_builtin_memchr (tree arg1, tree arg2, tree len, tree type)
          if (r == NULL)
            return build_int_cst (TREE_TYPE (arg1), 0);
 
-         tem = fold_build2 (POINTER_PLUS_EXPR, TREE_TYPE (arg1), arg1,
+         tem = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (arg1), arg1,
                             size_int (r - p1));
-         return fold_convert (type, tem);
+         return fold_convert_loc (loc, type, tem);
        }
       return NULL_TREE;
     }
@@ -9316,7 +9374,7 @@ fold_builtin_memchr (tree arg1, tree arg2, tree len, tree type)
    Return NULL_TREE if no simplification can be made.  */
 
 static tree
-fold_builtin_memcmp (tree arg1, tree arg2, tree len)
+fold_builtin_memcmp (location_t loc, tree arg1, tree arg2, tree len)
 {
   const char *p1, *p2;
 
@@ -9327,12 +9385,12 @@ fold_builtin_memcmp (tree arg1, tree arg2, tree len)
 
   /* If the LEN parameter is zero, return zero.  */
   if (integer_zerop (len))
-    return omit_two_operands (integer_type_node, integer_zero_node,
+    return omit_two_operands_loc (loc, integer_type_node, integer_zero_node,
                              arg1, arg2);
 
   /* If ARG1 and ARG2 are the same (and not volatile), return zero.  */
   if (operand_equal_p (arg1, arg2, 0))
-    return omit_one_operand (integer_type_node, integer_zero_node, len);
+    return omit_one_operand_loc (loc, integer_type_node, integer_zero_node, len);
 
   p1 = c_getstr (arg1);
   p2 = c_getstr (arg2);
@@ -9361,15 +9419,19 @@ fold_builtin_memcmp (tree arg1, tree arg2, tree len)
       tree cst_uchar_ptr_node
        = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
 
-      tree ind1 = fold_convert (integer_type_node,
-                               build1 (INDIRECT_REF, cst_uchar_node,
-                                       fold_convert (cst_uchar_ptr_node,
+      tree ind1
+       = fold_convert_loc (loc, integer_type_node,
+                           build1 (INDIRECT_REF, cst_uchar_node,
+                                   fold_convert_loc (loc,
+                                                     cst_uchar_ptr_node,
                                                      arg1)));
-      tree ind2 = fold_convert (integer_type_node,
-                               build1 (INDIRECT_REF, cst_uchar_node,
-                                       fold_convert (cst_uchar_ptr_node,
+      tree ind2
+       = fold_convert_loc (loc, integer_type_node,
+                           build1 (INDIRECT_REF, cst_uchar_node,
+                                   fold_convert_loc (loc,
+                                                     cst_uchar_ptr_node,
                                                      arg2)));
-      return fold_build2 (MINUS_EXPR, integer_type_node, ind1, ind2);
+      return fold_build2_loc (loc, MINUS_EXPR, integer_type_node, ind1, ind2);
     }
 
   return NULL_TREE;
@@ -9379,7 +9441,7 @@ fold_builtin_memcmp (tree arg1, tree arg2, tree len)
    Return NULL_TREE if no simplification can be made.  */
 
 static tree
-fold_builtin_strcmp (tree arg1, tree arg2)
+fold_builtin_strcmp (location_t loc, tree arg1, tree arg2)
 {
   const char *p1, *p2;
 
@@ -9412,10 +9474,11 @@ fold_builtin_strcmp (tree arg1, tree arg2)
       tree cst_uchar_ptr_node
        = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
 
-      return fold_convert (integer_type_node,
-                          build1 (INDIRECT_REF, cst_uchar_node,
-                                  fold_convert (cst_uchar_ptr_node,
-                                                arg1)));
+      return fold_convert_loc (loc, integer_type_node,
+                              build1 (INDIRECT_REF, cst_uchar_node,
+                                      fold_convert_loc (loc,
+                                                        cst_uchar_ptr_node,
+                                                        arg1)));
     }
 
   /* If the first arg is "", return -*(const unsigned char*)arg2.  */
@@ -9425,11 +9488,13 @@ fold_builtin_strcmp (tree arg1, tree arg2)
       tree cst_uchar_ptr_node
        = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
 
-      tree temp = fold_convert (integer_type_node,
-                               build1 (INDIRECT_REF, cst_uchar_node,
-                                       fold_convert (cst_uchar_ptr_node,
+      tree temp
+       = fold_convert_loc (loc, integer_type_node,
+                           build1 (INDIRECT_REF, cst_uchar_node,
+                                   fold_convert_loc (loc,
+                                                     cst_uchar_ptr_node,
                                                      arg2)));
-      return fold_build1 (NEGATE_EXPR, integer_type_node, temp);
+      return fold_build1_loc (loc, NEGATE_EXPR, integer_type_node, temp);
     }
 
   return NULL_TREE;
@@ -9439,7 +9504,7 @@ fold_builtin_strcmp (tree arg1, tree arg2)
    Return NULL_TREE if no simplification can be made.  */
 
 static tree
-fold_builtin_strncmp (tree arg1, tree arg2, tree len)
+fold_builtin_strncmp (location_t loc, tree arg1, tree arg2, tree len)
 {
   const char *p1, *p2;
 
@@ -9450,12 +9515,12 @@ fold_builtin_strncmp (tree arg1, tree arg2, tree len)
 
   /* If the LEN parameter is zero, return zero.  */
   if (integer_zerop (len))
-    return omit_two_operands (integer_type_node, integer_zero_node,
+    return omit_two_operands_loc (loc, integer_type_node, integer_zero_node,
                              arg1, arg2);
 
   /* If ARG1 and ARG2 are the same (and not volatile), return zero.  */
   if (operand_equal_p (arg1, arg2, 0))
-    return omit_one_operand (integer_type_node, integer_zero_node, len);
+    return omit_one_operand_loc (loc, integer_type_node, integer_zero_node, len);
 
   p1 = c_getstr (arg1);
   p2 = c_getstr (arg2);
@@ -9481,10 +9546,11 @@ fold_builtin_strncmp (tree arg1, tree arg2, tree len)
       tree cst_uchar_ptr_node
        = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
 
-      return fold_convert (integer_type_node,
-                          build1 (INDIRECT_REF, cst_uchar_node,
-                                  fold_convert (cst_uchar_ptr_node,
-                                                arg1)));
+      return fold_convert_loc (loc, integer_type_node,
+                              build1 (INDIRECT_REF, cst_uchar_node,
+                                      fold_convert_loc (loc,
+                                                        cst_uchar_ptr_node,
+                                                        arg1)));
     }
 
   /* If the first arg is "", and the length is greater than zero,
@@ -9497,11 +9563,12 @@ fold_builtin_strncmp (tree arg1, tree arg2, tree len)
       tree cst_uchar_ptr_node
        = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
 
-      tree temp = fold_convert (integer_type_node,
-                               build1 (INDIRECT_REF, cst_uchar_node,
-                                       fold_convert (cst_uchar_ptr_node,
-                                                     arg2)));
-      return fold_build1 (NEGATE_EXPR, integer_type_node, temp);
+      tree temp = fold_convert_loc (loc, integer_type_node,
+                                   build1 (INDIRECT_REF, cst_uchar_node,
+                                           fold_convert_loc (loc,
+                                                             cst_uchar_ptr_node,
+                                                             arg2)));
+      return fold_build1_loc (loc, NEGATE_EXPR, integer_type_node, temp);
     }
 
   /* If len parameter is one, return an expression corresponding to
@@ -9512,15 +9579,17 @@ fold_builtin_strncmp (tree arg1, tree arg2, tree len)
       tree cst_uchar_ptr_node
        = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
 
-      tree ind1 = fold_convert (integer_type_node,
-                               build1 (INDIRECT_REF, cst_uchar_node,
-                                       fold_convert (cst_uchar_ptr_node,
-                                                     arg1)));
-      tree ind2 = fold_convert (integer_type_node,
-                               build1 (INDIRECT_REF, cst_uchar_node,
-                                       fold_convert (cst_uchar_ptr_node,
-                                                     arg2)));
-      return fold_build2 (MINUS_EXPR, integer_type_node, ind1, ind2);
+      tree ind1 = fold_convert_loc (loc, integer_type_node,
+                                   build1 (INDIRECT_REF, cst_uchar_node,
+                                           fold_convert_loc (loc,
+                                                             cst_uchar_ptr_node,
+                                                             arg1)));
+      tree ind2 = fold_convert_loc (loc, integer_type_node,
+                                   build1 (INDIRECT_REF, cst_uchar_node,
+                                           fold_convert_loc (loc,
+                                                             cst_uchar_ptr_node,
+                                                             arg2)));
+      return fold_build2_loc (loc, MINUS_EXPR, integer_type_node, ind1, ind2);
     }
 
   return NULL_TREE;
@@ -9530,7 +9599,7 @@ fold_builtin_strncmp (tree arg1, tree arg2, tree len)
    ARG.  Return NULL_TREE if no simplification can be made.  */
 
 static tree
-fold_builtin_signbit (tree arg, tree type)
+fold_builtin_signbit (location_t loc, tree arg, tree type)
 {
   tree temp;
 
@@ -9545,16 +9614,16 @@ fold_builtin_signbit (tree arg, tree type)
 
       c = TREE_REAL_CST (arg);
       temp = REAL_VALUE_NEGATIVE (c) ? integer_one_node : integer_zero_node;
-      return fold_convert (type, temp);
+      return fold_convert_loc (loc, type, temp);
     }
 
   /* If ARG is non-negative, the result is always zero.  */
   if (tree_expr_nonnegative_p (arg))
-    return omit_one_operand (type, integer_zero_node, arg);
+    return omit_one_operand_loc (loc, type, integer_zero_node, arg);
 
   /* If ARG's format doesn't have signed zeros, return "arg < 0.0".  */
   if (!HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg))))
-    return fold_build2 (LT_EXPR, type, arg,
+    return fold_build2_loc (loc, LT_EXPR, type, arg,
                        build_real (TREE_TYPE (arg), dconst0));
 
   return NULL_TREE;
@@ -9565,7 +9634,8 @@ fold_builtin_signbit (tree arg, tree type)
    be made.  */
 
 static tree
-fold_builtin_copysign (tree fndecl, tree arg1, tree arg2, tree type)
+fold_builtin_copysign (location_t loc, tree fndecl,
+                      tree arg1, tree arg2, tree type)
 {
   tree tem;
 
@@ -9575,7 +9645,7 @@ fold_builtin_copysign (tree fndecl, tree arg1, tree arg2, tree type)
 
   /* copysign(X,X) is X.  */
   if (operand_equal_p (arg1, arg2, 0))
-    return fold_convert (type, arg1);
+    return fold_convert_loc (loc, type, arg1);
 
   /* If ARG1 and ARG2 are compile-time constants, determine the result.  */
   if (TREE_CODE (arg1) == REAL_CST
@@ -9595,14 +9665,14 @@ fold_builtin_copysign (tree fndecl, tree arg1, tree arg2, tree type)
   /* copysign(X, Y) is fabs(X) when Y is always non-negative.
      Remember to evaluate Y for side-effects.  */
   if (tree_expr_nonnegative_p (arg2))
-    return omit_one_operand (type,
-                            fold_build1 (ABS_EXPR, type, arg1),
+    return omit_one_operand_loc (loc, type,
+                            fold_build1_loc (loc, ABS_EXPR, type, arg1),
                             arg2);
 
   /* Strip sign changing operations for the first argument.  */
   tem = fold_strip_sign_ops (arg1);
   if (tem)
-    return build_call_expr (fndecl, 2, tem, arg2);
+    return build_call_expr_loc (loc, fndecl, 2, tem, arg2);
 
   return NULL_TREE;
 }
@@ -9610,7 +9680,7 @@ fold_builtin_copysign (tree fndecl, tree arg1, tree arg2, tree type)
 /* Fold a call to builtin isascii with argument ARG.  */
 
 static tree
-fold_builtin_isascii (tree arg)
+fold_builtin_isascii (location_t loc, tree arg)
 {
   if (!validate_arg (arg, INTEGER_TYPE))
     return NULL_TREE;
@@ -9620,7 +9690,7 @@ fold_builtin_isascii (tree arg)
       arg = build2 (BIT_AND_EXPR, integer_type_node, arg,
                    build_int_cst (NULL_TREE,
                                   ~ (unsigned HOST_WIDE_INT) 0x7f));
-      return fold_build2 (EQ_EXPR, integer_type_node,
+      return fold_build2_loc (loc, EQ_EXPR, integer_type_node,
                          arg, integer_zero_node);
     }
 }
@@ -9628,20 +9698,20 @@ fold_builtin_isascii (tree arg)
 /* Fold a call to builtin toascii with argument ARG.  */
 
 static tree
-fold_builtin_toascii (tree arg)
+fold_builtin_toascii (location_t loc, tree arg)
 {
   if (!validate_arg (arg, INTEGER_TYPE))
     return NULL_TREE;
       
   /* Transform toascii(c) -> (c & 0x7f).  */
-  return fold_build2 (BIT_AND_EXPR, integer_type_node, arg,
+  return fold_build2_loc (loc, BIT_AND_EXPR, integer_type_node, arg,
                      build_int_cst (NULL_TREE, 0x7f));
 }
 
 /* Fold a call to builtin isdigit with argument ARG.  */
 
 static tree
-fold_builtin_isdigit (tree arg)
+fold_builtin_isdigit (location_t loc, tree arg)
 {
   if (!validate_arg (arg, INTEGER_TYPE))
     return NULL_TREE;
@@ -9656,10 +9726,10 @@ fold_builtin_isdigit (tree arg)
       if (target_digit0 == 0)
        return NULL_TREE;
 
-      arg = fold_convert (unsigned_type_node, arg);
+      arg = fold_convert_loc (loc, unsigned_type_node, arg);
       arg = build2 (MINUS_EXPR, unsigned_type_node, arg,
                    build_int_cst (unsigned_type_node, target_digit0));
-      return fold_build2 (LE_EXPR, integer_type_node, arg,
+      return fold_build2_loc (loc, LE_EXPR, integer_type_node, arg,
                          build_int_cst (unsigned_type_node, 9));
     }
 }
@@ -9667,35 +9737,36 @@ fold_builtin_isdigit (tree arg)
 /* Fold a call to fabs, fabsf or fabsl with argument ARG.  */
 
 static tree
-fold_builtin_fabs (tree arg, tree type)
+fold_builtin_fabs (location_t loc, tree arg, tree type)
 {
   if (!validate_arg (arg, REAL_TYPE))
     return NULL_TREE;
 
-  arg = fold_convert (type, arg);
+  arg = fold_convert_loc (loc, type, arg);
   if (TREE_CODE (arg) == REAL_CST)
     return fold_abs_const (arg, type);
-  return fold_build1 (ABS_EXPR, type, arg);
+  return fold_build1_loc (loc, ABS_EXPR, type, arg);
 }
 
 /* Fold a call to abs, labs, llabs or imaxabs with argument ARG.  */
 
 static tree
-fold_builtin_abs (tree arg, tree type)
+fold_builtin_abs (location_t loc, tree arg, tree type)
 {
   if (!validate_arg (arg, INTEGER_TYPE))
     return NULL_TREE;
 
-  arg = fold_convert (type, arg);
+  arg = fold_convert_loc (loc, type, arg);
   if (TREE_CODE (arg) == INTEGER_CST)
     return fold_abs_const (arg, type);
-  return fold_build1 (ABS_EXPR, type, arg);
+  return fold_build1_loc (loc, ABS_EXPR, type, arg);
 }
 
 /* Fold a call to builtin fmin or fmax.  */
 
 static tree
-fold_builtin_fmin_fmax (tree arg0, tree arg1, tree type, bool max)
+fold_builtin_fmin_fmax (location_t loc, tree arg0, tree arg1,
+                       tree type, bool max)
 {
   if (validate_arg (arg0, REAL_TYPE) && validate_arg (arg1, REAL_TYPE))
     {
@@ -9712,16 +9783,16 @@ fold_builtin_fmin_fmax (tree arg0, tree arg1, tree type, bool max)
          && real_isnan (&TREE_REAL_CST (arg0))
          && (! HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
              || ! TREE_REAL_CST (arg0).signalling))
-       return omit_one_operand (type, arg1, arg0);
+       return omit_one_operand_loc (loc, type, arg1, arg0);
       if (TREE_CODE (arg1) == REAL_CST
          && real_isnan (&TREE_REAL_CST (arg1))
          && (! HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg1)))
              || ! TREE_REAL_CST (arg1).signalling))
-       return omit_one_operand (type, arg0, arg1);
+       return omit_one_operand_loc (loc, type, arg0, arg1);
 
       /* Transform fmin/fmax(x,x) -> x.  */
       if (operand_equal_p (arg0, arg1, OEP_PURE_SAME))
-       return omit_one_operand (type, arg0, arg1);
+       return omit_one_operand_loc (loc, type, arg0, arg1);
       
       /* Convert fmin/fmax to MIN_EXPR/MAX_EXPR.  C99 requires these
         functions to return the numeric arg if the other one is NaN.
@@ -9729,9 +9800,9 @@ fold_builtin_fmin_fmax (tree arg0, tree arg1, tree type, bool max)
         -ffinite-math-only is set.  C99 doesn't require -0.0 to be
         handled, so we don't have to worry about it either.  */
       if (flag_finite_math_only)
-       return fold_build2 ((max ? MAX_EXPR : MIN_EXPR), type,
-                           fold_convert (type, arg0),
-                           fold_convert (type, arg1));
+       return fold_build2_loc (loc, (max ? MAX_EXPR : MIN_EXPR), type,
+                           fold_convert_loc (loc, type, arg0),
+                           fold_convert_loc (loc, type, arg1));
     }
   return NULL_TREE;
 }
@@ -9739,7 +9810,7 @@ fold_builtin_fmin_fmax (tree arg0, tree arg1, tree type, bool max)
 /* Fold a call to builtin carg(a+bi) -> atan2(b,a).  */
 
 static tree
-fold_builtin_carg (tree arg, tree type)
+fold_builtin_carg (location_t loc, tree arg, tree type)
 {
   if (validate_arg (arg, COMPLEX_TYPE)
       && TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) == REAL_TYPE)
@@ -9749,9 +9820,9 @@ fold_builtin_carg (tree arg, tree type)
       if (atan2_fn)
         {
          tree new_arg = builtin_save_expr (arg);
-         tree r_arg = fold_build1 (REALPART_EXPR, type, new_arg);
-         tree i_arg = fold_build1 (IMAGPART_EXPR, type, new_arg);
-         return build_call_expr (atan2_fn, 2, i_arg, r_arg);
+         tree r_arg = fold_build1_loc (loc, REALPART_EXPR, type, new_arg);
+         tree i_arg = fold_build1_loc (loc, IMAGPART_EXPR, type, new_arg);
+         return build_call_expr_loc (loc, atan2_fn, 2, i_arg, r_arg);
        }
     }
   
@@ -9761,7 +9832,7 @@ fold_builtin_carg (tree arg, tree type)
 /* Fold a call to builtin logb/ilogb.  */
 
 static tree
-fold_builtin_logb (tree arg, tree rettype)
+fold_builtin_logb (location_t loc, tree arg, tree rettype)
 {
   if (! validate_arg (arg, REAL_TYPE))
     return NULL_TREE;
@@ -9778,7 +9849,7 @@ fold_builtin_logb (tree arg, tree rettype)
       case rvc_inf:
        /* If arg is Inf or NaN and we're logb, return it.  */
        if (TREE_CODE (rettype) == REAL_TYPE)
-         return fold_convert (rettype, arg);
+         return fold_convert_loc (loc, rettype, arg);
        /* Fall through... */
       case rvc_zero:
        /* Zero may set errno and/or raise an exception for logb, also
@@ -9790,8 +9861,9 @@ fold_builtin_logb (tree arg, tree rettype)
           want the exponent as if they were [1.0, 2.0) so get the
           exponent and subtract 1.  */
        if (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (arg)))->b == 2)
-         return fold_convert (rettype, build_int_cst (NULL_TREE,
-                                                      REAL_EXP (value)-1));
+         return fold_convert_loc (loc, rettype,
+                                  build_int_cst (NULL_TREE,
+                                                 REAL_EXP (value)-1));
        break;
       }
     }
@@ -9802,7 +9874,7 @@ fold_builtin_logb (tree arg, tree rettype)
 /* Fold a call to builtin significand, if radix == 2.  */
 
 static tree
-fold_builtin_significand (tree arg, tree rettype)
+fold_builtin_significand (location_t loc, tree arg, tree rettype)
 {
   if (! validate_arg (arg, REAL_TYPE))
     return NULL_TREE;
@@ -9819,7 +9891,7 @@ fold_builtin_significand (tree arg, tree rettype)
       case rvc_nan:
       case rvc_inf:
        /* If arg is +-0, +-Inf or +-NaN, then return it.  */
-       return fold_convert (rettype, arg);
+       return fold_convert_loc (loc, rettype, arg);
       case rvc_normal:
        /* For normal numbers, proceed iff radix == 2.  */
        if (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (arg)))->b == 2)
@@ -9841,7 +9913,7 @@ fold_builtin_significand (tree arg, tree rettype)
 /* Fold a call to builtin frexp, we can assume the base is 2.  */
 
 static tree
-fold_builtin_frexp (tree arg0, tree arg1, tree rettype)
+fold_builtin_frexp (location_t loc, tree arg0, tree arg1, tree rettype)
 {
   if (! validate_arg (arg0, REAL_TYPE) || ! validate_arg (arg1, POINTER_TYPE))
     return NULL_TREE;
@@ -9851,7 +9923,7 @@ fold_builtin_frexp (tree arg0, tree arg1, tree rettype)
   if (!(TREE_CODE (arg0) == REAL_CST && ! TREE_OVERFLOW (arg0)))
     return NULL_TREE;
   
-  arg1 = build_fold_indirect_ref (arg1);
+  arg1 = build_fold_indirect_ref_loc (loc, arg1);
 
   /* Proceed if a valid pointer type was passed in.  */
   if (TYPE_MAIN_VARIANT (TREE_TYPE (arg1)) == integer_type_node)
@@ -9869,7 +9941,7 @@ fold_builtin_frexp (tree arg0, tree arg1, tree rettype)
       case rvc_nan:
       case rvc_inf:
        /* For +-NaN or +-Inf, *exp is unspecified, return arg0.  */
-       return omit_one_operand (rettype, arg0, arg1);
+       return omit_one_operand_loc (loc, rettype, arg0, arg1);
       case rvc_normal:
        {
          /* Since the frexp function always expects base 2, and in
@@ -9886,9 +9958,9 @@ fold_builtin_frexp (tree arg0, tree arg1, tree rettype)
       }
                
       /* Create the COMPOUND_EXPR (*arg1 = trunc, frac). */
-      arg1 = fold_build2 (MODIFY_EXPR, rettype, arg1, exp);
+      arg1 = fold_build2_loc (loc, MODIFY_EXPR, rettype, arg1, exp);
       TREE_SIDE_EFFECTS (arg1) = 1;
-      return fold_build2 (COMPOUND_EXPR, rettype, arg1, frac);
+      return fold_build2_loc (loc, COMPOUND_EXPR, rettype, arg1, frac);
     }
 
   return NULL_TREE;
@@ -9899,7 +9971,8 @@ fold_builtin_frexp (tree arg0, tree arg1, tree rettype)
    check the mode of the TYPE parameter in certain cases.  */
 
 static tree
-fold_builtin_load_exponent (tree arg0, tree arg1, tree type, bool ldexp)
+fold_builtin_load_exponent (location_t loc, tree arg0, tree arg1,
+                           tree type, bool ldexp)
 {
   if (validate_arg (arg0, REAL_TYPE) && validate_arg (arg1, INTEGER_TYPE))
     {
@@ -9910,7 +9983,7 @@ fold_builtin_load_exponent (tree arg0, tree arg1, tree type, bool ldexp)
       if (real_zerop (arg0) || integer_zerop (arg1)
          || (TREE_CODE (arg0) == REAL_CST
              && !real_isfinite (&TREE_REAL_CST (arg0))))
-       return omit_one_operand (type, arg0, arg1);
+       return omit_one_operand_loc (loc, type, arg0, arg1);
       
       /* If both arguments are constant, then try to evaluate it.  */
       if ((ldexp || REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2)
@@ -9957,7 +10030,7 @@ fold_builtin_load_exponent (tree arg0, tree arg1, tree type, bool ldexp)
 /* Fold a call to builtin modf.  */
 
 static tree
-fold_builtin_modf (tree arg0, tree arg1, tree rettype)
+fold_builtin_modf (location_t loc, tree arg0, tree arg1, tree rettype)
 {
   if (! validate_arg (arg0, REAL_TYPE) || ! validate_arg (arg1, POINTER_TYPE))
     return NULL_TREE;
@@ -9967,7 +10040,7 @@ fold_builtin_modf (tree arg0, tree arg1, tree rettype)
   if (!(TREE_CODE (arg0) == REAL_CST && ! TREE_OVERFLOW (arg0)))
     return NULL_TREE;
   
-  arg1 = build_fold_indirect_ref (arg1);
+  arg1 = build_fold_indirect_ref_loc (loc, arg1);
 
   /* Proceed if a valid pointer type was passed in.  */
   if (TYPE_MAIN_VARIANT (TREE_TYPE (arg1)) == TYPE_MAIN_VARIANT (rettype))
@@ -10000,10 +10073,10 @@ fold_builtin_modf (tree arg0, tree arg1, tree rettype)
       }
              
       /* Create the COMPOUND_EXPR (*arg1 = trunc, frac). */
-      arg1 = fold_build2 (MODIFY_EXPR, rettype, arg1,
+      arg1 = fold_build2_loc (loc, MODIFY_EXPR, rettype, arg1,
                          build_real (rettype, trunc));
       TREE_SIDE_EFFECTS (arg1) = 1;
-      return fold_build2 (COMPOUND_EXPR, rettype, arg1,
+      return fold_build2_loc (loc, COMPOUND_EXPR, rettype, arg1,
                          build_real (rettype, frac));
     }
   
@@ -10014,7 +10087,7 @@ fold_builtin_modf (tree arg0, tree arg1, tree rettype)
    ARG is the argument for the call.  */
 
 static tree
-fold_builtin_classify (tree fndecl, tree arg, int builtin_index)
+fold_builtin_classify (location_t loc, tree fndecl, tree arg, int builtin_index)
 {
   tree type = TREE_TYPE (TREE_TYPE (fndecl));
   REAL_VALUE_TYPE r;
@@ -10026,7 +10099,7 @@ fold_builtin_classify (tree fndecl, tree arg, int builtin_index)
     {
     case BUILT_IN_ISINF:
       if (!HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (arg))))
-       return omit_one_operand (type, integer_zero_node, arg);
+       return omit_one_operand_loc (loc, type, integer_zero_node, arg);
 
       if (TREE_CODE (arg) == REAL_CST)
        {
@@ -10054,17 +10127,18 @@ fold_builtin_classify (tree fndecl, tree arg, int builtin_index)
 
        if (signbit_fn && isinf_fn)
          {
-           tree signbit_call = build_call_expr (signbit_fn, 1, arg);
-           tree isinf_call = build_call_expr (isinf_fn, 1, arg);
+           tree signbit_call = build_call_expr_loc (loc, signbit_fn, 1, arg);
+           tree isinf_call = build_call_expr_loc (loc, isinf_fn, 1, arg);
 
-           signbit_call = fold_build2 (NE_EXPR, integer_type_node,
+           signbit_call = fold_build2_loc (loc, NE_EXPR, integer_type_node,
                                        signbit_call, integer_zero_node);
-           isinf_call = fold_build2 (NE_EXPR, integer_type_node,
+           isinf_call = fold_build2_loc (loc, NE_EXPR, integer_type_node,
                                      isinf_call, integer_zero_node);
            
-           tmp = fold_build3 (COND_EXPR, integer_type_node, signbit_call,
+           tmp = fold_build3_loc (loc, COND_EXPR, integer_type_node, signbit_call,
                               integer_minus_one_node, integer_one_node);
-           tmp = fold_build3 (COND_EXPR, integer_type_node, isinf_call, tmp,
+           tmp = fold_build3_loc (loc, COND_EXPR, integer_type_node,
+                              isinf_call, tmp,
                               integer_zero_node);
          }
 
@@ -10074,7 +10148,7 @@ fold_builtin_classify (tree fndecl, tree arg, int builtin_index)
     case BUILT_IN_ISFINITE:
       if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg)))
          && !HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (arg))))
-       return omit_one_operand (type, integer_one_node, arg);
+       return omit_one_operand_loc (loc, type, integer_one_node, arg);
 
       if (TREE_CODE (arg) == REAL_CST)
        {
@@ -10086,7 +10160,7 @@ fold_builtin_classify (tree fndecl, tree arg, int builtin_index)
 
     case BUILT_IN_ISNAN:
       if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg))))
-       return omit_one_operand (type, integer_zero_node, arg);
+       return omit_one_operand_loc (loc, type, integer_zero_node, arg);
 
       if (TREE_CODE (arg) == REAL_CST)
        {
@@ -10095,7 +10169,7 @@ fold_builtin_classify (tree fndecl, tree arg, int builtin_index)
        }
 
       arg = builtin_save_expr (arg);
-      return fold_build2 (UNORDERED_EXPR, type, arg, arg);
+      return fold_build2_loc (loc, UNORDERED_EXPR, type, arg, arg);
 
     default:
       gcc_unreachable ();
@@ -10111,7 +10185,7 @@ fold_builtin_classify (tree fndecl, tree arg, int builtin_index)
    one floating point argument which is "type generic".  */
 
 static tree
-fold_builtin_fpclassify (tree exp)
+fold_builtin_fpclassify (location_t loc, tree exp)
 {
   tree fp_nan, fp_infinite, fp_normal, fp_subnormal, fp_zero,
     arg, type, res, tmp;
@@ -10133,7 +10207,7 @@ fold_builtin_fpclassify (tree exp)
   arg = CALL_EXPR_ARG (exp, 5);
   type = TREE_TYPE (arg);
   mode = TYPE_MODE (type);
-  arg = builtin_save_expr (fold_build1 (ABS_EXPR, type, arg));
+  arg = builtin_save_expr (fold_build1_loc (loc, ABS_EXPR, type, arg));
 
   /* fpclassify(x) -> 
        isnan(x) ? FP_NAN :
@@ -10141,27 +10215,30 @@ fold_builtin_fpclassify (tree exp)
           (fabs(x) >= DBL_MIN ? FP_NORMAL :
             (x == 0 ? FP_ZERO : FP_SUBNORMAL))).  */
   
-  tmp = fold_build2 (EQ_EXPR, integer_type_node, arg,
+  tmp = fold_build2_loc (loc, EQ_EXPR, integer_type_node, arg,
                     build_real (type, dconst0));
-  res = fold_build3 (COND_EXPR, integer_type_node, tmp, fp_zero, fp_subnormal);
+  res = fold_build3_loc (loc, COND_EXPR, integer_type_node,
+                    tmp, fp_zero, fp_subnormal);
 
   sprintf (buf, "0x1p%d", REAL_MODE_FORMAT (mode)->emin - 1);
   real_from_string (&r, buf);
-  tmp = fold_build2 (GE_EXPR, integer_type_node, arg, build_real (type, r));
-  res = fold_build3 (COND_EXPR, integer_type_node, tmp, fp_normal, res);
+  tmp = fold_build2_loc (loc, GE_EXPR, integer_type_node,
+                    arg, build_real (type, r));
+  res = fold_build3_loc (loc, COND_EXPR, integer_type_node, tmp, fp_normal, res);
   
   if (HONOR_INFINITIES (mode))
     {
       real_inf (&r);
-      tmp = fold_build2 (EQ_EXPR, integer_type_node, arg,
+      tmp = fold_build2_loc (loc, EQ_EXPR, integer_type_node, arg,
                         build_real (type, r));
-      res = fold_build3 (COND_EXPR, integer_type_node, tmp, fp_infinite, res);
+      res = fold_build3_loc (loc, COND_EXPR, integer_type_node, tmp,
+                        fp_infinite, res);
     }
 
   if (HONOR_NANS (mode))
     {
-      tmp = fold_build2 (ORDERED_EXPR, integer_type_node, arg, arg);
-      res = fold_build3 (COND_EXPR, integer_type_node, tmp, res, fp_nan);
+      tmp = fold_build2_loc (loc, ORDERED_EXPR, integer_type_node, arg, arg);
+      res = fold_build3_loc (loc, COND_EXPR, integer_type_node, tmp, res, fp_nan);
     }
   
   return res;
@@ -10176,7 +10253,7 @@ fold_builtin_fpclassify (tree exp)
    the rest.  */
 
 static tree
-fold_builtin_unordered_cmp (tree fndecl, tree arg0, tree arg1,
+fold_builtin_unordered_cmp (location_t loc, tree fndecl, tree arg0, tree arg1,
                            enum tree_code unordered_code,
                            enum tree_code ordered_code)
 {
@@ -10201,20 +10278,20 @@ fold_builtin_unordered_cmp (tree fndecl, tree arg0, tree arg1,
   else if (code0 == INTEGER_TYPE && code1 == REAL_TYPE)
     cmp_type = type1;
 
-  arg0 = fold_convert (cmp_type, arg0);
-  arg1 = fold_convert (cmp_type, arg1);
+  arg0 = fold_convert_loc (loc, cmp_type, arg0);
+  arg1 = fold_convert_loc (loc, cmp_type, arg1);
 
   if (unordered_code == UNORDERED_EXPR)
     {
       if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0))))
-       return omit_two_operands (type, integer_zero_node, arg0, arg1);
-      return fold_build2 (UNORDERED_EXPR, type, arg0, arg1);
+       return omit_two_operands_loc (loc, type, integer_zero_node, arg0, arg1);
+      return fold_build2_loc (loc, UNORDERED_EXPR, type, arg0, arg1);
     }
 
   code = HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0))) ? unordered_code
                                                   : ordered_code;
-  return fold_build1 (TRUTH_NOT_EXPR, type,
-                     fold_build2 (code, type, arg0, arg1));
+  return fold_build1_loc (loc, TRUTH_NOT_EXPR, type,
+                     fold_build2_loc (loc, code, type, arg0, arg1));
 }
 
 /* Fold a call to built-in function FNDECL with 0 arguments.
@@ -10222,7 +10299,7 @@ fold_builtin_unordered_cmp (tree fndecl, tree arg0, tree arg1,
    function returns NULL_TREE if no simplification was possible.  */
 
 static tree
-fold_builtin_0 (tree fndecl, bool ignore ATTRIBUTE_UNUSED)
+fold_builtin_0 (location_t loc, tree fndecl, bool ignore ATTRIBUTE_UNUSED)
 {
   tree type = TREE_TYPE (TREE_TYPE (fndecl));
   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
@@ -10232,10 +10309,10 @@ fold_builtin_0 (tree fndecl, bool ignore ATTRIBUTE_UNUSED)
     case BUILT_IN_INFD32:
     case BUILT_IN_INFD64:
     case BUILT_IN_INFD128:
-      return fold_builtin_inf (type, true);
+      return fold_builtin_inf (loc, type, true);
 
     CASE_FLT_FN (BUILT_IN_HUGE_VAL):
-      return fold_builtin_inf (type, false);
+      return fold_builtin_inf (loc, type, false);
 
     case BUILT_IN_CLASSIFY_TYPE:
       return fold_builtin_classify_type (NULL_TREE);
@@ -10251,7 +10328,7 @@ fold_builtin_0 (tree fndecl, bool ignore ATTRIBUTE_UNUSED)
    function returns NULL_TREE if no simplification was possible.  */
 
 static tree
-fold_builtin_1 (tree fndecl, tree arg0, bool ignore)
+fold_builtin_1 (location_t loc, tree fndecl, tree arg0, bool ignore)
 {
   tree type = TREE_TYPE (TREE_TYPE (fndecl));
   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
@@ -10275,39 +10352,39 @@ fold_builtin_1 (tree fndecl, tree arg0, bool ignore)
       return fold_builtin_classify_type (arg0);
 
     case BUILT_IN_STRLEN:
-      return fold_builtin_strlen (arg0);
+      return fold_builtin_strlen (loc, arg0);
 
     CASE_FLT_FN (BUILT_IN_FABS):
-      return fold_builtin_fabs (arg0, type);
+      return fold_builtin_fabs (loc, arg0, type);
 
     case BUILT_IN_ABS:
     case BUILT_IN_LABS:
     case BUILT_IN_LLABS:
     case BUILT_IN_IMAXABS:
-      return fold_builtin_abs (arg0, type);
+      return fold_builtin_abs (loc, arg0, type);
 
     CASE_FLT_FN (BUILT_IN_CONJ):
       if (validate_arg (arg0, COMPLEX_TYPE)
        && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE) 
-       return fold_build1 (CONJ_EXPR, type, arg0);
+       return fold_build1_loc (loc, CONJ_EXPR, type, arg0);
     break;
 
     CASE_FLT_FN (BUILT_IN_CREAL):
       if (validate_arg (arg0, COMPLEX_TYPE)
        && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE) 
-       return non_lvalue (fold_build1 (REALPART_EXPR, type, arg0));;
+       return non_lvalue_loc (loc, fold_build1_loc (loc, REALPART_EXPR, type, arg0));;
     break;
 
     CASE_FLT_FN (BUILT_IN_CIMAG):
       if (validate_arg (arg0, COMPLEX_TYPE))
-       return non_lvalue (fold_build1 (IMAGPART_EXPR, type, arg0));
+       return non_lvalue_loc (loc, fold_build1_loc (loc, IMAGPART_EXPR, type, arg0));
     break;
 
     CASE_FLT_FN (BUILT_IN_CCOS):
-      return fold_builtin_ccos(arg0, type, fndecl, /*hyper=*/ false);
+      return fold_builtin_ccos(loc, arg0, type, fndecl, /*hyper=*/ false);
     
     CASE_FLT_FN (BUILT_IN_CCOSH):
-      return fold_builtin_ccos(arg0, type, fndecl, /*hyper=*/ true);
+      return fold_builtin_ccos(loc, arg0, type, fndecl, /*hyper=*/ true);
     
 #ifdef HAVE_mpc
     CASE_FLT_FN (BUILT_IN_CSIN):
@@ -10348,16 +10425,16 @@ fold_builtin_1 (tree fndecl, tree arg0, bool ignore)
 #endif
     
     CASE_FLT_FN (BUILT_IN_CABS):
-      return fold_builtin_cabs (arg0, type, fndecl);
+      return fold_builtin_cabs (loc, arg0, type, fndecl);
 
     CASE_FLT_FN (BUILT_IN_CARG):
-      return fold_builtin_carg (arg0, type);
+      return fold_builtin_carg (loc, arg0, type);
 
     CASE_FLT_FN (BUILT_IN_SQRT):
-      return fold_builtin_sqrt (arg0, type);
+      return fold_builtin_sqrt (loc, arg0, type);
 
     CASE_FLT_FN (BUILT_IN_CBRT):
-      return fold_builtin_cbrt (arg0, type);
+      return fold_builtin_cbrt (loc, arg0, type);
 
     CASE_FLT_FN (BUILT_IN_ASIN):
       if (validate_arg (arg0, REAL_TYPE))
@@ -10399,13 +10476,13 @@ fold_builtin_1 (tree fndecl, tree arg0, bool ignore)
     break;
 
     CASE_FLT_FN (BUILT_IN_COS):
-      return fold_builtin_cos (arg0, type, fndecl);
+      return fold_builtin_cos (loc, arg0, type, fndecl);
 
     CASE_FLT_FN (BUILT_IN_TAN):
       return fold_builtin_tan (arg0, type);
 
     CASE_FLT_FN (BUILT_IN_CEXP):
-      return fold_builtin_cexp (arg0, type);
+      return fold_builtin_cexp (loc, arg0, type);
 
     CASE_FLT_FN (BUILT_IN_CEXPI):
       if (validate_arg (arg0, REAL_TYPE))
@@ -10418,7 +10495,7 @@ fold_builtin_1 (tree fndecl, tree arg0, bool ignore)
     break;
 
     CASE_FLT_FN (BUILT_IN_COSH):
-      return fold_builtin_cosh (arg0, type, fndecl);
+      return fold_builtin_cosh (loc, arg0, type, fndecl);
 
     CASE_FLT_FN (BUILT_IN_TANH):
       if (validate_arg (arg0, REAL_TYPE))
@@ -10441,14 +10518,14 @@ fold_builtin_1 (tree fndecl, tree arg0, bool ignore)
     break;
  
     CASE_FLT_FN (BUILT_IN_EXP):
-      return fold_builtin_exponent (fndecl, arg0, mpfr_exp);
+      return fold_builtin_exponent (loc, fndecl, arg0, mpfr_exp);
 
     CASE_FLT_FN (BUILT_IN_EXP2):
-      return fold_builtin_exponent (fndecl, arg0, mpfr_exp2);
+      return fold_builtin_exponent (loc, fndecl, arg0, mpfr_exp2);
 
     CASE_FLT_FN (BUILT_IN_EXP10):
     CASE_FLT_FN (BUILT_IN_POW10):
-      return fold_builtin_exponent (fndecl, arg0, mpfr_exp10);
+      return fold_builtin_exponent (loc, fndecl, arg0, mpfr_exp10);
 
     CASE_FLT_FN (BUILT_IN_EXPM1):
       if (validate_arg (arg0, REAL_TYPE))
@@ -10456,13 +10533,13 @@ fold_builtin_1 (tree fndecl, tree arg0, bool ignore)
     break;
  
     CASE_FLT_FN (BUILT_IN_LOG):
-      return fold_builtin_logarithm (fndecl, arg0, mpfr_log);
+    return fold_builtin_logarithm (loc, fndecl, arg0, mpfr_log);
 
     CASE_FLT_FN (BUILT_IN_LOG2):
-      return fold_builtin_logarithm (fndecl, arg0, mpfr_log2);
+      return fold_builtin_logarithm (loc, fndecl, arg0, mpfr_log2);
 
     CASE_FLT_FN (BUILT_IN_LOG10):
-      return fold_builtin_logarithm (fndecl, arg0, mpfr_log10);
+      return fold_builtin_logarithm (loc, fndecl, arg0, mpfr_log10);
 
     CASE_FLT_FN (BUILT_IN_LOG1P):
       if (validate_arg (arg0, REAL_TYPE))
@@ -10504,20 +10581,20 @@ fold_builtin_1 (tree fndecl, tree arg0, bool ignore)
       return fold_builtin_nan (arg0, type, false);
 
     CASE_FLT_FN (BUILT_IN_FLOOR):
-      return fold_builtin_floor (fndecl, arg0);
+      return fold_builtin_floor (loc, fndecl, arg0);
 
     CASE_FLT_FN (BUILT_IN_CEIL):
-      return fold_builtin_ceil (fndecl, arg0);
+      return fold_builtin_ceil (loc, fndecl, arg0);
 
     CASE_FLT_FN (BUILT_IN_TRUNC):
-      return fold_builtin_trunc (fndecl, arg0);
+      return fold_builtin_trunc (loc, fndecl, arg0);
 
     CASE_FLT_FN (BUILT_IN_ROUND):
-      return fold_builtin_round (fndecl, arg0);
+      return fold_builtin_round (loc, fndecl, arg0);
 
     CASE_FLT_FN (BUILT_IN_NEARBYINT):
     CASE_FLT_FN (BUILT_IN_RINT):
-      return fold_trunc_transparent_mathfn (fndecl, arg0);
+      return fold_trunc_transparent_mathfn (loc, fndecl, arg0);
 
     CASE_FLT_FN (BUILT_IN_LCEIL):
     CASE_FLT_FN (BUILT_IN_LLCEIL):
@@ -10525,11 +10602,11 @@ fold_builtin_1 (tree fndecl, tree arg0, bool ignore)
     CASE_FLT_FN (BUILT_IN_LLFLOOR):
     CASE_FLT_FN (BUILT_IN_LROUND):
     CASE_FLT_FN (BUILT_IN_LLROUND):
-      return fold_builtin_int_roundingfn (fndecl, arg0);
+      return fold_builtin_int_roundingfn (loc, fndecl, arg0);
 
     CASE_FLT_FN (BUILT_IN_LRINT):
     CASE_FLT_FN (BUILT_IN_LLRINT):
-      return fold_fixed_mathfn (fndecl, arg0);
+      return fold_fixed_mathfn (loc, fndecl, arg0);
 
     case BUILT_IN_BSWAP32:
     case BUILT_IN_BSWAP64:
@@ -10543,50 +10620,50 @@ fold_builtin_1 (tree fndecl, tree arg0, bool ignore)
       return fold_builtin_bitop (fndecl, arg0);
 
     CASE_FLT_FN (BUILT_IN_SIGNBIT):
-      return fold_builtin_signbit (arg0, type);
+      return fold_builtin_signbit (loc, arg0, type);
 
     CASE_FLT_FN (BUILT_IN_SIGNIFICAND):
-      return fold_builtin_significand (arg0, type);
+      return fold_builtin_significand (loc, arg0, type);
 
     CASE_FLT_FN (BUILT_IN_ILOGB):
     CASE_FLT_FN (BUILT_IN_LOGB):
-      return fold_builtin_logb (arg0, type);
+      return fold_builtin_logb (loc, arg0, type);
 
     case BUILT_IN_ISASCII:
-      return fold_builtin_isascii (arg0);
+      return fold_builtin_isascii (loc, arg0);
 
     case BUILT_IN_TOASCII:
-      return fold_builtin_toascii (arg0);
+      return fold_builtin_toascii (loc, arg0);
 
     case BUILT_IN_ISDIGIT:
-      return fold_builtin_isdigit (arg0);
+      return fold_builtin_isdigit (loc, arg0);
 
     CASE_FLT_FN (BUILT_IN_FINITE):
     case BUILT_IN_FINITED32:
     case BUILT_IN_FINITED64:
     case BUILT_IN_FINITED128:
     case BUILT_IN_ISFINITE:
-      return fold_builtin_classify (fndecl, arg0, BUILT_IN_ISFINITE);
+      return fold_builtin_classify (loc, fndecl, arg0, BUILT_IN_ISFINITE);
 
     CASE_FLT_FN (BUILT_IN_ISINF):
     case BUILT_IN_ISINFD32:
     case BUILT_IN_ISINFD64:
     case BUILT_IN_ISINFD128:
-      return fold_builtin_classify (fndecl, arg0, BUILT_IN_ISINF);
+      return fold_builtin_classify (loc, fndecl, arg0, BUILT_IN_ISINF);
 
     case BUILT_IN_ISINF_SIGN:
-      return fold_builtin_classify (fndecl, arg0, BUILT_IN_ISINF_SIGN);
+      return fold_builtin_classify (loc, fndecl, arg0, BUILT_IN_ISINF_SIGN);
 
     CASE_FLT_FN (BUILT_IN_ISNAN):
     case BUILT_IN_ISNAND32:
     case BUILT_IN_ISNAND64:
     case BUILT_IN_ISNAND128:
-      return fold_builtin_classify (fndecl, arg0, BUILT_IN_ISNAN);
+      return fold_builtin_classify (loc, fndecl, arg0, BUILT_IN_ISNAN);
 
     case BUILT_IN_PRINTF:
     case BUILT_IN_PRINTF_UNLOCKED:
     case BUILT_IN_VPRINTF:
-      return fold_builtin_printf (fndecl, arg0, NULL_TREE, ignore, fcode);
+      return fold_builtin_printf (loc, fndecl, arg0, NULL_TREE, ignore, fcode);
 
     default:
       break;
@@ -10601,7 +10678,7 @@ fold_builtin_1 (tree fndecl, tree arg0, bool ignore)
    function returns NULL_TREE if no simplification was possible.  */
 
 static tree
-fold_builtin_2 (tree fndecl, tree arg0, tree arg1, bool ignore)
+fold_builtin_2 (location_t loc, tree fndecl, tree arg0, tree arg1, bool ignore)
 {
   tree type = TREE_TYPE (TREE_TYPE (fndecl));
   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
@@ -10648,7 +10725,7 @@ fold_builtin_2 (tree fndecl, tree arg0, tree arg1, bool ignore)
     break;
 
     CASE_FLT_FN (BUILT_IN_HYPOT):
-      return fold_builtin_hypot (fndecl, arg0, arg1, type);
+      return fold_builtin_hypot (loc, fndecl, arg0, arg1, type);
 
 #ifdef HAVE_mpc_pow
     CASE_FLT_FN (BUILT_IN_CPOW):
@@ -10661,48 +10738,49 @@ fold_builtin_2 (tree fndecl, tree arg0, tree arg1, bool ignore)
 #endif
 
     CASE_FLT_FN (BUILT_IN_LDEXP):
-      return fold_builtin_load_exponent (arg0, arg1, type, /*ldexp=*/true);
+      return fold_builtin_load_exponent (loc, arg0, arg1, type, /*ldexp=*/true);
     CASE_FLT_FN (BUILT_IN_SCALBN):
     CASE_FLT_FN (BUILT_IN_SCALBLN):
-      return fold_builtin_load_exponent (arg0, arg1, type, /*ldexp=*/false);
+      return fold_builtin_load_exponent (loc, arg0, arg1,
+                                        type, /*ldexp=*/false);
 
     CASE_FLT_FN (BUILT_IN_FREXP):
-      return fold_builtin_frexp (arg0, arg1, type);
+      return fold_builtin_frexp (loc, arg0, arg1, type);
 
     CASE_FLT_FN (BUILT_IN_MODF):
-      return fold_builtin_modf (arg0, arg1, type);
+      return fold_builtin_modf (loc, arg0, arg1, type);
 
     case BUILT_IN_BZERO:
-      return fold_builtin_bzero (arg0, arg1, ignore);
+      return fold_builtin_bzero (loc, arg0, arg1, ignore);
 
     case BUILT_IN_FPUTS:
-      return fold_builtin_fputs (arg0, arg1, ignore, false, NULL_TREE);
+      return fold_builtin_fputs (loc, arg0, arg1, ignore, false, NULL_TREE);
 
     case BUILT_IN_FPUTS_UNLOCKED:
-      return fold_builtin_fputs (arg0, arg1, ignore, true, NULL_TREE);
+      return fold_builtin_fputs (loc, arg0, arg1, ignore, true, NULL_TREE);
 
     case BUILT_IN_STRSTR:
-      return fold_builtin_strstr (arg0, arg1, type);
+      return fold_builtin_strstr (loc, arg0, arg1, type);
 
     case BUILT_IN_STRCAT:
-      return fold_builtin_strcat (arg0, arg1);
+      return fold_builtin_strcat (loc, arg0, arg1);
 
     case BUILT_IN_STRSPN:
-      return fold_builtin_strspn (arg0, arg1);
+      return fold_builtin_strspn (loc, arg0, arg1);
 
     case BUILT_IN_STRCSPN:
-      return fold_builtin_strcspn (arg0, arg1);
+      return fold_builtin_strcspn (loc, arg0, arg1);
 
     case BUILT_IN_STRCHR:
     case BUILT_IN_INDEX:
-      return fold_builtin_strchr (arg0, arg1, type);
+      return fold_builtin_strchr (loc, arg0, arg1, type);
 
     case BUILT_IN_STRRCHR:
     case BUILT_IN_RINDEX:
-      return fold_builtin_strrchr (arg0, arg1, type);
+      return fold_builtin_strrchr (loc, arg0, arg1, type);
 
     case BUILT_IN_STRCPY:
-      return fold_builtin_strcpy (fndecl, arg0, arg1, NULL_TREE);
+      return fold_builtin_strcpy (loc, fndecl, arg0, arg1, NULL_TREE);
 
     case BUILT_IN_STPCPY:
       if (ignore)
@@ -10711,46 +10789,52 @@ fold_builtin_2 (tree fndecl, tree arg0, tree arg1, bool ignore)
          if (!fn)
            break;
 
-         return build_call_expr (fn, 2, arg0, arg1);
+         return build_call_expr_loc (loc, fn, 2, arg0, arg1);
        }
       break;
 
     case BUILT_IN_STRCMP:
-      return fold_builtin_strcmp (arg0, arg1);
+      return fold_builtin_strcmp (loc, arg0, arg1);
 
     case BUILT_IN_STRPBRK:
-      return fold_builtin_strpbrk (arg0, arg1, type);
+      return fold_builtin_strpbrk (loc, arg0, arg1, type);
 
     case BUILT_IN_EXPECT:
-      return fold_builtin_expect (arg0, arg1);
+      return fold_builtin_expect (loc, arg0, arg1);
 
     CASE_FLT_FN (BUILT_IN_POW):
-      return fold_builtin_pow (fndecl, arg0, arg1, type);
+      return fold_builtin_pow (loc, fndecl, arg0, arg1, type);
 
     CASE_FLT_FN (BUILT_IN_POWI):
-      return fold_builtin_powi (fndecl, arg0, arg1, type);
+      return fold_builtin_powi (loc, fndecl, arg0, arg1, type);
 
     CASE_FLT_FN (BUILT_IN_COPYSIGN):
-      return fold_builtin_copysign (fndecl, arg0, arg1, type);
+      return fold_builtin_copysign (loc, fndecl, arg0, arg1, type);
 
     CASE_FLT_FN (BUILT_IN_FMIN):
-      return fold_builtin_fmin_fmax (arg0, arg1, type, /*max=*/false);
+      return fold_builtin_fmin_fmax (loc, arg0, arg1, type, /*max=*/false);
 
     CASE_FLT_FN (BUILT_IN_FMAX):
-      return fold_builtin_fmin_fmax (arg0, arg1, type, /*max=*/true);
+      return fold_builtin_fmin_fmax (loc, arg0, arg1, type, /*max=*/true);
 
     case BUILT_IN_ISGREATER:
-      return fold_builtin_unordered_cmp (fndecl, arg0, arg1, UNLE_EXPR, LE_EXPR);
+      return fold_builtin_unordered_cmp (loc, fndecl,
+                                        arg0, arg1, UNLE_EXPR, LE_EXPR);
     case BUILT_IN_ISGREATEREQUAL:
-      return fold_builtin_unordered_cmp (fndecl, arg0, arg1, UNLT_EXPR, LT_EXPR);
+      return fold_builtin_unordered_cmp (loc, fndecl,
+                                        arg0, arg1, UNLT_EXPR, LT_EXPR);
     case BUILT_IN_ISLESS:
-      return fold_builtin_unordered_cmp (fndecl, arg0, arg1, UNGE_EXPR, GE_EXPR);
+      return fold_builtin_unordered_cmp (loc, fndecl,
+                                        arg0, arg1, UNGE_EXPR, GE_EXPR);
     case BUILT_IN_ISLESSEQUAL:
-      return fold_builtin_unordered_cmp (fndecl, arg0, arg1, UNGT_EXPR, GT_EXPR);
+      return fold_builtin_unordered_cmp (loc, fndecl,
+                                        arg0, arg1, UNGT_EXPR, GT_EXPR);
     case BUILT_IN_ISLESSGREATER:
-      return fold_builtin_unordered_cmp (fndecl, arg0, arg1, UNEQ_EXPR, EQ_EXPR);
+      return fold_builtin_unordered_cmp (loc, fndecl,
+                                        arg0, arg1, UNEQ_EXPR, EQ_EXPR);
     case BUILT_IN_ISUNORDERED:
-      return fold_builtin_unordered_cmp (fndecl, arg0, arg1, UNORDERED_EXPR,
+      return fold_builtin_unordered_cmp (loc, fndecl,
+                                        arg0, arg1, UNORDERED_EXPR,
                                         NOP_EXPR);
 
       /* We do the folding for va_start in the expander.  */
@@ -10758,7 +10842,7 @@ fold_builtin_2 (tree fndecl, tree arg0, tree arg1, bool ignore)
       break;
 
     case BUILT_IN_SPRINTF:
-      return fold_builtin_sprintf (arg0, arg1, NULL_TREE, ignore);
+      return fold_builtin_sprintf (loc, arg0, arg1, NULL_TREE, ignore);
 
     case BUILT_IN_OBJECT_SIZE:
       return fold_builtin_object_size (arg0, arg1);
@@ -10766,7 +10850,7 @@ fold_builtin_2 (tree fndecl, tree arg0, tree arg1, bool ignore)
     case BUILT_IN_PRINTF:
     case BUILT_IN_PRINTF_UNLOCKED:
     case BUILT_IN_VPRINTF:
-      return fold_builtin_printf (fndecl, arg0, arg1, ignore, fcode);
+      return fold_builtin_printf (loc, fndecl, arg0, arg1, ignore, fcode);
 
     case BUILT_IN_PRINTF_CHK:
     case BUILT_IN_VPRINTF_CHK:
@@ -10774,13 +10858,14 @@ fold_builtin_2 (tree fndecl, tree arg0, tree arg1, bool ignore)
          || TREE_SIDE_EFFECTS (arg0))
        return NULL_TREE;
       else
-       return fold_builtin_printf (fndecl, arg1, NULL_TREE, ignore, fcode);
+       return fold_builtin_printf (loc, fndecl,
+                                   arg1, NULL_TREE, ignore, fcode);
     break;
 
     case BUILT_IN_FPRINTF:
     case BUILT_IN_FPRINTF_UNLOCKED:
     case BUILT_IN_VFPRINTF:
-      return fold_builtin_fprintf (fndecl, arg0, arg1, NULL_TREE,
+      return fold_builtin_fprintf (loc, fndecl, arg0, arg1, NULL_TREE,
                                   ignore, fcode);
 
     default:
@@ -10794,7 +10879,8 @@ fold_builtin_2 (tree fndecl, tree arg0, tree arg1, bool ignore)
    This function returns NULL_TREE if no simplification was possible.  */
 
 static tree
-fold_builtin_3 (tree fndecl, tree arg0, tree arg1, tree arg2, bool ignore)
+fold_builtin_3 (location_t loc, tree fndecl,
+               tree arg0, tree arg1, tree arg2, bool ignore)
 {
   tree type = TREE_TYPE (TREE_TYPE (fndecl));
   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
@@ -10802,7 +10888,7 @@ fold_builtin_3 (tree fndecl, tree arg0, tree arg1, tree arg2, bool ignore)
     {
 
     CASE_FLT_FN (BUILT_IN_SINCOS):
-      return fold_builtin_sincos (arg0, arg1, arg2);
+      return fold_builtin_sincos (loc, arg0, arg1, arg2);
 
     CASE_FLT_FN (BUILT_IN_FMA):
       if (validate_arg (arg0, REAL_TYPE)
@@ -10819,46 +10905,50 @@ fold_builtin_3 (tree fndecl, tree arg0, tree arg1, tree arg2, bool ignore)
     break;
 
     case BUILT_IN_MEMSET:
-      return fold_builtin_memset (arg0, arg1, arg2, type, ignore);
+      return fold_builtin_memset (loc, arg0, arg1, arg2, type, ignore);
 
     case BUILT_IN_BCOPY:
-       return fold_builtin_memory_op (arg1, arg0, arg2, void_type_node, true, /*endp=*/3);
+      return fold_builtin_memory_op (loc, arg1, arg0, arg2,
+                                    void_type_node, true, /*endp=*/3);
 
     case BUILT_IN_MEMCPY:
-      return fold_builtin_memory_op (arg0, arg1, arg2, type, ignore, /*endp=*/0);
+      return fold_builtin_memory_op (loc, arg0, arg1, arg2,
+                                    type, ignore, /*endp=*/0);
 
     case BUILT_IN_MEMPCPY:
-      return fold_builtin_memory_op (arg0, arg1, arg2, type, ignore, /*endp=*/1);
+      return fold_builtin_memory_op (loc, arg0, arg1, arg2,
+                                    type, ignore, /*endp=*/1);
 
     case BUILT_IN_MEMMOVE:
-      return fold_builtin_memory_op (arg0, arg1, arg2, type, ignore, /*endp=*/3);
+      return fold_builtin_memory_op (loc, arg0, arg1, arg2,
+                                    type, ignore, /*endp=*/3);
 
     case BUILT_IN_STRNCAT:
-      return fold_builtin_strncat (arg0, arg1, arg2);
+      return fold_builtin_strncat (loc, arg0, arg1, arg2);
 
     case BUILT_IN_STRNCPY:
-      return fold_builtin_strncpy (fndecl, arg0, arg1, arg2, NULL_TREE);
+      return fold_builtin_strncpy (loc, fndecl, arg0, arg1, arg2, NULL_TREE);
 
     case BUILT_IN_STRNCMP:
-      return fold_builtin_strncmp (arg0, arg1, arg2);
+      return fold_builtin_strncmp (loc, arg0, arg1, arg2);
 
     case BUILT_IN_MEMCHR:
-      return fold_builtin_memchr (arg0, arg1, arg2, type);
+      return fold_builtin_memchr (loc, arg0, arg1, arg2, type);
 
     case BUILT_IN_BCMP:
     case BUILT_IN_MEMCMP:
-      return fold_builtin_memcmp (arg0, arg1, arg2);;
+      return fold_builtin_memcmp (loc, arg0, arg1, arg2);;
 
     case BUILT_IN_SPRINTF:
-      return fold_builtin_sprintf (arg0, arg1, arg2, ignore);
+      return fold_builtin_sprintf (loc, arg0, arg1, arg2, ignore);
 
     case BUILT_IN_STRCPY_CHK:
     case BUILT_IN_STPCPY_CHK:
-      return fold_builtin_stxcpy_chk (fndecl, arg0, arg1, arg2, NULL_TREE,
+      return fold_builtin_stxcpy_chk (loc, fndecl, arg0, arg1, arg2, NULL_TREE,
                                      ignore, fcode);
 
     case BUILT_IN_STRCAT_CHK:
-      return fold_builtin_strcat_chk (fndecl, arg0, arg1, arg2);
+      return fold_builtin_strcat_chk (loc, fndecl, arg0, arg1, arg2);
 
     case BUILT_IN_PRINTF_CHK:
     case BUILT_IN_VPRINTF_CHK:
@@ -10866,13 +10956,14 @@ fold_builtin_3 (tree fndecl, tree arg0, tree arg1, tree arg2, bool ignore)
          || TREE_SIDE_EFFECTS (arg0))
        return NULL_TREE;
       else
-       return fold_builtin_printf (fndecl, arg1, arg2, ignore, fcode);
+       return fold_builtin_printf (loc, fndecl, arg1, arg2, ignore, fcode);
     break;
 
     case BUILT_IN_FPRINTF:
     case BUILT_IN_FPRINTF_UNLOCKED:
     case BUILT_IN_VFPRINTF:
-      return fold_builtin_fprintf (fndecl, arg0, arg1, arg2, ignore, fcode);
+      return fold_builtin_fprintf (loc, fndecl, arg0, arg1, arg2,
+                                  ignore, fcode);
 
     case BUILT_IN_FPRINTF_CHK:
     case BUILT_IN_VFPRINTF_CHK:
@@ -10880,7 +10971,7 @@ fold_builtin_3 (tree fndecl, tree arg0, tree arg1, tree arg2, bool ignore)
          || TREE_SIDE_EFFECTS (arg1))
        return NULL_TREE;
       else
-       return fold_builtin_fprintf (fndecl, arg0, arg2, NULL_TREE,
+       return fold_builtin_fprintf (loc, fndecl, arg0, arg2, NULL_TREE,
                                     ignore, fcode);
 
     default:
@@ -10895,8 +10986,8 @@ fold_builtin_3 (tree fndecl, tree arg0, tree arg1, tree arg2, bool ignore)
    possible.  */
  
 static tree
-fold_builtin_4 (tree fndecl, tree arg0, tree arg1, tree arg2, tree arg3,
-               bool ignore)
+fold_builtin_4 (location_t loc, tree fndecl,
+               tree arg0, tree arg1, tree arg2, tree arg3, bool ignore)
 {
   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
 
@@ -10906,15 +10997,15 @@ fold_builtin_4 (tree fndecl, tree arg0, tree arg1, tree arg2, tree arg3,
     case BUILT_IN_MEMPCPY_CHK:
     case BUILT_IN_MEMMOVE_CHK:
     case BUILT_IN_MEMSET_CHK:
-      return fold_builtin_memory_chk (fndecl, arg0, arg1, arg2, arg3,
+      return fold_builtin_memory_chk (loc, fndecl, arg0, arg1, arg2, arg3,
                                      NULL_TREE, ignore,
                                      DECL_FUNCTION_CODE (fndecl));
 
     case BUILT_IN_STRNCPY_CHK:
-      return fold_builtin_strncpy_chk (arg0, arg1, arg2, arg3, NULL_TREE);
+      return fold_builtin_strncpy_chk (loc, arg0, arg1, arg2, arg3, NULL_TREE);
 
     case BUILT_IN_STRNCAT_CHK:
-      return fold_builtin_strncat_chk (fndecl, arg0, arg1, arg2, arg3);
+      return fold_builtin_strncat_chk (loc, fndecl, arg0, arg1, arg2, arg3);
 
     case BUILT_IN_FPRINTF_CHK:
     case BUILT_IN_VFPRINTF_CHK:
@@ -10922,7 +11013,7 @@ fold_builtin_4 (tree fndecl, tree arg0, tree arg1, tree arg2, tree arg3,
          || TREE_SIDE_EFFECTS (arg1))
        return NULL_TREE;
       else
-       return fold_builtin_fprintf (fndecl, arg0, arg2, arg3,
+       return fold_builtin_fprintf (loc, fndecl, arg0, arg2, arg3,
                                     ignore, fcode);
     break;
 
@@ -10943,26 +11034,26 @@ fold_builtin_4 (tree fndecl, tree arg0, tree arg1, tree arg2, tree arg3,
 #define MAX_ARGS_TO_FOLD_BUILTIN 4
  
 static tree
-fold_builtin_n (tree fndecl, tree *args, int nargs, bool ignore)
+fold_builtin_n (location_t loc, tree fndecl, tree *args, int nargs, bool ignore)
 {
   tree ret = NULL_TREE;
 
   switch (nargs)
     {
     case 0:
-      ret = fold_builtin_0 (fndecl, ignore);
+      ret = fold_builtin_0 (loc, fndecl, ignore);
       break;
     case 1:
-      ret = fold_builtin_1 (fndecl, args[0], ignore);
+      ret = fold_builtin_1 (loc, fndecl, args[0], ignore);
       break;
     case 2:
-      ret = fold_builtin_2 (fndecl, args[0], args[1], ignore);
+      ret = fold_builtin_2 (loc, fndecl, args[0], args[1], ignore);
       break;
     case 3:
-      ret = fold_builtin_3 (fndecl, args[0], args[1], args[2], ignore);
+      ret = fold_builtin_3 (loc, fndecl, args[0], args[1], args[2], ignore);
       break;
     case 4:
-      ret = fold_builtin_4 (fndecl, args[0], args[1], args[2], args[3],
+      ret = fold_builtin_4 (loc, fndecl, args[0], args[1], args[2], args[3],
                            ignore);
       break;
     default:
@@ -10971,6 +11062,7 @@ fold_builtin_n (tree fndecl, tree *args, int nargs, bool ignore)
   if (ret)
     {
       ret = build1 (NOP_EXPR, TREE_TYPE (ret), ret);
+      SET_EXPR_LOCATION (ret, loc);
       TREE_NO_WARNING (ret) = 1;
       return ret;
     }
@@ -10985,7 +11077,8 @@ fold_builtin_n (tree fndecl, tree *args, int nargs, bool ignore)
    result of the function call is ignored.  */
 
 static tree
-fold_builtin_varargs (tree fndecl, tree exp, bool ignore ATTRIBUTE_UNUSED)
+fold_builtin_varargs (location_t loc, tree fndecl, tree exp,
+                     bool ignore ATTRIBUTE_UNUSED)
 {
   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
   tree ret = NULL_TREE;
@@ -10994,16 +11087,16 @@ fold_builtin_varargs (tree fndecl, tree exp, bool ignore ATTRIBUTE_UNUSED)
     {
     case BUILT_IN_SPRINTF_CHK:
     case BUILT_IN_VSPRINTF_CHK:
-      ret = fold_builtin_sprintf_chk (exp, fcode);
+      ret = fold_builtin_sprintf_chk (loc, exp, fcode);
       break;
 
     case BUILT_IN_SNPRINTF_CHK:
     case BUILT_IN_VSNPRINTF_CHK:
-      ret = fold_builtin_snprintf_chk (exp, NULL_TREE, fcode);
+      ret = fold_builtin_snprintf_chk (loc, exp, NULL_TREE, fcode);
       break;
 
     case BUILT_IN_FPCLASSIFY:
-      ret = fold_builtin_fpclassify (exp);
+      ret = fold_builtin_fpclassify (loc, exp);
       break;
 
     default:
@@ -11012,6 +11105,7 @@ fold_builtin_varargs (tree fndecl, tree exp, bool ignore ATTRIBUTE_UNUSED)
   if (ret)
     {
       ret = build1 (NOP_EXPR, TREE_TYPE (ret), ret);
+      SET_EXPR_LOCATION (ret, loc);
       TREE_NO_WARNING (ret) = 1;
       return ret;
     }
@@ -11039,7 +11133,7 @@ avoid_folding_inline_builtin (tree fndecl)
    call node earlier than the warning is generated.  */
 
 tree
-fold_call_expr (tree exp, bool ignore)
+fold_call_expr (location_t loc, tree exp, bool ignore)
 {
   tree ret = NULL_TREE;
   tree fndecl = get_callee_fndecl (exp);
@@ -11077,27 +11171,12 @@ fold_call_expr (tree exp, bool ignore)
          if (nargs <= MAX_ARGS_TO_FOLD_BUILTIN)
            {
              tree *args = CALL_EXPR_ARGP (exp);
-             ret = fold_builtin_n (fndecl, args, nargs, ignore);
+             ret = fold_builtin_n (loc, fndecl, args, nargs, ignore);
            }
          if (!ret)
-           ret = fold_builtin_varargs (fndecl, exp, ignore);
+           ret = fold_builtin_varargs (loc, fndecl, exp, ignore);
          if (ret)
-           {
-             /* Propagate location information from original call to
-                expansion of builtin.  Otherwise things like
-                maybe_emit_chk_warning, that operate on the expansion
-                of a builtin, will use the wrong location information.  */
-             if (CAN_HAVE_LOCATION_P (exp) && EXPR_HAS_LOCATION (exp))
-               {
-                 tree realret = ret;
-                 if (TREE_CODE (ret) == NOP_EXPR)
-                   realret = TREE_OPERAND (ret, 0);
-                 if (CAN_HAVE_LOCATION_P (realret)
-                     && !EXPR_HAS_LOCATION (realret))
-                   SET_EXPR_LOCATION (realret, EXPR_LOCATION (exp));
-               }
-             return ret;
-           }
+           return ret;
        }
     }
   return NULL_TREE;
@@ -11107,17 +11186,17 @@ fold_call_expr (tree exp, bool ignore)
     function to be called and ARGLIST is a TREE_LIST of arguments.  */
  
 tree
-build_function_call_expr (tree fndecl, tree arglist)
+build_function_call_expr (location_t loc, tree fndecl, tree arglist)
 {
   tree fntype = TREE_TYPE (fndecl);
   tree fn = build1 (ADDR_EXPR, build_pointer_type (fntype), fndecl);
   int n = list_length (arglist);
   tree *argarray = (tree *) alloca (n * sizeof (tree));
   int i;
-  
+
   for (i = 0; i < n; i++, arglist = TREE_CHAIN (arglist))
     argarray[i] = TREE_VALUE (arglist);
-  return fold_builtin_call_array (TREE_TYPE (fntype), fn, n, argarray);
+  return fold_builtin_call_array (loc, TREE_TYPE (fntype), fn, n, argarray);
 }
 
 /* Conveniently construct a function call expression.  FNDECL names the
@@ -11125,7 +11204,7 @@ build_function_call_expr (tree fndecl, tree arglist)
    parameters are the argument expressions.  */
  
 tree
-build_call_expr (tree fndecl, int n, ...)
+build_call_expr_loc (location_t loc, tree fndecl, int n, ...)
 {
   va_list ap;
   tree fntype = TREE_TYPE (fndecl);
@@ -11137,14 +11216,14 @@ build_call_expr (tree fndecl, int n, ...)
   for (i = 0; i < n; i++)
     argarray[i] = va_arg (ap, tree);
   va_end (ap);
-  return fold_builtin_call_array (TREE_TYPE (fntype), fn, n, argarray);
+  return fold_builtin_call_array (loc, TREE_TYPE (fntype), fn, n, argarray);
 }
 
 /* Construct a CALL_EXPR with type TYPE with FN as the function expression.
    N arguments are passed in the array ARGARRAY.  */
 
 tree
-fold_builtin_call_array (tree type,
+fold_builtin_call_array (location_t loc, tree type,
                         tree fn,
                         int n,
                         tree *argarray)
@@ -11168,10 +11247,10 @@ fold_builtin_call_array (tree type,
                && TREE_CODE (fndecl2) == FUNCTION_DECL
                && DECL_BUILT_IN_CLASS (fndecl2) == BUILT_IN_NORMAL
                && DECL_FUNCTION_CODE (fndecl2) == BUILT_IN_VA_ARG_PACK)
-             return build_call_array (type, fn, n, argarray);
+             return build_call_array_loc (loc, type, fn, n, argarray);
          }
        if (avoid_folding_inline_builtin (fndecl))
-         return build_call_array (type, fn, n, argarray);
+         return build_call_array_loc (loc, type, fn, n, argarray);
         if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
           {
             tree arglist = NULL_TREE;
@@ -11180,25 +11259,25 @@ fold_builtin_call_array (tree type,
             ret = targetm.fold_builtin (fndecl, arglist, false);
             if (ret)
               return ret;
-           return build_call_array (type, fn, n, argarray);
+           return build_call_array_loc (loc, type, fn, n, argarray);
           }
         else if (n <= MAX_ARGS_TO_FOLD_BUILTIN)
           {
             /* First try the transformations that don't require consing up
                an exp.  */
-            ret = fold_builtin_n (fndecl, argarray, n, false);
+            ret = fold_builtin_n (loc, fndecl, argarray, n, false);
             if (ret)
               return ret;
           }
 
         /* If we got this far, we need to build an exp.  */
-        exp = build_call_array (type, fn, n, argarray);
-        ret = fold_builtin_varargs (fndecl, exp, false);
+        exp = build_call_array_loc (loc, type, fn, n, argarray);
+        ret = fold_builtin_varargs (loc, fndecl, exp, false);
         return ret ? ret : exp;
       }
   }
 
-  return build_call_array (type, fn, n, argarray);
+  return build_call_array_loc (loc, type, fn, n, argarray);
 }
 
 /* Construct a new CALL_EXPR using the tail of the argument list of EXP
@@ -11207,7 +11286,7 @@ fold_builtin_call_array (tree type,
    to do varargs-to-varargs transformations.  */
 
 static tree
-rewrite_call_expr (tree exp, int skip, tree fndecl, int n, ...)
+rewrite_call_expr (location_t loc, tree exp, int skip, tree fndecl, int n, ...)
 {
   int oldnargs = call_expr_nargs (exp);
   int nargs = oldnargs - skip + n;
@@ -11231,7 +11310,7 @@ rewrite_call_expr (tree exp, int skip, tree fndecl, int n, ...)
   else 
     buffer = CALL_EXPR_ARGP (exp) + skip;
 
-  return fold (build_call_array (TREE_TYPE (exp), fn, nargs, buffer));
+  return fold (build_call_array_loc (loc, TREE_TYPE (exp), fn, nargs, buffer));
 }
 
 /* Validate a single argument ARG against a tree code CODE representing
@@ -11412,7 +11491,7 @@ readonly_data_expr (tree exp)
    form of the builtin function call.  */
 
 static tree
-fold_builtin_strstr (tree s1, tree s2, tree type)
+fold_builtin_strstr (location_t loc, tree s1, tree s2, tree type)
 {
   if (!validate_arg (s1, POINTER_TYPE)
       || !validate_arg (s2, POINTER_TYPE))
@@ -11436,15 +11515,15 @@ fold_builtin_strstr (tree s1, tree s2, tree type)
            return build_int_cst (TREE_TYPE (s1), 0);
 
          /* Return an offset into the constant string argument.  */
-         tem = fold_build2 (POINTER_PLUS_EXPR, TREE_TYPE (s1),
+         tem = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (s1),
                             s1, size_int (r - p1));
-         return fold_convert (type, tem);
+         return fold_convert_loc (loc, type, tem);
        }
 
       /* The argument is const char *, and the result is char *, so we need
         a type conversion here to avoid a warning.  */
       if (p2[0] == '\0')
-       return fold_convert (type, s1);
+       return fold_convert_loc (loc, type, s1);
 
       if (p2[1] != '\0')
        return NULL_TREE;
@@ -11455,7 +11534,7 @@ fold_builtin_strstr (tree s1, tree s2, tree type)
 
       /* New argument list transforming strstr(s1, s2) to
         strchr(s1, s2[0]).  */
-      return build_call_expr (fn, 2, s1, build_int_cst (NULL_TREE, p2[0]));
+      return build_call_expr_loc (loc, fn, 2, s1, build_int_cst (NULL_TREE, p2[0]));
     }
 }
 
@@ -11478,7 +11557,7 @@ fold_builtin_strstr (tree s1, tree s2, tree type)
    form of the builtin function call.  */
 
 static tree
-fold_builtin_strchr (tree s1, tree s2, tree type)
+fold_builtin_strchr (location_t loc, tree s1, tree s2, tree type)
 {
   if (!validate_arg (s1, POINTER_TYPE)
       || !validate_arg (s2, INTEGER_TYPE))
@@ -11506,9 +11585,9 @@ fold_builtin_strchr (tree s1, tree s2, tree type)
            return build_int_cst (TREE_TYPE (s1), 0);
 
          /* Return an offset into the constant string argument.  */
-         tem = fold_build2 (POINTER_PLUS_EXPR, TREE_TYPE (s1),
+         tem = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (s1),
                             s1, size_int (r - p1));
-         return fold_convert (type, tem);
+         return fold_convert_loc (loc, type, tem);
        }
       return NULL_TREE;
     }
@@ -11533,7 +11612,7 @@ fold_builtin_strchr (tree s1, tree s2, tree type)
    form of the builtin function call.  */
 
 static tree
-fold_builtin_strrchr (tree s1, tree s2, tree type)
+fold_builtin_strrchr (location_t loc, tree s1, tree s2, tree type)
 {
   if (!validate_arg (s1, POINTER_TYPE)
       || !validate_arg (s2, INTEGER_TYPE))
@@ -11562,9 +11641,9 @@ fold_builtin_strrchr (tree s1, tree s2, tree type)
            return build_int_cst (TREE_TYPE (s1), 0);
 
          /* Return an offset into the constant string argument.  */
-         tem = fold_build2 (POINTER_PLUS_EXPR, TREE_TYPE (s1),
+         tem = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (s1),
                             s1, size_int (r - p1));
-         return fold_convert (type, tem);
+         return fold_convert_loc (loc, type, tem);
        }
 
       if (! integer_zerop (s2))
@@ -11575,7 +11654,7 @@ fold_builtin_strrchr (tree s1, tree s2, tree type)
        return NULL_TREE;
 
       /* Transform strrchr(s1, '\0') to strchr(s1, '\0').  */
-      return build_call_expr (fn, 2, s1, s2);
+      return build_call_expr_loc (loc, fn, 2, s1, s2);
     }
 }
 
@@ -11598,7 +11677,7 @@ fold_builtin_strrchr (tree s1, tree s2, tree type)
    form of the builtin function call.  */
 
 static tree
-fold_builtin_strpbrk (tree s1, tree s2, tree type)
+fold_builtin_strpbrk (location_t loc, tree s1, tree s2, tree type)
 {
   if (!validate_arg (s1, POINTER_TYPE)
       || !validate_arg (s2, POINTER_TYPE))
@@ -11622,15 +11701,15 @@ fold_builtin_strpbrk (tree s1, tree s2, tree type)
            return build_int_cst (TREE_TYPE (s1), 0);
 
          /* Return an offset into the constant string argument.  */
-         tem = fold_build2 (POINTER_PLUS_EXPR, TREE_TYPE (s1),
+         tem = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (s1),
                             s1, size_int (r - p1));
-         return fold_convert (type, tem);
+         return fold_convert_loc (loc, type, tem);
        }
 
       if (p2[0] == '\0')
        /* strpbrk(x, "") == NULL.
           Evaluate and ignore s1 in case it had side-effects.  */
-       return omit_one_operand (TREE_TYPE (s1), integer_zero_node, s1);
+       return omit_one_operand_loc (loc, TREE_TYPE (s1), integer_zero_node, s1);
 
       if (p2[1] != '\0')
        return NULL_TREE;  /* Really call strpbrk.  */
@@ -11641,7 +11720,7 @@ fold_builtin_strpbrk (tree s1, tree s2, tree type)
 
       /* New argument list transforming strpbrk(s1, s2) to
         strchr(s1, s2[0]).  */
-      return build_call_expr (fn, 2, s1, build_int_cst (NULL_TREE, p2[0]));
+      return build_call_expr_loc (loc, fn, 2, s1, build_int_cst (NULL_TREE, p2[0]));
     }
 }
 
@@ -11664,7 +11743,7 @@ fold_builtin_strpbrk (tree s1, tree s2, tree type)
    form of the builtin function call.  */
 
 static tree
-fold_builtin_strcat (tree dst, tree src)
+fold_builtin_strcat (location_t loc ATTRIBUTE_UNUSED, tree dst, tree src)
 {
   if (!validate_arg (dst, POINTER_TYPE)
       || !validate_arg (src, POINTER_TYPE))
@@ -11700,7 +11779,7 @@ fold_builtin_strcat (tree dst, tree src)
    form of the builtin function call.  */
 
 static tree
-fold_builtin_strncat (tree dst, tree src, tree len)
+fold_builtin_strncat (location_t loc, tree dst, tree src, tree len)
 {
   if (!validate_arg (dst, POINTER_TYPE)
       || !validate_arg (src, POINTER_TYPE)
@@ -11713,7 +11792,7 @@ fold_builtin_strncat (tree dst, tree src, tree len)
       /* If the requested length is zero, or the src parameter string
         length is zero, return the dst parameter.  */
       if (integer_zerop (len) || (p && *p == '\0'))
-       return omit_two_operands (TREE_TYPE (dst), dst, src, len);
+       return omit_two_operands_loc (loc, TREE_TYPE (dst), dst, src, len);
 
       /* If the requested len is greater than or equal to the string
         length, call strcat.  */
@@ -11727,7 +11806,7 @@ fold_builtin_strncat (tree dst, tree src, tree len)
          if (!fn)
            return NULL_TREE;
 
-         return build_call_expr (fn, 2, dst, src);
+         return build_call_expr_loc (loc, fn, 2, dst, src);
        }
       return NULL_TREE;
     }
@@ -11752,7 +11831,7 @@ fold_builtin_strncat (tree dst, tree src, tree len)
    form of the builtin function call.  */
 
 static tree
-fold_builtin_strspn (tree s1, tree s2)
+fold_builtin_strspn (location_t loc, tree s1, tree s2)
 {
   if (!validate_arg (s1, POINTER_TYPE)
       || !validate_arg (s2, POINTER_TYPE))
@@ -11772,7 +11851,7 @@ fold_builtin_strspn (tree s1, tree s2)
       if ((p1 && *p1 == '\0') || (p2 && *p2 == '\0'))
        /* Evaluate and ignore both arguments in case either one has
           side-effects.  */
-       return omit_two_operands (size_type_node, size_zero_node,
+       return omit_two_operands_loc (loc, size_type_node, size_zero_node,
                                  s1, s2);
       return NULL_TREE;
     }
@@ -11797,7 +11876,7 @@ fold_builtin_strspn (tree s1, tree s2)
    form of the builtin function call.  */
 
 static tree
-fold_builtin_strcspn (tree s1, tree s2)
+fold_builtin_strcspn (location_t loc, tree s1, tree s2)
 {
   if (!validate_arg (s1, POINTER_TYPE)
       || !validate_arg (s2, POINTER_TYPE))
@@ -11818,7 +11897,7 @@ fold_builtin_strcspn (tree s1, tree s2)
        {
          /* Evaluate and ignore argument s2 in case it has
             side-effects.  */
-         return omit_one_operand (size_type_node,
+         return omit_one_operand_loc (loc, size_type_node,
                                   size_zero_node, s2);
        }
 
@@ -11832,7 +11911,7 @@ fold_builtin_strcspn (tree s1, tree s2)
          if (!fn)
            return NULL_TREE;
 
-         return build_call_expr (fn, 1, s1);
+         return build_call_expr_loc (loc, fn, 1, s1);
        }
       return NULL_TREE;
     }
@@ -11846,7 +11925,8 @@ fold_builtin_strcspn (tree s1, tree s2)
    was possible.  */
 
 tree
-fold_builtin_fputs (tree arg0, tree arg1, bool ignore, bool unlocked, tree len)
+fold_builtin_fputs (location_t loc, tree arg0, tree arg1,
+                   bool ignore, bool unlocked, tree len)
 {
   /* If we're using an unlocked function, assume the other unlocked
      functions exist explicitly.  */
@@ -11876,7 +11956,8 @@ fold_builtin_fputs (tree arg0, tree arg1, bool ignore, bool unlocked, tree len)
   switch (compare_tree_int (len, 1))
     {
     case -1: /* length is 0, delete the call entirely .  */
-      return omit_one_operand (integer_type_node, integer_zero_node, arg1);;
+      return omit_one_operand_loc (loc, integer_type_node,
+                              integer_zero_node, arg1);;
 
     case 0: /* length is 1, call fputc.  */
       {
@@ -11885,7 +11966,7 @@ fold_builtin_fputs (tree arg0, tree arg1, bool ignore, bool unlocked, tree len)
        if (p != NULL)
          {
            if (fn_fputc)
-             return build_call_expr (fn_fputc, 2,
+             return build_call_expr_loc (loc, fn_fputc, 2,
                                      build_int_cst (NULL_TREE, p[0]), arg1);
            else
              return NULL_TREE;
@@ -11900,7 +11981,8 @@ fold_builtin_fputs (tree arg0, tree arg1, bool ignore, bool unlocked, tree len)
        /* New argument list transforming fputs(string, stream) to
           fwrite(string, 1, len, stream).  */
        if (fn_fwrite)
-         return build_call_expr (fn_fwrite, 4, arg0, size_one_node, len, arg1);
+         return build_call_expr_loc (loc, fn_fwrite, 4, arg0,
+                                 size_one_node, len, arg1);
        else
          return NULL_TREE;
       }
@@ -12017,7 +12099,8 @@ fold_builtin_next_arg (tree exp, bool va_start_p)
    the caller does not use the returned value of the function.  */
 
 static tree
-fold_builtin_sprintf (tree dest, tree fmt, tree orig, int ignored)
+fold_builtin_sprintf (location_t loc, tree dest, tree fmt,
+                     tree orig, int ignored)
 {
   tree call, retval;
   const char *fmt_str = NULL;
@@ -12056,7 +12139,7 @@ fold_builtin_sprintf (tree dest, tree fmt, tree orig, int ignored)
 
       /* Convert sprintf (str, fmt) into strcpy (str, fmt) when
         'format' is known to contain no % formats.  */
-      call = build_call_expr (fn, 2, dest, fmt);
+      call = build_call_expr_loc (loc, fn, 2, dest, fmt);
       if (!ignored)
        retval = build_int_cst (NULL_TREE, strlen (fmt_str));
     }
@@ -12081,13 +12164,13 @@ fold_builtin_sprintf (tree dest, tree fmt, tree orig, int ignored)
          if (!retval || TREE_CODE (retval) != INTEGER_CST)
            return NULL_TREE;
        }
-      call = build_call_expr (fn, 2, dest, orig);
+      call = build_call_expr_loc (loc, fn, 2, dest, orig);
     }
 
   if (call && retval)
     {
-      retval = fold_convert
-       (TREE_TYPE (TREE_TYPE (implicit_built_in_decls[BUILT_IN_SPRINTF])),
+      retval = fold_convert_loc
+       (loc, TREE_TYPE (TREE_TYPE (implicit_built_in_decls[BUILT_IN_SPRINTF])),
         retval);
       return build2 (COMPOUND_EXPR, TREE_TYPE (retval), call, retval);
     }
@@ -12478,7 +12561,7 @@ fold_builtin_object_size (tree ptr, tree ost)
    passed as third argument.  */
 
 tree
-fold_builtin_memory_chk (tree fndecl,
+fold_builtin_memory_chk (location_t loc, tree fndecl,
                         tree dest, tree src, tree len, tree size,
                         tree maxlen, bool ignore,
                         enum built_in_function fcode)
@@ -12498,11 +12581,13 @@ fold_builtin_memory_chk (tree fndecl,
   if (fcode != BUILT_IN_MEMSET_CHK && operand_equal_p (src, dest, 0))
     {
       if (fcode != BUILT_IN_MEMPCPY_CHK)
-       return omit_one_operand (TREE_TYPE (TREE_TYPE (fndecl)), dest, len);
+       return omit_one_operand_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)),
+                                dest, len);
       else
        {
-         tree temp = fold_build2 (POINTER_PLUS_EXPR, TREE_TYPE (dest), dest, len);
-         return fold_convert (TREE_TYPE (TREE_TYPE (fndecl)), temp);
+         tree temp = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (dest),
+                                  dest, len);
+         return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), temp);
        }
     }
 
@@ -12526,7 +12611,7 @@ fold_builtin_memory_chk (tree fndecl,
                  if (!fn)
                    return NULL_TREE;
 
-                 return build_call_expr (fn, 4, dest, src, len, size);
+                 return build_call_expr_loc (loc, fn, 4, dest, src, len, size);
                }
              return NULL_TREE;
            }
@@ -12562,7 +12647,7 @@ fold_builtin_memory_chk (tree fndecl,
   if (!fn)
     return NULL_TREE;
 
-  return build_call_expr (fn, 3, dest, src, len);
+  return build_call_expr_loc (loc, fn, 3, dest, src, len);
 }
 
 /* Fold a call to the __st[rp]cpy_chk builtin.
@@ -12572,7 +12657,8 @@ fold_builtin_memory_chk (tree fndecl,
    strings passed as second argument.  */
 
 tree
-fold_builtin_stxcpy_chk (tree fndecl, tree dest, tree src, tree size,
+fold_builtin_stxcpy_chk (location_t loc, tree fndecl, tree dest,
+                        tree src, tree size,
                         tree maxlen, bool ignore,
                         enum built_in_function fcode)
 {
@@ -12585,7 +12671,7 @@ fold_builtin_stxcpy_chk (tree fndecl, tree dest, tree src, tree size,
 
   /* If SRC and DEST are the same (and not volatile), return DEST.  */
   if (fcode == BUILT_IN_STRCPY_CHK && operand_equal_p (src, dest, 0))
-    return fold_convert (TREE_TYPE (TREE_TYPE (fndecl)), dest);
+    return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), dest);
 
   if (! host_integerp (size, 1))
     return NULL_TREE;
@@ -12611,7 +12697,7 @@ fold_builtin_stxcpy_chk (tree fndecl, tree dest, tree src, tree size,
                  if (!fn)
                    return NULL_TREE;
 
-                 return build_call_expr (fn, 3, dest, src, size);
+                 return build_call_expr_loc (loc, fn, 3, dest, src, size);
                }
 
              if (! len || TREE_SIDE_EFFECTS (len))
@@ -12623,10 +12709,10 @@ fold_builtin_stxcpy_chk (tree fndecl, tree dest, tree src, tree size,
              if (!fn)
                return NULL_TREE;
 
-             len = size_binop (PLUS_EXPR, len, ssize_int (1));
-             return fold_convert (TREE_TYPE (TREE_TYPE (fndecl)),
-                                  build_call_expr (fn, 4,
-                                                   dest, src, len, size));
+             len = size_binop_loc (loc, PLUS_EXPR, len, ssize_int (1));
+             return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)),
+                                      build_call_expr_loc (loc, fn, 4,
+                                                       dest, src, len, size));
            }
        }
       else
@@ -12642,7 +12728,7 @@ fold_builtin_stxcpy_chk (tree fndecl, tree dest, tree src, tree size,
   if (!fn)
     return NULL_TREE;
 
-  return build_call_expr (fn, 2, dest, src);
+  return build_call_expr_loc (loc, fn, 2, dest, src);
 }
 
 /* Fold a call to the __strncpy_chk builtin.  DEST, SRC, LEN, and SIZE
@@ -12650,8 +12736,8 @@ fold_builtin_stxcpy_chk (tree fndecl, tree dest, tree src, tree size,
    length passed as third argument.  */
 
 tree
-fold_builtin_strncpy_chk (tree dest, tree src, tree len, tree size,
-                         tree maxlen)
+fold_builtin_strncpy_chk (location_t loc, tree dest, tree src,
+                         tree len, tree size, tree maxlen)
 {
   tree fn;
 
@@ -12686,14 +12772,15 @@ fold_builtin_strncpy_chk (tree dest, tree src, tree len, tree size,
   if (!fn)
     return NULL_TREE;
 
-  return build_call_expr (fn, 3, dest, src, len);
+  return build_call_expr_loc (loc, fn, 3, dest, src, len);
 }
 
 /* Fold a call to the __strcat_chk builtin FNDECL.  DEST, SRC, and SIZE
    are the arguments to the call.  */
 
 static tree
-fold_builtin_strcat_chk (tree fndecl, tree dest, tree src, tree size)
+fold_builtin_strcat_chk (location_t loc, tree fndecl, tree dest,
+                        tree src, tree size)
 {
   tree fn;
   const char *p;
@@ -12706,7 +12793,7 @@ fold_builtin_strcat_chk (tree fndecl, tree dest, tree src, tree size)
   p = c_getstr (src);
   /* If the SRC parameter is "", return DEST.  */
   if (p && *p == '\0')
-    return omit_one_operand (TREE_TYPE (TREE_TYPE (fndecl)), dest, src);
+    return omit_one_operand_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), dest, src);
 
   if (! host_integerp (size, 1) || ! integer_all_onesp (size))
     return NULL_TREE;
@@ -12716,14 +12803,14 @@ fold_builtin_strcat_chk (tree fndecl, tree dest, tree src, tree size)
   if (!fn)
     return NULL_TREE;
 
-  return build_call_expr (fn, 2, dest, src);
+  return build_call_expr_loc (loc, fn, 2, dest, src);
 }
 
 /* Fold a call to the __strncat_chk builtin with arguments DEST, SRC,
    LEN, and SIZE.  */
 
 static tree
-fold_builtin_strncat_chk (tree fndecl,
+fold_builtin_strncat_chk (location_t loc, tree fndecl,
                          tree dest, tree src, tree len, tree size)
 {
   tree fn;
@@ -12738,9 +12825,9 @@ fold_builtin_strncat_chk (tree fndecl,
   p = c_getstr (src);
   /* If the SRC parameter is "" or if LEN is 0, return DEST.  */
   if (p && *p == '\0')
-    return omit_one_operand (TREE_TYPE (TREE_TYPE (fndecl)), dest, len);
+    return omit_one_operand_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), dest, len);
   else if (integer_zerop (len))
-    return omit_one_operand (TREE_TYPE (TREE_TYPE (fndecl)), dest, src);
+    return omit_one_operand_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), dest, src);
 
   if (! host_integerp (size, 1))
     return NULL_TREE;
@@ -12758,7 +12845,7 @@ fold_builtin_strncat_chk (tree fndecl,
          if (!fn)
            return NULL_TREE;
 
-         return build_call_expr (fn, 3, dest, src, size);
+         return build_call_expr_loc (loc, fn, 3, dest, src, size);
        }
       return NULL_TREE;
     }
@@ -12768,7 +12855,7 @@ fold_builtin_strncat_chk (tree fndecl,
   if (!fn)
     return NULL_TREE;
 
-  return build_call_expr (fn, 3, dest, src, len);
+  return build_call_expr_loc (loc, fn, 3, dest, src, len);
 }
 
 /* Fold a call EXP to __{,v}sprintf_chk.  Return NULL_TREE if
@@ -12776,7 +12863,8 @@ fold_builtin_strncat_chk (tree fndecl,
    inline.  FCODE is either BUILT_IN_SPRINTF_CHK or BUILT_IN_VSPRINTF_CHK.  */
 
 static tree
-fold_builtin_sprintf_chk (tree exp, enum built_in_function fcode)
+fold_builtin_sprintf_chk (location_t loc, tree exp,
+                         enum built_in_function fcode)
 {
   tree dest, size, len, fn, fmt, flag;
   const char *fmt_str;
@@ -12859,7 +12947,7 @@ fold_builtin_sprintf_chk (tree exp, enum built_in_function fcode)
   if (!fn)
     return NULL_TREE;
 
-  return rewrite_call_expr (exp, 4, fn, 2, dest, fmt);
+  return rewrite_call_expr (loc, exp, 4, fn, 2, dest, fmt);
 }
 
 /* Fold a call EXP to {,v}snprintf.  Return NULL_TREE if
@@ -12869,7 +12957,7 @@ fold_builtin_sprintf_chk (tree exp, enum built_in_function fcode)
    passed as second argument.  */
 
 tree
-fold_builtin_snprintf_chk (tree exp, tree maxlen,
+fold_builtin_snprintf_chk (location_t loc, tree exp, tree maxlen,
                           enum built_in_function fcode)
 {
   tree dest, size, len, fn, fmt, flag;
@@ -12936,7 +13024,7 @@ fold_builtin_snprintf_chk (tree exp, tree maxlen,
   if (!fn)
     return NULL_TREE;
 
-  return rewrite_call_expr (exp, 5, fn, 3, dest, len, fmt);
+  return rewrite_call_expr (loc, exp, 5, fn, 3, dest, len, fmt);
 }
 
 /* Fold a call to the {,v}printf{,_unlocked} and __{,v}printf_chk builtins.
@@ -12948,7 +13036,8 @@ fold_builtin_snprintf_chk (tree exp, tree maxlen,
    code of the function to be simplified.  */
 
 static tree
-fold_builtin_printf (tree fndecl, tree fmt, tree arg, bool ignore,
+fold_builtin_printf (location_t loc, tree fndecl, tree fmt,
+                    tree arg, bool ignore,
                     enum built_in_function fcode)
 {
   tree fn_putchar, fn_puts, newarg, call = NULL_TREE;
@@ -13021,7 +13110,7 @@ fold_builtin_printf (tree fndecl, tree fmt, tree arg, bool ignore,
             function.  */
          newarg = build_int_cst (NULL_TREE, str[0]);
          if (fn_putchar)
-           call = build_call_expr (fn_putchar, 1, newarg);
+           call = build_call_expr_loc (loc, fn_putchar, 1, newarg);
        }
       else
        {
@@ -13037,7 +13126,7 @@ fold_builtin_printf (tree fndecl, tree fmt, tree arg, bool ignore,
 
              newarg = build_string_literal (len, newstr);
              if (fn_puts)
-               call = build_call_expr (fn_puts, 1, newarg);
+               call = build_call_expr_loc (loc, fn_puts, 1, newarg);
            }
          else
            /* We'd like to arrange to call fputs(string,stdout) here,
@@ -13056,7 +13145,7 @@ fold_builtin_printf (tree fndecl, tree fmt, tree arg, bool ignore,
       if (!arg || !validate_arg (arg, POINTER_TYPE))
        return NULL_TREE;
       if (fn_puts)
-       call = build_call_expr (fn_puts, 1, arg);
+       call = build_call_expr_loc (loc, fn_puts, 1, arg);
     }
 
   /* If the format specifier was "%c", call __builtin_putchar(arg).  */
@@ -13065,13 +13154,13 @@ fold_builtin_printf (tree fndecl, tree fmt, tree arg, bool ignore,
       if (!arg || !validate_arg (arg, INTEGER_TYPE))
        return NULL_TREE;
       if (fn_putchar)
-       call = build_call_expr (fn_putchar, 1, arg);
+       call = build_call_expr_loc (loc, fn_putchar, 1, arg);
     }
 
   if (!call)
     return NULL_TREE;
 
-  return fold_convert (TREE_TYPE (TREE_TYPE (fndecl)), call);
+  return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), call);
 }
 
 /* Fold a call to the {,v}fprintf{,_unlocked} and __{,v}printf_chk builtins.
@@ -13083,7 +13172,8 @@ fold_builtin_printf (tree fndecl, tree fmt, tree arg, bool ignore,
    code of the function to be simplified.  */
 
 static tree
-fold_builtin_fprintf (tree fndecl, tree fp, tree fmt, tree arg, bool ignore,
+fold_builtin_fprintf (location_t loc, tree fndecl, tree fp,
+                     tree fmt, tree arg, bool ignore,
                      enum built_in_function fcode)
 {
   tree fn_fputc, fn_fputs, call = NULL_TREE;
@@ -13142,7 +13232,7 @@ fold_builtin_fprintf (tree fndecl, tree fp, tree fmt, tree arg, bool ignore,
         fprintf (fp, string) with fputs (string, fp).  The fputs
         builtin will take care of special cases like length == 1.  */
       if (fn_fputs)
-       call = build_call_expr (fn_fputs, 2, fmt, fp);
+       call = build_call_expr_loc (loc, fn_fputs, 2, fmt, fp);
     }
 
   /* The other optimizations can be done only on the non-va_list variants.  */
@@ -13155,7 +13245,7 @@ fold_builtin_fprintf (tree fndecl, tree fp, tree fmt, tree arg, bool ignore,
       if (!arg || !validate_arg (arg, POINTER_TYPE))
        return NULL_TREE;
       if (fn_fputs)
-       call = build_call_expr (fn_fputs, 2, arg, fp);
+       call = build_call_expr_loc (loc, fn_fputs, 2, arg, fp);
     }
 
   /* If the format specifier was "%c", call __builtin_fputc (arg, fp).  */
@@ -13164,12 +13254,12 @@ fold_builtin_fprintf (tree fndecl, tree fp, tree fmt, tree arg, bool ignore,
       if (!arg || !validate_arg (arg, INTEGER_TYPE))
        return NULL_TREE;
       if (fn_fputc)
-       call = build_call_expr (fn_fputc, 2, arg, fp);
+       call = build_call_expr_loc (loc, fn_fputc, 2, arg, fp);
     }
 
   if (!call)
     return NULL_TREE;
-  return fold_convert (TREE_TYPE (TREE_TYPE (fndecl)), call);
+  return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), call);
 }
 
 /* Initialize format string characters in the target charset.  */
@@ -13812,6 +13902,7 @@ gimple_rewrite_call_expr (gimple stmt, int skip, tree fndecl, int n, ...)
   tree *buffer;
   int i, j;
   va_list ap;
+  location_t loc = gimple_location (stmt);
 
   buffer = XALLOCAVEC (tree, nargs);
   va_start (ap, n);
@@ -13821,7 +13912,7 @@ gimple_rewrite_call_expr (gimple stmt, int skip, tree fndecl, int n, ...)
   for (j = skip; j < oldnargs; j++, i++)
     buffer[i] = gimple_call_arg (stmt, j);
 
-  return fold (build_call_array (TREE_TYPE (fntype), fn, nargs, buffer));
+  return fold (build_call_array_loc (loc, TREE_TYPE (fntype), fn, nargs, buffer));
 }
 
 /* Fold a call STMT to __{,v}sprintf_chk.  Return NULL_TREE if
@@ -14000,7 +14091,8 @@ gimple_fold_builtin_snprintf_chk (gimple stmt, tree maxlen,
    result of the function call is ignored.  */
 
 static tree
-gimple_fold_builtin_varargs (tree fndecl, gimple stmt, bool ignore ATTRIBUTE_UNUSED)
+gimple_fold_builtin_varargs (tree fndecl, gimple stmt,
+                            bool ignore ATTRIBUTE_UNUSED)
 {
   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
   tree ret = NULL_TREE;
@@ -14037,6 +14129,7 @@ fold_call_stmt (gimple stmt, bool ignore)
 {
   tree ret = NULL_TREE;
   tree fndecl = gimple_call_fndecl (stmt);
+  location_t loc = gimple_location (stmt);
   if (fndecl
       && TREE_CODE (fndecl) == FUNCTION_DECL
       && DECL_BUILT_IN (fndecl)
@@ -14063,7 +14156,7 @@ fold_call_stmt (gimple stmt, bool ignore)
               int i;
               for (i = 0; i < nargs; i++)
                 args[i] = gimple_call_arg (stmt, i);
-             ret = fold_builtin_n (fndecl, args, nargs, ignore);
+             ret = fold_builtin_n (loc, fndecl, args, nargs, ignore);
            }
          if (!ret)
            ret = gimple_fold_builtin_varargs (fndecl, stmt, ignore);
@@ -14080,7 +14173,7 @@ fold_call_stmt (gimple stmt, bool ignore)
                    realret = TREE_OPERAND (ret, 0);
                  if (CAN_HAVE_LOCATION_P (realret)
                      && !EXPR_HAS_LOCATION (realret))
-                   SET_EXPR_LOCATION (realret, gimple_location (stmt));
+                   SET_EXPR_LOCATION (realret, loc);
                   return realret;
                 }
              return ret;
index 069452c..3aa8ed9 100644 (file)
@@ -1086,6 +1086,7 @@ c_fully_fold (tree expr, bool in_init, bool *maybe_const)
   tree eptype = NULL_TREE;
   bool dummy = true;
   bool maybe_const_itself = true;
+  location_t loc = EXPR_LOCATION (expr);
 
   /* This function is not relevant to C++ because C++ folds while
      parsing, and may need changes to be correct for C++ when C++
@@ -1103,7 +1104,7 @@ c_fully_fold (tree expr, bool in_init, bool *maybe_const)
   ret = c_fully_fold_internal (expr, in_init, maybe_const,
                               &maybe_const_itself);
   if (eptype)
-    ret = fold_convert (eptype, ret);
+    ret = fold_convert_loc (loc, eptype, ret);
   *maybe_const &= maybe_const_itself;
   return ret;
 }
@@ -1300,8 +1301,8 @@ c_fully_fold_internal (tree expr, bool in_init, bool *maybe_const_operands,
       op1 = decl_constant_value_for_optimization (op1);
       if (op0 != orig_op0 || op1 != orig_op1 || in_init)
        ret = in_init
-         ? fold_build2_initializer (code, TREE_TYPE (expr), op0, op1)
-         : fold_build2 (code, TREE_TYPE (expr), op0, op1);
+         ? fold_build2_initializer_loc (loc, code, TREE_TYPE (expr), op0, op1)
+         : fold_build2_loc (loc, code, TREE_TYPE (expr), op0, op1);
       else
        ret = fold (expr);
       goto out;
@@ -1326,8 +1327,8 @@ c_fully_fold_internal (tree expr, bool in_init, bool *maybe_const_operands,
        op0 = decl_constant_value_for_optimization (op0);
       if (op0 != orig_op0 || in_init)
        ret = in_init
-         ? fold_build1_initializer (code, TREE_TYPE (expr), op0)
-         : fold_build1 (code, TREE_TYPE (expr), op0);
+         ? fold_build1_initializer_loc (loc, code, TREE_TYPE (expr), op0)
+         : fold_build1_loc (loc, code, TREE_TYPE (expr), op0);
       else
        ret = fold (expr);
       if (code == INDIRECT_REF
@@ -1350,8 +1351,8 @@ c_fully_fold_internal (tree expr, bool in_init, bool *maybe_const_operands,
       op1 = c_fully_fold_internal (op1, in_init, &op1_const, &op1_const_self);
       if (op0 != orig_op0 || op1 != orig_op1 || in_init)
        ret = in_init
-         ? fold_build2_initializer (code, TREE_TYPE (expr), op0, op1)
-         : fold_build2 (code, TREE_TYPE (expr), op0, op1);
+         ? fold_build2_initializer_loc (loc, code, TREE_TYPE (expr), op0, op1)
+         : fold_build2_loc (loc, code, TREE_TYPE (expr), op0, op1);
       else
        ret = fold (expr);
       *maybe_const_operands &= op0_const;
@@ -1379,7 +1380,7 @@ c_fully_fold_internal (tree expr, bool in_init, bool *maybe_const_operands,
       op1 = c_fully_fold_internal (op1, in_init, &op1_const, &op1_const_self);
       op2 = c_fully_fold_internal (op2, in_init, &op2_const, &op2_const_self);
       if (op0 != orig_op0 || op1 != orig_op1 || op2 != orig_op2)
-       ret = fold_build3 (code, TREE_TYPE (expr), op0, op1, op2);
+       ret = fold_build3_loc (loc, code, TREE_TYPE (expr), op0, op1, op2);
       else
        ret = fold (expr);
       *maybe_const_operands &= op0_const;
@@ -1620,7 +1621,8 @@ warn_logical_operator (location_t location, enum tree_code code, tree type,
   if (lhs && rhs && 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, lhs, in_p, low, high)))
+      && 0 != (tem = build_range_check (UNKNOWN_LOCATION,
+                                       type, lhs, in_p, low, high)))
     {
       if (TREE_CODE (tem) != INTEGER_CST)
        return;
@@ -3658,7 +3660,8 @@ shorten_compare (tree *op0_ptr, tree *op1_ptr, tree *restype_ptr,
    of pointer PTROP and integer INTOP.  */
 
 tree
-pointer_int_sum (enum tree_code resultcode, tree ptrop, tree intop)
+pointer_int_sum (location_t loc, enum tree_code resultcode,
+                tree ptrop, tree intop)
 {
   tree size_exp, ret;
 
@@ -3667,19 +3670,19 @@ pointer_int_sum (enum tree_code resultcode, tree ptrop, tree intop)
 
   if (TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE)
     {
-      pedwarn (input_location, pedantic ? OPT_pedantic : OPT_Wpointer_arith, 
+      pedwarn (loc, pedantic ? OPT_pedantic : OPT_Wpointer_arith, 
               "pointer of type %<void *%> used in arithmetic");
       size_exp = integer_one_node;
     }
   else if (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE)
     {
-      pedwarn (input_location, pedantic ? OPT_pedantic : OPT_Wpointer_arith, 
+      pedwarn (loc, pedantic ? OPT_pedantic : OPT_Wpointer_arith, 
               "pointer to a function used in arithmetic");
       size_exp = integer_one_node;
     }
   else if (TREE_CODE (TREE_TYPE (result_type)) == METHOD_TYPE)
     {
-      pedwarn (input_location, pedantic ? OPT_pedantic : OPT_Wpointer_arith, 
+      pedwarn (loc, pedantic ? OPT_pedantic : OPT_Wpointer_arith, 
               "pointer to member function used in arithmetic");
       size_exp = integer_one_node;
     }
@@ -3734,15 +3737,15 @@ pointer_int_sum (enum tree_code resultcode, tree ptrop, tree intop)
      Do this multiplication as signed, then convert to the appropriate
      type for the pointer operation.  */
   intop = convert (sizetype,
-                  build_binary_op (EXPR_LOCATION (intop),
+                  build_binary_op (loc,
                                    MULT_EXPR, intop,
                                    convert (TREE_TYPE (intop), size_exp), 1));
 
   /* Create the sum or difference.  */
   if (resultcode == MINUS_EXPR)
-    intop = fold_build1 (NEGATE_EXPR, sizetype, intop);
+    intop = fold_build1_loc (loc, NEGATE_EXPR, sizetype, intop);
 
-  ret = fold_build2 (POINTER_PLUS_EXPR, result_type, ptrop, intop);
+  ret = fold_build2_loc (loc, POINTER_PLUS_EXPR, result_type, ptrop, intop);
 
   fold_undefer_and_ignore_overflow_warnings ();
 
@@ -3925,7 +3928,7 @@ c_common_truthvalue_conversion (location_t location, tree expr)
       /* Distribute the conversion into the arms of a COND_EXPR.  */
       if (c_dialect_cxx ())
        {
-         expr = fold_build3 (COND_EXPR, truthvalue_type_node,
+         expr = fold_build3_loc (location, COND_EXPR, truthvalue_type_node,
                              TREE_OPERAND (expr, 0),
                              c_common_truthvalue_conversion (location,
                                                              TREE_OPERAND (expr,
@@ -4290,9 +4293,9 @@ c_sizeof_or_alignof_type (location_t loc,
     {
       if (is_sizeof)
        /* Convert in case a char is more than one unit.  */
-       value = size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
-                           size_int (TYPE_PRECISION (char_type_node)
-                                     / BITS_PER_UNIT));
+       value = size_binop_loc (loc, CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
+                               size_int (TYPE_PRECISION (char_type_node)
+                                         / BITS_PER_UNIT));
       else
        value = size_int (TYPE_ALIGN_UNIT (type));
     }
@@ -4301,7 +4304,7 @@ c_sizeof_or_alignof_type (location_t loc,
      TYPE_IS_SIZETYPE means that certain things (like overflow) will
      never happen.  However, this node should really have type
      `size_t', which is just a typedef for an ordinary integer type.  */
-  value = fold_convert (size_type_node, value);
+  value = fold_convert_loc (loc, size_type_node, value);
   gcc_assert (!TYPE_IS_SIZETYPE (TREE_TYPE (value)));
 
   return value;
@@ -4352,7 +4355,7 @@ c_alignof_expr (location_t loc, tree expr)
   else
     return c_alignof (loc, TREE_TYPE (expr));
 
-  return fold_convert (size_type_node, t);
+  return fold_convert_loc (loc, size_type_node, t);
 }
 \f
 /* Handle C and C++ default attributes.  */
@@ -5628,11 +5631,11 @@ boolean_increment (enum tree_code code, tree arg)
       break;
     case PREDECREMENT_EXPR:
       val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg,
-                   invert_truthvalue (arg));
+                   invert_truthvalue_loc (input_location, arg));
       break;
     case POSTDECREMENT_EXPR:
       val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg,
-                   invert_truthvalue (arg));
+                   invert_truthvalue_loc (input_location, arg));
       arg = save_expr (arg);
       val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
       val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
@@ -8357,9 +8360,10 @@ fold_offsetof_1 (tree expr, tree stop_ref)
                 "member %qD", t);
          return error_mark_node;
        }
-      off = size_binop (PLUS_EXPR, DECL_FIELD_OFFSET (t),
-                       size_int (tree_low_cst (DECL_FIELD_BIT_OFFSET (t), 1)
-                                 / BITS_PER_UNIT));
+      off = size_binop_loc (input_location, PLUS_EXPR, DECL_FIELD_OFFSET (t),
+                           size_int (tree_low_cst (DECL_FIELD_BIT_OFFSET (t),
+                                                   1)
+                                     / BITS_PER_UNIT));
       break;
 
     case ARRAY_REF:
@@ -8371,7 +8375,7 @@ fold_offsetof_1 (tree expr, tree stop_ref)
       if (TREE_CODE (t) == INTEGER_CST && tree_int_cst_sgn (t) < 0)
        {
          code = MINUS_EXPR;
-         t = fold_build1 (NEGATE_EXPR, TREE_TYPE (t), t);
+         t = fold_build1_loc (input_location, NEGATE_EXPR, TREE_TYPE (t), t);
        }
       t = convert (sizetype, t);
       off = size_binop (MULT_EXPR, TYPE_SIZE_UNIT (TREE_TYPE (expr)), t);
@@ -8464,9 +8468,9 @@ complete_array_type (tree *ptype, tree initial_value, bool do_default)
              bool fold_p = false;
 
              if (VEC_index (constructor_elt, v, 0)->index)
-               maxindex = fold_convert (sizetype,
-                                        VEC_index (constructor_elt,
-                                                   v, 0)->index);
+               maxindex = fold_convert_loc (input_location, sizetype,
+                                            VEC_index (constructor_elt,
+                                                       v, 0)->index);
              curindex = maxindex;
 
              for (cnt = 1;
@@ -8480,7 +8484,8 @@ complete_array_type (tree *ptype, tree initial_value, bool do_default)
                    {
                      if (fold_p)
                        curindex = fold_convert (sizetype, curindex);
-                     curindex = size_binop (PLUS_EXPR, curindex, size_one_node);
+                     curindex = size_binop (PLUS_EXPR, curindex,
+                                            size_one_node);
                    }
                  if (tree_int_cst_lt (maxindex, curindex))
                    maxindex = curindex, fold_p = curfold_p;
index ec5705e..21d3648 100644 (file)
@@ -830,7 +830,7 @@ extern tree shorten_binary_op (tree result_type, tree op0, tree op1, bool bitwis
    and, if so, perhaps change them both back to their original type.  */
 extern tree shorten_compare (tree *, tree *, tree *, enum tree_code *);
 
-extern tree pointer_int_sum (enum tree_code, tree, tree);
+extern tree pointer_int_sum (location_t, enum tree_code, tree, tree);
 
 /* Add qualifiers to a type, in the fashion for C.  */
 extern tree c_build_qualified_type (tree, int);
index 5349d7a..09638d5 100644 (file)
@@ -71,6 +71,7 @@ convert (tree type, tree expr)
   enum tree_code code = TREE_CODE (type);
   const char *invalid_conv_diag;
   tree ret;
+  location_t loc = EXPR_LOCATION (expr);
 
   if (type == error_mark_node
       || expr == error_mark_node
@@ -93,7 +94,7 @@ convert (tree type, tree expr)
   STRIP_TYPE_NOPS (e);
 
   if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (TREE_TYPE (expr)))
-    return fold_convert (type, expr);
+    return fold_convert_loc (loc, type, expr);
   if (TREE_CODE (TREE_TYPE (expr)) == ERROR_MARK)
     return error_mark_node;
   if (TREE_CODE (TREE_TYPE (expr)) == VOID_TYPE)
@@ -105,7 +106,7 @@ convert (tree type, tree expr)
   switch (code)
     {
     case VOID_TYPE:
-      return fold_convert (type, e);
+      return fold_convert_loc (loc, type, e);
 
     case INTEGER_TYPE:
     case ENUMERAL_TYPE:
@@ -113,8 +114,8 @@ convert (tree type, tree expr)
       goto maybe_fold;
 
     case BOOLEAN_TYPE:
-      return fold_convert 
-       (type, c_objc_common_truthvalue_conversion (input_location, expr));
+      return fold_convert_loc
+       (loc, type, c_objc_common_truthvalue_conversion (input_location, expr));
 
     case POINTER_TYPE:
     case REFERENCE_TYPE:
index fa578cb..7ed646c 100644 (file)
@@ -5224,10 +5224,10 @@ grokdeclarator (const struct c_declarator *declarator,
                       - 1.  Do the calculation in index_type, so that
                       if it is a variable the computations will be
                       done in the proper mode.  */
-                   itype = fold_build2 (MINUS_EXPR, index_type,
-                                        convert (index_type, size),
-                                        convert (index_type,
-                                                 size_one_node));
+                   itype = fold_build2_loc (loc, MINUS_EXPR, index_type,
+                                            convert (index_type, size),
+                                            convert (index_type,
+                                                     size_one_node));
 
                    /* If that overflowed, the array is too big.  ???
                       While a size of INT_MAX+1 technically shouldn't
index 5ec9f94..b949501 100644 (file)
@@ -81,8 +81,7 @@ c_finish_omp_barrier (location_t loc)
   tree x;
 
   x = built_in_decls[BUILT_IN_GOMP_BARRIER];
-  x = build_call_expr (x, 0);
-  SET_EXPR_LOCATION (x, loc);
+  x = build_call_expr_loc (loc, x, 0);
   add_stmt (x);
 }
 
@@ -96,8 +95,7 @@ c_finish_omp_taskwait (location_t loc)
   tree x;
 
   x = built_in_decls[BUILT_IN_GOMP_TASKWAIT];
-  x = build_call_expr (x, 0);
-  SET_EXPR_LOCATION (x, loc);
+  x = build_call_expr_loc (loc, x, 0);
   add_stmt (x);
 }
 
@@ -175,8 +173,7 @@ c_finish_omp_flush (location_t loc)
   tree x;
 
   x = built_in_decls[BUILT_IN_SYNCHRONIZE];
-  x = build_call_expr (x, 0);
-  SET_EXPR_LOCATION (x, loc);
+  x = build_call_expr_loc (loc, x, 0);
   add_stmt (x);
 }
 
@@ -185,7 +182,7 @@ c_finish_omp_flush (location_t loc)
    Helper function for c_finish_omp_for.  */
 
 static tree
-check_omp_for_incr_expr (tree exp, tree decl)
+check_omp_for_incr_expr (location_t loc, tree exp, tree decl)
 {
   tree t;
 
@@ -199,22 +196,25 @@ check_omp_for_incr_expr (tree exp, tree decl)
   switch (TREE_CODE (exp))
     {
     CASE_CONVERT:
-      t = check_omp_for_incr_expr (TREE_OPERAND (exp, 0), decl);
+      t = check_omp_for_incr_expr (loc, TREE_OPERAND (exp, 0), decl);
       if (t != error_mark_node)
-        return fold_convert (TREE_TYPE (exp), t);
+        return fold_convert_loc (loc, TREE_TYPE (exp), t);
       break;
     case MINUS_EXPR:
-      t = check_omp_for_incr_expr (TREE_OPERAND (exp, 0), decl);
+      t = check_omp_for_incr_expr (loc, TREE_OPERAND (exp, 0), decl);
       if (t != error_mark_node)
-        return fold_build2 (MINUS_EXPR, TREE_TYPE (exp), t, TREE_OPERAND (exp, 1));
+        return fold_build2_loc (loc, MINUS_EXPR,
+                           TREE_TYPE (exp), t, TREE_OPERAND (exp, 1));
       break;
     case PLUS_EXPR:
-      t = check_omp_for_incr_expr (TREE_OPERAND (exp, 0), decl);
+      t = check_omp_for_incr_expr (loc, TREE_OPERAND (exp, 0), decl);
       if (t != error_mark_node)
-        return fold_build2 (PLUS_EXPR, TREE_TYPE (exp), t, TREE_OPERAND (exp, 1));
-      t = check_omp_for_incr_expr (TREE_OPERAND (exp, 1), decl);
+        return fold_build2_loc (loc, PLUS_EXPR,
+                           TREE_TYPE (exp), t, TREE_OPERAND (exp, 1));
+      t = check_omp_for_incr_expr (loc, TREE_OPERAND (exp, 1), decl);
       if (t != error_mark_node)
-        return fold_build2 (PLUS_EXPR, TREE_TYPE (exp), TREE_OPERAND (exp, 0), t);
+        return fold_build2_loc (loc, PLUS_EXPR,
+                           TREE_TYPE (exp), TREE_OPERAND (exp, 0), t);
       break;
     default:
       break;
@@ -322,7 +322,7 @@ c_finish_omp_for (location_t locus, tree declv, tree initv, tree condv,
                {
                  TREE_OPERAND (cond, 0) = TREE_OPERAND (op0, 0);
                  TREE_OPERAND (cond, 1)
-                   = fold_build1 (NOP_EXPR, TREE_TYPE (decl),
+                   = fold_build1_loc (elocus, NOP_EXPR, TREE_TYPE (decl),
                                   TREE_OPERAND (cond, 1));
                }
              else if (TREE_CODE (op1) == NOP_EXPR
@@ -330,7 +330,7 @@ c_finish_omp_for (location_t locus, tree declv, tree initv, tree condv,
                {
                  TREE_OPERAND (cond, 1) = TREE_OPERAND (op1, 0);
                  TREE_OPERAND (cond, 0)
-                   = fold_build1 (NOP_EXPR, TREE_TYPE (decl),
+                   = fold_build1_loc (elocus, NOP_EXPR, TREE_TYPE (decl),
                                   TREE_OPERAND (cond, 0));
                }
 
@@ -396,11 +396,12 @@ c_finish_omp_for (location_t locus, tree declv, tree initv, tree condv,
              if (POINTER_TYPE_P (TREE_TYPE (decl))
                  && TREE_OPERAND (incr, 1))
                {
-                 tree t = fold_convert (sizetype, TREE_OPERAND (incr, 1));
+                 tree t = fold_convert_loc (elocus,
+                                            sizetype, TREE_OPERAND (incr, 1));
 
                  if (TREE_CODE (incr) == POSTDECREMENT_EXPR
                      || TREE_CODE (incr) == PREDECREMENT_EXPR)
-                   t = fold_build1 (NEGATE_EXPR, sizetype, t);
+                   t = fold_build1_loc (elocus, NEGATE_EXPR, sizetype, t);
                  t = build2 (POINTER_PLUS_EXPR, TREE_TYPE (decl), decl, t);
                  incr = build2 (MODIFY_EXPR, void_type_node, decl, t);
                }
@@ -422,7 +423,8 @@ c_finish_omp_for (location_t locus, tree declv, tree initv, tree condv,
                incr_ok = true;
              else
                {
-                 tree t = check_omp_for_incr_expr (TREE_OPERAND (incr, 1),
+                 tree t = check_omp_for_incr_expr (elocus,
+                                                   TREE_OPERAND (incr, 1),
                                                    decl);
                  if (t != error_mark_node)
                    {
index 4d6e2d3..43b0c8c 100644 (file)
@@ -7338,7 +7338,7 @@ c_parser_omp_clause_num_threads (c_parser *parser, tree list)
        }
 
       /* Attempt to statically determine when the number isn't positive.  */
-      c = fold_build2 (LE_EXPR, boolean_type_node, t,
+      c = fold_build2_loc (expr_loc, LE_EXPR, boolean_type_node, t,
                       build_int_cst (TREE_TYPE (t), 0));
       if (CAN_HAVE_LOCATION_P (c))
        SET_EXPR_LOCATION (c, expr_loc);
index f7df74e..42bebe3 100644 (file)
@@ -86,7 +86,7 @@ static int type_lists_compatible_p (const_tree, const_tree, bool *);
 static tree lookup_field (tree, tree);
 static int convert_arguments (tree, VEC(tree,gc) *, VEC(tree,gc) *, tree,
                              tree);
-static tree pointer_diff (tree, tree);
+static tree pointer_diff (location_t, tree, tree);
 static tree convert_for_assignment (location_t, tree, tree, tree,
                                    enum impl_conv, bool, tree, tree, int);
 static tree valid_compound_expr_initializer (tree, tree);
@@ -1625,9 +1625,9 @@ c_size_in_bytes (const_tree type)
     }
 
   /* Convert in case a char is more than one unit.  */
-  return size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
-                    size_int (TYPE_PRECISION (char_type_node)
-                              / BITS_PER_UNIT));
+  return size_binop_loc (input_location, CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
+                        size_int (TYPE_PRECISION (char_type_node)
+                                  / BITS_PER_UNIT));
 }
 \f
 /* Return either DECL or its known constant value (if it has one).  */
@@ -2586,7 +2586,7 @@ build_function_call_vec (location_t loc, tree function, VEC(tree,gc) *params,
       if (VOID_TYPE_P (return_type))
        {
          if (TYPE_QUALS (return_type) != TYPE_UNQUALIFIED)
-           pedwarn (input_location, 0,
+           pedwarn (loc, 0,
                     "function with qualified void return type called");
          return trap;
        }
@@ -2599,7 +2599,7 @@ build_function_call_vec (location_t loc, tree function, VEC(tree,gc) *params,
                                          build_constructor (return_type, 0),
                                          false);
          else
-           rhs = fold_convert (return_type, integer_zero_node);
+           rhs = fold_convert_loc (loc, return_type, integer_zero_node);
 
          return require_complete_type (build2 (COMPOUND_EXPR, return_type,
                                                trap, rhs));
@@ -2623,23 +2623,24 @@ build_function_call_vec (location_t loc, tree function, VEC(tree,gc) *params,
       && !strncmp (IDENTIFIER_POINTER (name), "__builtin_", 10))
     {
       if (require_constant_value)
-       result = fold_build_call_array_initializer (TREE_TYPE (fntype),
-                                                   function, nargs, argarray);
+       result = 
+         fold_build_call_array_initializer_loc (loc, TREE_TYPE (fntype),
+                                                function, nargs, argarray);
       else
-       result = fold_build_call_array (TREE_TYPE (fntype),
-                                       function, nargs, argarray);
+       result = fold_build_call_array_loc (loc, TREE_TYPE (fntype),
+                                           function, nargs, argarray);
       if (TREE_CODE (result) == NOP_EXPR
          && TREE_CODE (TREE_OPERAND (result, 0)) == INTEGER_CST)
        STRIP_TYPE_NOPS (result);
     }
   else
-    result = build_call_array (TREE_TYPE (fntype),
-                              function, nargs, argarray);
+    result = build_call_array_loc (loc, TREE_TYPE (fntype),
+                                  function, nargs, argarray);
 
   if (VOID_TYPE_P (TREE_TYPE (result)))
     {
       if (TYPE_QUALS (TREE_TYPE (result)) != TYPE_UNQUALIFIED)
-       pedwarn (input_location, 0,
+       pedwarn (loc, 0,
                 "function with qualified void return type called");
       return result;
     }
@@ -3058,7 +3059,7 @@ parser_build_binary_op (location_t location, enum tree_code code,
    The resulting tree has type int.  */
 
 static tree
-pointer_diff (tree op0, tree op1)
+pointer_diff (location_t loc, tree op0, tree op1)
 {
   tree restype = ptrdiff_type_node;
 
@@ -3067,10 +3068,10 @@ pointer_diff (tree op0, tree op1)
   tree orig_op1 = op1;
 
   if (TREE_CODE (target_type) == VOID_TYPE)
-    pedwarn (input_location, pedantic ? OPT_pedantic : OPT_Wpointer_arith, 
+    pedwarn (loc, pedantic ? OPT_pedantic : OPT_Wpointer_arith, 
             "pointer of type %<void *%> used in subtraction");
   if (TREE_CODE (target_type) == FUNCTION_TYPE)
-    pedwarn (input_location, pedantic ? OPT_pedantic : OPT_Wpointer_arith, 
+    pedwarn (loc, pedantic ? OPT_pedantic : OPT_Wpointer_arith, 
             "pointer to a function used in subtraction");
 
   /* If the conversion to ptrdiff_type does anything like widening or
@@ -3122,18 +3123,19 @@ pointer_diff (tree op0, tree op1)
      Do not do default conversions on the minus operator
      in case restype is a short type.  */
 
-  op0 = build_binary_op (input_location,
+  op0 = build_binary_op (loc,
                         MINUS_EXPR, convert (restype, op0),
                         convert (restype, op1), 0);
   /* This generates an error if op1 is pointer to incomplete type.  */
   if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (TREE_TYPE (orig_op1))))
-    error ("arithmetic on pointer to an incomplete type");
+    error_at (loc, "arithmetic on pointer to an incomplete type");
 
   /* This generates an error if op0 is pointer to incomplete type.  */
   op1 = c_size_in_bytes (target_type);
 
   /* Divide by the size, in easiest possible way.  */
-  return fold_build2 (EXACT_DIV_EXPR, restype, op0, convert (restype, op1));
+  return fold_build2_loc (loc, EXACT_DIV_EXPR, restype,
+                         op0, convert (restype, op1));
 }
 \f
 /* Construct and perhaps optimize a tree representation
@@ -3203,7 +3205,7 @@ build_unary_op (location_t location,
        }
       else if (!noconvert)
        arg = default_conversion (arg);
-      arg = non_lvalue (arg);
+      arg = non_lvalue_loc (location, arg);
       break;
 
     case NEGATE_EXPR:
@@ -3274,7 +3276,7 @@ build_unary_op (location_t location,
          return error_mark_node;
        }
       arg = c_objc_common_truthvalue_conversion (location, arg);
-      ret = invert_truthvalue (arg);
+      ret = invert_truthvalue_loc (location, arg);
       /* If the TRUTH_NOT_EXPR has been folded, reset the location.  */
       if (EXPR_P (ret) && EXPR_HAS_LOCATION (ret))
        location = EXPR_LOCATION (ret);
@@ -3284,7 +3286,8 @@ build_unary_op (location_t location,
       if (TREE_CODE (arg) == COMPLEX_CST)
        ret = TREE_REALPART (arg);
       else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
-       ret = fold_build1 (REALPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg);
+       ret = fold_build1_loc (location,
+                              REALPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg);
       else
        ret = arg;
       if (eptype && TREE_CODE (eptype) == COMPLEX_TYPE)
@@ -3295,9 +3298,11 @@ build_unary_op (location_t location,
       if (TREE_CODE (arg) == COMPLEX_CST)
        ret = TREE_IMAGPART (arg);
       else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
-       ret = fold_build1 (IMAGPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg);
+       ret = fold_build1_loc (location,
+                              IMAGPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg);
       else
-       ret = omit_one_operand (TREE_TYPE (arg), integer_zero_node, arg);
+       ret = omit_one_operand_loc (location, TREE_TYPE (arg),
+                               integer_zero_node, arg);
       if (eptype && TREE_CODE (eptype) == COMPLEX_TYPE)
        eptype = TREE_TYPE (eptype);
       goto return_build_unary_op;
@@ -3405,7 +3410,7 @@ build_unary_op (location_t location,
              }
 
            inc = c_size_in_bytes (TREE_TYPE (argtype));
-           inc = fold_convert (sizetype, inc);
+           inc = fold_convert_loc (location, sizetype, inc);
          }
        else if (FRACT_MODE_P (TYPE_MODE (argtype)))
          {
@@ -3475,7 +3480,7 @@ build_unary_op (location_t location,
        {
          /* Don't let this be an lvalue.  */
          if (lvalue_p (TREE_OPERAND (arg, 0)))
-           return non_lvalue (TREE_OPERAND (arg, 0));
+           return non_lvalue_loc (location, TREE_OPERAND (arg, 0));
          ret = TREE_OPERAND (arg, 0);
          goto return_build_unary_op;
        }
@@ -3541,10 +3546,11 @@ build_unary_op (location_t location,
       if (val && TREE_CODE (val) == INDIRECT_REF
           && TREE_CONSTANT (TREE_OPERAND (val, 0)))
        {
-         tree op0 = fold_convert (sizetype, fold_offsetof (arg, val)), op1;
+         tree op0 = fold_convert_loc (location, sizetype,
+                                      fold_offsetof (arg, val)), op1;
 
-         op1 = fold_convert (argtype, TREE_OPERAND (val, 0));
-         ret = fold_build2 (POINTER_PLUS_EXPR, argtype, op1, op0);
+         op1 = fold_convert_loc (location, argtype, TREE_OPERAND (val, 0));
+         ret = fold_build2_loc (location, POINTER_PLUS_EXPR, argtype, op1, op0);
          goto return_build_unary_op;
        }
 
@@ -3561,8 +3567,8 @@ build_unary_op (location_t location,
     argtype = TREE_TYPE (arg);
   if (TREE_CODE (arg) == INTEGER_CST)
     ret = (require_constant_value
-          ? fold_build1_initializer (code, argtype, arg)
-          : fold_build1 (code, argtype, arg));
+          ? fold_build1_initializer_loc (location, code, argtype, arg)
+          : fold_build1_loc (location, code, argtype, arg));
   else
     ret = build1 (code, argtype, arg);
  return_build_unary_op:
@@ -4048,7 +4054,7 @@ build_conditional_expr (location_t colon_loc, tree ifexp, bool ifexp_bcp,
                       && !TREE_OVERFLOW (orig_op2)));
     }
   if (int_const || (ifexp_bcp && TREE_CODE (ifexp) == INTEGER_CST))
-    ret = fold_build3 (COND_EXPR, result_type, ifexp, op1, op2);
+    ret = fold_build3_loc (colon_loc, COND_EXPR, result_type, ifexp, op1, op2);
   else
     {
       ret = build3 (COND_EXPR, result_type, ifexp, op1, op2);
@@ -4402,7 +4408,7 @@ build_c_cast (location_t loc, tree type, tree expr)
 
   /* Don't let a cast be an lvalue.  */
   if (value == expr)
-    value = non_lvalue (value);
+    value = non_lvalue_loc (loc, value);
 
   /* Don't allow the results of casting to floating-point or complex
      types be confused with actual constants, or casts involving
@@ -4939,7 +4945,7 @@ convert_for_assignment (location_t location, tree type, tree rhs,
            pedwarn (location, OPT_pedantic, 
                     "ISO C prohibits argument conversion to union type");
 
-         rhs = fold_convert (TREE_TYPE (memb), rhs);
+         rhs = fold_convert_loc (location, TREE_TYPE (memb), rhs);
          return build_constructor_single (type, memb, rhs);
        }
     }
@@ -7316,8 +7322,8 @@ output_init_element (tree value, tree origtype, bool strict_string, tree type,
   /* Advance the variable that indicates sequential elements output.  */
   if (TREE_CODE (constructor_type) == ARRAY_TYPE)
     constructor_unfilled_index
-      = size_binop (PLUS_EXPR, constructor_unfilled_index,
-                   bitsize_one_node);
+      = size_binop_loc (input_location, PLUS_EXPR, constructor_unfilled_index,
+                       bitsize_one_node);
   else if (TREE_CODE (constructor_type) == RECORD_TYPE)
     {
       constructor_unfilled_fields
@@ -7632,9 +7638,9 @@ process_init_element (struct c_expr value, bool implicit)
              /* For a record, keep track of end position of last field.  */
              if (DECL_SIZE (constructor_fields))
                constructor_bit_index
-                 = size_binop (PLUS_EXPR,
-                               bit_position (constructor_fields),
-                               DECL_SIZE (constructor_fields));
+                 = size_binop_loc (input_location, PLUS_EXPR,
+                                   bit_position (constructor_fields),
+                                   DECL_SIZE (constructor_fields));
 
              /* If the current field was the first one not yet written out,
                 it isn't now, so update.  */
@@ -7769,7 +7775,8 @@ process_init_element (struct c_expr value, bool implicit)
            }
 
          constructor_index
-           = size_binop (PLUS_EXPR, constructor_index, bitsize_one_node);
+           = size_binop_loc (input_location, PLUS_EXPR,
+                             constructor_index, bitsize_one_node);
 
          if (!value.value)
            /* If we are doing the bookkeeping for an element that was
@@ -7801,7 +7808,8 @@ process_init_element (struct c_expr value, bool implicit)
            }
 
          constructor_index
-           = size_binop (PLUS_EXPR, constructor_index, bitsize_one_node);
+           = size_binop_loc (input_location,
+                             PLUS_EXPR, constructor_index, bitsize_one_node);
 
          if (!value.value)
            /* If we are doing the bookkeeping for an element that was
@@ -7850,7 +7858,8 @@ process_init_element (struct c_expr value, bool implicit)
              process_init_element (pop_init_level (1), true);
            }
 
-         p->index = size_binop (PLUS_EXPR, p->index, bitsize_one_node);
+         p->index = size_binop_loc (input_location,
+                                    PLUS_EXPR, p->index, bitsize_one_node);
          if (tree_int_cst_equal (p->index, p->range_end) && !p->prev)
            finish = 1;
 
@@ -8416,11 +8425,12 @@ c_finish_loop (location_t start_locus, tree cond, tree incr, tree body,
            }
 
          t = build_and_jump (&blab);
-         exit = fold_build3 (COND_EXPR, void_type_node, cond, exit, t);
          if (cond_is_first)
-           SET_EXPR_LOCATION (exit, start_locus);
+           exit = fold_build3_loc (start_locus,
+                               COND_EXPR, void_type_node, cond, exit, t);
          else
-           SET_EXPR_LOCATION (exit, input_location);
+           exit = fold_build3_loc (input_location,
+                               COND_EXPR, void_type_node, cond, exit, t);
        }
 
       add_stmt (top);
@@ -8935,12 +8945,12 @@ build_binary_op (location_t location, enum tree_code code,
       /* Handle the pointer + int case.  */
       if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
        {
-         ret = pointer_int_sum (PLUS_EXPR, op0, op1);
+         ret = pointer_int_sum (location, PLUS_EXPR, op0, op1);
          goto return_build_binary_op;
        }
       else if (code1 == POINTER_TYPE && code0 == INTEGER_TYPE)
        {
-         ret = pointer_int_sum (PLUS_EXPR, op1, op0);
+         ret = pointer_int_sum (location, PLUS_EXPR, op1, op0);
          goto return_build_binary_op;
        }
       else
@@ -8953,13 +8963,13 @@ build_binary_op (location_t location, enum tree_code code,
       if (code0 == POINTER_TYPE && code1 == POINTER_TYPE
          && comp_target_types (location, type0, type1))
        {
-         ret = pointer_diff (op0, op1);
+         ret = pointer_diff (location, op0, op1);
          goto return_build_binary_op;
        }
       /* Handle pointer minus int.  Just like pointer plus int.  */
       else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
        {
-         ret = pointer_int_sum (MINUS_EXPR, op0, op1);
+         ret = pointer_int_sum (location, MINUS_EXPR, op0, op1);
          goto return_build_binary_op;
        }
       else
@@ -9572,8 +9582,9 @@ build_binary_op (location_t location, enum tree_code code,
   /* Treat expressions in initializers specially as they can't trap.  */
   if (int_const_or_overflow)
     ret = (require_constant_value
-          ? fold_build2_initializer (resultcode, build_type, op0, op1)
-          : fold_build2 (resultcode, build_type, op0, op1));
+          ? fold_build2_initializer_loc (location, resultcode, build_type,
+                                         op0, op1)
+          : fold_build2_loc (location, resultcode, build_type, op0, op1));
   else
     ret = build2 (resultcode, build_type, op0, op1);
   if (final_type != 0)
index c3d7639..bac4f8b 100644 (file)
@@ -949,6 +949,7 @@ initialize_argument_information (int num_actuals ATTRIBUTE_UNUSED,
                                 int *must_preallocate, int *ecf_flags,
                                 bool *may_tailcall, bool call_from_thunk_p)
 {
+  location_t loc = EXPR_LOCATION (exp);
   /* 1 if scanning parms front to back, -1 if scanning back to front.  */
   int inc;
 
@@ -1062,7 +1063,8 @@ initialize_argument_information (int num_actuals ATTRIBUTE_UNUSED,
              if (!call_from_thunk_p && DECL_P (base) && !TREE_STATIC (base))
                *may_tailcall = false;
 
-             args[i].tree_value = build_fold_addr_expr (args[i].tree_value);
+             args[i].tree_value = build_fold_addr_expr_loc (loc,
+                                                        args[i].tree_value);
              type = TREE_TYPE (args[i].tree_value);
 
              if (*ecf_flags & ECF_CONST)
@@ -1114,7 +1116,7 @@ initialize_argument_information (int num_actuals ATTRIBUTE_UNUSED,
                *ecf_flags &= ~(ECF_PURE | ECF_LOOPING_CONST_OR_PURE);
 
              args[i].tree_value
-               = build_fold_addr_expr (make_tree (type, copy));
+               = build_fold_addr_expr_loc (loc, make_tree (type, copy));
              type = TREE_TYPE (args[i].tree_value);
              *may_tailcall = false;
            }
index 4521f3b..0a3cc6c 100644 (file)
@@ -208,7 +208,8 @@ build_cdtor (bool ctor_p, tree *cdtors, size_t len)
            priority = p;
          else if (p != priority)
            break;
-         append_to_statement_list (build_function_call_expr (fn, 0),
+         append_to_statement_list (build_function_call_expr (UNKNOWN_LOCATION,
+                                                             fn, 0),
                                    &body);
          ++i;
        }
index 706dc41..a1ac330 100644 (file)
@@ -42,6 +42,7 @@ along with GCC; see the file COPYING3.  If not see
 tree
 convert_to_pointer (tree type, tree expr)
 {
+  location_t loc = EXPR_LOCATION (expr);
   if (TREE_TYPE (expr) == type)
     return expr;
 
@@ -53,16 +54,16 @@ convert_to_pointer (tree type, tree expr)
     {
     case POINTER_TYPE:
     case REFERENCE_TYPE:
-      return fold_build1 (NOP_EXPR, type, expr);
+      return fold_build1_loc (loc, NOP_EXPR, type, expr);
 
     case INTEGER_TYPE:
     case ENUMERAL_TYPE:
     case BOOLEAN_TYPE:
       if (TYPE_PRECISION (TREE_TYPE (expr)) != POINTER_SIZE)
-       expr = fold_build1 (NOP_EXPR,
+       expr = fold_build1_loc (loc, NOP_EXPR,
                             lang_hooks.types.type_for_size (POINTER_SIZE, 0),
                            expr);
-      return fold_build1 (CONVERT_EXPR, type, expr);
+      return fold_build1_loc (loc, CONVERT_EXPR, type, expr);
 
 
     default:
index 81cc8e0..71d2105 100644 (file)
@@ -1,3 +1,21 @@
+2009-07-17  Aldy Hernandez  <aldyh@redhat.com>
+           Manuel López-Ibáñez  <manu@gcc.gnu.org>
+
+       PR 40435 
+       * typeck.c, init.c, class.c, method.c, rtti.c, except.c, error.c,
+       tree.c, cp-gimplify.c, cxx-pretty-print.c, pt.c, semantics.c,
+       call.c, cvt.c, mangle.c: Add location argument to
+       fold_{unary,binary,ternary}, fold_build[123], build_call_expr,
+       build_size_arg, build_fold_addr_expr, build_call_array,
+       non_lvalue, size_diffop, fold_build1_initializer,
+       fold_build2_initializer, fold_build3_initializer,
+       fold_build_call_array, fold_build_call_array_initializer,
+       fold_single_bit_test, omit_one_operand, omit_two_operands,
+       invert_truthvalue, fold_truth_not_expr, build_fold_indirect_ref,
+       fold_indirect_ref, combine_comparisons, fold_builtin_*,
+       fold_call_expr, build_range_check, maybe_fold_offset_to_address,
+       round_up, round_down.
+
 2009-07-16  Jason Merrill  <jason@redhat.com>
 
        PR libstdc++/37907
index 6a7a1b8..f4b5b02 100644 (file)
@@ -362,7 +362,8 @@ build_call_a (tree function, int n, tree *argarray)
                                argarray[i], t);
        }
 
-  function = build_call_array (result_type, function, n, argarray);
+  function = build_call_array_loc (input_location,
+                                  result_type, function, n, argarray);
   TREE_HAS_CONSTRUCTOR (function) = is_constructor;
   TREE_NOTHROW (function) = nothrow;
 
@@ -5365,8 +5366,9 @@ build_over_call (struct z_candidate *cand, int flags, tsubst_flags_t complain)
            alcarray[ix + 1] = arg;
          argarray = alcarray;
        }
-      expr = build_call_array (return_type, build_addr_func (fn), nargs,
-                              argarray);
+      expr = build_call_array_loc (input_location,
+                                  return_type, build_addr_func (fn), nargs,
+                                  argarray);
       if (TREE_THIS_VOLATILE (fn) && cfun)
        current_function_returns_abnormally = 1;
       if (!VOID_TYPE_P (return_type))
index 373f457..9a76883 100644 (file)
@@ -333,7 +333,7 @@ build_base_path (enum tree_code code,
   if (null_test)
     {
       tree zero = cp_convert (TREE_TYPE (expr), integer_zero_node);
-      null_test = fold_build2 (NE_EXPR, boolean_type_node,
+      null_test = fold_build2_loc (input_location, NE_EXPR, boolean_type_node,
                               expr, zero);
     }
 
@@ -385,7 +385,7 @@ build_base_path (enum tree_code code,
       TREE_CONSTANT (v_offset) = 1;
 
       offset = convert_to_integer (ptrdiff_type_node,
-                                  size_diffop (offset,
+                                  size_diffop_loc (input_location, offset,
                                                BINFO_OFFSET (v_binfo)));
 
       if (!integer_zerop (offset))
@@ -417,7 +417,7 @@ build_base_path (enum tree_code code,
     {
       offset = fold_convert (sizetype, offset);
       if (code == MINUS_EXPR)
-       offset = fold_build1 (NEGATE_EXPR, sizetype, offset);
+       offset = fold_build1_loc (input_location, NEGATE_EXPR, sizetype, offset);
       expr = build2 (POINTER_PLUS_EXPR, ptr_target_type, expr, offset);
     }
   else
@@ -428,8 +428,8 @@ build_base_path (enum tree_code code,
 
  out:
   if (null_test)
-    expr = fold_build3 (COND_EXPR, target_type, null_test, expr,
-                       fold_build1 (NOP_EXPR, target_type,
+    expr = fold_build3_loc (input_location, COND_EXPR, target_type, null_test, expr,
+                       fold_build1_loc (input_location, NOP_EXPR, target_type,
                                     integer_zero_node));
 
   return expr;
@@ -553,10 +553,11 @@ convert_to_base_statically (tree expr, tree base)
       expr = cp_build_unary_op (ADDR_EXPR, expr, /*noconvert=*/1, 
                              tf_warning_or_error);
       if (!integer_zerop (BINFO_OFFSET (base)))
-        expr = fold_build2 (POINTER_PLUS_EXPR, pointer_type, expr,
+        expr = fold_build2_loc (input_location,
+                           POINTER_PLUS_EXPR, pointer_type, expr,
                            fold_convert (sizetype, BINFO_OFFSET (base)));
       expr = fold_convert (build_pointer_type (BINFO_TYPE (base)), expr);
-      expr = build_fold_indirect_ref (expr);
+      expr = build_fold_indirect_ref_loc (input_location, expr);
     }
 
   return expr;
@@ -1396,7 +1397,8 @@ determine_primary_bases (tree t)
              /* A virtual binfo might have been copied from within
                 another hierarchy. As we're about to use it as a
                 primary base, make sure the offsets match.  */
-             delta = size_diffop (convert (ssizetype,
+             delta = size_diffop_loc (input_location,
+                                  convert (ssizetype,
                                            BINFO_OFFSET (base_binfo)),
                                   convert (ssizetype,
                                            BINFO_OFFSET (this_primary)));
@@ -1459,7 +1461,7 @@ determine_primary_bases (tree t)
          /* A virtual binfo might have been copied from within
             another hierarchy. As we're about to use it as a primary
             base, make sure the offsets match.  */
-         delta = size_diffop (ssize_int (0),
+         delta = size_diffop_loc (input_location, ssize_int (0),
                               convert (ssizetype, BINFO_OFFSET (primary)));
 
          propagate_binfo_offsets (primary, delta);
@@ -2162,9 +2164,10 @@ update_vtable_entry_for_fn (tree t, tree binfo, tree fn, tree* virtuals,
                {
                  /* We convert via virtual base.  Adjust the fixed
                     offset to be from there.  */
-                 offset = size_diffop
-                   (offset, convert
-                    (ssizetype, BINFO_OFFSET (virtual_offset)));
+                 offset = 
+                   size_diffop (offset,
+                                convert (ssizetype,
+                                         BINFO_OFFSET (virtual_offset)));
                }
              if (fixed_offset)
                /* There was an existing fixed offset, this must be
@@ -2247,7 +2250,8 @@ update_vtable_entry_for_fn (tree t, tree binfo, tree fn, tree* virtuals,
   if (virtual_base)
     /* The `this' pointer needs to be adjusted from the declaration to
        the nearest virtual base.  */
-    delta = size_diffop (convert (ssizetype, BINFO_OFFSET (virtual_base)),
+    delta = size_diffop_loc (input_location,
+                        convert (ssizetype, BINFO_OFFSET (virtual_base)),
                         convert (ssizetype, BINFO_OFFSET (first_defn)));
   else if (lost)
     /* If the nearest definition is in a lost primary, we don't need an
@@ -2260,7 +2264,8 @@ update_vtable_entry_for_fn (tree t, tree binfo, tree fn, tree* virtuals,
        BINFO to pointing at the base where the final overrider
        appears.  */
     virtual_covariant:
-    delta = size_diffop (convert (ssizetype,
+    delta = size_diffop_loc (input_location,
+                        convert (ssizetype,
                                  BINFO_OFFSET (TREE_VALUE (overrider))),
                         convert (ssizetype, BINFO_OFFSET (binfo)));
 
@@ -3574,7 +3579,8 @@ layout_nonempty_base_or_field (record_layout_info rli,
        hierarchy.  Therefore, we may not need to add the entire
        OFFSET.  */
     propagate_binfo_offsets (binfo,
-                            size_diffop (convert (ssizetype, offset),
+                            size_diffop_loc (input_location,
+                                         convert (ssizetype, offset),
                                          convert (ssizetype,
                                                   BINFO_OFFSET (binfo))));
 }
@@ -3611,7 +3617,8 @@ layout_empty_base (record_layout_info rli, tree binfo,
     {
       if (abi_version_at_least (2))
        propagate_binfo_offsets
-         (binfo, size_diffop (size_zero_node, BINFO_OFFSET (binfo)));
+         (binfo, size_diffop_loc (input_location,
+                              size_zero_node, BINFO_OFFSET (binfo)));
       else
        warning (OPT_Wabi,
                 "offset of empty base %qT may not be ABI-compliant and may"
@@ -3717,7 +3724,8 @@ build_base_field (record_layout_info rli, tree binfo,
 
       /* On some platforms (ARM), even empty classes will not be
         byte-aligned.  */
-      eoc = round_up (rli_size_unit_so_far (rli),
+      eoc = round_up_loc (input_location,
+                     rli_size_unit_so_far (rli),
                      CLASSTYPE_ALIGN_UNIT (basetype));
       atend = layout_empty_base (rli, binfo, eoc, offsets);
       /* A nearly-empty class "has no proper base class that is empty,
@@ -4637,7 +4645,8 @@ layout_virtual_bases (record_layout_info rli, splay_tree offsets)
              && first_vbase
              && (tree_int_cst_lt
                  (size_binop (CEIL_DIV_EXPR,
-                              round_up (CLASSTYPE_SIZE (t),
+                              round_up_loc (input_location,
+                                        CLASSTYPE_SIZE (t),
                                         CLASSTYPE_ALIGN (basetype)),
                               bitsize_unit_node),
                   BINFO_OFFSET (vbase))))
@@ -5070,7 +5079,7 @@ layout_class_type (tree t, tree *virtuals_p)
       /* Make sure that we are on a byte boundary so that the size of
         the class without virtual bases will always be a round number
         of bytes.  */
-      rli->bitpos = round_up (rli->bitpos, BITS_PER_UNIT);
+      rli->bitpos = round_up_loc (input_location, rli->bitpos, BITS_PER_UNIT);
       normalize_rli (rli);
     }
 
@@ -7765,11 +7774,12 @@ build_vbase_offset_vtbl_entries (tree binfo, vtbl_init_data* vid)
         The vbase offsets go in reverse inheritance-graph order, and
         we are walking in inheritance graph order so these end up in
         the right order.  */
-      delta = size_diffop (BINFO_OFFSET (b), BINFO_OFFSET (non_primary_binfo));
+      delta = size_diffop_loc (input_location,
+                          BINFO_OFFSET (b), BINFO_OFFSET (non_primary_binfo));
 
       *vid->last_init
        = build_tree_list (NULL_TREE,
-                          fold_build1 (NOP_EXPR,
+                          fold_build1_loc (input_location, NOP_EXPR,
                                        vtable_entry_type,
                                        delta));
       vid->last_init = &TREE_CHAIN (*vid->last_init);
@@ -7999,9 +8009,11 @@ add_vcall_offset (tree orig_fn, tree binfo, vtbl_init_data *vid)
             vid->binfo.  But it might be a lost primary, so its
             BINFO_OFFSET might be wrong, so we just use the
             BINFO_OFFSET from vid->binfo.  */
-         vcall_offset = size_diffop (BINFO_OFFSET (base),
+         vcall_offset = size_diffop_loc (input_location,
+                                     BINFO_OFFSET (base),
                                      BINFO_OFFSET (vid->binfo));
-         vcall_offset = fold_build1 (NOP_EXPR, vtable_entry_type,
+         vcall_offset = fold_build1_loc (input_location,
+                                     NOP_EXPR, vtable_entry_type,
                                      vcall_offset);
        }
       /* Add the initializer to the vtable.  */
@@ -8040,7 +8052,8 @@ build_rtti_vtbl_entries (tree binfo, vtbl_init_data* vid)
                  && BINFO_INHERITANCE_CHAIN (primary_base) == b);
       b = primary_base;
     }
-  offset = size_diffop (BINFO_OFFSET (vid->rtti_binfo), BINFO_OFFSET (b));
+  offset = size_diffop_loc (input_location,
+                       BINFO_OFFSET (vid->rtti_binfo), BINFO_OFFSET (b));
 
   /* The second entry is the address of the typeinfo object.  */
   if (flag_rtti)
index fc30c06..4cf78df 100644 (file)
@@ -924,9 +924,9 @@ cxx_omp_clause_apply_fn (tree fn, tree arg1, tree arg2)
                             size_zero_node, NULL, NULL);
        }
       while (TREE_CODE (inner_type) == ARRAY_TYPE);
-      start1 = build_fold_addr_expr (start1);
+      start1 = build_fold_addr_expr_loc (input_location, start1);
       if (arg2)
-       start2 = build_fold_addr_expr (start2);
+       start2 = build_fold_addr_expr_loc (input_location, start2);
 
       end1 = TYPE_SIZE_UNIT (TREE_TYPE (arg1));
       end1 = build2 (POINTER_PLUS_EXPR, TREE_TYPE (start1), start1, end1);
@@ -980,9 +980,9 @@ cxx_omp_clause_apply_fn (tree fn, tree arg1, tree arg2)
     }
   else
     {
-      argarray[i++] = build_fold_addr_expr (arg1);
+      argarray[i++] = build_fold_addr_expr_loc (input_location, arg1);
       if (arg2)
-       argarray[i++] = build_fold_addr_expr (arg2);
+       argarray[i++] = build_fold_addr_expr_loc (input_location, arg2);
       /* Handle default arguments.  */
       for (parm = defparm; parm && parm != void_list_node;
           parm = TREE_CHAIN (parm), i++)
index 88ae05a..c42d21c 100644 (file)
@@ -936,10 +936,11 @@ convert_to_void (tree expr, const char *implicit, tsubst_flags_t complain)
              && !AGGR_INIT_VIA_CTOR_P (init))
            {
              tree fn = AGGR_INIT_EXPR_FN (init);
-             expr = build_call_array (TREE_TYPE (TREE_TYPE (TREE_TYPE (fn))),
-                                      fn,
-                                      aggr_init_expr_nargs (init),
-                                      AGGR_INIT_EXPR_ARGP (init));
+             expr = build_call_array_loc (input_location,
+                                          TREE_TYPE (TREE_TYPE (TREE_TYPE (fn))),
+                                          fn,
+                                          aggr_init_expr_nargs (init),
+                                          AGGR_INIT_EXPR_ARGP (init));
            }
        }
       break;
index 0b13bc1..1d7f9cf 100644 (file)
@@ -659,7 +659,8 @@ pp_cxx_new_expression (cxx_pretty_printer *pp, tree t)
       if (TREE_CODE (type) == ARRAY_REF)
        type = build_cplus_array_type
          (TREE_OPERAND (type, 0),
-          build_index_type (fold_build2 (MINUS_EXPR, integer_type_node,
+          build_index_type (fold_build2_loc (input_location,
+                                         MINUS_EXPR, integer_type_node,
                                          TREE_OPERAND (type, 1),
                                          integer_one_node)));
       pp_cxx_type_id (pp, type);
index a0ba51a..939400b 100644 (file)
@@ -770,7 +770,8 @@ dump_type_suffix (tree t, int flags)
            dump_expr (TREE_OPERAND (max, 0),
                       flags & ~TFF_EXPR_IN_PARENS);
          else
-           dump_expr (fold_build2 (PLUS_EXPR, dtype, max,
+           dump_expr (fold_build2_loc (input_location,
+                                   PLUS_EXPR, dtype, max,
                                    build_int_cst (dtype, 1)),
                       flags & ~TFF_EXPR_IN_PARENS);
        }
index 0151286..fdef154 100644 (file)
@@ -450,7 +450,8 @@ expand_start_catch_block (tree decl)
       exp = build_exc_ptr ();
       exp = build1 (NOP_EXPR, build_pointer_type (type), exp);
       exp = build2 (POINTER_PLUS_EXPR, TREE_TYPE (exp), exp,
-                   fold_build1 (NEGATE_EXPR, sizetype,
+                   fold_build1_loc (input_location,
+                                NEGATE_EXPR, sizetype,
                                 TYPE_SIZE_UNIT (TREE_TYPE (exp))));
       exp = cp_build_indirect_ref (exp, NULL, tf_warning_or_error);
       initialize_handler_parm (decl, exp);
index 9118c61..73403e9 100644 (file)
@@ -219,7 +219,8 @@ build_zero_init (tree type, tree nelts, bool static_storage_p)
 
       /* Iterate over the array elements, building initializations.  */
       if (nelts)
-       max_index = fold_build2 (MINUS_EXPR, TREE_TYPE (nelts),
+       max_index = fold_build2_loc (input_location,
+                                MINUS_EXPR, TREE_TYPE (nelts),
                                 nelts, integer_one_node);
       else
        max_index = array_type_nelts (type);
@@ -965,7 +966,8 @@ expand_cleanup_for_base (tree binfo, tree flag)
                                    LOOKUP_NORMAL | LOOKUP_NONVIRTUAL,
                                     tf_warning_or_error);
   if (flag)
-    expr = fold_build3 (COND_EXPR, void_type_node,
+    expr = fold_build3_loc (input_location,
+                       COND_EXPR, void_type_node,
                        c_common_truthvalue_conversion (input_location, flag),
                        expr, integer_zero_node);
 
@@ -2048,7 +2050,8 @@ build_new_1 (VEC(tree,gc) **placement, tree type, tree nelts,
         many elements to destroy later.  We use the last sizeof
         (size_t) bytes to store the number of elements.  */
       cookie_ptr = size_binop (MINUS_EXPR, cookie_size, size_in_bytes (sizetype));
-      cookie_ptr = fold_build2 (POINTER_PLUS_EXPR, TREE_TYPE (alloc_node),
+      cookie_ptr = fold_build2_loc (input_location,
+                               POINTER_PLUS_EXPR, TREE_TYPE (alloc_node),
                                alloc_node, cookie_ptr);
       size_ptr_type = build_pointer_type (sizetype);
       cookie_ptr = fold_convert (size_ptr_type, cookie_ptr);
@@ -2060,7 +2063,8 @@ build_new_1 (VEC(tree,gc) **placement, tree type, tree nelts,
        {
          /* Also store the element size.  */
          cookie_ptr = build2 (POINTER_PLUS_EXPR, size_ptr_type, cookie_ptr,
-                              fold_build1 (NEGATE_EXPR, sizetype,
+                              fold_build1_loc (input_location,
+                                           NEGATE_EXPR, sizetype,
                                            size_in_bytes (sizetype)));
 
          cookie = cp_build_indirect_ref (cookie_ptr, NULL, complain);
@@ -2498,7 +2502,8 @@ build_vec_delete_1 (tree base, tree maxindex, tree type,
 
   tbase = create_temporary_var (ptype);
   tbase_init = cp_build_modify_expr (tbase, NOP_EXPR,
-                                    fold_build2 (POINTER_PLUS_EXPR, ptype,
+                                    fold_build2_loc (input_location,
+                                                 POINTER_PLUS_EXPR, ptype,
                                                  fold_convert (ptype, base),
                                                  virtual_size),
                                     tf_warning_or_error);
@@ -2510,7 +2515,7 @@ build_vec_delete_1 (tree base, tree maxindex, tree type,
   body = build1 (EXIT_EXPR, void_type_node,
                 build2 (EQ_EXPR, boolean_type_node, tbase,
                         fold_convert (ptype, base)));
-  tmp = fold_build1 (NEGATE_EXPR, sizetype, size_exp);
+  tmp = fold_build1_loc (input_location, NEGATE_EXPR, sizetype, size_exp);
   body = build_compound_expr
     (input_location, 
      body, cp_build_modify_expr (tbase, NOP_EXPR,
@@ -2575,8 +2580,9 @@ build_vec_delete_1 (tree base, tree maxindex, tree type,
     body = integer_zero_node;
 
   /* Outermost wrapper: If pointer is null, punt.  */
-  body = fold_build3 (COND_EXPR, void_type_node,
-                     fold_build2 (NE_EXPR, boolean_type_node, base,
+  body = fold_build3_loc (input_location, COND_EXPR, void_type_node,
+                     fold_build2_loc (input_location,
+                                  NE_EXPR, boolean_type_node, base,
                                   convert (TREE_TYPE (base),
                                            integer_zero_node)),
                      body, integer_zero_node);
@@ -3279,7 +3285,8 @@ build_vec_delete (tree base, tree maxindex,
          base = TARGET_EXPR_SLOT (base_init);
        }
       type = strip_array_types (TREE_TYPE (type));
-      cookie_addr = fold_build1 (NEGATE_EXPR, sizetype, TYPE_SIZE_UNIT (sizetype));
+      cookie_addr = fold_build1_loc (input_location, NEGATE_EXPR,
+                                sizetype, TYPE_SIZE_UNIT (sizetype));
       cookie_addr = build2 (POINTER_PLUS_EXPR,
                            size_ptr_type,
                            fold_convert (size_ptr_type, base),
index c49439d..1c79dcc 100644 (file)
@@ -1264,16 +1264,16 @@ write_integer_cst (const tree cst)
       if (sign < 0)
        {
          write_char ('n');
-         n = fold_build1 (NEGATE_EXPR, type, n);
+         n = fold_build1_loc (input_location, NEGATE_EXPR, type, n);
        }
       do
        {
-         tree d = fold_build2 (FLOOR_DIV_EXPR, type, n, base);
-         tree tmp = fold_build2 (MULT_EXPR, type, d, base);
+         tree d = fold_build2_loc (input_location, FLOOR_DIV_EXPR, type, n, base);
+         tree tmp = fold_build2_loc (input_location, MULT_EXPR, type, d, base);
          unsigned c;
 
          done = integer_zerop (d);
-         tmp = fold_build2 (MINUS_EXPR, type, n, tmp);
+         tmp = fold_build2_loc (input_location, MINUS_EXPR, type, n, tmp);
          c = hwint_to_ascii (TREE_INT_CST_LOW (tmp), 10, ptr,
                              done ? 1 : chunk_digits);
          ptr -= c;
index 4e22a20..c1da08b 100644 (file)
@@ -221,7 +221,8 @@ thunk_adjust (tree ptr, bool this_adjusting,
 {
   if (this_adjusting)
     /* Adjust the pointer by the constant.  */
-    ptr = fold_build2 (POINTER_PLUS_EXPR, TREE_TYPE (ptr), ptr,
+    ptr = fold_build2_loc (input_location,
+                      POINTER_PLUS_EXPR, TREE_TYPE (ptr), ptr,
                       size_int (fixed_offset));
 
   /* If there's a virtual offset, look up that value in the vtable and
@@ -239,18 +240,21 @@ thunk_adjust (tree ptr, bool this_adjusting,
       /* Form the vtable address.  */
       vtable = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (vtable)), vtable);
       /* Find the entry with the vcall offset.  */
-      vtable = fold_build2 (POINTER_PLUS_EXPR, TREE_TYPE (vtable), vtable,
-                      fold_convert (sizetype, virtual_offset));
+      vtable = fold_build2_loc (input_location,
+                           POINTER_PLUS_EXPR, TREE_TYPE (vtable), vtable,
+                           fold_convert (sizetype, virtual_offset));
       /* Get the offset itself.  */
       vtable = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (vtable)), vtable);
       /* Adjust the `this' pointer.  */
-      ptr = fold_build2 (POINTER_PLUS_EXPR, TREE_TYPE (ptr), ptr,
+      ptr = fold_build2_loc (input_location,
+                        POINTER_PLUS_EXPR, TREE_TYPE (ptr), ptr,
                         fold_convert (sizetype, vtable));
     }
 
   if (!this_adjusting)
     /* Adjust the pointer by the constant.  */
-    ptr = fold_build2 (POINTER_PLUS_EXPR, TREE_TYPE (ptr), ptr,
+    ptr = fold_build2_loc (input_location,
+                      POINTER_PLUS_EXPR, TREE_TYPE (ptr), ptr,
                       size_int (fixed_offset));
 
   return ptr;
index 68250c2..de9f828 100644 (file)
@@ -9850,7 +9850,8 @@ tsubst (tree t, tree args, tsubst_flags_t complain, tree in_decl)
        if (e1 == error_mark_node || e2 == error_mark_node)
          return error_mark_node;
 
-       return fold_build2 (TREE_CODE (t), TREE_TYPE (t), e1, e2);
+       return fold_build2_loc (input_location,
+                           TREE_CODE (t), TREE_TYPE (t), e1, e2);
       }
 
     case NEGATE_EXPR:
@@ -9860,7 +9861,7 @@ tsubst (tree t, tree args, tsubst_flags_t complain, tree in_decl)
        if (e == error_mark_node)
          return error_mark_node;
 
-       return fold_build1 (TREE_CODE (t), TREE_TYPE (t), e);
+       return fold_build1_loc (input_location, TREE_CODE (t), TREE_TYPE (t), e);
       }
 
     case TYPENAME_TYPE:
@@ -14073,12 +14074,12 @@ unify (tree tparms, tree targs, tree parm, tree arg, int strict)
          /* If only one of the bounds used a MINUS_EXPR, compensate
             by adding one to the other bound.  */
          if (parm_cst && !arg_cst)
-           parm_max = fold_build2 (PLUS_EXPR,
+           parm_max = fold_build2_loc (input_location, PLUS_EXPR,
                                    integer_type_node,
                                    parm_max,
                                    integer_one_node);
          else if (arg_cst && !parm_cst)
-           arg_max = fold_build2 (PLUS_EXPR,
+           arg_max = fold_build2_loc (input_location, PLUS_EXPR,
                                   integer_type_node,
                                   arg_max,
                                   integer_one_node);
index c78d92b..01bba34 100644 (file)
@@ -1099,9 +1099,11 @@ get_pseudo_ti_init (tree type, unsigned tk_index)
 
            /* Combine offset and flags into one field.  */
            offset = fold_convert (offset_type, offset);
-           offset = fold_build2 (LSHIFT_EXPR, offset_type, offset,
+           offset = fold_build2_loc (input_location,
+                                 LSHIFT_EXPR, offset_type, offset,
                                  build_int_cst (offset_type, 8));
-           offset = fold_build2 (BIT_IOR_EXPR, offset_type, offset,
+           offset = fold_build2_loc (input_location,
+                                 BIT_IOR_EXPR, offset_type, offset,
                                  build_int_cst (offset_type, flags));
            base_init = tree_cons (NULL_TREE, offset, base_init);
            base_init = tree_cons (NULL_TREE, tinfo, base_init);
index 4473c49..9ac88fd 100644 (file)
@@ -3129,10 +3129,11 @@ simplify_aggr_init_expr (tree *tp)
       style = arg;
     }
 
-  call_expr = build_call_array (TREE_TYPE (TREE_TYPE (TREE_TYPE (fn))),
-                               fn,
-                               aggr_init_expr_nargs (aggr_init_expr),
-                               AGGR_INIT_EXPR_ARGP (aggr_init_expr));
+  call_expr = build_call_array_loc (input_location,
+                                   TREE_TYPE (TREE_TYPE (TREE_TYPE (fn))),
+                                   fn,
+                                   aggr_init_expr_nargs (aggr_init_expr),
+                                   AGGR_INIT_EXPR_ARGP (aggr_init_expr));
 
   if (style == ctor)
     {
index 255a297..83869c1 100644 (file)
@@ -1595,7 +1595,8 @@ cxx_print_statistics (void)
 tree
 array_type_nelts_top (tree type)
 {
-  return fold_build2 (PLUS_EXPR, sizetype,
+  return fold_build2_loc (input_location,
+                     PLUS_EXPR, sizetype,
                      array_type_nelts (type),
                      size_one_node);
 }
@@ -1612,7 +1613,8 @@ array_type_nelts_total (tree type)
   while (TREE_CODE (type) == ARRAY_TYPE)
     {
       tree n = array_type_nelts_top (type);
-      sz = fold_build2 (MULT_EXPR, sizetype, sz, n);
+      sz = fold_build2_loc (input_location,
+                       MULT_EXPR, sizetype, sz, n);
       type = TREE_TYPE (type);
     }
   return sz;
index 9e49ce5..8b684dd 100644 (file)
@@ -2429,7 +2429,8 @@ build_ptrmemfunc_access_expr (tree ptrmem, tree member_name)
                          /*want_type=*/false);
   member_type = cp_build_qualified_type (TREE_TYPE (member),
                                         cp_type_quals (ptrmem_type));
-  return fold_build3 (COMPONENT_REF, member_type,
+  return fold_build3_loc (input_location,
+                     COMPONENT_REF, member_type,
                      ptrmem, member, NULL_TREE);
 }
 
@@ -2836,7 +2837,8 @@ get_member_function_from_ptrfunc (tree *instance_ptrptr, tree function)
       TREE_NO_WARNING (vtbl) = 1;
 
       /* Finally, extract the function pointer from the vtable.  */
-      e2 = fold_build2 (POINTER_PLUS_EXPR, TREE_TYPE (vtbl), vtbl,
+      e2 = fold_build2_loc (input_location,
+                       POINTER_PLUS_EXPR, TREE_TYPE (vtbl), vtbl,
                        fold_convert (sizetype, idx));
       e2 = cp_build_indirect_ref (e2, NULL, tf_warning_or_error);
       TREE_CONSTANT (e2) = 1;
@@ -4095,7 +4097,7 @@ cp_pointer_int_sum (enum tree_code resultcode, tree ptrop, tree intop)
      pointer_int_sum() anyway.  */
   complete_type (TREE_TYPE (res_type));
 
-  return pointer_int_sum (resultcode, ptrop,
+  return pointer_int_sum (input_location, resultcode, ptrop,
                          fold_if_not_in_template (intop));
 }
 
@@ -4393,7 +4395,7 @@ cp_build_unary_op (enum tree_code code, tree xarg, int noconvert,
     case TRUTH_NOT_EXPR:
       arg = perform_implicit_conversion (boolean_type_node, arg,
                                         complain);
-      val = invert_truthvalue (arg);
+      val = invert_truthvalue_loc (input_location, arg);
       if (arg != error_mark_node)
        return val;
       errstring = "in argument to unary !";
@@ -5201,7 +5203,8 @@ convert_ptrmem (tree type, tree expr, bool allow_inverse_p,
                                    PLUS_EXPR, op1, delta,
                                    tf_warning_or_error);
 
-         expr = fold_build3 (COND_EXPR, ptrdiff_type_node, cond, op1, op2);
+         expr = fold_build3_loc (input_location,
+                             COND_EXPR, ptrdiff_type_node, cond, op1, op2);
                         
        }
 
@@ -6384,7 +6387,8 @@ get_delta_difference (tree from, tree to,
        result = get_delta_difference_1 (to, from, c_cast_p);
 
        if (result)
-         result = size_diffop (size_zero_node, result);
+         result = size_diffop_loc (input_location,
+                               size_zero_node, result);
        else
          {
            error_not_base_type (from, to);
index b3cd2b1..aafa1aa 100644 (file)
@@ -4486,6 +4486,7 @@ store_expr (tree exp, rtx target, int call_param_p, bool nontemporal)
   rtx temp;
   rtx alt_rtl = NULL_RTX;
   int dont_return_target = 0;
+  location_t loc = EXPR_LOCATION (exp);
 
   if (VOID_TYPE_P (TREE_TYPE (exp)))
     {
@@ -4561,13 +4562,13 @@ store_expr (tree exp, rtx target, int call_param_p, bool nontemporal)
                  (TYPE_MODE (TREE_TYPE (exp)),
                   SUBREG_PROMOTED_UNSIGNED_P (target));
 
-             exp = fold_convert (ntype, exp);
+             exp = fold_convert_loc (loc, ntype, exp);
            }
 
-         exp = fold_convert (lang_hooks.types.type_for_mode
-                               (GET_MODE (SUBREG_REG (target)),
-                                SUBREG_PROMOTED_UNSIGNED_P (target)),
-                             exp);
+         exp = fold_convert_loc (loc, lang_hooks.types.type_for_mode
+                                 (GET_MODE (SUBREG_REG (target)),
+                                  SUBREG_PROMOTED_UNSIGNED_P (target)),
+                                 exp);
 
          inner_target = SUBREG_REG (target);
        }
@@ -4741,9 +4742,9 @@ store_expr (tree exp, rtx target, int call_param_p, bool nontemporal)
            {
              /* Compute the size of the data to copy from the string.  */
              tree copy_size
-               = size_binop (MIN_EXPR,
-                             make_tree (sizetype, size),
-                             size_int (TREE_STRING_LENGTH (exp)));
+               = size_binop_loc (loc, MIN_EXPR,
+                                 make_tree (sizetype, size),
+                                 size_int (TREE_STRING_LENGTH (exp)));
              rtx copy_size_rtx
                = expand_expr (copy_size, NULL_RTX, VOIDmode,
                               (call_param_p
@@ -6171,6 +6172,7 @@ array_ref_element_size (tree exp)
 {
   tree aligned_size = TREE_OPERAND (exp, 3);
   tree elmt_type = TREE_TYPE (TREE_TYPE (TREE_OPERAND (exp, 0)));
+  location_t loc = EXPR_LOCATION (exp);
 
   /* If a size was specified in the ARRAY_REF, it's the size measured
      in alignment units of the element type.  So multiply by that value.  */
@@ -6179,9 +6181,9 @@ array_ref_element_size (tree exp)
       /* ??? tree_ssa_useless_type_conversion will eliminate casts to
         sizetype from another type of the same width and signedness.  */
       if (TREE_TYPE (aligned_size) != sizetype)
-       aligned_size = fold_convert (sizetype, aligned_size);
-      return size_binop (MULT_EXPR, aligned_size,
-                        size_int (TYPE_ALIGN_UNIT (elmt_type)));
+       aligned_size = fold_convert_loc (loc, sizetype, aligned_size);
+      return size_binop_loc (loc, MULT_EXPR, aligned_size,
+                            size_int (TYPE_ALIGN_UNIT (elmt_type)));
     }
 
   /* Otherwise, take the size from that of the element type.  Substitute
@@ -6236,6 +6238,7 @@ component_ref_field_offset (tree exp)
 {
   tree aligned_offset = TREE_OPERAND (exp, 2);
   tree field = TREE_OPERAND (exp, 1);
+  location_t loc = EXPR_LOCATION (exp);
 
   /* If an offset was specified in the COMPONENT_REF, it's the offset measured
      in units of DECL_OFFSET_ALIGN / BITS_PER_UNIT.  So multiply by that
@@ -6245,9 +6248,10 @@ component_ref_field_offset (tree exp)
       /* ??? tree_ssa_useless_type_conversion will eliminate casts to
         sizetype from another type of the same width and signedness.  */
       if (TREE_TYPE (aligned_offset) != sizetype)
-       aligned_offset = fold_convert (sizetype, aligned_offset);
-      return size_binop (MULT_EXPR, aligned_offset,
-                        size_int (DECL_OFFSET_ALIGN (field) / BITS_PER_UNIT));
+       aligned_offset = fold_convert_loc (loc, sizetype, aligned_offset);
+      return size_binop_loc (loc, MULT_EXPR, aligned_offset,
+                            size_int (DECL_OFFSET_ALIGN (field)
+                                      / BITS_PER_UNIT));
     }
 
   /* Otherwise, take the offset from that of the field.  Substitute
@@ -6755,7 +6759,7 @@ emutls_var_address (tree var)
   tree fn = built_in_decls [BUILT_IN_EMUTLS_GET_ADDRESS];
   tree arg = build_fold_addr_expr_with_type (emuvar, ptr_type_node);
   tree arglist = build_tree_list (NULL_TREE, arg);
-  tree call = build_function_call_expr (fn, arglist);
+  tree call = build_function_call_expr (UNKNOWN_LOCATION, fn, arglist);
   return fold_convert (build_pointer_type (TREE_TYPE (var)), call);
 }
 \f
@@ -7221,6 +7225,7 @@ expand_expr_real_1 (tree exp, rtx target, enum machine_mode tmode,
   bool reduce_bit_field;
   gimple subexp0_def, subexp1_def;
   tree top0, top1;
+  location_t loc = EXPR_LOCATION (exp);
 #define REDUCE_BIT_FIELD(expr) (reduce_bit_field                         \
                                 ? reduce_to_bit_field_precision ((expr), \
                                                                  target, \
@@ -7347,7 +7352,7 @@ expand_expr_real_1 (tree exp, rtx target, enum machine_mode tmode,
          && TREE_CODE (exp) == VAR_DECL
          && DECL_THREAD_LOCAL_P (exp))
        {
-         exp = build_fold_indirect_ref (emutls_var_address (exp));
+         exp = build_fold_indirect_ref_loc (loc, emutls_var_address (exp));
          return expand_expr_real_1 (exp, target, tmode, modifier, NULL);
        }
 
@@ -7457,7 +7462,7 @@ expand_expr_real_1 (tree exp, rtx target, enum machine_mode tmode,
          {
            tree type_for_mode = lang_hooks.types.type_for_mode (mode, 1);
            if (type_for_mode)
-             tmp = fold_unary (VIEW_CONVERT_EXPR, type_for_mode, exp);
+             tmp = fold_unary_loc (loc, VIEW_CONVERT_EXPR, type_for_mode, exp);
          }
        if (!tmp)
          tmp = build_constructor_from_list (type,
@@ -7738,7 +7743,8 @@ expand_expr_real_1 (tree exp, rtx target, enum machine_mode tmode,
                  {
                    tree index1 = index;
                    tree low_bound = array_ref_low_bound (exp);
-                   index1 = fold_convert (sizetype, TREE_OPERAND (exp, 1));
+                   index1 = fold_convert_loc (loc, sizetype,
+                                              TREE_OPERAND (exp, 1));
 
                    /* Optimize the special-case of a zero lower bound.
 
@@ -7749,8 +7755,9 @@ expand_expr_real_1 (tree exp, rtx target, enum machine_mode tmode,
                       +INDEX), which becomes (ARRAY+255+INDEX).  Opps!)  */
 
                    if (! integer_zerop (low_bound))
-                     index1 = size_diffop (index1, fold_convert (sizetype,
-                                                                 low_bound));
+                     index1 = size_diffop_loc (loc, index1,
+                                           fold_convert_loc (loc, sizetype,
+                                                             low_bound));
 
                    if (0 > compare_tree_int (index1,
                                              TREE_STRING_LENGTH (init)))
@@ -8403,11 +8410,12 @@ expand_expr_real_1 (tree exp, rtx target, enum machine_mode tmode,
       /* Make sure to sign-extend the sizetype offset in a POINTER_PLUS_EXPR
          if sizetype precision is smaller than pointer precision.  */
       if (TYPE_PRECISION (sizetype) < TYPE_PRECISION (type))
-       exp = build2 (PLUS_EXPR, type,
-                     TREE_OPERAND (exp, 0),
-                     fold_convert (type,
-                                   fold_convert (ssizetype,
-                                                 TREE_OPERAND (exp, 1))));
+       exp
+         = build2 (PLUS_EXPR, type,
+                   TREE_OPERAND (exp, 0),
+                   fold_convert_loc (loc, type,
+                                     fold_convert_loc (loc, ssizetype,
+                                                       TREE_OPERAND (exp, 1))));
     case PLUS_EXPR:
 
       /* Check if this is a case for multiplication and addition.  */
@@ -9738,6 +9746,7 @@ do_store_flag (tree exp, rtx target, enum machine_mode mode)
   int unsignedp;
   rtx op0, op1;
   rtx subtarget = target;
+  location_t loc = EXPR_LOCATION (exp);
 
   arg0 = TREE_OPERAND (exp, 0);
   arg1 = TREE_OPERAND (exp, 1);
@@ -9862,7 +9871,8 @@ do_store_flag (tree exp, rtx target, enum machine_mode mode)
       && integer_pow2p (TREE_OPERAND (arg0, 1)))
     {
       tree type = lang_hooks.types.type_for_mode (mode, unsignedp);
-      return expand_expr (fold_single_bit_test (code == NE ? NE_EXPR : EQ_EXPR,
+      return expand_expr (fold_single_bit_test (loc,
+                                               code == NE ? NE_EXPR : EQ_EXPR,
                                                arg0, arg1, type),
                          target, VOIDmode, EXPAND_NORMAL);
     }
index eba8690..803c7a5 100644 (file)
@@ -99,18 +99,21 @@ 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 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 pedantic_omit_one_operand (tree, tree, tree);
-static tree distribute_bit_expr (enum tree_code, tree, tree, tree);
-static tree make_bit_field_ref (tree, tree, HOST_WIDE_INT, HOST_WIDE_INT, int);
-static tree optimize_bit_field_compare (enum tree_code, tree, tree, tree);
-static tree decode_field_reference (tree, HOST_WIDE_INT *, HOST_WIDE_INT *,
+static tree eval_subst (location_t, tree, tree, tree, tree, tree);
+static tree pedantic_omit_one_operand_loc (location_t, tree, tree, tree);
+static tree distribute_bit_expr (location_t, enum tree_code, tree, tree, tree);
+static tree make_bit_field_ref (location_t, tree, tree,
+                               HOST_WIDE_INT, HOST_WIDE_INT, 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);
@@ -120,23 +123,25 @@ static tree range_binop (enum tree_code, tree, tree, int, tree, int);
 static tree range_predecessor (tree);
 static tree range_successor (tree);
 extern tree make_range (tree, int *, tree *, tree *, bool *);
-extern tree build_range_check (tree, tree, int, tree, tree);
 extern bool merge_ranges (int *, tree *, tree *, int, tree, tree, int,
                          tree, tree);
-static tree fold_range_test (enum tree_code, tree, tree, tree);
-static tree fold_cond_expr_with_comparison (tree, tree, tree, tree);
+static tree fold_range_test (location_t, enum tree_code, tree, tree, tree);
+static tree fold_cond_expr_with_comparison (location_t, tree, tree, tree, tree);
 static tree unextend (tree, int, int, tree);
-static tree fold_truthop (enum tree_code, tree, tree, tree);
-static tree optimize_minmax_comparison (enum tree_code, tree, tree, tree);
+static tree fold_truthop (location_t, 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_div_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 (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);
@@ -1232,7 +1237,7 @@ negate_expr_p (tree t)
    returned.  */
 
 static tree
-fold_negate_expr (tree t)
+fold_negate_expr (location_t loc, tree t)
 {
   tree type = TREE_TYPE (t);
   tree tem;
@@ -1242,7 +1247,7 @@ fold_negate_expr (tree 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;
       
@@ -1279,15 +1284,15 @@ fold_negate_expr (tree t)
 
     case COMPLEX_EXPR:
       if (negate_expr_p (t))
-       return fold_build2 (COMPLEX_EXPR, type,
-                           fold_negate_expr (TREE_OPERAND (t, 0)),
-                           fold_negate_expr (TREE_OPERAND (t, 1)));
+       return fold_build2_loc (loc, COMPLEX_EXPR, type,
+                           fold_negate_expr (loc, TREE_OPERAND (t, 0)),
+                           fold_negate_expr (loc, TREE_OPERAND (t, 1)));
       break;
       
     case CONJ_EXPR:
       if (negate_expr_p (t))
-       return fold_build1 (CONJ_EXPR, type,
-                           fold_negate_expr (TREE_OPERAND (t, 0)));
+       return fold_build1_loc (loc, CONJ_EXPR, type,
+                           fold_negate_expr (loc, TREE_OPERAND (t, 0)));
       break;
 
     case NEGATE_EXPR:
@@ -1303,7 +1308,7 @@ fold_negate_expr (tree t)
                                     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));
            }
 
@@ -1311,7 +1316,7 @@ fold_negate_expr (tree t)
          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));
            }
        }
@@ -1322,7 +1327,7 @@ fold_negate_expr (tree t)
       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;
 
@@ -1337,11 +1342,11 @@ fold_negate_expr (tree t)
        {
          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;
@@ -1367,7 +1372,7 @@ fold_negate_expr (tree t)
                  && (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);
@@ -1377,7 +1382,7 @@ fold_negate_expr (tree t)
                  && (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));
            }
         }
@@ -1389,7 +1394,7 @@ fold_negate_expr (tree t)
        {
          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;
 
@@ -1402,7 +1407,7 @@ fold_negate_expr (tree t)
 
          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;
 
@@ -1418,9 +1423,9 @@ fold_negate_expr (tree t)
              tree ntype = TYPE_UNSIGNED (type)
                           ? signed_type_for (type)
                           : unsigned_type_for (type);
-             tree temp = fold_convert (ntype, TREE_OPERAND (t, 0));
-             temp = fold_build2 (RSHIFT_EXPR, ntype, temp, op1);
-             return fold_convert (type, temp);
+             tree temp = fold_convert_loc (loc, ntype, TREE_OPERAND (t, 0));
+             temp = fold_build2_loc (loc, RSHIFT_EXPR, ntype, temp, op1);
+             return fold_convert_loc (loc, type, temp);
            }
        }
       break;
@@ -1440,17 +1445,22 @@ 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);
 }
 \f
 /* Split a tree IN into a constant, literal and variable parts that could be
@@ -1552,13 +1562,16 @@ split_tree (tree in, enum tree_code code, tree *conp, tree *litp,
   return var;
 }
 
-/* Re-associate trees split by the above function.  T1 and T2 are either
-   expressions to associate or null.  Return the new expression, if any.  If
+/* Re-associate trees split by the above function.  T1 and T2 are
+   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)
@@ -1573,26 +1586,30 @@ associate_trees (tree t1, tree t2, enum tree_code code, tree type)
       if (code == PLUS_EXPR)
        {
          if (TREE_CODE (t1) == NEGATE_EXPR)
-           return build2 (MINUS_EXPR, type, fold_convert (type, t2),
-                          fold_convert (type, TREE_OPERAND (t1, 0)));
+           tem = build2 (MINUS_EXPR, type, fold_convert_loc (loc, type, t2),
+                         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),
-                          fold_convert (type, TREE_OPERAND (t2, 0)));
+           tem = build2 (MINUS_EXPR, type, fold_convert_loc (loc, type, t1),
+                         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),
-                    fold_convert (type, t2));
+      tem = build2 (code, type, fold_convert_loc (loc, type, t1),
+                   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;
 }
 \f
 /* Check whether TYPE1 and TYPE2 are equivalent integer types, suitable
@@ -2061,7 +2078,7 @@ size_int_kind (HOST_WIDE_INT number, enum size_type_kind kind)
    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);
 
@@ -2097,7 +2114,7 @@ size_binop (enum tree_code code, tree arg0, tree arg1)
       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,
@@ -2105,7 +2122,7 @@ size_binop (enum tree_code code, tree arg0, tree arg1)
    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;
@@ -2115,7 +2132,7 @@ size_diffop (tree arg0, tree 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;
@@ -2128,8 +2145,9 @@ size_diffop (tree arg0, tree arg1)
      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),
-                      fold_convert (ctype, arg1));
+    return size_binop_loc (loc, MINUS_EXPR,
+                          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
@@ -2138,11 +2156,14 @@ size_diffop (tree arg0, tree arg1)
   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),
-                      fold_convert (ctype, size_binop (MINUS_EXPR,
-                                                       arg1, arg0)));
+    return size_binop_loc (loc, MINUS_EXPR, build_int_cst (ctype, 0),
+                          fold_convert_loc (loc, ctype,
+                                            size_binop_loc (loc,
+                                                            MINUS_EXPR,
+                                                            arg1, arg0)));
 }
 \f
 /* A subroutine of fold_convert_const handling conversions of an
@@ -2529,7 +2550,7 @@ fold_convertible_p (const_tree type, const_tree arg)
    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;
@@ -2543,7 +2564,7 @@ fold_convert (tree type, tree arg)
     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))
     {
@@ -2558,15 +2579,14 @@ fold_convert (tree type, tree arg)
        }
       if (INTEGRAL_TYPE_P (orig) || POINTER_TYPE_P (orig)
          || TREE_CODE (orig) == OFFSET_TYPE)
-        return fold_build1 (NOP_EXPR, type,