OSDN Git Service

2010-09-05 Tobias Burnus <burnus@net-b.de>
authorburnus <burnus@138bc75d-0d04-0410-961f-82ee72b054a4>
Sun, 5 Sep 2010 18:10:11 +0000 (18:10 +0000)
committerburnus <burnus@138bc75d-0d04-0410-961f-82ee72b054a4>
Sun, 5 Sep 2010 18:10:11 +0000 (18:10 +0000)
        PR fortran/45186
        * trans-intrinsic.c (gfc_conv_intrinsic_sign,
        gfc_conv_intrinsic_leadz): Use build_call_expr_loc instead
        of build_call_expr.
        * trans-expr.c (gfc_conv_expr_present, gfc_conv_missing_dummy,
        gfc_conv_string_length, gfc_conv_substring,
        gfc_conv_component_ref, gfc_conv_unary_op, gfc_conv_powi,
        gfc_conv_cst_int_power, gfc_conv_string_tmp, gfc_conv_concat_op,
        gfc_conv_expr_op, gfc_build_compare_string,
        gfc_set_interface_mapping_bounds, gfc_conv_subref_array_arg,
        gfc_conv_derived_to_class, conv_isocbinding_procedure,
        gfc_conv_procedure_call, fill_with_spaces,
        gfc_trans_string_copy, gfc_trans_alloc_subarray_assign,
        gfc_trans_structure_assign, gfc_trans_pointer_assignment,
        gfc_trans_scalar_assign, gfc_trans_zero_assign,
        gfc_trans_array_copy, gfc_trans_array_constructor_copy): Change
        fold_build[0-9] to fold_build[0-9]_loc.
        * trans-io.c (set_parameter_const, set_parameter_value,
        set_parameter_ref, gfc_convert_array_to_string, set_string,
        set_internal_unit, io_result, set_error_locus,
        nml_get_addr_expr, build_dt): Ditto.
        * trans-openmp.c (gfc_omp_clause_default_ctor,
        gfc_omp_clause_copy_ctor, gfc_omp_clause_assign_op,
        gfc_trans_omp_array_reduction, gfc_trans_omp_atomic,
        gfc_trans_omp_do): Ditto.
        * trans.c (gfc_add_modify, gfc_build_addr_expr,
        gfc_build_array_ref, gfc_trans_runtime_error_vararg,
        gfc_trans_runtime_check, gfc_call_malloc,
        gfc_allocate_with_status, gfc_allocate_array_with_status,
        gfc_call_free, gfc_deallocate_with_status,
        gfc_call_realloc): Ditto.

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

gcc/fortran/ChangeLog
gcc/fortran/convert.c
gcc/fortran/f95-lang.c
gcc/fortran/trans-intrinsic.c

index d9dbb73..0d8a590 100644 (file)
@@ -1,3 +1,37 @@
+2010-09-05  Tobias Burnus <burnus@net-b.de>
+
+       PR fortran/45186
+       * f95-lang.c (gfc_truthvalue_conversion): Use
+       fold_build[0-9]_loc instead of fold_build[0-9].
+       * convert.c (convert): Ditto.
+       * trans-intrinsic.c (gfc_conv_intrinsic_conversion,
+       build_fixbound_expr, build_fix_expr, gfc_conv_intrinsic_aint,
+       gfc_conv_intrinsic_int, gfc_conv_intrinsic_imagpart,
+       gfc_conv_intrinsic_conjg, gfc_trans_same_strlen_check,
+       gfc_conv_intrinsic_bound, gfc_conv_intrinsic_abs,
+       gfc_conv_intrinsic_cmplx, gfc_conv_intrinsic_mod,
+       gfc_conv_intrinsic_dim, gfc_conv_intrinsic_sign,
+       gfc_conv_intrinsic_dprod, gfc_conv_intrinsic_char,
+       gfc_conv_intrinsic_ctime, gfc_conv_intrinsic_fdate,
+       gfc_conv_intrinsic_ttynam, gfc_conv_intrinsic_minmax,
+       gfc_conv_intrinsic_minmax_char, gfc_conv_intrinsic_anyall,
+       gfc_conv_intrinsic_count, gfc_conv_intrinsic_arith,
+       gfc_conv_intrinsic_dot_product, gfc_conv_intrinsic_minmaxloc,
+       gfc_conv_intrinsic_minmaxval, gfc_conv_intrinsic_btest,
+       gfc_conv_intrinsic_bitop, gfc_conv_intrinsic_not,
+       gfc_conv_intrinsic_singlebitop, gfc_conv_intrinsic_ibits,
+       gfc_conv_intrinsic_rlshift, gfc_conv_intrinsic_ishft,
+       gfc_conv_intrinsic_ishftc, gfc_conv_intrinsic_leadz,
+       gfc_conv_intrinsic_trailz, gfc_conv_intrinsic_popcnt_poppar,
+       gfc_conv_intrinsic_ichar, gfc_conv_has_intvalue,
+       gfc_conv_intrinsic_merge, gfc_conv_intrinsic_spacing,
+       gfc_conv_intrinsic_rrspacing, gfc_conv_intrinsic_size,
+       size_of_string_in_bytes, gfc_conv_intrinsic_sizeof,
+       gfc_conv_intrinsic_storage_size, gfc_conv_intrinsic_strcmp,
+       gfc_conv_intrinsic_transfer, gfc_conv_allocated,
+       gfc_conv_associated, gfc_conv_same_type_as,
+       gfc_conv_intrinsic_trim, gfc_conv_intrinsic_repeat): Ditto.
+
 2010-09-04  Tobias Burnus  <burnus@net-b.de>
 
        PR fortran/45530
index 50e3a6a..0493f3f 100644 (file)
@@ -80,7 +80,7 @@ convert (tree type, tree expr)
     return expr;
 
   if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (TREE_TYPE (expr)))
-    return fold_build1 (NOP_EXPR, type, expr);
+    return fold_build1_loc (input_location, NOP_EXPR, type, expr);
   if (TREE_CODE (TREE_TYPE (expr)) == ERROR_MARK)
     return error_mark_node;
   if (TREE_CODE (TREE_TYPE (expr)) == VOID_TYPE)
@@ -89,7 +89,7 @@ convert (tree type, tree expr)
       return error_mark_node;
     }
   if (code == VOID_TYPE)
-    return fold_build1 (CONVERT_EXPR, type, e);
+    return fold_build1_loc (input_location, CONVERT_EXPR, type, e);
 #if 0
   /* This is incorrect.  A truncation can't be stripped this way.
      Extensions will be stripped by the use of get_unwidened.  */
@@ -105,9 +105,10 @@ convert (tree type, tree expr)
       /* If we have a NOP_EXPR, we must fold it here to avoid
         infinite recursion between fold () and convert ().  */
       if (TREE_CODE (e) == NOP_EXPR)
-       return fold_build1 (NOP_EXPR, type, TREE_OPERAND (e, 0));
+       return fold_build1_loc (input_location, NOP_EXPR, type,
+                               TREE_OPERAND (e, 0));
       else
-       return fold_build1 (NOP_EXPR, type, e);
+       return fold_build1_loc (input_location, NOP_EXPR, type, e);
     }
   if (code == POINTER_TYPE || code == REFERENCE_TYPE)
     return fold (convert_to_pointer (type, e));
index c239702..8c957d2 100644 (file)
@@ -200,17 +200,18 @@ gfc_truthvalue_conversion (tree expr)
          return expr;
        }
       else if (TREE_CODE (expr) == NOP_EXPR)
-        return fold_build1 (NOP_EXPR,
+        return fold_build1_loc (input_location, NOP_EXPR,
                            boolean_type_node, TREE_OPERAND (expr, 0));
       else
-        return fold_build1 (NOP_EXPR, boolean_type_node, expr);
+        return fold_build1_loc (input_location, NOP_EXPR, boolean_type_node,
+                               expr);
 
     case INTEGER_TYPE:
       if (TREE_CODE (expr) == INTEGER_CST)
        return integer_zerop (expr) ? boolean_false_node : boolean_true_node;
       else
-        return fold_build2 (NE_EXPR, boolean_type_node, expr,
-                           build_int_cst (TREE_TYPE (expr), 0));
+        return fold_build2_loc (input_location, NE_EXPR, boolean_type_node,
+                               expr, build_int_cst (TREE_TYPE (expr), 0));
 
     default:
       internal_error ("Unexpected type in truthvalue_conversion");
index 55a3b2f..38b7ecc 100644 (file)
@@ -331,7 +331,8 @@ gfc_conv_intrinsic_conversion (gfc_se * se, gfc_expr * expr)
       tree artype;
 
       artype = TREE_TYPE (TREE_TYPE (args[0]));
-      args[0] = fold_build1 (REALPART_EXPR, artype, args[0]);
+      args[0] = fold_build1_loc (input_location, REALPART_EXPR, artype,
+                                args[0]);
     }
 
   se->expr = convert (type, args[0]);
@@ -357,11 +358,12 @@ build_fixbound_expr (stmtblock_t * pblock, tree arg, tree type, int up)
   intval = gfc_evaluate_now (intval, pblock);
 
   tmp = convert (argtype, intval);
-  cond = fold_build2 (up ? GE_EXPR : LE_EXPR, boolean_type_node, tmp, arg);
+  cond = fold_build2_loc (input_location, up ? GE_EXPR : LE_EXPR,
+                         boolean_type_node, tmp, arg);
 
-  tmp = fold_build2 (up ? PLUS_EXPR : MINUS_EXPR, type, intval,
-                    build_int_cst (type, 1));
-  tmp = fold_build3 (COND_EXPR, type, cond, intval, tmp);
+  tmp = fold_build2_loc (input_location, up ? PLUS_EXPR : MINUS_EXPR, type,
+                        intval, build_int_cst (type, 1));
+  tmp = fold_build3_loc (input_location, COND_EXPR, type, cond, intval, tmp);
   return tmp;
 }
 
@@ -424,7 +426,7 @@ build_fix_expr (stmtblock_t * pblock, tree arg, tree type,
       break;
 
     case RND_TRUNC:
-      return fold_build1 (FIX_TRUNC_EXPR, type, arg);
+      return fold_build1_loc (input_location, FIX_TRUNC_EXPR, type, arg);
       break;
 
     default:
@@ -496,17 +498,21 @@ gfc_conv_intrinsic_aint (gfc_se * se, gfc_expr * expr, enum rounding_mode op)
   n = gfc_validate_kind (BT_INTEGER, kind, false);
   mpfr_set_z (huge, gfc_integer_kinds[n].huge, GFC_RND_MODE);
   tmp = gfc_conv_mpfr_to_tree (huge, kind, 0);
-  cond = fold_build2 (LT_EXPR, boolean_type_node, arg[0], tmp);
+  cond = fold_build2_loc (input_location, LT_EXPR, boolean_type_node, arg[0],
+                         tmp);
 
   mpfr_neg (huge, huge, GFC_RND_MODE);
   tmp = gfc_conv_mpfr_to_tree (huge, kind, 0);
-  tmp = fold_build2 (GT_EXPR, boolean_type_node, arg[0], tmp);
-  cond = fold_build2 (TRUTH_AND_EXPR, boolean_type_node, cond, tmp);
+  tmp = fold_build2_loc (input_location, GT_EXPR, boolean_type_node, arg[0],
+                        tmp);
+  cond = fold_build2_loc (input_location, TRUTH_AND_EXPR, boolean_type_node,
+                         cond, tmp);
   itype = gfc_get_int_type (kind);
 
   tmp = build_fix_expr (&se->pre, arg[0], itype, op);
   tmp = convert (type, tmp);
-  se->expr = fold_build3 (COND_EXPR, type, cond, tmp, arg[0]);
+  se->expr = fold_build3_loc (input_location, COND_EXPR, type, cond, tmp,
+                             arg[0]);
   mpfr_clear (huge);
 }
 
@@ -544,7 +550,8 @@ gfc_conv_intrinsic_int (gfc_se * se, gfc_expr * expr, enum rounding_mode op)
          tree artype;
 
          artype = TREE_TYPE (TREE_TYPE (args[0]));
-         args[0] = fold_build1 (REALPART_EXPR, artype, args[0]);
+         args[0] = fold_build1_loc (input_location, REALPART_EXPR, artype,
+                                    args[0]);
        }
 
       se->expr = build_fix_expr (&se->pre, args[0], type, op);
@@ -560,7 +567,8 @@ gfc_conv_intrinsic_imagpart (gfc_se * se, gfc_expr * expr)
   tree arg;
 
   gfc_conv_intrinsic_function_args (se, expr, &arg, 1);
-  se->expr = fold_build1 (IMAGPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg);
+  se->expr = fold_build1_loc (input_location, IMAGPART_EXPR,
+                             TREE_TYPE (TREE_TYPE (arg)), arg);
 }
 
 
