/* Utility routines for data type conversion for GCC.
Copyright (C) 1987, 1988, 1991, 1992, 1993, 1994, 1995, 1997, 1998,
- 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
+ 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
This file is part of GCC.
return
convert_to_pointer (type,
- convert ((*lang_hooks.types.type_for_size)
+ convert (lang_hooks.types.type_for_size
(POINTER_SIZE, 0), expr));
default:
present in runtime. */
/* Convert (float)sqrt((double)x) where x is float into sqrtf(x) */
if (optimize
- && (fcode == BUILT_IN_SQRT
- || fcode == BUILT_IN_SQRTL
- || fcode == BUILT_IN_SIN
- || fcode == BUILT_IN_SINL
- || fcode == BUILT_IN_COS
- || fcode == BUILT_IN_COSL
- || fcode == BUILT_IN_EXP
- || fcode == BUILT_IN_EXPL
- || fcode == BUILT_IN_LOG
- || fcode == BUILT_IN_LOGL)
&& (TYPE_MODE (type) == TYPE_MODE (double_type_node)
|| TYPE_MODE (type) == TYPE_MODE (float_type_node)))
{
- tree arg0 = strip_float_extensions (TREE_VALUE (TREE_OPERAND (expr, 1)));
- tree newtype = type;
-
- /* We have (outertype)sqrt((innertype)x). Choose the wider mode from
- the both as the safe type for operation. */
- if (TYPE_PRECISION (TREE_TYPE (arg0)) > TYPE_PRECISION (type))
- newtype = TREE_TYPE (arg0);
-
- /* Be careful about integer to fp conversions.
- These may overflow still. */
- if (FLOAT_TYPE_P (TREE_TYPE (arg0))
- && TYPE_PRECISION (newtype) < TYPE_PRECISION (itype)
- && (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)
+ switch (fcode)
+ {
+#define CASE_MATHFN(FN) case BUILT_IN_##FN: case BUILT_IN_##FN##L:
+ CASE_MATHFN (ACOS)
+ CASE_MATHFN (ACOSH)
+ CASE_MATHFN (ASIN)
+ CASE_MATHFN (ASINH)
+ CASE_MATHFN (ATAN)
+ CASE_MATHFN (ATANH)
+ CASE_MATHFN (CBRT)
+ CASE_MATHFN (COS)
+ CASE_MATHFN (COSH)
+ CASE_MATHFN (ERF)
+ CASE_MATHFN (ERFC)
+ CASE_MATHFN (EXP)
+ CASE_MATHFN (EXP10)
+ CASE_MATHFN (EXP2)
+ CASE_MATHFN (EXPM1)
+ CASE_MATHFN (FABS)
+ CASE_MATHFN (GAMMA)
+ CASE_MATHFN (J0)
+ CASE_MATHFN (J1)
+ CASE_MATHFN (LGAMMA)
+ CASE_MATHFN (LOG)
+ CASE_MATHFN (LOG10)
+ CASE_MATHFN (LOG1P)
+ CASE_MATHFN (LOG2)
+ CASE_MATHFN (LOGB)
+ CASE_MATHFN (POW10)
+ CASE_MATHFN (SIN)
+ CASE_MATHFN (SINH)
+ CASE_MATHFN (SQRT)
+ CASE_MATHFN (TAN)
+ CASE_MATHFN (TANH)
+ CASE_MATHFN (TGAMMA)
+ CASE_MATHFN (Y0)
+ CASE_MATHFN (Y1)
+#undef CASE_MATHFN
{
- arglist = build_tree_list (NULL_TREE, fold (convert_to_real (newtype, arg0)));
- expr = build_function_call_expr (fn, arglist);
- if (newtype == type)
- return expr;
+ tree arg0 = strip_float_extensions (TREE_VALUE (TREE_OPERAND (expr, 1)));
+ tree newtype = type;
+
+ /* We have (outertype)sqrt((innertype)x). Choose the wider mode from
+ the both as the safe type for operation. */
+ if (TYPE_PRECISION (TREE_TYPE (arg0)) > TYPE_PRECISION (type))
+ newtype = TREE_TYPE (arg0);
+
+ /* Be careful about integer to fp conversions.
+ These may overflow still. */
+ if (FLOAT_TYPE_P (TREE_TYPE (arg0))
+ && TYPE_PRECISION (newtype) < TYPE_PRECISION (itype)
+ && (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);
+ if (newtype == type)
+ return expr;
+ }
+ }
}
+ default:
+ break;
}
}
if (optimize
&& (((fcode == BUILT_IN_FLOORL
|| fcode == BUILT_IN_CEILL
- || fcode == BUILT_IN_ROUND
- || fcode == BUILT_IN_TRUNC
- || fcode == BUILT_IN_NEARBYINT)
+ || fcode == BUILT_IN_ROUNDL
+ || fcode == BUILT_IN_RINTL
+ || fcode == BUILT_IN_TRUNCL
+ || fcode == BUILT_IN_NEARBYINTL)
&& (TYPE_MODE (type) == TYPE_MODE (double_type_node)
|| TYPE_MODE (type) == TYPE_MODE (float_type_node)))
|| ((fcode == BUILT_IN_FLOOR
|| fcode == BUILT_IN_CEIL
|| fcode == BUILT_IN_ROUND
+ || fcode == BUILT_IN_RINT
|| fcode == BUILT_IN_TRUNC
|| fcode == BUILT_IN_NEARBYINT)
&& (TYPE_MODE (type) == TYPE_MODE (float_type_node)))))
if (integer_zerop (expr))
expr = integer_zero_node;
else
- expr = fold (build1 (CONVERT_EXPR, (*lang_hooks.types.type_for_size)
- (POINTER_SIZE, 0), expr));
+ expr = fold (build1 (CONVERT_EXPR,
+ lang_hooks.types.type_for_size (POINTER_SIZE, 0),
+ expr));
return convert_to_integer (type, expr);
conversion necessitates an explicit sign-extension. In
the signed-to-unsigned case the high-order bits have to
be cleared. */
- if (TREE_UNSIGNED (type) != TREE_UNSIGNED (TREE_TYPE (expr))
+ if (TYPE_UNSIGNED (type) != TYPE_UNSIGNED (TREE_TYPE (expr))
&& (TYPE_PRECISION (TREE_TYPE (expr))
!= GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (expr)))))
code = CONVERT_EXPR;
else if (TREE_CODE (type) == ENUMERAL_TYPE
|| outprec != GET_MODE_BITSIZE (TYPE_MODE (type)))
return build1 (NOP_EXPR, type,
- convert ((*lang_hooks.types.type_for_mode)
- (TYPE_MODE (type), TREE_UNSIGNED (type)),
+ convert (lang_hooks.types.type_for_mode
+ (TYPE_MODE (type), TYPE_UNSIGNED (type)),
expr));
/* Here detect when we can distribute the truncation down past some
the target type is unsigned. */
if (TREE_CODE (TREE_OPERAND (expr, 1)) == INTEGER_CST
&& tree_int_cst_sgn (TREE_OPERAND (expr, 1)) >= 0
- && TREE_UNSIGNED (type)
+ && TYPE_UNSIGNED (type)
&& TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST)
{
/* If shift count is less than the width of the truncated type,
&& outprec >= TYPE_PRECISION (TREE_TYPE (arg1))
/* If signedness of arg0 and arg1 don't match,
we can't necessarily find a type to compare them in. */
- && (TREE_UNSIGNED (TREE_TYPE (arg0))
- == TREE_UNSIGNED (TREE_TYPE (arg1))))
+ && (TYPE_UNSIGNED (TREE_TYPE (arg0))
+ == TYPE_UNSIGNED (TREE_TYPE (arg1))))
goto trunc1;
break;
}
/* Can't do arithmetic in enumeral types
so use an integer type that will hold the values. */
if (TREE_CODE (typex) == ENUMERAL_TYPE)
- typex = (*lang_hooks.types.type_for_size)
- (TYPE_PRECISION (typex), TREE_UNSIGNED (typex));
+ typex = lang_hooks.types.type_for_size
+ (TYPE_PRECISION (typex), TYPE_UNSIGNED (typex));
/* But now perhaps TYPEX is as wide as INPREC.
In that case, do nothing special here.
signed-overflow undefinedness.
And we may need to do it as unsigned
if we truncate to the original size. */
- if (TREE_UNSIGNED (TREE_TYPE (expr))
- || (TREE_UNSIGNED (TREE_TYPE (arg0))
- && (TREE_UNSIGNED (TREE_TYPE (arg1))
+ if (TYPE_UNSIGNED (TREE_TYPE (expr))
+ || (TYPE_UNSIGNED (TREE_TYPE (arg0))
+ && (TYPE_UNSIGNED (TREE_TYPE (arg1))
|| ex_form == LSHIFT_EXPR
|| ex_form == RSHIFT_EXPR
|| ex_form == LROTATE_EXPR
|| ex_form == RROTATE_EXPR))
|| ex_form == LSHIFT_EXPR)
- typex = (*lang_hooks.types.unsigned_type) (typex);
+ typex = lang_hooks.types.unsigned_type (typex);
else
- typex = (*lang_hooks.types.signed_type) (typex);
+ typex = lang_hooks.types.signed_type (typex);
return convert (type,
fold (build (ex_form, typex,
convert (typex, arg0),
- convert (typex, arg1),
- 0)));
+ convert (typex, arg1))));
}
}
}
/* Can't do arithmetic in enumeral types
so use an integer type that will hold the values. */
if (TREE_CODE (typex) == ENUMERAL_TYPE)
- typex = (*lang_hooks.types.type_for_size)
- (TYPE_PRECISION (typex), TREE_UNSIGNED (typex));
+ typex = lang_hooks.types.type_for_size
+ (TYPE_PRECISION (typex), TYPE_UNSIGNED (typex));
/* But now perhaps TYPEX is as wide as INPREC.
In that case, do nothing special here.
{
/* Don't do unsigned arithmetic where signed was wanted,
or vice versa. */
- if (TREE_UNSIGNED (TREE_TYPE (expr)))
- typex = (*lang_hooks.types.unsigned_type) (typex);
+ if (TYPE_UNSIGNED (TREE_TYPE (expr)))
+ typex = lang_hooks.types.unsigned_type (typex);
else
- typex = (*lang_hooks.types.signed_type) (typex);
+ typex = lang_hooks.types.signed_type (typex);
return convert (type,
fold (build1 (ex_form, typex,
convert (typex,
OSDN Git Service
