/* Utility routines for data type conversion for GCC.
Copyright (C) 1987, 1988, 1991, 1992, 1993, 1994, 1995, 1997, 1998,
- 2000, 2001, 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
+ 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
+ Free Software Foundation, Inc.
This file is part of GCC.
/* Propagate overflow to the NULL pointer. */
if (integer_zerop (expr))
- return force_fit_type_double (type, 0, 0, 0, TREE_OVERFLOW (expr),
- TREE_CONSTANT_OVERFLOW (expr));
+ return force_fit_type_double (type, 0, 0, 0, TREE_OVERFLOW (expr));
switch (TREE_CODE (TREE_TYPE (expr)))
{
CASE_MATHFN (Y1)
#undef CASE_MATHFN
{
- tree arg0 = strip_float_extensions (TREE_VALUE (TREE_OPERAND (expr, 1)));
+ tree arg0 = strip_float_extensions (CALL_EXPR_ARG (expr, 0));
tree newtype = type;
/* We have (outertype)sqrt((innertype)x). Choose the wider mode from
&& (TYPE_MODE (newtype) == TYPE_MODE (double_type_node)
|| TYPE_MODE (newtype) == TYPE_MODE (float_type_node)))
{
- tree arglist;
tree fn = mathfn_built_in (newtype, fcode);
if (fn)
{
- arglist = build_tree_list (NULL_TREE, fold (convert_to_real (newtype, arg0)));
- expr = build_function_call_expr (fn, arglist);
+ tree arg = fold (convert_to_real (newtype, arg0));
+ expr = build_call_expr (fn, 1, arg);
if (newtype == type)
return expr;
}
if (fn)
{
- tree arg
- = strip_float_extensions (TREE_VALUE (TREE_OPERAND (expr, 1)));
+ tree arg = strip_float_extensions (CALL_EXPR_ARG (expr, 0));
/* Make sure (type)arg0 is an extension, otherwise we could end up
changing (float)floor(double d) into floorf((float)d), which is
incorrect because (float)d uses round-to-nearest and can round
up to the next integer. */
if (TYPE_PRECISION (type) >= TYPE_PRECISION (TREE_TYPE (arg)))
- return
- build_function_call_expr (fn,
- build_tree_list (NULL_TREE,
- fold (convert_to_real (type, arg))));
+ return build_call_expr (fn, 1, fold (convert_to_real (type, arg)));
}
}
fn = mathfn_built_in (s_intype, BUILT_IN_LLROUND);
break;
- CASE_FLT_FN (BUILT_IN_RINT):
- /* Only convert rint* if we can ignore math exceptions. */
+ CASE_FLT_FN (BUILT_IN_NEARBYINT):
+ /* Only convert nearbyint* if we can ignore math exceptions. */
if (flag_trapping_math)
break;
/* ... Fall through ... */
- CASE_FLT_FN (BUILT_IN_NEARBYINT):
+ CASE_FLT_FN (BUILT_IN_RINT):
if (outprec < TYPE_PRECISION (long_integer_type_node)
|| (outprec == TYPE_PRECISION (long_integer_type_node)
&& !TYPE_UNSIGNED (type)))
break;
CASE_FLT_FN (BUILT_IN_TRUNC):
- {
- tree arglist = TREE_OPERAND (s_expr, 1);
- return convert_to_integer (type, TREE_VALUE (arglist));
- }
+ return convert_to_integer (type, CALL_EXPR_ARG (s_expr, 0));
default:
break;
if (fn)
{
- tree arglist = TREE_OPERAND (s_expr, 1);
- tree newexpr = build_function_call_expr (fn, arglist);
+ tree newexpr = build_call_expr (fn, 1, CALL_EXPR_ARG (s_expr, 0));
return convert_to_integer (type, newexpr);
}
}
PLUS_EXPR or MINUS_EXPR in an unsigned
type. Otherwise, we would introduce
signed-overflow undefinedness. */
- || (!flag_wrapv
+ || ((!TYPE_OVERFLOW_WRAPS (TREE_TYPE (arg0))
+ || !TYPE_OVERFLOW_WRAPS (TREE_TYPE (arg1)))
&& (ex_form == PLUS_EXPR
- || ex_form == MINUS_EXPR)
- && (!TYPE_UNSIGNED (TREE_TYPE (arg0))
- || !TYPE_UNSIGNED (TREE_TYPE (arg1)))))
- typex = lang_hooks.types.unsigned_type (typex);
+ || ex_form == MINUS_EXPR)))
+ typex = unsigned_type_for (typex);
else
- typex = lang_hooks.types.signed_type (typex);
+ typex = signed_type_for (typex);
return convert (type,
fold_build2 (ex_form, typex,
convert (typex, arg0),
/* Don't do unsigned arithmetic where signed was wanted,
or vice versa. */
if (TYPE_UNSIGNED (TREE_TYPE (expr)))
- typex = lang_hooks.types.unsigned_type (type);
+ typex = unsigned_type_for (type);
else
- typex = lang_hooks.types.signed_type (type);
+ typex = signed_type_for (type);
return convert (type,
fold_build1 (ex_form, typex,
convert (typex,