@@ -572,7 +580,7 @@ gfc_conv_intrinsic_conjg (gfc_se * se, gfc_expr * expr)
   tree arg;
 
   gfc_conv_intrinsic_function_args (se, expr, &arg, 1);
-  se->expr = fold_build1 (CONJ_EXPR, TREE_TYPE (arg), arg);
+  se->expr = fold_build1_loc (input_location, CONJ_EXPR, TREE_TYPE (arg), arg);
 }
 
 
@@ -875,7 +883,7 @@ gfc_trans_same_strlen_check (const char* intr_name, locus* where,
     return;
 
   /* Compare the two string lengths.  */
-  cond = fold_build2 (NE_EXPR, boolean_type_node, a, b);
+  cond = fold_build2_loc (input_location, NE_EXPR, boolean_type_node, a, b);
 
   /* Output the runtime-check.  */
   name = gfc_build_cstring_const (intr_name);
@@ -942,8 +950,9 @@ gfc_conv_intrinsic_bound (gfc_se * se, gfc_expr * expr, int upper)
       gcc_assert (se->ss->expr == expr);
       gfc_advance_se_ss_chain (se);
       bound = se->loop->loopvar[0];
-      bound = fold_build2 (MINUS_EXPR, gfc_array_index_type, bound,
-                          se->loop->from[0]);
+      bound = fold_build2_loc (input_location, MINUS_EXPR,
+                              gfc_array_index_type, bound,
+                              se->loop->from[0]);
     }
   else
     {
@@ -954,8 +963,9 @@ gfc_conv_intrinsic_bound (gfc_se * se, gfc_expr * expr, int upper)
       gfc_add_block_to_block (&se->pre, &argse.pre);
       bound = argse.expr;
       /* Convert from one based to zero based.  */
-      bound = fold_build2 (MINUS_EXPR, gfc_array_index_type, bound,
-                          gfc_index_one_node);
+      bound = fold_build2_loc (input_location, MINUS_EXPR,
+                              gfc_array_index_type, bound,
+                              gfc_index_one_node);
     }
 
   /* TODO: don't re-evaluate the descriptor on each iteration.  */
@@ -985,11 +995,13 @@ gfc_conv_intrinsic_bound (gfc_se * se, gfc_expr * expr, int upper)
       if (gfc_option.rtcheck & GFC_RTCHECK_BOUNDS)
         {
           bound = gfc_evaluate_now (bound, &se->pre);
-          cond = fold_build2 (LT_EXPR, boolean_type_node,
-                             bound, build_int_cst (TREE_TYPE (bound), 0));
+          cond = fold_build2_loc (input_location, LT_EXPR, boolean_type_node,
+                                 bound, build_int_cst (TREE_TYPE (bound), 0));
           tmp = gfc_rank_cst[GFC_TYPE_ARRAY_RANK (TREE_TYPE (desc))];
-          tmp = fold_build2 (GE_EXPR, boolean_type_node, bound, tmp);
-          cond = fold_build2 (TRUTH_ORIF_EXPR, boolean_type_node, cond, tmp);
+          tmp = fold_build2_loc (input_location, GE_EXPR, boolean_type_node,
+                                bound, tmp);
+          cond = fold_build2_loc (input_location, TRUTH_ORIF_EXPR,
+                                 boolean_type_node, cond, tmp);
           gfc_trans_runtime_check (true, false, cond, &se->pre, &expr->where,
                                   gfc_msg_fault);
         }
@@ -1025,53 +1037,63 @@ gfc_conv_intrinsic_bound (gfc_se * se, gfc_expr * expr, int upper)
     {
       tree stride = gfc_conv_descriptor_stride_get (desc, bound);
 
-      cond1 = fold_build2 (GE_EXPR, boolean_type_node, ubound, lbound);
-
-      cond3 = fold_build2 (GE_EXPR, boolean_type_node, stride,
-                          gfc_index_zero_node);
-      cond3 = fold_build2 (TRUTH_AND_EXPR, boolean_type_node, cond3, cond1);
-
-      cond4 = fold_build2 (LT_EXPR, boolean_type_node, stride,
-                          gfc_index_zero_node);
+      cond1 = fold_build2_loc (input_location, GE_EXPR, boolean_type_node,
+                              ubound, lbound);
+      cond3 = fold_build2_loc (input_location, GE_EXPR, boolean_type_node,
+                              stride, gfc_index_zero_node);
+      cond3 = fold_build2_loc (input_location, TRUTH_AND_EXPR,
+                              boolean_type_node, cond3, cond1);
+      cond4 = fold_build2_loc (input_location, LT_EXPR, boolean_type_node,
+                              stride, gfc_index_zero_node);
 
       if (upper)
        {
          tree cond5;
-         cond = fold_build2 (TRUTH_OR_EXPR, boolean_type_node, cond3, cond4);
-
-         cond5 = fold_build2 (EQ_EXPR, boolean_type_node, gfc_index_one_node, lbound);
-         cond5 = fold_build2 (TRUTH_AND_EXPR, boolean_type_node, cond4, cond5);
-
-         cond = fold_build2 (TRUTH_OR_EXPR, boolean_type_node, cond, cond5);
-
-         se->expr = fold_build3 (COND_EXPR, gfc_array_index_type, cond,
-                                 ubound, gfc_index_zero_node);
+         cond = fold_build2_loc (input_location, TRUTH_OR_EXPR,
+                                 boolean_type_node, cond3, cond4);
+         cond5 = fold_build2_loc (input_location, EQ_EXPR, boolean_type_node,
+                                  gfc_index_one_node, lbound);
+         cond5 = fold_build2_loc (input_location, TRUTH_AND_EXPR,
+                                  boolean_type_node, cond4, cond5);
+
+         cond = fold_build2_loc (input_location, TRUTH_OR_EXPR,
+                                 boolean_type_node, cond, cond5);
+
+         se->expr = fold_build3_loc (input_location, COND_EXPR,
+                                     gfc_array_index_type, cond,
+                                     ubound, gfc_index_zero_node);
        }
       else
        {
          if (as->type == AS_ASSUMED_SIZE)
-           cond = fold_build2 (EQ_EXPR, boolean_type_node, bound,
-                               build_int_cst (TREE_TYPE (bound),
-                                              arg->expr->rank - 1));
+           cond = fold_build2_loc (input_location, EQ_EXPR, boolean_type_node,
+                                   bound, build_int_cst (TREE_TYPE (bound),
+                                                         arg->expr->rank - 1));
          else
            cond = boolean_false_node;
 
-         cond1 = fold_build2 (TRUTH_OR_EXPR, boolean_type_node, cond3, cond4);
-         cond = fold_build2 (TRUTH_OR_EXPR, boolean_type_node, cond, cond1);
+         cond1 = fold_build2_loc (input_location, TRUTH_OR_EXPR,
+                                  boolean_type_node, cond3, cond4);
+         cond = fold_build2_loc (input_location, TRUTH_OR_EXPR,
+                                 boolean_type_node, cond, cond1);
 
-         se->expr = fold_build3 (COND_EXPR, gfc_array_index_type, cond,
-                                 lbound, gfc_index_one_node);
+         se->expr = fold_build3_loc (input_location, COND_EXPR,
+                                     gfc_array_index_type, cond,
+                                     lbound, gfc_index_one_node);
        }
     }
   else
     {
       if (upper)
         {
-         size = fold_build2 (MINUS_EXPR, gfc_array_index_type, ubound, lbound);
-         se->expr = fold_build2 (PLUS_EXPR, gfc_array_index_type, size,
+         size = fold_build2_loc (input_location, MINUS_EXPR,
+                                 gfc_array_index_type, ubound, lbound);
+         se->expr = fold_build2_loc (input_location, PLUS_EXPR,
+                                     gfc_array_index_type, size,
                                  gfc_index_one_node);
-         se->expr = fold_build2 (MAX_EXPR, gfc_array_index_type, se->expr,
-                                 gfc_index_zero_node);
+         se->expr = fold_build2_loc (input_location, MAX_EXPR,
+                                     gfc_array_index_type, se->expr,
+                                     gfc_index_zero_node);
        }
       else
        se->expr = gfc_index_one_node;
@@ -1093,7 +1115,8 @@ gfc_conv_intrinsic_abs (gfc_se * se, gfc_expr * expr)
     {
     case BT_INTEGER:
     case BT_REAL:
-      se->expr = fold_build1 (ABS_EXPR, TREE_TYPE (arg), arg);
+      se->expr = fold_build1_loc (input_location, ABS_EXPR, TREE_TYPE (arg),
+                                 arg);
       break;
 
     case BT_COMPLEX:
@@ -1128,14 +1151,14 @@ gfc_conv_intrinsic_cmplx (gfc_se * se, gfc_expr * expr, int both)
     imag = convert (TREE_TYPE (type), args[1]);
   else if (TREE_CODE (TREE_TYPE (args[0])) == COMPLEX_TYPE)
     {
-      imag = fold_build1 (IMAGPART_EXPR, TREE_TYPE (TREE_TYPE (args[0])),
-                         args[0]);
+      imag = fold_build1_loc (input_location, IMAGPART_EXPR,
+                             TREE_TYPE (TREE_TYPE (args[0])), args[0]);
       imag = convert (TREE_TYPE (type), imag);
     }
   else
     imag = build_real_from_int_cst (TREE_TYPE (type), integer_zero_node);
 
-  se->expr = fold_build2 (COMPLEX_EXPR, type, real, imag);
+  se->expr = fold_build2_loc (input_location, COMPLEX_EXPR, type, real, imag);
 }
 
 /* Remainder function MOD(A, P) = A - INT(A / P) * P
@@ -1164,9 +1187,11 @@ gfc_conv_intrinsic_mod (gfc_se * se, gfc_expr * expr, int modulo)
       type = TREE_TYPE (args[0]);
 
       if (modulo)
-       se->expr = fold_build2 (FLOOR_MOD_EXPR, type, args[0], args[1]);
+       se->expr = fold_build2_loc (input_location, FLOOR_MOD_EXPR, type,
+                                  args[0], args[1]);
       else
-       se->expr = fold_build2 (TRUNC_MOD_EXPR, type, args[0], args[1]);
+       se->expr = fold_build2_loc (input_location, TRUNC_MOD_EXPR, type,
+                                  args[0], args[1]);
       break;
 
     case BT_REAL:
@@ -1201,21 +1226,26 @@ gfc_conv_intrinsic_mod (gfc_se * se, gfc_expr * expr, int modulo)
        {
          tree zero = gfc_build_const (type, integer_zero_node);
          tmp = gfc_evaluate_now (se->expr, &se->pre);
-         test = fold_build2 (LT_EXPR, boolean_type_node, args[0], zero);
-         test2 = fold_build2 (LT_EXPR, boolean_type_node, args[1], zero);
-         test2 = fold_build2 (TRUTH_XOR_EXPR, boolean_type_node, test, test2);
-         test = fold_build2 (NE_EXPR, boolean_type_node, tmp, zero);
-         test = fold_build2 (TRUTH_AND_EXPR, boolean_type_node, test, test2);
+         test = fold_build2_loc (input_location, LT_EXPR, boolean_type_node,
+                                 args[0], zero);
+         test2 = fold_build2_loc (input_location, LT_EXPR, boolean_type_node,
+                                  args[1], zero);
+         test2 = fold_build2_loc (input_location, TRUTH_XOR_EXPR,
+                                  boolean_type_node, test, test2);
+         test = fold_build2_loc (input_location, NE_EXPR, boolean_type_node,
+                                 tmp, zero);
+         test = fold_build2_loc (input_location, TRUTH_AND_EXPR,
+                                 boolean_type_node, test, test2);
          test = gfc_evaluate_now (test, &se->pre);
-         se->expr = fold_build3 (COND_EXPR, type, test,
-                                 fold_build2 (PLUS_EXPR, type, tmp, args[1]),
-                                 tmp);
+         se->expr = fold_build3_loc (input_location, COND_EXPR, type, test,
+                                 fold_build2_loc (input_location, PLUS_EXPR,
+                                                  type, tmp, args[1]), tmp);
          return;
        }
 
       /* If we do not have a built_in fmod, the calculation is going to
         have to be done longhand.  */
-      tmp = fold_build2 (RDIV_EXPR, type, args[0], args[1]);
+      tmp = fold_build2_loc (input_location, RDIV_EXPR, type, args[0], args[1]);
 
       /* Test if the value is too large to handle sensibly.  */
       gfc_set_model_kind (expr->ts.kind);
@@ -1229,12 +1259,15 @@ gfc_conv_intrinsic_mod (gfc_se * se, gfc_expr * expr, int modulo)
        }
       mpfr_set_z (huge, gfc_integer_kinds[n].huge, GFC_RND_MODE);
       test = gfc_conv_mpfr_to_tree (huge, expr->ts.kind, 0);
-      test2 = fold_build2 (LT_EXPR, boolean_type_node, tmp, test);
+      test2 = fold_build2_loc (input_location, LT_EXPR, boolean_type_node,
+                              tmp, test);
 
       mpfr_neg (huge, huge, GFC_RND_MODE);
       test = gfc_conv_mpfr_to_tree (huge, expr->ts.kind, 0);
-      test = fold_build2 (GT_EXPR, boolean_type_node, tmp, test);
-      test2 = fold_build2 (TRUTH_AND_EXPR, boolean_type_node, test, test2);
+      test = fold_build2_loc (input_location, GT_EXPR, boolean_type_node, tmp,
+                             test);
+      test2 = fold_build2_loc (input_location, TRUTH_AND_EXPR,
+                              boolean_type_node, test, test2);
 
       itype = gfc_get_int_type (ikind);
       if (modulo)
@@ -1242,9 +1275,11 @@ gfc_conv_intrinsic_mod (gfc_se * se, gfc_expr * expr, int modulo)
       else
        tmp = build_fix_expr (&se->pre, tmp, itype, RND_TRUNC);
       tmp = convert (type, tmp);
-      tmp = fold_build3 (COND_EXPR, type, test2, tmp, args[0]);
-      tmp = fold_build2 (MULT_EXPR, type, tmp, args[1]);
-      se->expr = fold_build2 (MINUS_EXPR, type, args[0], tmp);
+      tmp = fold_build3_loc (input_location, COND_EXPR, type, test2, tmp,
+                            args[0]);
+      tmp = fold_build2_loc (input_location, MULT_EXPR, type, tmp, args[1]);
+      se->expr = fold_build2_loc (input_location, MINUS_EXPR, type, args[0],
+                                 tmp);
       mpfr_clear (huge);
       break;
 
@@ -1267,12 +1302,12 @@ gfc_conv_intrinsic_dim (gfc_se * se, gfc_expr * expr)
   gfc_conv_intrinsic_function_args (se, expr, args, 2);
   type = TREE_TYPE (args[0]);
 
-  val = fold_build2 (MINUS_EXPR, type, args[0], args[1]);
+  val = fold_build2_loc (input_location, MINUS_EXPR, type, args[0], args[1]);
   val = gfc_evaluate_now (val, &se->pre);
 
   zero = gfc_build_const (type, integer_zero_node);
-  tmp = fold_build2 (LE_EXPR, boolean_type_node, val, zero);
-  se->expr = fold_build3 (COND_EXPR, type, tmp, zero, val);
+  tmp = fold_build2_loc (input_location, LE_EXPR, boolean_type_node, val, zero);
+  se->expr = fold_build3_loc (input_location, COND_EXPR, type, tmp, zero, val);
 }
 
 
