else
{
tree s1 = TREE_VALUE (arglist), s2 = TREE_VALUE (TREE_CHAIN (arglist));
- tree fn;
+ tree fn, tmp;
const char *p1, *p2;
p2 = c_getstr (s2);
return const0_rtx;
/* Return an offset into the constant string argument. */
- return expand_expr (fold (build (PLUS_EXPR, TREE_TYPE (s1), s1,
- fold_convert (TREE_TYPE (s1),
- ssize_int (r - p1)))),
- target, mode, EXPAND_NORMAL);
+ tmp = fold (build2 (PLUS_EXPR, TREE_TYPE (s1), s1,
+ fold_convert (TREE_TYPE (s1),
+ ssize_int (r - p1))));
+ return expand_expr (tmp, target, mode, EXPAND_NORMAL);
}
if (p2[0] == '\0')
{
char c;
const char *r;
+ tree tmp;
if (target_char_cast (s2, &c))
return 0;
return const0_rtx;
/* Return an offset into the constant string argument. */
- return expand_expr (fold (build (PLUS_EXPR, TREE_TYPE (s1), s1,
- fold_convert (TREE_TYPE (s1),
- ssize_int (r - p1)))),
- target, mode, EXPAND_NORMAL);
+ tmp = fold (build2 (PLUS_EXPR, TREE_TYPE (s1), s1,
+ fold_convert (TREE_TYPE (s1),
+ ssize_int (r - p1))));
+ return expand_expr (tmp, target, mode, EXPAND_NORMAL);
}
/* FIXME: Should use here strchrM optab so that ports can optimize
else
{
tree s1 = TREE_VALUE (arglist), s2 = TREE_VALUE (TREE_CHAIN (arglist));
- tree fn;
+ tree fn, tmp;
const char *p1;
if (TREE_CODE (s2) != INTEGER_CST)
return const0_rtx;
/* Return an offset into the constant string argument. */
- return expand_expr (fold (build (PLUS_EXPR, TREE_TYPE (s1), s1,
- fold_convert (TREE_TYPE (s1),
- ssize_int (r - p1)))),
- target, mode, EXPAND_NORMAL);
+ tmp = fold (build2 (PLUS_EXPR, TREE_TYPE (s1), s1,
+ fold_convert (TREE_TYPE (s1),
+ ssize_int (r - p1))));
+ return expand_expr (tmp, target, mode, EXPAND_NORMAL);
}
if (! integer_zerop (s2))
else
{
tree s1 = TREE_VALUE (arglist), s2 = TREE_VALUE (TREE_CHAIN (arglist));
- tree fn;
+ tree fn, tmp;
const char *p1, *p2;
p2 = c_getstr (s2);
return const0_rtx;
/* Return an offset into the constant string argument. */
- return expand_expr (fold (build (PLUS_EXPR, TREE_TYPE (s1), s1,
- fold_convert (TREE_TYPE (s1),
- ssize_int (r - p1)))),
- target, mode, EXPAND_NORMAL);
+ tmp = fold (build2 (PLUS_EXPR, TREE_TYPE (s1), s1,
+ fold_convert (TREE_TYPE (s1),
+ ssize_int (r - p1))));
+ return expand_expr (tmp, target, mode, EXPAND_NORMAL);
}
if (p2[0] == '\0')
}
if (endp == 2)
- len = fold (build (MINUS_EXPR, TREE_TYPE (len), dest,
- integer_one_node));
+ len = fold (build2 (MINUS_EXPR, TREE_TYPE (len), len,
+ integer_one_node));
len = fold_convert (TREE_TYPE (dest), len);
- expr = fold (build (PLUS_EXPR, TREE_TYPE (dest), dest, len));
+ expr = fold (build2 (PLUS_EXPR, TREE_TYPE (dest), dest, len));
return expand_expr (expr, target, mode, EXPAND_NORMAL);
}
fold (build1 (CONVERT_EXPR, integer_type_node,
build1 (INDIRECT_REF, cst_uchar_node,
fold_convert (cst_uchar_ptr_node, arg2))));
- tree result = fold (build (MINUS_EXPR, integer_type_node, ind1, ind2));
+ tree result = fold (build2 (MINUS_EXPR, integer_type_node, ind1, ind2));
return expand_expr (result, target, mode, EXPAND_NORMAL);
}
fold (build1 (CONVERT_EXPR, integer_type_node,
build1 (INDIRECT_REF, cst_uchar_node,
fold_convert (cst_uchar_ptr_node, arg2))));
- tree result = fold (build (MINUS_EXPR, integer_type_node, ind1, ind2));
+ tree result = fold (build2 (MINUS_EXPR, integer_type_node, ind1, ind2));
return expand_expr (result, target, mode, EXPAND_NORMAL);
}
fold (build1 (CONVERT_EXPR, integer_type_node,
build1 (INDIRECT_REF, cst_uchar_node,
fold_convert (cst_uchar_ptr_node, arg2))));
- tree result = fold (build (MINUS_EXPR, integer_type_node, ind1, ind2));
+ tree result = fold (build2 (MINUS_EXPR, integer_type_node, ind1, ind2));
return expand_expr (result, target, mode, EXPAND_NORMAL);
}
return 0;
/* The actual new length parameter is MIN(len,arg3). */
- len = fold (build (MIN_EXPR, TREE_TYPE (len), len, arg3));
+ len = fold (build2 (MIN_EXPR, TREE_TYPE (len), len, arg3));
/* If we don't have POINTER_TYPE, call the function. */
if (arg1_align == 0 || arg2_align == 0)
build_tree_list (NULL_TREE,
dst)));
/* Create (dst + strlen (dst)). */
- newdst = fold (build (PLUS_EXPR, TREE_TYPE (dst), dst, newdst));
+ newdst = fold (build2 (PLUS_EXPR, TREE_TYPE (dst), dst, newdst));
/* Prepend the new dst argument. */
arglist = tree_cons (NULL_TREE, newdst, arglist);
{
tree t;
- t = build (MODIFY_EXPR, TREE_TYPE (valist), valist,
- make_tree (ptr_type_node, nextarg));
+ t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist,
+ make_tree (ptr_type_node, nextarg));
TREE_SIDE_EFFECTS (t) = 1;
expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
{
if (!PAD_VARARGS_DOWN)
{
- t = build (MODIFY_EXPR, TREE_TYPE (valist), valist,
- build (PLUS_EXPR, TREE_TYPE (valist), valist,
- build_int_2 (boundary / BITS_PER_UNIT - 1, 0)));
+ t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist,
+ build2 (PLUS_EXPR, TREE_TYPE (valist), valist,
+ build_int_2 (boundary / BITS_PER_UNIT - 1, 0)));
TREE_SIDE_EFFECTS (t) = 1;
expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
}
- t = build (MODIFY_EXPR, TREE_TYPE (valist), valist,
- build (BIT_AND_EXPR, TREE_TYPE (valist), valist,
- build_int_2 (~(boundary / BITS_PER_UNIT - 1), -1)));
+ t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist,
+ build2 (BIT_AND_EXPR, TREE_TYPE (valist), valist,
+ build_int_2 (~(boundary / BITS_PER_UNIT - 1), -1)));
TREE_SIDE_EFFECTS (t) = 1;
expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
}
|| TREE_OVERFLOW (type_size))
rounded_size = size_zero_node;
else
- rounded_size = fold (build (MULT_EXPR, sizetype,
- fold (build (TRUNC_DIV_EXPR, sizetype,
- fold (build (PLUS_EXPR, sizetype,
- type_size, alignm1)),
- align)),
- align));
+ {
+ rounded_size = fold (build2 (PLUS_EXPR, sizetype, type_size, alignm1));
+ rounded_size = fold (build2 (TRUNC_DIV_EXPR, sizetype,
+ rounded_size, align));
+ rounded_size = fold (build2 (MULT_EXPR, sizetype,
+ rounded_size, align));
+ }
/* Get AP. */
addr_tree = valist;
if (PAD_VARARGS_DOWN && ! integer_zerop (rounded_size))
{
/* Small args are padded downward. */
- addr_tree = fold (build (PLUS_EXPR, TREE_TYPE (addr_tree), addr_tree,
- fold (build (COND_EXPR, sizetype,
- fold (build (GT_EXPR, sizetype,
- rounded_size,
- align)),
- size_zero_node,
- fold (build (MINUS_EXPR, sizetype,
- rounded_size,
- type_size))))));
+ addr_tree = fold (build2 (PLUS_EXPR, TREE_TYPE (addr_tree), addr_tree,
+ fold (build3 (COND_EXPR, sizetype,
+ fold (build2 (GT_EXPR, sizetype,
+ rounded_size,
+ align)),
+ size_zero_node,
+ fold (build2 (MINUS_EXPR,
+ sizetype,
+ rounded_size,
+ type_size))))));
}
addr = expand_expr (addr_tree, NULL_RTX, Pmode, EXPAND_NORMAL);
/* Compute new value for AP. */
if (! integer_zerop (rounded_size))
{
- t = build (MODIFY_EXPR, TREE_TYPE (valist), valist,
- build (PLUS_EXPR, TREE_TYPE (valist), valist,
- rounded_size));
+ t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist,
+ build2 (PLUS_EXPR, TREE_TYPE (valist), valist,
+ rounded_size));
TREE_SIDE_EFFECTS (t) = 1;
expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
}
if (TREE_CODE (va_list_type_node) != ARRAY_TYPE)
{
- t = build (MODIFY_EXPR, va_list_type_node, dst, src);
+ t = build2 (MODIFY_EXPR, va_list_type_node, dst, src);
TREE_SIDE_EFFECTS (t) = 1;
expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
}
if (fmt->has_signed_zero && HONOR_SIGNED_ZEROS (fmode))
return 0;
- arg = fold (build (LT_EXPR, TREE_TYPE (exp), arg,
- build_real (TREE_TYPE (arg), dconst0)));
+ arg = fold (build2 (LT_EXPR, TREE_TYPE (exp), arg,
+ build_real (TREE_TYPE (arg), dconst0)));
return expand_expr (arg, target, VOIDmode, EXPAND_NORMAL);
}
rpart = builtin_save_expr (rpart);
ipart = builtin_save_expr (ipart);
- result = fold (build (PLUS_EXPR, type,
- fold (build (MULT_EXPR, type,
- rpart, rpart)),
- fold (build (MULT_EXPR, type,
- ipart, ipart))));
+ result = fold (build2 (PLUS_EXPR, type,
+ fold (build2 (MULT_EXPR, type,
+ rpart, rpart)),
+ fold (build2 (MULT_EXPR, type,
+ ipart, ipart))));
arglist = build_tree_list (NULL_TREE, result);
return build_function_call_expr (sqrtfn, arglist);
tree logfn;
arglist = build_tree_list (NULL_TREE, x);
logfn = build_function_call_expr (fndecl, arglist);
- return fold (build (MULT_EXPR, type, exponent, logfn));
+ return fold (build2 (MULT_EXPR, type, exponent, logfn));
}
}
}
if (operand_equal_p (src, dest, 0))
{
tree temp = fold_convert (TREE_TYPE (dest), len);
- temp = fold (build (PLUS_EXPR, TREE_TYPE (dest), dest, temp));
+ temp = fold (build2 (PLUS_EXPR, TREE_TYPE (dest), dest, temp));
return fold_convert (TREE_TYPE (exp), temp);
}
/* If ARG's format doesn't have signed zeros, return "arg < 0.0". */
if (!HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg))))
- return fold (build (LT_EXPR, TREE_TYPE (exp), arg,
- build_real (TREE_TYPE (arg), dconst0)));
+ return fold (build2 (LT_EXPR, TREE_TYPE (exp), arg,
+ build_real (TREE_TYPE (arg), dconst0)));
return NULL_TREE;
}
/* Transform isascii(c) -> ((c & ~0x7f) == 0). */
tree arg = TREE_VALUE (arglist);
- arg = fold (build (EQ_EXPR, integer_type_node,
- build (BIT_AND_EXPR, integer_type_node, arg,
- build_int_2 (~ (unsigned HOST_WIDE_INT) 0x7f,
- ~ (HOST_WIDE_INT) 0)),
- integer_zero_node));
+ arg = fold (build2 (EQ_EXPR, integer_type_node,
+ build2 (BIT_AND_EXPR, integer_type_node, arg,
+ build_int_2 (~ (unsigned HOST_WIDE_INT) 0x7f,
+ ~ (HOST_WIDE_INT) 0)),
+ integer_zero_node));
if (in_gimple_form && !TREE_CONSTANT (arg))
return NULL_TREE;
/* Transform toascii(c) -> (c & 0x7f). */
tree arg = TREE_VALUE (arglist);
- return fold (build (BIT_AND_EXPR, integer_type_node, arg,
- build_int_2 (0x7f, 0)));
+ return fold (build2 (BIT_AND_EXPR, integer_type_node, arg,
+ build_int_2 (0x7f, 0)));
}
}
/* According to the C standard, isdigit is unaffected by locale. */
tree arg = TREE_VALUE (arglist);
arg = fold_convert (unsigned_type_node, arg);
- arg = build (MINUS_EXPR, unsigned_type_node, arg,
- fold_convert (unsigned_type_node,
- build_int_2 (TARGET_DIGIT0, 0)));
- arg = build (LE_EXPR, integer_type_node, arg,
- fold_convert (unsigned_type_node, build_int_2 (9, 0)));
+ arg = build2 (MINUS_EXPR, unsigned_type_node, arg,
+ fold_convert (unsigned_type_node,
+ build_int_2 (TARGET_DIGIT0, 0)));
+ arg = build2 (LE_EXPR, integer_type_node, arg,
+ fold_convert (unsigned_type_node, build_int_2 (9, 0)));
arg = fold (arg);
if (in_gimple_form && !TREE_CONSTANT (arg))
return NULL_TREE;
if (flag_unsafe_math_optimizations && BUILTIN_EXPONENT_P (fcode))
{
tree expfn = TREE_OPERAND (TREE_OPERAND (arg, 0), 0);
- arg = fold (build (MULT_EXPR, type,
- TREE_VALUE (TREE_OPERAND (arg, 1)),
- build_real (type, dconsthalf)));
+ arg = fold (build2 (MULT_EXPR, type,
+ TREE_VALUE (TREE_OPERAND (arg, 1)),
+ build_real (type, dconsthalf)));
arglist = build_tree_list (NULL_TREE, arg);
return build_function_call_expr (expfn, arglist);
}
tree powfn = TREE_OPERAND (TREE_OPERAND (arg, 0), 0);
tree arg0 = TREE_VALUE (TREE_OPERAND (arg, 1));
tree arg1 = TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg, 1)));
- tree narg1 = fold (build (MULT_EXPR, type, arg1,
- build_real (type, dconsthalf)));
+ tree narg1 = fold (build2 (MULT_EXPR, type, arg1,
+ build_real (type, dconsthalf)));
arglist = tree_cons (NULL_TREE, arg0,
build_tree_list (NULL_TREE, narg1));
return build_function_call_expr (powfn, arglist);
tree expfn = TREE_OPERAND (TREE_OPERAND (arg, 0), 0);
const REAL_VALUE_TYPE third_trunc =
real_value_truncate (TYPE_MODE (type), dconstthird);
- arg = fold (build (MULT_EXPR, type,
- TREE_VALUE (TREE_OPERAND (arg, 1)),
- build_real (type, third_trunc)));
+ arg = fold (build2 (MULT_EXPR, type,
+ TREE_VALUE (TREE_OPERAND (arg, 1)),
+ build_real (type, third_trunc)));
arglist = build_tree_list (NULL_TREE, arg);
return build_function_call_expr (expfn, arglist);
}
/* Optimize pow(x,-1.0) = 1.0/x. */
if (REAL_VALUES_EQUAL (c, dconstm1))
- return fold (build (RDIV_EXPR, type,
- build_real (type, dconst1),
- arg0));
+ return fold (build2 (RDIV_EXPR, type,
+ build_real (type, dconst1), arg0));
/* Optimize pow(x,0.5) = sqrt(x). */
if (flag_unsafe_math_optimizations
{
tree expfn = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
tree arg = TREE_VALUE (TREE_OPERAND (arg0, 1));
- arg = fold (build (MULT_EXPR, type, arg, arg1));
+ arg = fold (build2 (MULT_EXPR, type, arg, arg1));
arglist = build_tree_list (NULL_TREE, arg);
return build_function_call_expr (expfn, arglist);
}
if (flag_unsafe_math_optimizations && BUILTIN_SQRT_P (fcode))
{
tree narg0 = TREE_VALUE (TREE_OPERAND (arg0, 1));
- tree narg1 = fold (build (MULT_EXPR, type, arg1,
- build_real (type, dconsthalf)));
+ tree narg1 = fold (build2 (MULT_EXPR, type, arg1,
+ build_real (type, dconsthalf)));
arglist = tree_cons (NULL_TREE, narg0,
build_tree_list (NULL_TREE, narg1));
{
tree arg00 = TREE_VALUE (TREE_OPERAND (arg0, 1));
tree arg01 = TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg0, 1)));
- tree narg1 = fold (build (MULT_EXPR, type, arg01, arg1));
+ tree narg1 = fold (build2 (MULT_EXPR, type, arg01, arg1));
arglist = tree_cons (NULL_TREE, arg00,
build_tree_list (NULL_TREE, narg1));
return build_function_call_expr (fndecl, arglist);
tree call_expr;
call_expr = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (fn)), fn);
- call_expr = build (CALL_EXPR, TREE_TYPE (TREE_TYPE (fn)),
- call_expr, arglist, NULL_TREE);
+ call_expr = build3 (CALL_EXPR, TREE_TYPE (TREE_TYPE (fn)),
+ call_expr, arglist, NULL_TREE);
return fold (call_expr);
}
return fold_convert (TREE_TYPE (s1), integer_zero_node);
/* Return an offset into the constant string argument. */
- return fold (build (PLUS_EXPR, TREE_TYPE (s1),
- s1, fold_convert (TREE_TYPE (s1),
- ssize_int (r - p1))));
+ return fold (build2 (PLUS_EXPR, TREE_TYPE (s1),
+ s1, fold_convert (TREE_TYPE (s1),
+ ssize_int (r - p1))));
}
/* FIXME: Should use here strchrM optab so that ports can optimize
return fold_convert (TREE_TYPE (s1), integer_zero_node);
/* Return an offset into the constant string argument. */
- return fold (build (PLUS_EXPR, TREE_TYPE (s1),
- s1, fold_convert (TREE_TYPE (s1),
- ssize_int (r - p1))));
+ return fold (build2 (PLUS_EXPR, TREE_TYPE (s1),
+ s1, fold_convert (TREE_TYPE (s1),
+ ssize_int (r - p1))));
}
if (! integer_zerop (s2))
return fold_convert (TREE_TYPE (s1), integer_zero_node);
/* Return an offset into the constant string argument. */
- return fold (build (PLUS_EXPR, TREE_TYPE (s1),
- s1, fold_convert (TREE_TYPE (s1),
- ssize_int (r - p1))));
+ return fold (build2 (PLUS_EXPR, TREE_TYPE (s1),
+ s1, fold_convert (TREE_TYPE (s1),
+ ssize_int (r - p1))));
}
if (p2[0] == '\0')
- {
- /* strpbrk(x, "") == NULL.
- Evaluate and ignore the arguments in case they had
- side-effects. */
- return build (COMPOUND_EXPR, integer_type_node, s1,
- integer_zero_node);
- }
+ /* strpbrk(x, "") == NULL.
+ Evaluate and ignore s1 in case it had side-effects. */
+ return omit_one_operand (TREE_TYPE (s1), integer_zero_node, s1);
if (p2[1] != '\0')
return 0; /* Really call strpbrk. */
/* If the len parameter is zero, return the dst parameter. */
if (integer_zerop (len))
- {
- /* Evaluate and ignore the src argument in case it has
- side-effects and return the dst parameter. */
- return build (COMPOUND_EXPR, TREE_TYPE (TREE_VALUE (arglist)),
- TREE_VALUE (TREE_CHAIN (arglist)),
- TREE_VALUE (arglist));
- }
+ /* Evaluate and ignore the src argument in case it has
+ side-effects and return the dst parameter. */
+ return omit_one_operand (TREE_TYPE (TREE_VALUE (arglist)),
+ TREE_VALUE (arglist),
+ TREE_VALUE (TREE_CHAIN (arglist)));
if (!slen)
slen = c_strlen (TREE_VALUE (TREE_CHAIN (arglist)), 0);
{
/* Evaluate and ignore arg1 and arg2 in case they have
side-effects. */
- return build (COMPOUND_EXPR, integer_type_node, arg1,
- build (COMPOUND_EXPR, integer_type_node,
- arg2, integer_zero_node));
+ return build2 (COMPOUND_EXPR, integer_type_node, arg1,
+ build2 (COMPOUND_EXPR, integer_type_node,
+ arg2, integer_zero_node));
}
p1 = c_getstr (arg1);
fold (build1 (CONVERT_EXPR, integer_type_node,
build1 (INDIRECT_REF, cst_uchar_node,
build1 (NOP_EXPR, cst_uchar_ptr_node, arg2))));
- return fold (build (MINUS_EXPR, integer_type_node, ind1, ind2));
+ return fold (build2 (MINUS_EXPR, integer_type_node, ind1, ind2));
}
return 0;
fold (build1 (CONVERT_EXPR, integer_type_node,
build1 (INDIRECT_REF, cst_uchar_node,
build1 (NOP_EXPR, cst_uchar_ptr_node, arg2))));
- return fold (build (MINUS_EXPR, integer_type_node, ind1, ind2));
+ return fold (build2 (MINUS_EXPR, integer_type_node, ind1, ind2));
}
return 0;
{
/* Evaluate and ignore arg1 and arg2 in case they have
side-effects. */
- return build (COMPOUND_EXPR, integer_type_node, arg1,
- build (COMPOUND_EXPR, integer_type_node,
- arg2, integer_zero_node));
+ return build2 (COMPOUND_EXPR, integer_type_node, arg1,
+ build2 (COMPOUND_EXPR, integer_type_node,
+ arg2, integer_zero_node));
}
/* If arg1 and arg2 are equal (and not volatile), return zero. */
if (operand_equal_p (arg1, arg2, 0))
- {
- /* Evaluate and ignore arg3 in case it has side-effects. */
- return build (COMPOUND_EXPR, integer_type_node, arg3, integer_zero_node);
- }
+ /* Evaluate and ignore arg3 in case it has side-effects. */
+ return omit_one_operand (integer_type_node, integer_zero_node, arg3);
p1 = c_getstr (arg1);
p2 = c_getstr (arg2);
fold (build1 (CONVERT_EXPR, integer_type_node,
build1 (INDIRECT_REF, cst_uchar_node,
build1 (NOP_EXPR, cst_uchar_ptr_node, arg2))));
- return fold (build (MINUS_EXPR, integer_type_node, ind1, ind2));
+ return fold (build2 (MINUS_EXPR, integer_type_node, ind1, ind2));
}
return 0;
/* If the requested length is zero, or the src parameter string
length is zero, return the dst parameter. */
if (integer_zerop (len) || (p && *p == '\0'))
- return build (COMPOUND_EXPR, TREE_TYPE (dst), src,
- build (COMPOUND_EXPR, integer_type_node, len, dst));
+ return build2 (COMPOUND_EXPR, TREE_TYPE (dst), src,
+ build2 (COMPOUND_EXPR, integer_type_node, len, dst));
/* If the requested len is greater than or equal to the string
length, call strcat. */
{
/* Evaluate and ignore both arguments in case either one has
side-effects. */
- return build (COMPOUND_EXPR, integer_type_node, s1,
- build (COMPOUND_EXPR, integer_type_node,
- s2, integer_zero_node));
+ return build2 (COMPOUND_EXPR, integer_type_node, s1,
+ build2 (COMPOUND_EXPR, integer_type_node,
+ s2, integer_zero_node));
}
return 0;
}
{
/* Evaluate and ignore argument s2 in case it has
side-effects. */
- return build (COMPOUND_EXPR, integer_type_node,
- s2, integer_zero_node);
+ return omit_one_operand (integer_type_node,
+ integer_zero_node, s2);
}
/* If the second argument is "", return __builtin_strlen(s1). */
switch (compare_tree_int (len, 1))
{
case -1: /* length is 0, delete the call entirely . */
- {
- return build (COMPOUND_EXPR, integer_type_node,
- TREE_VALUE (TREE_CHAIN (arglist)), integer_zero_node);
- }
+ return omit_one_operand (integer_type_node, integer_zero_node,
+ TREE_VALUE (TREE_CHAIN (arglist)));
+
case 0: /* length is 1, call fputc. */
{
const char *p = c_getstr (TREE_VALUE (arglist));
retval = convert
(TREE_TYPE (TREE_TYPE (implicit_built_in_decls[BUILT_IN_SPRINTF])),
retval);
- return build (COMPOUND_EXPR, TREE_TYPE (retval), call, retval);
+ return build2 (COMPOUND_EXPR, TREE_TYPE (retval), call, retval);
}
else
return call;
projects / platform / upstream / gcc.git / commitdiff