return const0_rtx;
/* Return an offset into the constant string argument. */
- return expand_expr (fold (build (PLUS_EXPR, TREE_TYPE (s1),
- s1, convert (TREE_TYPE (s1),
- ssize_int (r - p1)))),
+ return expand_expr (fold (build (PLUS_EXPR, TREE_TYPE (s1), s1,
+ fold_convert (TREE_TYPE (s1),
+ ssize_int (r - p1)))),
target, mode, EXPAND_NORMAL);
}
return const0_rtx;
/* Return an offset into the constant string argument. */
- return expand_expr (fold (build (PLUS_EXPR, TREE_TYPE (s1),
- s1, convert (TREE_TYPE (s1),
- ssize_int (r - p1)))),
+ return expand_expr (fold (build (PLUS_EXPR, TREE_TYPE (s1), s1,
+ fold_convert (TREE_TYPE (s1),
+ ssize_int (r - p1)))),
target, mode, EXPAND_NORMAL);
}
return const0_rtx;
/* Return an offset into the constant string argument. */
- return expand_expr (fold (build (PLUS_EXPR, TREE_TYPE (s1),
- s1, convert (TREE_TYPE (s1),
- ssize_int (r - p1)))),
+ return expand_expr (fold (build (PLUS_EXPR, TREE_TYPE (s1), s1,
+ fold_convert (TREE_TYPE (s1),
+ ssize_int (r - p1)))),
target, mode, EXPAND_NORMAL);
}
return const0_rtx;
/* Return an offset into the constant string argument. */
- return expand_expr (fold (build (PLUS_EXPR, TREE_TYPE (s1),
- s1, convert (TREE_TYPE (s1),
- ssize_int (r - p1)))),
+ return expand_expr (fold (build (PLUS_EXPR, TREE_TYPE (s1), s1,
+ fold_convert (TREE_TYPE (s1),
+ ssize_int (r - p1)))),
target, mode, EXPAND_NORMAL);
}
if (endp == 2)
len = fold (build (MINUS_EXPR, TREE_TYPE (len), dest,
integer_one_node));
- len = convert (TREE_TYPE (dest), len);
+ len = fold_convert (TREE_TYPE (dest), len);
expr = fold (build (PLUS_EXPR, TREE_TYPE (dest), dest, len));
return expand_expr (expr, target, mode, EXPAND_NORMAL);
}
so that if it isn't expanded inline, we fallback to
calling bcopy instead of memmove. */
- newarglist = build_tree_list (NULL_TREE, convert (sizetype, size));
+ newarglist = build_tree_list (NULL_TREE, fold_convert (sizetype, size));
newarglist = tree_cons (NULL_TREE, src, newarglist);
newarglist = tree_cons (NULL_TREE, dest, newarglist);
so that if it isn't expanded inline, we fallback to
calling bzero instead of memset. */
- newarglist = build_tree_list (NULL_TREE, convert (sizetype, size));
+ newarglist = build_tree_list (NULL_TREE, fold_convert (sizetype, size));
newarglist = tree_cons (NULL_TREE, integer_zero_node, newarglist);
newarglist = tree_cons (NULL_TREE, dest, newarglist);
tree ind1 =
fold (build1 (CONVERT_EXPR, integer_type_node,
build1 (INDIRECT_REF, cst_uchar_node,
- build1 (NOP_EXPR, cst_uchar_ptr_node, arg1))));
+ fold_convert (cst_uchar_ptr_node, arg1))));
tree ind2 =
fold (build1 (CONVERT_EXPR, integer_type_node,
build1 (INDIRECT_REF, cst_uchar_node,
- build1 (NOP_EXPR, cst_uchar_ptr_node, arg2))));
+ fold_convert (cst_uchar_ptr_node, arg2))));
tree result = fold (build (MINUS_EXPR, integer_type_node, ind1, ind2));
return expand_expr (result, target, mode, EXPAND_NORMAL);
}
tree ind1 =
fold (build1 (CONVERT_EXPR, integer_type_node,
build1 (INDIRECT_REF, cst_uchar_node,
- build1 (NOP_EXPR, cst_uchar_ptr_node, arg1))));
+ fold_convert (cst_uchar_ptr_node, arg1))));
tree ind2 =
fold (build1 (CONVERT_EXPR, integer_type_node,
build1 (INDIRECT_REF, cst_uchar_node,
- build1 (NOP_EXPR, cst_uchar_ptr_node, arg2))));
+ fold_convert (cst_uchar_ptr_node, arg2))));
tree result = fold (build (MINUS_EXPR, integer_type_node, ind1, ind2));
return expand_expr (result, target, mode, EXPAND_NORMAL);
}
tree ind1 =
fold (build1 (CONVERT_EXPR, integer_type_node,
build1 (INDIRECT_REF, cst_uchar_node,
- build1 (NOP_EXPR, cst_uchar_ptr_node, arg1))));
+ fold_convert (cst_uchar_ptr_node, arg1))));
tree ind2 =
fold (build1 (CONVERT_EXPR, integer_type_node,
build1 (INDIRECT_REF, cst_uchar_node,
- build1 (NOP_EXPR, cst_uchar_ptr_node, arg2))));
+ fold_convert (cst_uchar_ptr_node, arg2))));
tree result = fold (build (MINUS_EXPR, integer_type_node, ind1, ind2));
return expand_expr (result, target, mode, EXPAND_NORMAL);
}
tree p2 = build_pointer_type (va_list_type_node);
valist = build1 (ADDR_EXPR, p2, valist);
- valist = fold (build1 (NOP_EXPR, p1, valist));
+ valist = fold_convert (p1, valist);
}
}
else
if (target == const0_rtx)
return const0_rtx;
exp = build_int_2 (strlen (fmt_str), 0);
- exp = fold (build1 (NOP_EXPR, integer_type_node, exp));
+ exp = fold_convert (integer_type_node, exp);
return expand_expr (exp, target, mode, EXPAND_NORMAL);
}
/* If the format is "%s", use strcpy if the result isn't used. */
&& (decl = mathfn_built_in (newtype, fcode)))
{
arglist =
- build_tree_list (NULL_TREE, fold (convert (newtype, arg0)));
- return convert (ftype,
- build_function_call_expr (decl, arglist));
+ build_tree_list (NULL_TREE, fold_convert (newtype, arg0));
+ return fold_convert (ftype,
+ build_function_call_expr (decl, arglist));
}
}
return 0;
|| fcode == BUILT_IN_EXP2F
|| fcode == BUILT_IN_EXP2L))
|| (value == &dconst10 && (BUILTIN_EXP10_P (fcode)))))
- return convert (type, TREE_VALUE (TREE_OPERAND (arg, 1)));
+ return fold_convert (type, TREE_VALUE (TREE_OPERAND (arg, 1)));
/* Optimize logN(func()) for various exponential functions. We
want to determine the value "x" and the power "exponent" in
&& (fcode == BUILT_IN_LOG10
|| fcode == BUILT_IN_LOG10F
|| fcode == BUILT_IN_LOG10L)))
- return convert (type, TREE_VALUE (TREE_OPERAND (arg, 1)));
+ return fold_convert (type, TREE_VALUE (TREE_OPERAND (arg, 1)));
}
}
/* If SRC and DEST are the same (and not volatile), return DEST+LEN. */
if (operand_equal_p (src, dest, 0))
{
- tree temp = convert (TREE_TYPE (dest), len);
- temp = fold (build (PLUS_EXPR, TREE_TYPE (dest), dest, len));
- return convert (TREE_TYPE (exp), temp);
+ tree temp = fold_convert (TREE_TYPE (dest), len);
+ temp = fold (build (PLUS_EXPR, TREE_TYPE (dest), dest, temp));
+ return fold_convert (TREE_TYPE (exp), temp);
}
return 0;
/* If SRC and DEST are the same (and not volatile), return DEST. */
if (operand_equal_p (src, dest, 0))
- return convert (TREE_TYPE (exp), dest);
+ return fold_convert (TREE_TYPE (exp), dest);
return 0;
}
/* If ARG1 and ARG2 are the same (and not volatile), return zero. */
if (operand_equal_p (arg1, arg2, 0))
- return convert (TREE_TYPE (exp), integer_zero_node);
+ return fold_convert (TREE_TYPE (exp), integer_zero_node);
p1 = c_getstr (arg1);
p2 = c_getstr (arg2);
temp = integer_one_node;
else
temp = integer_zero_node;
- return convert (TREE_TYPE (exp), temp);
+ return fold_convert (TREE_TYPE (exp), temp);
}
return 0;
temp = integer_one_node;
else
temp = integer_zero_node;
- return convert (TREE_TYPE (exp), temp);
+ return fold_convert (TREE_TYPE (exp), temp);
}
return 0;
c = TREE_REAL_CST (arg);
temp = REAL_VALUE_NEGATIVE (c) ? integer_one_node : integer_zero_node;
- return convert (TREE_TYPE (exp), temp);
+ return fold_convert (TREE_TYPE (exp), temp);
}
/* If ARG is non-negative, the result is always zero. */
/* Transform isdigit(c) -> (unsigned)(c) - '0' <= 9. */
/* According to the C standard, isdigit is unaffected by locale. */
tree arg = TREE_VALUE (arglist);
- arg = build1 (NOP_EXPR, unsigned_type_node, arg);
+ arg = fold_convert (unsigned_type_node, arg);
arg = build (MINUS_EXPR, unsigned_type_node, arg,
- fold (build1 (NOP_EXPR, unsigned_type_node,
- build_int_2 (TARGET_DIGIT0, 0))));
+ fold_convert (unsigned_type_node,
+ build_int_2 (TARGET_DIGIT0, 0)));
arg = build (LE_EXPR, integer_type_node, arg,
- fold (build1 (NOP_EXPR, unsigned_type_node,
- build_int_2 (9, 0))));
+ fold_convert (unsigned_type_node, build_int_2 (9, 0)));
return fold (arg);
}
}
{
/* Convert from the internal "sizetype" type to "size_t". */
if (size_type_node)
- len = convert (size_type_node, len);
+ len = fold_convert (size_type_node, len);
return len;
}
}