@@ -1304,8 +1339,10 @@ gfc_conv_intrinsic_sign (gfc_se * se, gfc_expr * expr)
        {
          tree cond, zero;
          zero = build_real_from_int_cst (TREE_TYPE (args[1]), integer_zero_node);
-         cond = fold_build2 (EQ_EXPR, boolean_type_node, args[1], zero);
-         se->expr = fold_build3 (COND_EXPR, TREE_TYPE (args[0]), cond,
+         cond = fold_build2_loc (input_location, EQ_EXPR, boolean_type_node,
+                                 args[1], zero);
+         se->expr = fold_build3_loc (input_location, COND_EXPR,
+                                 TREE_TYPE (args[0]), cond,
                                  build_call_expr_loc (input_location, abs, 1,
                                                       args[0]),
                                  build_call_expr_loc (input_location, tmp, 2,
@@ -1326,16 +1363,16 @@ gfc_conv_intrinsic_sign (gfc_se * se, gfc_expr * expr)
 
   /* Construct (A ^ B) >> 31, which generates a bit mask of all zeros if
      the signs of A and B are the same, and of all ones if they differ.  */
-  tmp = fold_build2 (BIT_XOR_EXPR, type, args[0], args[1]);
-  tmp = fold_build2 (RSHIFT_EXPR, type, tmp,
-                    build_int_cst (type, TYPE_PRECISION (type) - 1));
+  tmp = fold_build2_loc (input_location, BIT_XOR_EXPR, type, args[0], args[1]);
+  tmp = fold_build2_loc (input_location, RSHIFT_EXPR, type, tmp,
+                        build_int_cst (type, TYPE_PRECISION (type) - 1));
   tmp = gfc_evaluate_now (tmp, &se->pre);
 
   /* Construct (A + tmp) ^ tmp, which is A if tmp is zero, and -A if tmp]
      is all ones (i.e. -1).  */
-  se->expr = fold_build2 (BIT_XOR_EXPR, type,
-                         fold_build2 (PLUS_EXPR, type, args[0], tmp),
-                         tmp);
+  se->expr = fold_build2_loc (input_location, BIT_XOR_EXPR, type,
+                             fold_build2_loc (input_location, PLUS_EXPR,
+                                              type, args[0], tmp), tmp);
 }
 
 
@@ -1367,7 +1404,8 @@ gfc_conv_intrinsic_dprod (gfc_se * se, gfc_expr * expr)
   type = gfc_typenode_for_spec (&expr->ts);
   args[0] = convert (type, args[0]);
   args[1] = convert (type, args[1]);
-  se->expr = fold_build2 (MULT_EXPR, type, args[0], args[1]);
+  se->expr = fold_build2_loc (input_location, MULT_EXPR, type, args[0],
+                             args[1]);
 }
 
 
@@ -1387,7 +1425,7 @@ gfc_conv_intrinsic_char (gfc_se * se, gfc_expr * expr)
   type = gfc_get_char_type (expr->ts.kind);
   var = gfc_create_var (type, "char");
 
-  arg[0] = fold_build1 (NOP_EXPR, type, arg[0]);
+  arg[0] = fold_build1_loc (input_location, NOP_EXPR, type, arg[0]);
   gfc_add_modify (&se->pre, var, arg[0]);
   se->expr = gfc_build_addr_expr (build_pointer_type (type), var);
   se->string_length = integer_one_node;
@@ -1422,8 +1460,8 @@ gfc_conv_intrinsic_ctime (gfc_se * se, gfc_expr * expr)
   gfc_add_expr_to_block (&se->pre, tmp);
 
   /* Free the temporary afterwards, if necessary.  */
-  cond = fold_build2 (GT_EXPR, boolean_type_node,
-                     len, build_int_cst (TREE_TYPE (len), 0));
+  cond = fold_build2_loc (input_location, GT_EXPR, boolean_type_node,
+                         len, build_int_cst (TREE_TYPE (len), 0));
   tmp = gfc_call_free (var);
   tmp = build3_v (COND_EXPR, cond, tmp, build_empty_stmt (input_location));
   gfc_add_expr_to_block (&se->post, tmp);
@@ -1461,8 +1499,8 @@ gfc_conv_intrinsic_fdate (gfc_se * se, gfc_expr * expr)
   gfc_add_expr_to_block (&se->pre, tmp);
 
   /* Free the temporary afterwards, if necessary.  */
-  cond = fold_build2 (GT_EXPR, boolean_type_node,
-                     len, build_int_cst (TREE_TYPE (len), 0));
+  cond = fold_build2_loc (input_location, GT_EXPR, boolean_type_node,
+                         len, build_int_cst (TREE_TYPE (len), 0));
   tmp = gfc_call_free (var);
   tmp = build3_v (COND_EXPR, cond, tmp, build_empty_stmt (input_location));
   gfc_add_expr_to_block (&se->post, tmp);
@@ -1502,8 +1540,8 @@ gfc_conv_intrinsic_ttynam (gfc_se * se, gfc_expr * expr)
   gfc_add_expr_to_block (&se->pre, tmp);
 
   /* Free the temporary afterwards, if necessary.  */
-  cond = fold_build2 (GT_EXPR, boolean_type_node,
-                     len, build_int_cst (TREE_TYPE (len), 0));
+  cond = fold_build2_loc (input_location, GT_EXPR, boolean_type_node,
+                         len, build_int_cst (TREE_TYPE (len), 0));
   tmp = gfc_call_free (var);
   tmp = build3_v (COND_EXPR, cond, tmp, build_empty_stmt (input_location));
   gfc_add_expr_to_block (&se->post, tmp);
@@ -1580,7 +1618,8 @@ gfc_conv_intrinsic_minmax (gfc_se * se, gfc_expr * expr, enum tree_code op)
 
       thencase = build2_v (MODIFY_EXPR, mvar, convert (type, val));
 
-      tmp = fold_build2 (op, boolean_type_node, convert (type, val), mvar);
+      tmp = fold_build2_loc (input_location, op, boolean_type_node,
+                            convert (type, val), mvar);
 
       /* FIXME: When the IEEE_ARITHMETIC module is implemented, the call to
         __builtin_isnan might be made dependent on that module being loaded,
@@ -1589,8 +1628,9 @@ gfc_conv_intrinsic_minmax (gfc_se * se, gfc_expr * expr, enum tree_code op)
        {
          isnan = build_call_expr_loc (input_location,
                                   built_in_decls[BUILT_IN_ISNAN], 1, mvar);
-         tmp = fold_build2 (TRUTH_OR_EXPR, boolean_type_node, tmp,
-                            fold_convert (boolean_type_node, isnan));
+         tmp = fold_build2_loc (input_location, TRUTH_OR_EXPR,
+                                boolean_type_node, tmp,
+                                fold_convert (boolean_type_node, isnan));
        }
       tmp = build3_v (COND_EXPR, tmp, thencase,
                      build_empty_stmt (input_location));
@@ -1642,8 +1682,8 @@ gfc_conv_intrinsic_minmax_char (gfc_se * se, gfc_expr * expr, int op)
   gfc_add_expr_to_block (&se->pre, tmp);
 
   /* Free the temporary afterwards, if necessary.  */
-  cond = fold_build2 (GT_EXPR, boolean_type_node,
-                     len, build_int_cst (TREE_TYPE (len), 0));
+  cond = fold_build2_loc (input_location, GT_EXPR, boolean_type_node,
+                         len, build_int_cst (TREE_TYPE (len), 0));
   tmp = gfc_call_free (var);
   tmp = build3_v (COND_EXPR, cond, tmp, build_empty_stmt (input_location));
   gfc_add_expr_to_block (&se->post, tmp);
@@ -1841,8 +1881,8 @@ gfc_conv_intrinsic_anyall (gfc_se * se, gfc_expr * expr, enum tree_code op)
   gfc_conv_expr_val (&arrayse, actual->expr);
 
   gfc_add_block_to_block (&body, &arrayse.pre);
-  tmp = fold_build2 (op, boolean_type_node, arrayse.expr,
-                    build_int_cst (TREE_TYPE (arrayse.expr), 0));
+  tmp = fold_build2_loc (input_location, op, boolean_type_node, arrayse.expr,
+                        build_int_cst (TREE_TYPE (arrayse.expr), 0));
   tmp = build3_v (COND_EXPR, tmp, found, build_empty_stmt (input_location));
   gfc_add_expr_to_block (&body, tmp);
   gfc_add_block_to_block (&body, &arrayse.post);
@@ -1902,8 +1942,8 @@ gfc_conv_intrinsic_count (gfc_se * se, gfc_expr * expr)
   /* Generate the loop body.  */
   gfc_start_scalarized_body (&loop, &body);
 
-  tmp = fold_build2 (PLUS_EXPR, TREE_TYPE (resvar),
-                    resvar, build_int_cst (TREE_TYPE (resvar), 1));
+  tmp = fold_build2_loc (input_location, PLUS_EXPR, TREE_TYPE (resvar),
+                        resvar, build_int_cst (TREE_TYPE (resvar), 1));
   tmp = build2_v (MODIFY_EXPR, resvar, tmp);
 
   gfc_init_se (&arrayse, NULL);
@@ -2059,43 +2099,48 @@ gfc_conv_intrinsic_arith (gfc_se * se, gfc_expr * expr, enum tree_code op,
 
       absX = gfc_create_var (type, "absX");
       gfc_add_modify (&ifblock1, absX,
-                     fold_build1 (ABS_EXPR, type, arrayse.expr));
+                     fold_build1_loc (input_location, ABS_EXPR, type,
+                                      arrayse.expr));
       val = gfc_create_var (type, "val");
       gfc_add_expr_to_block (&ifblock1, val);
 
       gfc_init_block (&ifblock2);
       gfc_add_modify (&ifblock2, val,
-                     fold_build2 (RDIV_EXPR, type, scale, absX));
-      res1 = fold_build2 (MULT_EXPR, type, val, val); 
-      res1 = fold_build2 (MULT_EXPR, type, resvar, res1);
-      res1 = fold_build2 (PLUS_EXPR, type, res1,
-                         gfc_build_const (type, integer_one_node));
+                     fold_build2_loc (input_location, RDIV_EXPR, type, scale,
+                                      absX));
+      res1 = fold_build2_loc (input_location, MULT_EXPR, type, val, val); 
+      res1 = fold_build2_loc (input_location, MULT_EXPR, type, resvar, res1);
+      res1 = fold_build2_loc (input_location, PLUS_EXPR, type, res1,
+                             gfc_build_const (type, integer_one_node));
       gfc_add_modify (&ifblock2, resvar, res1);
       gfc_add_modify (&ifblock2, scale, absX);
       res1 = gfc_finish_block (&ifblock2); 
 
       gfc_init_block (&ifblock3);
       gfc_add_modify (&ifblock3, val,
-                     fold_build2 (RDIV_EXPR, type, absX, scale));
-      res2 = fold_build2 (MULT_EXPR, type, val, val); 
-      res2 = fold_build2 (PLUS_EXPR, type, resvar, res2);
+                     fold_build2_loc (input_location, RDIV_EXPR, type, absX,
+                                      scale));
+      res2 = fold_build2_loc (input_location, MULT_EXPR, type, val, val); 
+      res2 = fold_build2_loc (input_location, PLUS_EXPR, type, resvar, res2);
       gfc_add_modify (&ifblock3, resvar, res2);
       res2 = gfc_finish_block (&ifblock3);
 
