convert.c (convert): Replace fold (buildN (...)) with fold_buildN.

	* convert.c (convert): Replace fold (buildN (...)) with fold_buildN.
	* trans-array.c (gfc_trans_allocate_array_storage,
	gfc_trans_allocate_temp_array gfc_trans_array_constructor_value,
	gfc_conv_array_index_ref, gfc_trans_array_bound_check,
	gfc_conv_array_index_offset, gfc_conv_scalarized_array_ref,
	gfc_conv_array_ref, gfc_trans_preloop_setup, gfc_conv_ss_startstride,
	gfc_conv_loop_setup, gfc_array_init_size, gfc_trans_array_bounds,
	gfc_trans_auto_array_allocation, gfc_trans_dummy_array_bias,
	gfc_conv_expr_descriptor): Likewise.
	* trans-expr.c (gfc_conv_powi, gfc_conv_string_tmp,
	gfc_conv_concat_op, gfc_conv_expr_op): Likewise.
	* trans-intrinsic.c (build_round_expr, gfc_conv_intrinsic_bound,
	gfc_conv_intrinsic_cmplx, gfc_conv_intrinsic_sign,
	gfc_conv_intrinsic_minmaxloc, gfc_conv_intrinsic_minmaxval,
	gfc_conv_intrinsic_btest, gfc_conv_intrinsic_bitop,
	gfc_conv_intrinsic_singlebitop, gfc_conv_intrinsic_ibits,
	gfc_conv_intrinsic_ishft, gfc_conv_intrinsic_ishftc,
	gfc_conv_intrinsic_merge, prepare_arg_info,
	gfc_conv_intrinsic_rrspacing, gfc_conv_intrinsic_repeat): Likewise.
	* trans-stmt.c (gfc_trans_simple_do, gfc_trans_do, gfc_trans_do_while,
	gfc_trans_forall_loop, gfc_do_allocate, generate_loop_for_temp_to_lhs,
	generate_loop_for_rhs_to_temp, compute_inner_temp_size,
	allocate_temp_for_forall_nest, gfc_trans_pointer_assign_need_temp,
	gfc_trans_forall_1, gfc_evaluate_where_mask, gfc_trans_where_assign):
	Likewise.
	* trans-types.c (gfc_get_dtype, gfc_get_array_type_bounds): Likewise.
	* trans.c (gfc_add_modify_expr): Likewise.

From-SVN: r96926

1 files changed, 98 insertions, 98 deletions