-      cond = fold_build2 (GT_EXPR, boolean_type_node, absX, scale);
+      cond = fold_build2_loc (input_location, GT_EXPR, boolean_type_node,
+                             absX, scale);
       tmp = build3_v (COND_EXPR, cond, res1, res2);
       gfc_add_expr_to_block (&ifblock1, tmp);  
       tmp = gfc_finish_block (&ifblock1);
 
-      cond = fold_build2 (NE_EXPR, boolean_type_node, arrayse.expr,
-                         gfc_build_const (type, integer_zero_node));
+      cond = fold_build2_loc (input_location, NE_EXPR, boolean_type_node,
+                             arrayse.expr,
+                             gfc_build_const (type, integer_zero_node));
 
       tmp = build3_v (COND_EXPR, cond, tmp, build_empty_stmt (input_location));
       gfc_add_expr_to_block (&block, tmp);  
     }
   else
     {
-      tmp = fold_build2 (op, type, resvar, arrayse.expr);
+      tmp = fold_build2_loc (input_location, op, type, resvar, arrayse.expr);
       gfc_add_modify (&block, resvar, tmp);
     }
 
@@ -2145,7 +2190,7 @@ gfc_conv_intrinsic_arith (gfc_se * se, gfc_expr * expr, enum tree_code op,
       sqrt = gfc_builtin_decl_for_float_kind (BUILT_IN_SQRT, expr->ts.kind);
       resvar = build_call_expr_loc (input_location,
                                    sqrt, 1, resvar);
-      resvar = fold_build2 (MULT_EXPR, type, scale, resvar);
+      resvar = fold_build2_loc (input_location, MULT_EXPR, type, scale, resvar);
     }
 
   se->expr = resvar;
@@ -2213,7 +2258,8 @@ gfc_conv_intrinsic_dot_product (gfc_se * se, gfc_expr * expr)
   arrayse1.ss = arrayss1;
   gfc_conv_expr_val (&arrayse1, arrayexpr1);
   if (expr->ts.type == BT_COMPLEX)
-    arrayse1.expr = fold_build1 (CONJ_EXPR, type, arrayse1.expr);
+    arrayse1.expr = fold_build1_loc (input_location, CONJ_EXPR, type,
+                                    arrayse1.expr);
   gfc_add_block_to_block (&block, &arrayse1.pre);
 
   /* Make the tree expression for array2.  */
@@ -2226,13 +2272,15 @@ gfc_conv_intrinsic_dot_product (gfc_se * se, gfc_expr * expr)
   /* Do the actual product and sum.  */
   if (expr->ts.type == BT_LOGICAL)
     {
-      tmp = fold_build2 (TRUTH_AND_EXPR, type, arrayse1.expr, arrayse2.expr);
-      tmp = fold_build2 (TRUTH_OR_EXPR, type, resvar, tmp);
+      tmp = fold_build2_loc (input_location, TRUTH_AND_EXPR, type,
+                            arrayse1.expr, arrayse2.expr);
+      tmp = fold_build2_loc (input_location, TRUTH_OR_EXPR, type, resvar, tmp);
     }
   else
     {
-      tmp = fold_build2 (MULT_EXPR, type, arrayse1.expr, arrayse2.expr);
-      tmp = fold_build2 (PLUS_EXPR, type, resvar, tmp);
+      tmp = fold_build2_loc (input_location, MULT_EXPR, type, arrayse1.expr,
+                            arrayse2.expr);
+      tmp = fold_build2_loc (input_location, PLUS_EXPR, type, resvar, tmp);
     }
   gfc_add_modify (&block, resvar, tmp);
 
@@ -2375,8 +2423,9 @@ gfc_conv_intrinsic_minmaxloc (gfc_se * se, gfc_expr * expr, enum tree_code op)
        {
          nonempty = gfc_conv_mpz_to_tree (asize, gfc_index_integer_kind);
          mpz_clear (asize);
-         nonempty = fold_build2 (GT_EXPR, boolean_type_node, nonempty,
-                                 gfc_index_zero_node);
+         nonempty = fold_build2_loc (input_location, GT_EXPR,
+                                     boolean_type_node, nonempty,
+                                     gfc_index_zero_node);
        }
       maskss = NULL;
     }
@@ -2411,10 +2460,10 @@ gfc_conv_intrinsic_minmaxloc (gfc_se * se, gfc_expr * expr, enum tree_code op)
      -HUGE for BT_REAL and (-HUGE - 1) for BT_INTEGER; the most positive
      possible value is HUGE in both cases.  */
   if (op == GT_EXPR)
-    tmp = fold_build1 (NEGATE_EXPR, TREE_TYPE (tmp), tmp);
+    tmp = fold_build1_loc (input_location, NEGATE_EXPR, TREE_TYPE (tmp), tmp);
   if (op == GT_EXPR && expr->ts.type == BT_INTEGER)
-    tmp = fold_build2 (MINUS_EXPR, TREE_TYPE (tmp), tmp,
-                      build_int_cst (type, 1));
+    tmp = fold_build2_loc (input_location, MINUS_EXPR, TREE_TYPE (tmp), tmp,
+                          build_int_cst (type, 1));
 
   gfc_add_modify (&se->pre, limit, tmp);
 
@@ -2430,8 +2479,8 @@ gfc_conv_intrinsic_minmaxloc (gfc_se * se, gfc_expr * expr, enum tree_code op)
 
   gcc_assert (loop.dimen == 1);
   if (nonempty == NULL && maskss == NULL && loop.from[0] && loop.to[0])
-    nonempty = fold_build2 (LE_EXPR, boolean_type_node, loop.from[0],
-                           loop.to[0]);
+    nonempty = fold_build2_loc (input_location, LE_EXPR, boolean_type_node,
+                               loop.from[0], loop.to[0]);
 
   lab1 = NULL;
   lab2 = NULL;
@@ -2442,9 +2491,10 @@ gfc_conv_intrinsic_minmaxloc (gfc_se * se, gfc_expr * expr, enum tree_code op)
      the inner loop.  */
   if (nonempty != NULL && !HONOR_NANS (DECL_MODE (limit)))
     gfc_add_modify (&loop.pre, pos,
-                   fold_build3 (COND_EXPR, gfc_array_index_type,
-                                nonempty, gfc_index_one_node,
-                                gfc_index_zero_node));
+                   fold_build3_loc (input_location, COND_EXPR,
+                                    gfc_array_index_type,
+                                    nonempty, gfc_index_one_node,
+                                    gfc_index_zero_node));
   else
     {
       gfc_add_modify (&loop.pre, pos, gfc_index_zero_node);
@@ -2490,8 +2540,8 @@ gfc_conv_intrinsic_minmaxloc (gfc_se * se, gfc_expr * expr, enum tree_code op)
   /* Remember where we are.  An offset must be added to the loop
      counter to obtain the required position.  */
   if (loop.from[0])
-    tmp = fold_build2 (MINUS_EXPR, gfc_array_index_type,
-                      gfc_index_one_node, loop.from[0]);
+    tmp = fold_build2_loc (input_location, MINUS_EXPR, gfc_array_index_type,
+                          gfc_index_one_node, loop.from[0]);
   else
     tmp = gfc_index_one_node;
 
@@ -2503,19 +2553,19 @@ gfc_conv_intrinsic_minmaxloc (gfc_se * se, gfc_expr * expr, enum tree_code op)
       tree ifbody2;
 
       gfc_start_block (&ifblock2);
-      tmp = fold_build2 (PLUS_EXPR, TREE_TYPE (pos),
-                        loop.loopvar[0], offset);
+      tmp = fold_build2_loc (input_location, PLUS_EXPR, TREE_TYPE (pos),
+                            loop.loopvar[0], offset);
       gfc_add_modify (&ifblock2, pos, tmp);
       ifbody2 = gfc_finish_block (&ifblock2);
-      cond = fold_build2 (EQ_EXPR, boolean_type_node, pos,
-                         gfc_index_zero_node);
+      cond = fold_build2_loc (input_location, EQ_EXPR, boolean_type_node, pos,
+                             gfc_index_zero_node);
       tmp = build3_v (COND_EXPR, cond, ifbody2,
                      build_empty_stmt (input_location));
       gfc_add_expr_to_block (&block, tmp);
     }
 
-  tmp = fold_build2 (PLUS_EXPR, TREE_TYPE (pos),
-                    loop.loopvar[0], offset);
+  tmp = fold_build2_loc (input_location, PLUS_EXPR, TREE_TYPE (pos),
+                        loop.loopvar[0], offset);
   gfc_add_modify (&ifblock, pos, tmp);
 
   if (lab1)
@@ -2526,10 +2576,12 @@ gfc_conv_intrinsic_minmaxloc (gfc_se * se, gfc_expr * expr, enum tree_code op)
   if (!lab1 || HONOR_NANS (DECL_MODE (limit)))
     {
       if (lab1)
-       cond = fold_build2 (op == GT_EXPR ? GE_EXPR : LE_EXPR,
-                           boolean_type_node, arrayse.expr, limit);
+       cond = fold_build2_loc (input_location,
+                               op == GT_EXPR ? GE_EXPR : LE_EXPR,
+                               boolean_type_node, arrayse.expr, limit);
       else
-       cond = fold_build2 (op, boolean_type_node, arrayse.expr, limit);
+       cond = fold_build2_loc (input_location, op, boolean_type_node,
+                               arrayse.expr, limit);
 
       ifbody = build3_v (COND_EXPR, cond, ifbody,
                         build_empty_stmt (input_location));
@@ -2597,20 +2649,21 @@ gfc_conv_intrinsic_minmaxloc (gfc_se * se, gfc_expr * expr, enum tree_code op)
       /* Remember where we are.  An offset must be added to the loop
         counter to obtain the required position.  */
       if (loop.from[0])
-       tmp = fold_build2 (MINUS_EXPR, gfc_array_index_type,
-                          gfc_index_one_node, loop.from[0]);
+       tmp = fold_build2_loc (input_location, MINUS_EXPR, gfc_array_index_type,
+                              gfc_index_one_node, loop.from[0]);
       else
        tmp = gfc_index_one_node;
 
       gfc_add_modify (&block, offset, tmp);
 
-      tmp = fold_build2 (PLUS_EXPR, TREE_TYPE (pos),
-                        loop.loopvar[0], offset);
+      tmp = fold_build2_loc (input_location, PLUS_EXPR, TREE_TYPE (pos),
+                            loop.loopvar[0], offset);
       gfc_add_modify (&ifblock, pos, tmp);
 
       ifbody = gfc_finish_block (&ifblock);
 
-      cond = fold_build2 (op, boolean_type_node, arrayse.expr, limit);
+      cond = fold_build2_loc (input_location, op, boolean_type_node,
+                             arrayse.expr, limit);
 
       tmp = build3_v (COND_EXPR, cond, ifbody,
                      build_empty_stmt (input_location));
@@ -2830,14 +2883,15 @@ gfc_conv_intrinsic_minmaxval (gfc_se * se, gfc_expr * expr, enum tree_code op)
      possible value is HUGE in both cases.  */
   if (op == GT_EXPR)
     {
-      tmp = fold_build1 (NEGATE_EXPR, TREE_TYPE (tmp), tmp);
+      tmp = fold_build1_loc (input_location, NEGATE_EXPR, TREE_TYPE (tmp), tmp);
       if (huge_cst)
-       huge_cst = fold_build1 (NEGATE_EXPR, TREE_TYPE (huge_cst), huge_cst);
+       huge_cst = fold_build1_loc (input_location, NEGATE_EXPR,
+                                   TREE_TYPE (huge_cst), huge_cst);
     }
 
   if (op == GT_EXPR && expr->ts.type == BT_INTEGER)
-    tmp = fold_build2 (MINUS_EXPR, TREE_TYPE (tmp),
-                      tmp, build_int_cst (type, 1));
+    tmp = fold_build2_loc (input_location, MINUS_EXPR, TREE_TYPE (tmp),
+                          tmp, build_int_cst (type, 1));
 
   gfc_add_modify (&se->pre, limit, tmp);
 
@@ -2863,8 +2917,9 @@ gfc_conv_intrinsic_minmaxval (gfc_se * se, gfc_expr * expr, enum tree_code op)
        {
          nonempty = gfc_conv_mpz_to_tree (asize, gfc_index_integer_kind);
          mpz_clear (asize);
-         nonempty = fold_build2 (GT_EXPR, boolean_type_node, nonempty,
-                                 gfc_index_zero_node);
+         nonempty = fold_build2_loc (input_location, GT_EXPR,
+                                     boolean_type_node, nonempty,
+                                     gfc_index_zero_node);
        }
       maskss = NULL;
     }
@@ -2881,8 +2936,8 @@ gfc_conv_intrinsic_minmaxval (gfc_se * se, gfc_expr * expr, enum tree_code op)
 
   if (nonempty == NULL && maskss == NULL
       && loop.dimen == 1 && loop.from[0] && loop.to[0])
-    nonempty = fold_build2 (LE_EXPR, boolean_type_node, loop.from[0],
-                           loop.to[0]);
+    nonempty = fold_build2_loc (input_location, LE_EXPR, boolean_type_node,
+                               loop.from[0], loop.to[0]);
   nonempty_var = NULL;
   if (nonempty == NULL
       && (HONOR_INFINITIES (DECL_MODE (limit))
@@ -2942,8 +2997,8 @@ gfc_conv_intrinsic_minmaxval (gfc_se * se, gfc_expr * expr, enum tree_code op)
 
   if (HONOR_NANS (DECL_MODE (limit)))
     {
-      tmp = fold_build2 (op == GT_EXPR ? GE_EXPR : LE_EXPR,
-                        boolean_type_node, arrayse.expr, limit);
+      tmp = fold_build2_loc (input_location, op == GT_EXPR ? GE_EXPR : LE_EXPR,
+                            boolean_type_node, arrayse.expr, limit);
       if (lab)
        ifbody = build1_v (GOTO_EXPR, lab);
       else
@@ -2965,7 +3020,8 @@ gfc_conv_intrinsic_minmaxval (gfc_se * se, gfc_expr * expr, enum tree_code op)
         signed zeros.  */
       if (HONOR_SIGNED_ZEROS (DECL_MODE (limit)))
        {
-         tmp = fold_build2 (op, boolean_type_node, arrayse.expr, limit);
+         tmp = fold_build2_loc (input_location, op, boolean_type_node,
+                                arrayse.expr, limit);
          ifbody = build2_v (MODIFY_EXPR, limit, arrayse.expr);
          tmp = build3_v (COND_EXPR, tmp, ifbody,
                          build_empty_stmt (input_location));
@@ -2973,8 +3029,9 @@ gfc_conv_intrinsic_minmaxval (gfc_se * se, gfc_expr * expr, enum tree_code op)
        }
       else
        {
-         tmp = fold_build2 (op == GT_EXPR ? MAX_EXPR : MIN_EXPR,
-                            type, arrayse.expr, limit);
+         tmp = fold_build2_loc (input_location,
+                                op == GT_EXPR ? MAX_EXPR : MIN_EXPR,
+                                type, arrayse.expr, limit);
          gfc_add_modify (&block2, limit, tmp);
        }
     }
@@ -2988,15 +3045,17 @@ gfc_conv_intrinsic_minmaxval (gfc_se * se, gfc_expr * expr, enum tree_code op)
       if (HONOR_NANS (DECL_MODE (limit))
          || HONOR_SIGNED_ZEROS (DECL_MODE (limit)))
        {
-         tmp = fold_build2 (op, boolean_type_node, arrayse.expr, limit);
+         tmp = fold_build2_loc (input_location, op, boolean_type_node,
+                                arrayse.expr, limit);
          ifbody = build2_v (MODIFY_EXPR, limit, arrayse.expr);
          ifbody = build3_v (COND_EXPR, tmp, ifbody,
                             build_empty_stmt (input_location));
        }
       else
        {
-         tmp = fold_build2 (op == GT_EXPR ? MAX_EXPR : MIN_EXPR,
-                            type, arrayse.expr, limit);
+         tmp = fold_build2_loc (input_location,
+                                op == GT_EXPR ? MAX_EXPR : MIN_EXPR,
+                                type, arrayse.expr, limit);
          ifbody = build2_v (MODIFY_EXPR, limit, tmp);
        }
       tmp = build3_v (COND_EXPR, fast, ifbody, elsebody);
@@ -3018,7 +3077,8 @@ gfc_conv_intrinsic_minmaxval (gfc_se * se, gfc_expr * expr, enum tree_code op)
     {
       gfc_trans_scalarized_loop_end (&loop, 0, &body);
 
-      tmp = fold_build3 (COND_EXPR, type, nonempty, nan_cst, huge_cst);
+      tmp = fold_build3_loc (input_location, COND_EXPR, type, nonempty,
+                            nan_cst, huge_cst);
       gfc_add_modify (&loop.code[0], limit, tmp);
       gfc_add_expr_to_block (&loop.code[0], build1_v (LABEL_EXPR, lab));
 
@@ -3050,7 +3110,8 @@ gfc_conv_intrinsic_minmaxval (gfc_se * se, gfc_expr * expr, enum tree_code op)
       if (HONOR_NANS (DECL_MODE (limit))
          || HONOR_SIGNED_ZEROS (DECL_MODE (limit)))
        {
-         tmp = fold_build2 (op, boolean_type_node, arrayse.expr, limit);
+         tmp = fold_build2_loc (input_location, op, boolean_type_node,
+                                arrayse.expr, limit);
          ifbody = build2_v (MODIFY_EXPR, limit, arrayse.expr);
          tmp = build3_v (COND_EXPR, tmp, ifbody,
                          build_empty_stmt (input_location));
@@ -3058,8 +3119,9 @@ gfc_conv_intrinsic_minmaxval (gfc_se * se, gfc_expr * expr, enum tree_code op)
        }
       else
        {
-         tmp = fold_build2 (op == GT_EXPR ? MAX_EXPR : MIN_EXPR,
-                            type, arrayse.expr, limit);
+         tmp = fold_build2_loc (input_location,
+                                op == GT_EXPR ? MAX_EXPR : MIN_EXPR,
+                                type, arrayse.expr, limit);
          gfc_add_modify (&block, limit, tmp);
        }
 
@@ -3079,7 +3141,8 @@ gfc_conv_intrinsic_minmaxval (gfc_se * se, gfc_expr * expr, enum tree_code op)
 
   if (fast)
     {
-      tmp = fold_build3 (COND_EXPR, type, nonempty, nan_cst, huge_cst);
+      tmp = fold_build3_loc (input_location, COND_EXPR, type, nonempty,
+                            nan_cst, huge_cst);
       ifbody = build2_v (MODIFY_EXPR, limit, tmp);
       tmp = build3_v (COND_EXPR, fast, build_empty_stmt (input_location),
                      ifbody);
@@ -3087,7 +3150,8 @@ gfc_conv_intrinsic_minmaxval (gfc_se * se, gfc_expr * expr, enum tree_code op)
     }
   else if (HONOR_INFINITIES (DECL_MODE (limit)) && !lab)
     {
-      tmp = fold_build3 (COND_EXPR, type, nonempty, limit, huge_cst);
+      tmp = fold_build3_loc (input_location, COND_EXPR, type, nonempty, limit,
+                            huge_cst);
       gfc_add_modify (&loop.pre, limit, tmp);
     }
 
@@ -3133,10 +3197,11 @@ gfc_conv_intrinsic_btest (gfc_se * se, gfc_expr * expr)
   gfc_conv_intrinsic_function_args (se, expr, args, 2);
   type = TREE_TYPE (args[0]);
 
-  tmp = fold_build2 (LSHIFT_EXPR, type, build_int_cst (type, 1), args[1]);
-  tmp = fold_build2 (BIT_AND_EXPR, type, args[0], tmp);
-  tmp = fold_build2 (NE_EXPR, boolean_type_node, tmp,
-                    build_int_cst (type, 0));
+  tmp = fold_build2_loc (input_location, LSHIFT_EXPR, type,
+                        build_int_cst (type, 1), args[1]);
+  tmp = fold_build2_loc (input_location, BIT_AND_EXPR, type, args[0], tmp);
+  tmp = fold_build2_loc (input_location, NE_EXPR, boolean_type_node, tmp,
+                        build_int_cst (type, 0));
   type = gfc_typenode_for_spec (&expr->ts);
   se->expr = convert (type, tmp);
 }
@@ -3148,7 +3213,8 @@ gfc_conv_intrinsic_bitop (gfc_se * se, gfc_expr * expr, enum tree_code op)
   tree args[2];
 
   gfc_conv_intrinsic_function_args (se, expr, args, 2);
-  se->expr = fold_build2 (op, TREE_TYPE (args[0]), args[0], args[1]);
+  se->expr = fold_build2_loc (input_location, op, TREE_TYPE (args[0]),
+                             args[0], args[1]);
 }
 
 /* Bitwise not.  */
@@ -3158,7 +3224,8 @@ gfc_conv_intrinsic_not (gfc_se * se, gfc_expr * expr)
   tree arg;
 
   gfc_conv_intrinsic_function_args (se, expr, &arg, 1);
-  se->expr = fold_build1 (BIT_NOT_EXPR, TREE_TYPE (arg), arg);
+  se->expr = fold_build1_loc (input_location, BIT_NOT_EXPR,
+                             TREE_TYPE (arg), arg);
 }
 
 /* Set or clear a single bit.  */
@@ -3173,15 +3240,16 @@ gfc_conv_intrinsic_singlebitop (gfc_se * se, gfc_expr * expr, int set)
   gfc_conv_intrinsic_function_args (se, expr, args, 2);
   type = TREE_TYPE (args[0]);
 
-  tmp = fold_build2 (LSHIFT_EXPR, type, build_int_cst (type, 1), args[1]);
+  tmp = fold_build2_loc (input_location, LSHIFT_EXPR, type,
+                        build_int_cst (type, 1), args[1]);
   if (set)
     op = BIT_IOR_EXPR;
   else
     {
       op = BIT_AND_EXPR;
-      tmp = fold_build1 (BIT_NOT_EXPR, type, tmp);
+      tmp = fold_build1_loc (input_location, BIT_NOT_EXPR, type, tmp);
     }
-  se->expr = fold_build2 (op, type, args[0], tmp);
+  se->expr = fold_build2_loc (input_location, op, type, args[0], tmp);
 }
 
 /* Extract a sequence of bits.
@@ -3198,12 +3266,12 @@ gfc_conv_intrinsic_ibits (gfc_se * se, gfc_expr * expr)
   type = TREE_TYPE (args[0]);
 
   mask = build_int_cst (type, -1);
-  mask = fold_build2 (LSHIFT_EXPR, type, mask, args[2]);
-  mask = fold_build1 (BIT_NOT_EXPR, type, mask);
+  mask = fold_build2_loc (input_location, LSHIFT_EXPR, type, mask, args[2]);
+  mask = fold_build1_loc (input_location, BIT_NOT_EXPR, type, mask);
 
-  tmp = fold_build2 (RSHIFT_EXPR, type, args[0], args[1]);
+  tmp = fold_build2_loc (input_location, RSHIFT_EXPR, type, args[0], args[1]);
 
-  se->expr = fold_build2 (BIT_AND_EXPR, type, tmp, mask);
+  se->expr = fold_build2_loc (input_location, BIT_AND_EXPR, type, tmp, mask);
 }
 
 /* RSHIFT (I, SHIFT) = I >> SHIFT
@@ -3215,8 +3283,9 @@ gfc_conv_intrinsic_rlshift (gfc_se * se, gfc_expr * expr, int right_shift)
 
   gfc_conv_intrinsic_function_args (se, expr, args, 2);
 
-  se->expr = fold_build2 (right_shift ? RSHIFT_EXPR : LSHIFT_EXPR,
-                         TREE_TYPE (args[0]), args[0], args[1]);
+  se->expr = fold_build2_loc (input_location,
+                             right_shift ? RSHIFT_EXPR : LSHIFT_EXPR,
+                             TREE_TYPE (args[0]), args[0], args[1]);
 }
 
 /* ISHFT (I, SHIFT) = (abs (shift) >= BIT_SIZE (i))
@@ -3244,31 +3313,32 @@ gfc_conv_intrinsic_ishft (gfc_se * se, gfc_expr * expr)
   type = TREE_TYPE (args[0]);
   utype = unsigned_type_for (type);
 
-  width = fold_build1 (ABS_EXPR, TREE_TYPE (args[1]), args[1]);
+  width = fold_build1_loc (input_location, ABS_EXPR, TREE_TYPE (args[1]),
+                          args[1]);
 
   /* Left shift if positive.  */