diff --git a/gcc/fortran/trans-array.c b/gcc/fortran/trans-array.c
index b53f862..2d0bff8 100644
--- a/gcc/fortran/trans-array.c
+++ b/gcc/fortran/trans-array.c
@@ -429,8 +429,8 @@ gfc_trans_allocate_array_storage (gfc_loopinfo * loop, gfc_ss_info * info,
       if (onstack)
 	{
 	  /* Make a temporary variable to hold the data.  */
-	  tmp = fold (build2 (MINUS_EXPR, TREE_TYPE (nelem), nelem,
-			      integer_one_node));
+	  tmp = fold_build2 (MINUS_EXPR, TREE_TYPE (nelem), nelem,
+			     integer_one_node);
 	  tmp = build_range_type (gfc_array_index_type, gfc_index_zero_node,
 				  tmp);
 	  tmp = build_array_type (gfc_get_element_type (TREE_TYPE (desc)),
@@ -508,8 +508,8 @@ gfc_trans_allocate_temp_array (gfc_loopinfo * loop, gfc_ss_info * info,
 	{
 	  /* Callee allocated arrays may not have a known bound yet.  */
           if (loop->to[n])
-              loop->to[n] = fold (build2 (MINUS_EXPR, gfc_array_index_type,
-					  loop->to[n], loop->from[n]));
+              loop->to[n] = fold_build2 (MINUS_EXPR, gfc_array_index_type,
+					 loop->to[n], loop->from[n]);
 	  loop->from[n] = gfc_index_zero_node;
 	}
 
@@ -569,18 +569,18 @@ gfc_trans_allocate_temp_array (gfc_loopinfo * loop, gfc_ss_info * info,
       tmp = gfc_conv_descriptor_ubound (desc, gfc_rank_cst[n]);
       gfc_add_modify_expr (&loop->pre, tmp, loop->to[n]);
 
-      tmp = fold (build2 (PLUS_EXPR, gfc_array_index_type,
-			  loop->to[n], gfc_index_one_node));
+      tmp = fold_build2 (PLUS_EXPR, gfc_array_index_type,
+			 loop->to[n], gfc_index_one_node);
 
-      size = fold (build2 (MULT_EXPR, gfc_array_index_type, size, tmp));
+      size = fold_build2 (MULT_EXPR, gfc_array_index_type, size, tmp);
       size = gfc_evaluate_now (size, &loop->pre);
     }
 
   /* Get the size of the array.  */
   nelem = size;
   if (size)
-    size = fold (build2 (MULT_EXPR, gfc_array_index_type, size,
-			 TYPE_SIZE_UNIT (gfc_get_element_type (type))));
+    size = fold_build2 (MULT_EXPR, gfc_array_index_type, size,
+			TYPE_SIZE_UNIT (gfc_get_element_type (type)));
 
   gfc_trans_allocate_array_storage (loop, info, size, nelem);
 
@@ -765,8 +765,8 @@ gfc_trans_array_constructor_value (stmtblock_t * pblock, tree type,
 	      gfc_trans_array_ctor_element (&body, pointer, *poffset, &se,
 					    c->expr);
 
-	      *poffset = fold (build2 (PLUS_EXPR, gfc_array_index_type,
-				       *poffset, gfc_index_one_node));
+	      *poffset = fold_build2 (PLUS_EXPR, gfc_array_index_type,
+				      *poffset, gfc_index_one_node);
 	    }
 	  else
 	    {
@@ -832,8 +832,8 @@ gfc_trans_array_constructor_value (stmtblock_t * pblock, tree type,
 					     tmp);
 	      gfc_add_expr_to_block (&body, tmp);
 
-	      *poffset = fold (build2 (PLUS_EXPR, gfc_array_index_type,
-				       *poffset, bound));
+	      *poffset = fold_build2 (PLUS_EXPR, gfc_array_index_type,
+				      *poffset, bound);
 	    }
 	  if (!INTEGER_CST_P (*poffset))
             {
@@ -1399,9 +1399,9 @@ gfc_conv_array_index_ref (gfc_se * se, tree pointer, tree * indices,
     {
       /* index = index + stride[n]*indices[n] */
       tmp = gfc_conv_array_stride (se->expr, n);
-      tmp = fold (build2 (MULT_EXPR, gfc_array_index_type, indices[n], tmp));
+      tmp = fold_build2 (MULT_EXPR, gfc_array_index_type, indices[n], tmp);
 
-      index = fold (build2 (PLUS_EXPR, gfc_array_index_type, index, tmp));
+      index = fold_build2 (PLUS_EXPR, gfc_array_index_type, index, tmp);
     }
 
   /* Result = data[index].  */
@@ -1429,11 +1429,11 @@ gfc_trans_array_bound_check (gfc_se * se, tree descriptor, tree index, int n)
   index = gfc_evaluate_now (index, &se->pre);
   /* Check lower bound.  */
   tmp = gfc_conv_array_lbound (descriptor, n);
-  fault = fold (build2 (LT_EXPR, boolean_type_node, index, tmp));
+  fault = fold_build2 (LT_EXPR, boolean_type_node, index, tmp);
   /* Check upper bound.  */
   tmp = gfc_conv_array_ubound (descriptor, n);
-  cond = fold (build2 (GT_EXPR, boolean_type_node, index, tmp));
-  fault = fold (build2 (TRUTH_OR_EXPR, boolean_type_node, fault, cond));
+  cond = fold_build2 (GT_EXPR, boolean_type_node, index, tmp);
+  fault = fold_build2 (TRUTH_OR_EXPR, boolean_type_node, fault, cond);
 
   gfc_trans_runtime_check (fault, gfc_strconst_fault, &se->pre);
 
@@ -1528,10 +1528,10 @@ gfc_conv_array_index_offset (gfc_se * se, gfc_ss_info * info, int dim, int i,
 
           /* Multiply the loop variable by the stride and delta.  */
 	  index = se->loop->loopvar[i];
-	  index = fold (build2 (MULT_EXPR, gfc_array_index_type, index,
-				info->stride[i]));
-	  index = fold (build2 (PLUS_EXPR, gfc_array_index_type, index,
-				info->delta[i]));
+	  index = fold_build2 (MULT_EXPR, gfc_array_index_type, index,
+			       info->stride[i]);
+	  index = fold_build2 (PLUS_EXPR, gfc_array_index_type, index,
+			       info->delta[i]);
 
 	  if (ar->dimen_type[dim] == DIMEN_VECTOR)
 	    {
@@ -1552,12 +1552,12 @@ gfc_conv_array_index_offset (gfc_se * se, gfc_ss_info * info, int dim, int i,
       gcc_assert (se->loop);
       index = se->loop->loopvar[se->loop->order[i]];
       if (!integer_zerop (info->delta[i]))
-	index = fold (build2 (PLUS_EXPR, gfc_array_index_type,
-			      index, info->delta[i]));
+	index = fold_build2 (PLUS_EXPR, gfc_array_index_type,
+			     index, info->delta[i]);
     }
 
   /* Multiply by the stride.  */
-  index = fold (build2 (MULT_EXPR, gfc_array_index_type, index, stride));
+  index = fold_build2 (MULT_EXPR, gfc_array_index_type, index, stride);
 
   return index;
 }
@@ -1583,7 +1583,7 @@ gfc_conv_scalarized_array_ref (gfc_se * se, gfc_array_ref * ar)
 				       info->stride0);
   /* Add the offset for this dimension to the stored offset for all other
      dimensions.  */
-  index = fold (build2 (PLUS_EXPR, gfc_array_index_type, index, info->offset));
+  index = fold_build2 (PLUS_EXPR, gfc_array_index_type, index, info->offset);
 
   tmp = gfc_build_indirect_ref (info->data);
   se->expr = gfc_build_array_ref (tmp, index);
@@ -1643,25 +1643,25 @@ gfc_conv_array_ref (gfc_se * se, gfc_array_ref * ar)
 	  indexse.expr = gfc_evaluate_now (indexse.expr, &se->pre);
 
 	  tmp = gfc_conv_array_lbound (se->expr, n);
-	  cond = fold (build2 (LT_EXPR, boolean_type_node, 
-			       indexse.expr, tmp));
+	  cond = fold_build2 (LT_EXPR, boolean_type_node, 
+			      indexse.expr, tmp);
 	  fault =
-	    fold (build2 (TRUTH_OR_EXPR, boolean_type_node, fault, cond));
+	    fold_build2 (TRUTH_OR_EXPR, boolean_type_node, fault, cond);
 
 	  tmp = gfc_conv_array_ubound (se->expr, n);
-	  cond = fold (build2 (GT_EXPR, boolean_type_node, 
-			       indexse.expr, tmp));
+	  cond = fold_build2 (GT_EXPR, boolean_type_node, 
+			      indexse.expr, tmp);
 	  fault =
-	    fold (build2 (TRUTH_OR_EXPR, boolean_type_node, fault, cond));
+	    fold_build2 (TRUTH_OR_EXPR, boolean_type_node, fault, cond);
 	}
 
       /* Multiply the index by the stride.  */
       stride = gfc_conv_array_stride (se->expr, n);
-      tmp = fold (build2 (MULT_EXPR, gfc_array_index_type, indexse.expr,
-			  stride));
+      tmp = fold_build2 (MULT_EXPR, gfc_array_index_type, indexse.expr,
+			 stride);
 
       /* And add it to the total.  */
-      index = fold (build2 (PLUS_EXPR, gfc_array_index_type, index, tmp));
+      index = fold_build2 (PLUS_EXPR, gfc_array_index_type, index, tmp);
     }
 
   if (flag_bounds_check)
@@ -1669,7 +1669,7 @@ gfc_conv_array_ref (gfc_se * se, gfc_array_ref * ar)
 
   tmp = gfc_conv_array_offset (se->expr);
   if (!integer_zerop (tmp))
-    index = fold (build2 (PLUS_EXPR, gfc_array_index_type, index, tmp));
+    index = fold_build2 (PLUS_EXPR, gfc_array_index_type, index, tmp);
       
   /* Access the calculated element.  */
   tmp = gfc_conv_array_data (se->expr);
@@ -1730,8 +1730,8 @@ gfc_trans_preloop_setup (gfc_loopinfo * loop, int dim, int flag,
 						       stride);
 		  gfc_add_block_to_block (pblock, &se.pre);
 
-		  info->offset = fold (build2 (PLUS_EXPR, gfc_array_index_type,
-					       info->offset, index));
+		  info->offset = fold_build2 (PLUS_EXPR, gfc_array_index_type,
+					      info->offset, index);
 		  info->offset = gfc_evaluate_now (info->offset, pblock);
 		}
 
@@ -1769,8 +1769,8 @@ gfc_trans_preloop_setup (gfc_loopinfo * loop, int dim, int flag,
 	  index = gfc_conv_array_index_offset (&se, info, info->dim[i], i,
 					       ar, stride);
 	  gfc_add_block_to_block (pblock, &se.pre);
-	  info->offset = fold (build2 (PLUS_EXPR, gfc_array_index_type,
-				       info->offset, index));
+	  info->offset = fold_build2 (PLUS_EXPR, gfc_array_index_type,
+				      info->offset, index);
 	  info->offset = gfc_evaluate_now (info->offset, pblock);
 	}
 
@@ -2168,28 +2168,28 @@ gfc_conv_ss_startstride (gfc_loopinfo * loop)
 	      /* Check lower bound.  */
 	      bound = gfc_conv_array_lbound (desc, dim);
 	      tmp = info->start[n];
-	      tmp = fold (build2 (LT_EXPR, boolean_type_node, tmp, bound));
-	      fault = fold (build2 (TRUTH_OR_EXPR, boolean_type_node, fault,
-				    tmp));
+	      tmp = fold_build2 (LT_EXPR, boolean_type_node, tmp, bound);
+	      fault = fold_build2 (TRUTH_OR_EXPR, boolean_type_node, fault,
+				   tmp);
 
 	      /* Check the upper bound.  */
 	      bound = gfc_conv_array_ubound (desc, dim);
 	      end = gfc_conv_section_upper_bound (ss, n, &block);
-	      tmp = fold (build2 (GT_EXPR, boolean_type_node, end, bound));
-	      fault = fold (build2 (TRUTH_OR_EXPR, boolean_type_node, fault,
-				    tmp));
+	      tmp = fold_build2 (GT_EXPR, boolean_type_node, end, bound);
+	      fault = fold_build2 (TRUTH_OR_EXPR, boolean_type_node, fault,
+				   tmp);
 
 	      /* Check the section sizes match.  */
-	      tmp = fold (build2 (MINUS_EXPR, gfc_array_index_type, end,
-				  info->start[n]));
-	      tmp = fold (build2 (FLOOR_DIV_EXPR, gfc_array_index_type, tmp,
-				  info->stride[n]));
+	      tmp = fold_build2 (MINUS_EXPR, gfc_array_index_type, end,
+				 info->start[n]);
+	      tmp = fold_build2 (FLOOR_DIV_EXPR, gfc_array_index_type, tmp,
+				 info->stride[n]);
 	      /* We remember the size of the first section, and check all the
 	         others against this.  */
 	      if (size[n])
 		{
 		  tmp =
-		    fold (build2 (NE_EXPR, boolean_type_node, tmp, size[n]));
+		    fold_build2 (NE_EXPR, boolean_type_node, tmp, size[n]);
 		  fault =
 		    build2 (TRUTH_OR_EXPR, boolean_type_node, fault, tmp);
 		}
@@ -2467,10 +2467,10 @@ gfc_conv_loop_setup (gfc_loopinfo * loop)
 	  /* To = from + (size - 1) * stride.  */
 	  tmp = gfc_conv_mpz_to_tree (i, gfc_index_integer_kind);
 	  if (!integer_onep (info->stride[n]))
-	    tmp = fold (build2 (MULT_EXPR, gfc_array_index_type,
-				tmp, info->stride[n]));
-	  loop->to[n] = fold (build2 (PLUS_EXPR, gfc_array_index_type,
-				      loop->from[n], tmp));
+	    tmp = fold_build2 (MULT_EXPR, gfc_array_index_type,
+			       tmp, info->stride[n]);
+	  loop->to[n] = fold_build2 (PLUS_EXPR, gfc_array_index_type,
+				     loop->from[n], tmp);
 	}
       else
 	{
@@ -2508,10 +2508,10 @@ gfc_conv_loop_setup (gfc_loopinfo * loop)
 	     with start = 0, this simplifies to
 	     last = end / step;
 	     for (i = 0; i<=last; i++){...};  */
-	  tmp = fold (build2 (MINUS_EXPR, gfc_array_index_type,
-			      loop->to[n], loop->from[n]));
-	  tmp = fold (build2 (TRUNC_DIV_EXPR, gfc_array_index_type, 
-			      tmp, info->stride[n]));
+	  tmp = fold_build2 (MINUS_EXPR, gfc_array_index_type,
+			     loop->to[n], loop->from[n]);
+	  tmp = fold_build2 (TRUNC_DIV_EXPR, gfc_array_index_type, 
+			     tmp, info->stride[n]);
 	  loop->to[n] = gfc_evaluate_now (tmp, &loop->pre);
 	  /* Make the loop variable start at 0.  */
 	  loop->from[n] = gfc_index_zero_node;
@@ -2563,12 +2563,12 @@ gfc_conv_loop_setup (gfc_loopinfo * loop)
 	    {
 	      /* Calculate the offset relative to the loop variable.
 	         First multiply by the stride.  */
-	      tmp = fold (build2 (MULT_EXPR, gfc_array_index_type,
-				  loop->from[n], info->stride[n]));
+	      tmp = fold_build2 (MULT_EXPR, gfc_array_index_type,
+				 loop->from[n], info->stride[n]);
 
 	      /* Then subtract this from our starting value.  */
-	      tmp = fold (build2 (MINUS_EXPR, gfc_array_index_type,
-				  info->start[n], tmp));
+	      tmp = fold_build2 (MINUS_EXPR, gfc_array_index_type,
+				 info->start[n], tmp);
 
 	      info->delta[n] = gfc_evaluate_now (tmp, &loop->pre);
 	    }
@@ -2650,8 +2650,8 @@ gfc_array_init_size (tree descriptor, int rank, tree * poffset,
       gfc_add_modify_expr (pblock, tmp, se.expr);
 
       /* Work out the offset for this component.  */
-      tmp = fold (build2 (MULT_EXPR, gfc_array_index_type, se.expr, stride));
-      offset = fold (build2 (MINUS_EXPR, gfc_array_index_type, offset, tmp));
+      tmp = fold_build2 (MULT_EXPR, gfc_array_index_type, se.expr, stride);
+      offset = fold_build2 (MINUS_EXPR, gfc_array_index_type, offset, tmp);
 
       /* Start the calculation for the size of this dimension.  */
       size = build2 (MINUS_EXPR, gfc_array_index_type,
@@ -2671,17 +2671,17 @@ gfc_array_init_size (tree descriptor, int rank, tree * poffset,
       gfc_add_modify_expr (pblock, tmp, stride);
 
       /* Calculate the size of this dimension.  */
-      size = fold (build2 (PLUS_EXPR, gfc_array_index_type, se.expr, size));
+      size = fold_build2 (PLUS_EXPR, gfc_array_index_type, se.expr, size);
 
       /* Multiply the stride by the number of elements in this dimension.  */
-      stride = fold (build2 (MULT_EXPR, gfc_array_index_type, stride, size));
+      stride = fold_build2 (MULT_EXPR, gfc_array_index_type, stride, size);
       stride = gfc_evaluate_now (stride, pblock);
     }
 
   /* The stride is the number of elements in the array, so multiply by the
      size of an element to get the total size.  */
   tmp = TYPE_SIZE_UNIT (gfc_get_element_type (type));
-  size = fold (build2 (MULT_EXPR, gfc_array_index_type, stride, tmp));
+  size = fold_build2 (MULT_EXPR, gfc_array_index_type, stride, tmp);
 
   if (poffset != NULL)
     {
@@ -2957,8 +2957,8 @@ gfc_trans_array_bounds (tree type, gfc_symbol * sym, tree * poffset,
           gfc_add_modify_expr (pblock, ubound, se.expr);
         }
       /* The offset of this dimension.  offset = offset - lbound * stride.  */
-      tmp = fold (build2 (MULT_EXPR, gfc_array_index_type, lbound, size));
-      offset = fold (build2 (MINUS_EXPR, gfc_array_index_type, offset, tmp));
+      tmp = fold_build2 (MULT_EXPR, gfc_array_index_type, lbound, size);
+      offset = fold_build2 (MINUS_EXPR, gfc_array_index_type, offset, tmp);
 
       /* The size of this dimension, and the stride of the next.  */
       if (dim + 1 < as->rank)
@@ -2969,10 +2969,10 @@ gfc_trans_array_bounds (tree type, gfc_symbol * sym, tree * poffset,
       if (ubound != NULL_TREE && !(stride && INTEGER_CST_P (stride)))
         {
           /* Calculate stride = size * (ubound + 1 - lbound).  */
-          tmp = fold (build2 (MINUS_EXPR, gfc_array_index_type,
-			      gfc_index_one_node, lbound));
-          tmp = fold (build2 (PLUS_EXPR, gfc_array_index_type, ubound, tmp));
-          tmp = fold (build2 (MULT_EXPR, gfc_array_index_type, size, tmp));
+          tmp = fold_build2 (MINUS_EXPR, gfc_array_index_type,
+			     gfc_index_one_node, lbound);
+          tmp = fold_build2 (PLUS_EXPR, gfc_array_index_type, ubound, tmp);
+          tmp = fold_build2 (MULT_EXPR, gfc_array_index_type, size, tmp);
           if (stride)
             gfc_add_modify_expr (pblock, stride, tmp);
           else
@@ -3045,7 +3045,7 @@ gfc_trans_auto_array_allocation (tree decl, gfc_symbol * sym, tree fnbody)
   /* The size is the number of elements in the array, so multiply by the
      size of an element to get the total size.  */
   tmp = TYPE_SIZE_UNIT (gfc_get_element_type (type));
-  size = fold (build2 (MULT_EXPR, gfc_array_index_type, size, tmp));
+  size = fold_build2 (MULT_EXPR, gfc_array_index_type, size, tmp);
 
   /* Allocate memory to hold the data.  */
   tmp = gfc_chainon_list (NULL_TREE, size);
@@ -3203,7 +3203,7 @@ gfc_trans_dummy_array_bias (gfc_symbol * sym, tree tmpdesc, tree body)
       partial = gfc_create_var (boolean_type_node, "partial");
       TREE_USED (partial) = 1;
       tmp = gfc_conv_descriptor_stride (dumdesc, gfc_rank_cst[0]);
-      tmp = fold (build2 (EQ_EXPR, boolean_type_node, tmp, integer_one_node));
+      tmp = fold_build2 (EQ_EXPR, boolean_type_node, tmp, integer_one_node);
       gfc_add_modify_expr (&block, partial, tmp);
     }
   else
@@ -3304,11 +3304,11 @@ gfc_trans_dummy_array_bias (gfc_symbol * sym, tree tmpdesc, tree body)
 	    {
 	      /* Check (ubound(a) - lbound(a) == ubound(b) - lbound(b)).  */
 
-	      tmp = fold (build2 (MINUS_EXPR, gfc_array_index_type,
-				  ubound, lbound));
+	      tmp = fold_build2 (MINUS_EXPR, gfc_array_index_type,
+				 ubound, lbound);
               stride = build2 (MINUS_EXPR, gfc_array_index_type,
 			       dubound, dlbound);
-              tmp = fold (build2 (NE_EXPR, gfc_array_index_type, tmp, stride));
+              tmp = fold_build2 (NE_EXPR, gfc_array_index_type, tmp, stride);
 	      gfc_trans_runtime_check (tmp, gfc_strconst_bounds, &block);
 	    }
 	}
@@ -3317,12 +3317,12 @@ gfc_trans_dummy_array_bias (gfc_symbol * sym, tree tmpdesc, tree body)
 	  /* For assumed shape arrays move the upper bound by the same amount
 	     as the lower bound.  */
           tmp = build2 (MINUS_EXPR, gfc_array_index_type, dubound, dlbound);
-          tmp = fold (build2 (PLUS_EXPR, gfc_array_index_type, tmp, lbound));
+          tmp = fold_build2 (PLUS_EXPR, gfc_array_index_type, tmp, lbound);
           gfc_add_modify_expr (&block, ubound, tmp);
 	}
       /* The offset of this dimension.  offset = offset - lbound * stride.  */
-      tmp = fold (build2 (MULT_EXPR, gfc_array_index_type, lbound, stride));
-      offset = fold (build2 (MINUS_EXPR, gfc_array_index_type, offset, tmp));
+      tmp = fold_build2 (MULT_EXPR, gfc_array_index_type, lbound, stride);
+      offset = fold_build2 (MINUS_EXPR, gfc_array_index_type, offset, tmp);
 
       /* The size of this dimension, and the stride of the next.  */
       if (n + 1 < sym->as->rank)
@@ -3343,12 +3343,12 @@ gfc_trans_dummy_array_bias (gfc_symbol * sym, tree tmpdesc, tree body)
               else
                 {
                   /* Calculate stride = size * (ubound + 1 - lbound).  */
-                  tmp = fold (build2 (MINUS_EXPR, gfc_array_index_type,
-				      gfc_index_one_node, lbound));
-                  tmp = fold (build2 (PLUS_EXPR, gfc_array_index_type,
-				      ubound, tmp));
-                  size = fold (build2 (MULT_EXPR, gfc_array_index_type,
-				       size, tmp));
+                  tmp = fold_build2 (MINUS_EXPR, gfc_array_index_type,
+				     gfc_index_one_node, lbound);
+                  tmp = fold_build2 (PLUS_EXPR, gfc_array_index_type,
+				     ubound, tmp);
+                  size = fold_build2 (MULT_EXPR, gfc_array_index_type,
+				      size, tmp);
                   stmt_packed = size;
                 }
 
@@ -3759,10 +3759,10 @@ gfc_conv_expr_descriptor (gfc_se * se, gfc_expr * expr, gfc_ss * ss)
 	    }
 
 	  tmp = gfc_conv_array_lbound (desc, n);
-	  tmp = fold (build2 (MINUS_EXPR, TREE_TYPE (tmp), start, tmp));
+	  tmp = fold_build2 (MINUS_EXPR, TREE_TYPE (tmp), start, tmp);
 
-	  tmp = fold (build2 (MULT_EXPR, TREE_TYPE (tmp), tmp, stride));
-	  offset = fold (build2 (PLUS_EXPR, TREE_TYPE (tmp), offset, tmp));
+	  tmp = fold_build2 (MULT_EXPR, TREE_TYPE (tmp), tmp, stride);
+	  offset = fold_build2 (PLUS_EXPR, TREE_TYPE (tmp), offset, tmp);
 
 	  if (info->ref->u.ar.dimen_type[n] == DIMEN_ELEMENT)
 	    {
@@ -3779,9 +3779,9 @@ gfc_conv_expr_descriptor (gfc_se * se, gfc_expr * expr, gfc_ss * ss)
           if (!integer_onep (from))
 	    {
 	      /* Make sure the new section starts at 1.  */
-	      tmp = fold (build2 (MINUS_EXPR, gfc_array_index_type,
-				 gfc_index_one_node, from));
-	      to = fold (build2 (PLUS_EXPR, gfc_array_index_type, to, tmp));
+	      tmp = fold_build2 (MINUS_EXPR, gfc_array_index_type,
+				 gfc_index_one_node, from);
+	      to = fold_build2 (PLUS_EXPR, gfc_array_index_type, to, tmp);
 	      from = gfc_index_one_node;
 	    }
 	  tmp = gfc_conv_descriptor_lbound (parm, gfc_rank_cst[dim]);
@@ -3793,12 +3793,12 @@ gfc_conv_expr_descriptor (gfc_se * se, gfc_expr * expr, gfc_ss * ss)
 
 	  /* Multiply the stride by the section stride to get the
 	     total stride.  */
-	  stride = fold (build2 (MULT_EXPR, gfc_array_index_type,
-				 stride, info->stride[dim]));
+	  stride = fold_build2 (MULT_EXPR, gfc_array_index_type,
+				stride, info->stride[dim]);
 
 	  if (se->direct_byref)
-	    base = fold (build2 (MINUS_EXPR, TREE_TYPE (base),
-				 base, stride));
+	    base = fold_build2 (MINUS_EXPR, TREE_TYPE (base),
+				base, stride);
 
 	  /* Store the new stride.  */
 	  tmp = gfc_conv_descriptor_stride (parm, gfc_rank_cst[dim]);