-  lshift = fold_build2 (LSHIFT_EXPR, type, args[0], width);
+  lshift = fold_build2_loc (input_location, LSHIFT_EXPR, type, args[0], width);
 
   /* Right shift if negative.
      We convert to an unsigned type because we want a logical shift.
      The standard doesn't define the case of shifting negative
      numbers, and we try to be compatible with other compilers, most
      notably g77, here.  */
-  rshift = fold_convert (type, fold_build2 (RSHIFT_EXPR, utype, 
-                                           convert (utype, args[0]), width));
+  rshift = fold_convert (type, fold_build2_loc (input_location, RSHIFT_EXPR,
+                                   utype, convert (utype, args[0]), width));
 
-  tmp = fold_build2 (GE_EXPR, boolean_type_node, args[1],
-                    build_int_cst (TREE_TYPE (args[1]), 0));
-  tmp = fold_build3 (COND_EXPR, type, tmp, lshift, rshift);
+  tmp = fold_build2_loc (input_location, GE_EXPR, boolean_type_node, args[1],
+                        build_int_cst (TREE_TYPE (args[1]), 0));
+  tmp = fold_build3_loc (input_location, COND_EXPR, type, tmp, lshift, rshift);
 
   /* The Fortran standard allows shift widths <= BIT_SIZE(I), whereas
      gcc requires a shift width < BIT_SIZE(I), so we have to catch this
      special case.  */
   num_bits = build_int_cst (TREE_TYPE (args[1]), TYPE_PRECISION (type));
-  cond = fold_build2 (GE_EXPR, boolean_type_node, width, num_bits);
-
-  se->expr = fold_build3 (COND_EXPR, type, cond,
-                         build_int_cst (type, 0), tmp);
+  cond = fold_build2_loc (input_location, GE_EXPR, boolean_type_node, width,
+                         num_bits);
+  se->expr = fold_build3_loc (input_location, COND_EXPR, type, cond,
+                             build_int_cst (type, 0), tmp);
 }
 
 
@@ -3341,19 +3411,23 @@ gfc_conv_intrinsic_ishftc (gfc_se * se, gfc_expr * expr)
   args[1] = gfc_evaluate_now (args[1], &se->pre);
 
   /* Rotate left if positive.  */
-  lrot = fold_build2 (LROTATE_EXPR, type, args[0], args[1]);
+  lrot = fold_build2_loc (input_location, LROTATE_EXPR, type, args[0], args[1]);
 
   /* Rotate right if negative.  */
-  tmp = fold_build1 (NEGATE_EXPR, TREE_TYPE (args[1]), args[1]);
-  rrot = fold_build2 (RROTATE_EXPR, type, args[0], tmp);
+  tmp = fold_build1_loc (input_location, NEGATE_EXPR, TREE_TYPE (args[1]),
+                        args[1]);
+  rrot = fold_build2_loc (input_location,RROTATE_EXPR, type, args[0], tmp);
 
   zero = build_int_cst (TREE_TYPE (args[1]), 0);
-  tmp = fold_build2 (GT_EXPR, boolean_type_node, args[1], zero);
-  rrot = fold_build3 (COND_EXPR, type, tmp, lrot, rrot);
+  tmp = fold_build2_loc (input_location, GT_EXPR, boolean_type_node, args[1],
+                        zero);
+  rrot = fold_build3_loc (input_location, COND_EXPR, type, tmp, lrot, rrot);
 
   /* Do nothing if shift == 0.  */
-  tmp = fold_build2 (EQ_EXPR, boolean_type_node, args[1], zero);
-  se->expr = fold_build3 (COND_EXPR, type, tmp, args[0], rrot);
+  tmp = fold_build2_loc (input_location, EQ_EXPR, boolean_type_node, args[1],
+                        zero);
+  se->expr = fold_build3_loc (input_location, COND_EXPR, type, tmp, args[0],
+                             rrot);
 }
 
 /* LEADZ (i) = (i == 0) ? BIT_SIZE (i)
@@ -3416,15 +3490,16 @@ gfc_conv_intrinsic_leadz (gfc_se * se, gfc_expr * expr)
   s = TYPE_PRECISION (arg_type) - argsize;
   tmp = fold_convert (result_type, build_call_expr_loc (input_location, func,
                                                        1, arg));
-  leadz = fold_build2 (MINUS_EXPR, result_type,
-                      tmp, build_int_cst (result_type, s));
+  leadz = fold_build2_loc (input_location, MINUS_EXPR, result_type,
+                          tmp, build_int_cst (result_type, s));
 
   /* Build BIT_SIZE.  */
   bit_size = build_int_cst (result_type, argsize);
 
-  cond = fold_build2 (EQ_EXPR, boolean_type_node,
-                     arg, build_int_cst (arg_type, 0));
-  se->expr = fold_build3 (COND_EXPR, result_type, cond, bit_size, leadz);
+  cond = fold_build2_loc (input_location, EQ_EXPR, boolean_type_node,
+                         arg, build_int_cst (arg_type, 0));
+  se->expr = fold_build3_loc (input_location, COND_EXPR, result_type, cond,
+                             bit_size, leadz);
 }
 
 /* TRAILZ(i) = (i == 0) ? BIT_SIZE (i) : __builtin_ctz(i)
@@ -3485,9 +3560,10 @@ gfc_conv_intrinsic_trailz (gfc_se * se, gfc_expr *expr)
   /* Build BIT_SIZE.  */
   bit_size = build_int_cst (result_type, argsize);
 
-  cond = fold_build2 (EQ_EXPR, boolean_type_node,
-                     arg, build_int_cst (arg_type, 0));
-  se->expr = fold_build3 (COND_EXPR, result_type, cond, bit_size, trailz);
+  cond = fold_build2_loc (input_location, EQ_EXPR, boolean_type_node,
+                         arg, build_int_cst (arg_type, 0));
+  se->expr = fold_build3_loc (input_location, COND_EXPR, result_type, cond,
+                             bit_size, trailz);
 }
 
 /* Using __builtin_popcount for POPCNT and __builtin_parity for POPPAR;
@@ -3546,17 +3622,19 @@ gfc_conv_intrinsic_popcnt_poppar (gfc_se * se, gfc_expr *expr, int parity)
                                   fold_convert (long_long_unsigned_type_node,
                                                 arg));
 
-      arg2 = fold_build2 (RSHIFT_EXPR, utype, arg,
-                         build_int_cst (utype, LONG_LONG_TYPE_SIZE));
+      arg2 = fold_build2_loc (input_location, RSHIFT_EXPR, utype, arg,
+                             build_int_cst (utype, LONG_LONG_TYPE_SIZE));
       call2 = build_call_expr_loc (input_location, func, 1,
                                   fold_convert (long_long_unsigned_type_node,
                                                 arg2));
                          
       /* Combine the results.  */
       if (parity)
-       se->expr = fold_build2 (BIT_XOR_EXPR, result_type, call1, call2);
+       se->expr = fold_build2_loc (input_location, BIT_XOR_EXPR, result_type,
+                                   call1, call2);
       else
-       se->expr = fold_build2 (PLUS_EXPR, result_type, call1, call2);
+       se->expr = fold_build2_loc (input_location, PLUS_EXPR, result_type,
+                                   call1, call2);
 
       return;
     }
@@ -3767,7 +3845,7 @@ gfc_conv_intrinsic_ichar (gfc_se * se, gfc_expr * expr)
   gfc_conv_intrinsic_function_args (se, expr, args, 2);
   gcc_assert (POINTER_TYPE_P (TREE_TYPE (args[1])));
   pchartype = gfc_get_pchar_type (expr->value.function.actual->expr->ts.kind);
-  args[1] = fold_build1 (NOP_EXPR, pchartype, args[1]);
+  args[1] = fold_build1_loc (input_location, NOP_EXPR, pchartype, args[1]);
   type = gfc_typenode_for_spec (&expr->ts);
 
   se->expr = build_fold_indirect_ref_loc (input_location,
@@ -3800,8 +3878,9 @@ gfc_conv_has_intvalue (gfc_se * se, gfc_expr * expr, const int value)
   tree arg;
 
   gfc_conv_intrinsic_function_args (se, expr, &arg, 1);
-  se->expr = fold_build2 (EQ_EXPR, gfc_typenode_for_spec (&expr->ts),
-                         arg, build_int_cst (TREE_TYPE (arg), value));
+  se->expr = fold_build2_loc (input_location, EQ_EXPR,
+                             gfc_typenode_for_spec (&expr->ts),
+                             arg, build_int_cst (TREE_TYPE (arg), value));
 }
 
 
@@ -3845,8 +3924,8 @@ gfc_conv_intrinsic_merge (gfc_se * se, gfc_expr * expr)
       se->string_length = len;
     }
   type = TREE_TYPE (tsource);
-  se->expr = fold_build3 (COND_EXPR, type, mask, tsource,
-                         fold_convert (type, fsource));
+  se->expr = fold_build3_loc (input_location, COND_EXPR, type, mask, tsource,
+                             fold_convert (type, fsource));
 }
 
 
@@ -3939,17 +4018,18 @@ gfc_conv_intrinsic_spacing (gfc_se * se, gfc_expr * expr)
                             gfc_build_addr_expr (NULL_TREE, e));
   gfc_add_expr_to_block (&block, tmp);
 
-  tmp = fold_build2 (MINUS_EXPR, integer_type_node, e, prec);
-  gfc_add_modify (&block, e, fold_build2 (MAX_EXPR, integer_type_node,
-                                         tmp, emin));
+  tmp = fold_build2_loc (input_location, MINUS_EXPR, integer_type_node, e,
+                        prec);
+  gfc_add_modify (&block, e, fold_build2_loc (input_location, MAX_EXPR,
+                                             integer_type_node, tmp, emin));
 
   tmp = build_call_expr_loc (input_location, scalbn, 2,
                         build_real_from_int_cst (type, integer_one_node), e);
   gfc_add_modify (&block, res, tmp);
 
   /* Finish by building the IF statement.  */
-  cond = fold_build2 (EQ_EXPR, boolean_type_node, arg,
-                     build_real_from_int_cst (type, integer_zero_node));
+  cond = fold_build2_loc (input_location, EQ_EXPR, boolean_type_node, arg,
+                         build_real_from_int_cst (type, integer_zero_node));
   tmp = build3_v (COND_EXPR, cond, build2_v (MODIFY_EXPR, res, tiny),
                  gfc_finish_block (&block));
 
@@ -4000,14 +4080,14 @@ gfc_conv_intrinsic_rrspacing (gfc_se * se, gfc_expr * expr)
                             gfc_build_addr_expr (NULL_TREE, e));
   gfc_add_expr_to_block (&block, tmp);
 
-  tmp = fold_build2 (MINUS_EXPR, integer_type_node,
-                    build_int_cst (NULL_TREE, prec), e);
+  tmp = fold_build2_loc (input_location, MINUS_EXPR, integer_type_node,
+                        build_int_cst (NULL_TREE, prec), e);
   tmp = build_call_expr_loc (input_location, scalbn, 2, x, tmp);
   gfc_add_modify (&block, x, tmp);
   stmt = gfc_finish_block (&block);
 
-  cond = fold_build2 (NE_EXPR, boolean_type_node, x,
-                     build_real_from_int_cst (type, integer_zero_node));
+  cond = fold_build2_loc (input_location, NE_EXPR, boolean_type_node, x,
+                         build_real_from_int_cst (type, integer_zero_node));
   tmp = build3_v (COND_EXPR, cond, stmt, build_empty_stmt (input_location));
   gfc_add_expr_to_block (&se->pre, tmp);
 
@@ -4108,17 +4188,18 @@ gfc_conv_intrinsic_size (gfc_se * se, gfc_expr * expr)
          argse.data_not_needed = 1;
          gfc_conv_expr (&argse, actual->expr);
          gfc_add_block_to_block (&se->pre, &argse.pre);
-         tmp = fold_build2 (NE_EXPR, boolean_type_node,
-                            argse.expr, null_pointer_node);
+         tmp = fold_build2_loc (input_location, NE_EXPR, boolean_type_node,
+                                argse.expr, null_pointer_node);
          tmp = gfc_evaluate_now (tmp, &se->pre);
-         se->expr = fold_build3 (COND_EXPR, pvoid_type_node,
-                                 tmp, fncall1, fncall0);
+         se->expr = fold_build3_loc (input_location, COND_EXPR,
+                                     pvoid_type_node, tmp, fncall1, fncall0);
        }
       else
        {
          se->expr = NULL_TREE;
-         argse.expr = fold_build2 (MINUS_EXPR, gfc_array_index_type,
-                                   argse.expr, gfc_index_one_node);
+         argse.expr = fold_build2_loc (input_location, MINUS_EXPR,
+                                       gfc_array_index_type,
+                                       argse.expr, gfc_index_one_node);
        }
     }
   else if (expr->value.function.actual->expr->rank == 1)
@@ -4137,12 +4218,14 @@ gfc_conv_intrinsic_size (gfc_se * se, gfc_expr * expr)
                                      arg1);
       ubound = gfc_conv_descriptor_ubound_get (arg1, argse.expr);
       lbound = gfc_conv_descriptor_lbound_get (arg1, argse.expr);
-      se->expr = fold_build2 (MINUS_EXPR, gfc_array_index_type,
-                             ubound, lbound);
-      se->expr = fold_build2 (PLUS_EXPR, gfc_array_index_type, se->expr,
-                             gfc_index_one_node);
-      se->expr = fold_build2 (MAX_EXPR, gfc_array_index_type, se->expr,
-                             gfc_index_zero_node);
+      se->expr = fold_build2_loc (input_location, MINUS_EXPR,
+                                 gfc_array_index_type, ubound, lbound);
+      se->expr = fold_build2_loc (input_location, PLUS_EXPR,
+                                 gfc_array_index_type,
+                                 se->expr, gfc_index_one_node);
+      se->expr = fold_build2_loc (input_location, MAX_EXPR,
+                                 gfc_array_index_type, se->expr,
+                                 gfc_index_zero_node);
     }
 
   type = gfc_typenode_for_spec (&expr->ts);
@@ -4163,8 +4246,9 @@ size_of_string_in_bytes (int kind, tree string_length)
   bytesize = build_int_cst (gfc_array_index_type,
                            gfc_character_kinds[i].bit_size / 8);
 
-  return fold_build2 (MULT_EXPR, gfc_array_index_type, bytesize,
-                     fold_convert (gfc_array_index_type, string_length));
+  return fold_build2_loc (input_location, MULT_EXPR, gfc_array_index_type,
+                         bytesize,
+                         fold_convert (gfc_array_index_type, string_length));
 }
 
 
@@ -4225,12 +4309,12 @@ gfc_conv_intrinsic_sizeof (gfc_se *se, gfc_expr *expr)
          idx = gfc_rank_cst[n];
          lower = gfc_conv_descriptor_lbound_get (argse.expr, idx);
          upper = gfc_conv_descriptor_ubound_get (argse.expr, idx);
-         tmp = fold_build2 (MINUS_EXPR, gfc_array_index_type,
-                            upper, lower);
-         tmp = fold_build2 (PLUS_EXPR, gfc_array_index_type,
-                            tmp, gfc_index_one_node);
-         tmp = fold_build2 (MULT_EXPR, gfc_array_index_type,
-                            tmp, source_bytes);
+         tmp = fold_build2_loc (input_location, MINUS_EXPR,
+                                gfc_array_index_type, upper, lower);
+         tmp = fold_build2_loc (input_location, PLUS_EXPR,
+                                gfc_array_index_type, tmp, gfc_index_one_node);
+         tmp = fold_build2_loc (input_location, MULT_EXPR,
+                                gfc_array_index_type, tmp, source_bytes);
          gfc_add_modify (&argse.pre, source_bytes, tmp);
        }
       se->expr = source_bytes;
@@ -4285,7 +4369,8 @@ gfc_conv_intrinsic_storage_size (gfc_se *se, gfc_expr *expr)
     tmp = fold_convert (result_type, size_in_bytes (type)); 
 
 done:
-  se->expr = fold_build2 (MULT_EXPR, result_type, tmp, eight.expr);
+  se->expr = fold_build2_loc (input_location, MULT_EXPR, result_type, tmp,
+                             eight.expr);
   gfc_add_block_to_block (&se->pre, &argse.pre);
 }
 
@@ -4303,8 +4388,9 @@ gfc_conv_intrinsic_strcmp (gfc_se * se, gfc_expr * expr, enum tree_code op)
     = gfc_build_compare_string (args[0], args[1], args[2], args[3],
                                expr->value.function.actual->expr->ts.kind,
                                op);
-  se->expr = fold_build2 (op, gfc_typenode_for_spec (&expr->ts), se->expr,
-                         build_int_cst (TREE_TYPE (se->expr), 0));
+  se->expr = fold_build2_loc (input_location, op,
+                             gfc_typenode_for_spec (&expr->ts), se->expr,
+                             build_int_cst (TREE_TYPE (se->expr), 0));
 }
 
 /* Generate a call to the adjustl/adjustr library function.  */
@@ -4442,7 +4528,8 @@ gfc_conv_intrinsic_transfer (gfc_se * se, gfc_expr * expr)
          /* Clean up if it was repacked.  */
          gfc_init_block (&block);
          tmp = gfc_conv_array_data (argse.expr);
-         tmp = fold_build2 (NE_EXPR, boolean_type_node, source, tmp);
+         tmp = fold_build2_loc (input_location, NE_EXPR, boolean_type_node,
+                                source, tmp);
          tmp = build3_v (COND_EXPR, tmp, stmt,
                          build_empty_stmt (input_location));
          gfc_add_expr_to_block (&block, tmp);
@@ -4468,13 +4555,14 @@ gfc_conv_intrinsic_transfer (gfc_se * se, gfc_expr * expr)
          gfc_add_modify (&argse.pre, source_bytes, tmp);
          lower = gfc_conv_descriptor_lbound_get (argse.expr, idx);
          upper = gfc_conv_descriptor_ubound_get (argse.expr, idx);
-         tmp = fold_build2 (MINUS_EXPR, gfc_array_index_type,
-                            upper, lower);
+         tmp = fold_build2_loc (input_location, MINUS_EXPR,
+                                gfc_array_index_type, upper, lower);
          gfc_add_modify (&argse.pre, extent, tmp);
-         tmp = fold_build2 (PLUS_EXPR, gfc_array_index_type,
-                            extent, gfc_index_one_node);
-         tmp = fold_build2 (MULT_EXPR, gfc_array_index_type,
-                            tmp, source_bytes);
+         tmp = fold_build2_loc (input_location, PLUS_EXPR,
+                                gfc_array_index_type, extent,
+                                gfc_index_one_node);
+         tmp = fold_build2_loc (input_location, MULT_EXPR,
+                                gfc_array_index_type, tmp, source_bytes);
        }
     }
 
@@ -4552,15 +4640,16 @@ gfc_conv_intrinsic_transfer (gfc_se * se, gfc_expr * expr)
 
   size_bytes = gfc_create_var (gfc_array_index_type, NULL);
   if (tmp != NULL_TREE)
-    tmp = fold_build2 (MULT_EXPR, gfc_array_index_type,
-                      tmp, dest_word_len);
+    tmp = fold_build2_loc (input_location, MULT_EXPR, gfc_array_index_type,
+                          tmp, dest_word_len);
   else
     tmp = source_bytes;
 
   gfc_add_modify (&se->pre, size_bytes, tmp);
   gfc_add_modify (&se->pre, size_words,
-                      fold_build2 (CEIL_DIV_EXPR, gfc_array_index_type,
-                                   size_bytes, dest_word_len));
+                      fold_build2_loc (input_location, CEIL_DIV_EXPR,
+                                       gfc_array_index_type,
+                                       size_bytes, dest_word_len));
 
   /* Evaluate the bounds of the result.  If the loop range exists, we have
      to check if it is too large.  If so, we modify loop->to be consistent
@@ -4569,25 +4658,26 @@ gfc_conv_intrinsic_transfer (gfc_se * se, gfc_expr * expr)
   n = se->loop->order[0];
   if (se->loop->to[n] != NULL_TREE)
     {
-      tmp = fold_build2 (MINUS_EXPR, gfc_array_index_type,
-                        se->loop->to[n], se->loop->from[n]);
-      tmp = fold_build2 (PLUS_EXPR, gfc_array_index_type,
-                        tmp, gfc_index_one_node);
-      tmp = fold_build2 (MIN_EXPR, gfc_array_index_type,
+      tmp = fold_build2_loc (input_location, MINUS_EXPR, gfc_array_index_type,
+                            se->loop->to[n], se->loop->from[n]);
+      tmp = fold_build2_loc (input_location, PLUS_EXPR, gfc_array_index_type,
+                            tmp, gfc_index_one_node);
+      tmp = fold_build2_loc (input_location, MIN_EXPR, gfc_array_index_type,
                         tmp, size_words);
       gfc_add_modify (&se->pre, size_words, tmp);
       gfc_add_modify (&se->pre, size_bytes,
-                          fold_build2 (MULT_EXPR, gfc_array_index_type,
-                                       size_words, dest_word_len));
-      upper = fold_build2 (PLUS_EXPR, gfc_array_index_type,
-                          size_words, se->loop->from[n]);
-      upper = fold_build2 (MINUS_EXPR, gfc_array_index_type,
-                          upper, gfc_index_one_node);
+                          fold_build2_loc (input_location, MULT_EXPR,
+                                           gfc_array_index_type,
+                                           size_words, dest_word_len));
+      upper = fold_build2_loc (input_location, PLUS_EXPR, gfc_array_index_type,
+                              size_words, se->loop->from[n]);
+      upper = fold_build2_loc (input_location, MINUS_EXPR, gfc_array_index_type,
+                              upper, gfc_index_one_node);
     }
   else
     {
-      upper = fold_build2 (MINUS_EXPR, gfc_array_index_type,
-                          size_words, gfc_index_one_node);
+      upper = fold_build2_loc (input_location, MINUS_EXPR, gfc_array_index_type,
+                              size_words, gfc_index_one_node);
       se->loop->from[n] = gfc_index_zero_node;
     }
 
@@ -4609,8 +4699,9 @@ gfc_conv_intrinsic_transfer (gfc_se * se, gfc_expr * expr)
                         3,
                         tmp,
                         fold_convert (pvoid_type_node, source),
-                        fold_build2 (MIN_EXPR, gfc_array_index_type,
-                                     size_bytes, source_bytes));
+                        fold_build2_loc (input_location, MIN_EXPR,
+                                         gfc_array_index_type,
+                                         size_bytes, source_bytes));
   gfc_add_expr_to_block (&se->pre, tmp);
 
   se->expr = info->descriptor;
@@ -4621,10 +4712,10 @@ gfc_conv_intrinsic_transfer (gfc_se * se, gfc_expr * expr)
 
 /* Deal with scalar results.  */
 scalar_transfer:
-  extent = fold_build2 (MIN_EXPR, gfc_array_index_type,
-                       dest_word_len, source_bytes);
-  extent = fold_build2 (MAX_EXPR, gfc_array_index_type,
-                       extent, gfc_index_zero_node);
+  extent = fold_build2_loc (input_location, MIN_EXPR, gfc_array_index_type,
+                           dest_word_len, source_bytes);
+  extent = fold_build2_loc (input_location, MAX_EXPR, gfc_array_index_type,
+                           extent, gfc_index_zero_node);
 
   if (expr->ts.type == BT_CHARACTER)
     {
@@ -4657,8 +4748,8 @@ scalar_transfer:
       indirect = gfc_finish_block (&block);
 
       /* Wrap it up with the condition.  */
-      tmp = fold_build2 (LE_EXPR, boolean_type_node,
-                        dest_word_len, source_bytes);
+      tmp = fold_build2_loc (input_location, LE_EXPR, boolean_type_node,
+                            dest_word_len, source_bytes);
       tmp = build3_v (COND_EXPR, tmp, direct, indirect);
       gfc_add_expr_to_block (&se->pre, tmp);
 
@@ -4717,8 +4808,8 @@ gfc_conv_allocated (gfc_se *se, gfc_expr *expr)
       tmp = gfc_conv_descriptor_data_get (arg1se.expr);
     }
 
-  tmp = fold_build2 (NE_EXPR, boolean_type_node,
-                    tmp, fold_convert (TREE_TYPE (tmp), null_pointer_node));
+  tmp = fold_build2_loc (input_location, NE_EXPR, boolean_type_node, tmp,
+                        fold_convert (TREE_TYPE (tmp), null_pointer_node));
   se->expr = convert (gfc_typenode_for_spec (&expr->ts), tmp);
 }
 
@@ -4768,8 +4859,8 @@ gfc_conv_associated (gfc_se *se, gfc_expr *expr)
         }
       gfc_add_block_to_block (&se->pre, &arg1se.pre);
       gfc_add_block_to_block (&se->post, &arg1se.post);
-      tmp = fold_build2 (NE_EXPR, boolean_type_node, tmp2,
-                        fold_convert (TREE_TYPE (tmp2), null_pointer_node));
+      tmp = fold_build2_loc (input_location, NE_EXPR, boolean_type_node, tmp2,
+                            fold_convert (TREE_TYPE (tmp2), null_pointer_node));
       se->expr = tmp;
     }
   else
@@ -4781,9 +4872,10 @@ gfc_conv_associated (gfc_se *se, gfc_expr *expr)
 
       nonzero_charlen = NULL_TREE;
       if (arg1->expr->ts.type == BT_CHARACTER)
-       nonzero_charlen = fold_build2 (NE_EXPR, boolean_type_node,
-                                      arg1->expr->ts.u.cl->backend_decl,
-                                      integer_zero_node);
+       nonzero_charlen = fold_build2_loc (input_location, NE_EXPR,
+                                          boolean_type_node,
+                                          arg1->expr->ts.u.cl->backend_decl,
+                                          integer_zero_node);
 
       if (ss1 == gfc_ss_terminator)
         {
@@ -4795,12 +4887,12 @@ gfc_conv_associated (gfc_se *se, gfc_expr *expr)
           gfc_conv_expr (&arg2se, arg2->expr);
          gfc_add_block_to_block (&se->pre, &arg1se.pre);
          gfc_add_block_to_block (&se->post, &arg1se.post);
-          tmp = fold_build2 (EQ_EXPR, boolean_type_node,
-                            arg1se.expr, arg2se.expr);
-          tmp2 = fold_build2 (NE_EXPR, boolean_type_node,
-                             arg1se.expr, null_pointer_node);
-          se->expr = fold_build2 (TRUTH_AND_EXPR, boolean_type_node,
-                                 tmp, tmp2);
+          tmp = fold_build2_loc (input_location, EQ_EXPR, boolean_type_node,
+                                arg1se.expr, arg2se.expr);
+          tmp2 = fold_build2_loc (input_location, NE_EXPR, boolean_type_node,
+                                 arg1se.expr, null_pointer_node);
+          se->expr = fold_build2_loc (input_location, TRUTH_AND_EXPR,
+                                     boolean_type_node, tmp, tmp2);
         }
       else
         {
@@ -4810,8 +4902,9 @@ gfc_conv_associated (gfc_se *se, gfc_expr *expr)
          gfc_conv_expr_lhs (&arg1se, arg1->expr);
          tmp = gfc_conv_descriptor_stride_get (arg1se.expr,
                                            gfc_rank_cst[arg1->expr->rank - 1]);
-         nonzero_arraylen = fold_build2 (NE_EXPR, boolean_type_node, tmp,
-                                         build_int_cst (TREE_TYPE (tmp), 0));
+         nonzero_arraylen = fold_build2_loc (input_location, NE_EXPR,
+                                             boolean_type_node, tmp,
+                                             build_int_cst (TREE_TYPE (tmp), 0));
 
           /* A pointer to an array, call library function _gfor_associated.  */
           gcc_assert (ss2 != gfc_ss_terminator);
@@ -4826,15 +4919,17 @@ gfc_conv_associated (gfc_se *se, gfc_expr *expr)
                                      gfor_fndecl_associated, 2,
                                      arg1se.expr, arg2se.expr);
          se->expr = convert (boolean_type_node, se->expr);
-         se->expr = fold_build2 (TRUTH_AND_EXPR, boolean_type_node,
-                                 se->expr, nonzero_arraylen);
+         se->expr = fold_build2_loc (input_location, TRUTH_AND_EXPR,
+                                     boolean_type_node, se->expr,
+                                     nonzero_arraylen);
         }
 
       /* If target is present zero character length pointers cannot
         be associated.  */
       if (nonzero_charlen != NULL_TREE)
-       se->expr = fold_build2 (TRUTH_AND_EXPR, boolean_type_node,
-                               se->expr, nonzero_charlen);
+       se->expr = fold_build2_loc (input_location, TRUTH_AND_EXPR,
+                                   boolean_type_node,
+                                   se->expr, nonzero_charlen);
     }
 
   se->expr = convert (gfc_typenode_for_spec (&expr->ts), se->expr);
@@ -4878,8 +4973,8 @@ gfc_conv_same_type_as (gfc_se *se, gfc_expr *expr)
   gfc_conv_expr (&se1, a);
   gfc_conv_expr (&se2, b);
 
-  tmp = fold_build2 (EQ_EXPR, boolean_type_node,
-                    se1.expr, fold_convert (TREE_TYPE (se1.expr), se2.expr));
+  tmp = fold_build2_loc (input_location, EQ_EXPR, boolean_type_node,
+                        se1.expr, fold_convert (TREE_TYPE (se1.expr), se2.expr));
   se->expr = convert (gfc_typenode_for_spec (&expr->ts), tmp);
 }
 
@@ -5004,8 +5099,8 @@ gfc_conv_intrinsic_trim (gfc_se * se, gfc_expr * expr)
   gfc_add_expr_to_block (&se->pre, tmp);
 
   /* Free the temporary afterwards, if necessary.  */
-  cond = fold_build2 (GT_EXPR, boolean_type_node,
-                     len, build_int_cst (TREE_TYPE (len), 0));
+  cond = fold_build2_loc (input_location, GT_EXPR, boolean_type_node,
+                         len, build_int_cst (TREE_TYPE (len), 0));
   tmp = gfc_call_free (var);
   tmp = build3_v (COND_EXPR, cond, tmp, build_empty_stmt (input_location));
   gfc_add_expr_to_block (&se->post, tmp);
@@ -5038,8 +5133,8 @@ gfc_conv_intrinsic_repeat (gfc_se * se, gfc_expr * expr)
   ncopies_type = TREE_TYPE (ncopies);
 
   /* Check that NCOPIES is not negative.  */
-  cond = fold_build2 (LT_EXPR, boolean_type_node, ncopies,
-                     build_int_cst (ncopies_type, 0));
+  cond = fold_build2_loc (input_location, LT_EXPR, boolean_type_node, ncopies,
+                         build_int_cst (ncopies_type, 0));
   gfc_trans_runtime_check (true, false, cond, &se->pre, &expr->where,
                           "Argument NCOPIES of REPEAT intrinsic is negative "
                           "(its value is %lld)",
@@ -5048,10 +5143,10 @@ gfc_conv_intrinsic_repeat (gfc_se * se, gfc_expr * expr)
   /* If the source length is zero, any non negative value of NCOPIES
      is valid, and nothing happens.  */
   n = gfc_create_var (ncopies_type, "ncopies");
-  cond = fold_build2 (EQ_EXPR, boolean_type_node, slen,
-                     build_int_cst (size_type_node, 0));
-  tmp = fold_build3 (COND_EXPR, ncopies_type, cond,
-                    build_int_cst (ncopies_type, 0), ncopies);
+  cond = fold_build2_loc (input_location, EQ_EXPR, boolean_type_node, slen,
+                         build_int_cst (size_type_node, 0));
+  tmp = fold_build3_loc (input_location, COND_EXPR, ncopies_type, cond,
+                        build_int_cst (ncopies_type, 0), ncopies);
   gfc_add_modify (&se->pre, n, tmp);
   ncopies = n;
 
@@ -5061,24 +5156,24 @@ gfc_conv_intrinsic_repeat (gfc_se * se, gfc_expr * expr)
      case to avoid the division by zero.  */
   i = gfc_validate_kind (BT_INTEGER, gfc_charlen_int_kind, false);
   max = gfc_conv_mpz_to_tree (gfc_integer_kinds[i].huge, gfc_charlen_int_kind);
-  max = fold_build2 (TRUNC_DIV_EXPR, size_type_node,
-                    fold_convert (size_type_node, max), slen);
+  max = fold_build2_loc (input_location, TRUNC_DIV_EXPR, size_type_node,
+                         fold_convert (size_type_node, max), slen);
   largest = TYPE_PRECISION (size_type_node) > TYPE_PRECISION (ncopies_type)
              ? size_type_node : ncopies_type;
-  cond = fold_build2 (GT_EXPR, boolean_type_node,
-                     fold_convert (largest, ncopies),
-                     fold_convert (largest, max));
-  tmp = fold_build2 (EQ_EXPR, boolean_type_node, slen,
-                    build_int_cst (size_type_node, 0));
-  cond = fold_build3 (COND_EXPR, boolean_type_node, tmp, boolean_false_node,
-                     cond);
+  cond = fold_build2_loc (input_location, GT_EXPR, boolean_type_node,
+                         fold_convert (largest, ncopies),
+                         fold_convert (largest, max));
+  tmp = fold_build2_loc (input_location, EQ_EXPR, boolean_type_node, slen,
+                        build_int_cst (size_type_node, 0));
+  cond = fold_build3_loc (input_location, COND_EXPR, boolean_type_node, tmp,
+                         boolean_false_node, cond);
   gfc_trans_runtime_check (true, false, cond, &se->pre, &expr->where,
                           "Argument NCOPIES of REPEAT intrinsic is too large");
 
   /* Compute the destination length.  */
-  dlen = fold_build2 (MULT_EXPR, gfc_charlen_type_node,
-                     fold_convert (gfc_charlen_type_node, slen),
-                     fold_convert (gfc_charlen_type_node, ncopies));
+  dlen = fold_build2_loc (input_location, MULT_EXPR, gfc_charlen_type_node,
+                         fold_convert (gfc_charlen_type_node, slen),
+                         fold_convert (gfc_charlen_type_node, ncopies));
   type = gfc_get_character_type (expr->ts.kind, expr->ts.u.cl);
   dest = gfc_conv_string_tmp (se, build_pointer_type (type), dlen);
 
@@ -5094,31 +5189,34 @@ gfc_conv_intrinsic_repeat (gfc_se * se, gfc_expr * expr)
   gfc_start_block (&body);
 
   /* Exit the loop if count >= ncopies.  */
-  cond = fold_build2 (GE_EXPR, boolean_type_node, count, ncopies);
+  cond = fold_build2_loc (input_location, GE_EXPR, boolean_type_node, count,
+                         ncopies);
   tmp = build1_v (GOTO_EXPR, exit_label);
   TREE_USED (exit_label) = 1;
-  tmp = fold_build3 (COND_EXPR, void_type_node, cond, tmp,
-                    build_empty_stmt (input_location));
+  tmp = fold_build3_loc (input_location, COND_EXPR, void_type_node, cond, tmp,
+                        build_empty_stmt (input_location));
   gfc_add_expr_to_block (&body, tmp);
 
   /* Call memmove (dest + (i*slen*size), src, slen*size).  */
-  tmp = fold_build2 (MULT_EXPR, gfc_charlen_type_node,
-                    fold_convert (gfc_charlen_type_node, slen),
-                    fold_convert (gfc_charlen_type_node, count));
-  tmp = fold_build2 (MULT_EXPR, gfc_charlen_type_node,
-                    tmp, fold_convert (gfc_charlen_type_node, size));
-  tmp = fold_build2 (POINTER_PLUS_EXPR, pvoid_type_node,
-                    fold_convert (pvoid_type_node, dest),
-                    fold_convert (sizetype, tmp));
+  tmp = fold_build2_loc (input_location, MULT_EXPR, gfc_charlen_type_node,
+                        fold_convert (gfc_charlen_type_node, slen),
+                        fold_convert (gfc_charlen_type_node, count));
+  tmp = fold_build2_loc (input_location, MULT_EXPR, gfc_charlen_type_node,
+                        tmp, fold_convert (gfc_charlen_type_node, size));
+  tmp = fold_build2_loc (input_location, POINTER_PLUS_EXPR, pvoid_type_node,
+                        fold_convert (pvoid_type_node, dest),
+                        fold_convert (sizetype, tmp));
   tmp = build_call_expr_loc (input_location,
-                        built_in_decls[BUILT_IN_MEMMOVE], 3, tmp, src,
-                        fold_build2 (MULT_EXPR, size_type_node, slen,
-                                     fold_convert (size_type_node, size)));
+                            built_in_decls[BUILT_IN_MEMMOVE], 3, tmp, src,
+                            fold_build2_loc (input_location, MULT_EXPR,
+                                             size_type_node, slen,
+                                             fold_convert (size_type_node,
+                                                           size)));
   gfc_add_expr_to_block (&body, tmp);
 
   /* Increment count.  */
-  tmp = fold_build2 (PLUS_EXPR, ncopies_type,
-                    count, build_int_cst (TREE_TYPE (count), 1));
+  tmp = fold_build2_loc (input_location, PLUS_EXPR, ncopies_type,
+                        count, build_int_cst (TREE_TYPE (count), 1));
   gfc_add_modify (&body, count, tmp);
 
   /* Build the loop.  */