Skip to content

R
riscv-gcc-1
Commit 2b5e5642 by Kaveh R. Ghazi Committed by Kaveh Ghazi
Options

builtins.c (fold_builtin_load_exponent): New. 

	* builtins.c (fold_builtin_load_exponent): New.
	(fold_builtin_2): Use it.

testsuite:
	* gcc.dg/torture/builtin-ldexp-1.c: New.
	* gcc.dg/torture/builtin-math-2.c: Add ldexp/scalbn/scalbln cases.

From-SVN: r122110
parent 278a7a38
Showing with 348 additions and 1 deletions
gcc/ChangeLog
2007-02-18 Kaveh R. Ghazi <ghazi@caip.rutgers.edu>
* builtins.c (fold_builtin_load_exponent): New.
(fold_builtin_2): Use it.
2007-02-18 Steven Bosscher <steven@gcc.gnu.org>
PR rtl-optimization/30773
......
gcc/builtins.c
......@@ -9000,6 +9000,67 @@ fold_builtin_carg (tree arg, tree type)
return NULL_TREE;
}
/* Fold a call to builtin ldexp or scalbn/scalbln. If LDEXP is true
then we can assume the base is two. If it's false, then we have to
check the mode of the TYPE parameter in certain cases. */
static tree
fold_builtin_load_exponent (tree arg0, tree arg1, tree type, bool ldexp)
{
if (validate_arg (arg0, REAL_TYPE) && validate_arg (arg1, INTEGER_TYPE))
{
STRIP_NOPS (arg0);
STRIP_NOPS (arg1);
/* If arg0 is 0, Inf or NaN, or if arg1 is 0, then return arg0. */
if (real_zerop (arg0) || integer_zerop (arg1)
|| (TREE_CODE (arg0) == REAL_CST
&& (real_isnan (&TREE_REAL_CST (arg0))
|| real_isinf (&TREE_REAL_CST (arg0)))))
return omit_one_operand (type, arg0, arg1);
/* If both arguments are constant, then try to evaluate it. */
if ((ldexp || REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2)
&& TREE_CODE (arg0) == REAL_CST && !TREE_OVERFLOW (arg0)
&& host_integerp (arg1, 0))
{
/* Bound the maximum adjustment to twice the range of the
mode's valid exponents. Use abs to ensure the range is
positive as a sanity check. */
const long max_exp_adj = 2 *
labs (REAL_MODE_FORMAT (TYPE_MODE (type))->emax
- REAL_MODE_FORMAT (TYPE_MODE (type))->emin);
/* Get the user-requested adjustment. */
const HOST_WIDE_INT req_exp_adj = tree_low_cst (arg1, 0);
/* The requested adjustment must be inside this range. This
is a preliminary cap to avoid things like overflow, we
may still fail to compute the result for other reasons. */
if (-max_exp_adj < req_exp_adj && req_exp_adj < max_exp_adj)
{
REAL_VALUE_TYPE initial_result;
real_ldexp (&initial_result, &TREE_REAL_CST (arg0), req_exp_adj);
/* Ensure we didn't overflow. */
if (! real_isinf (&initial_result))
{
const REAL_VALUE_TYPE trunc_result
= real_value_truncate (TYPE_MODE (type), initial_result);
/* Only proceed if the target mode can hold the
resulting value. */
if (REAL_VALUES_EQUAL (initial_result, trunc_result))
return build_real (type, trunc_result);
}
}
}
}
return NULL_TREE;
}
/* Fold a call to __builtin_isnan(), __builtin_isinf, __builtin_finite.
ARG is the argument for the call. */
......@@ -9460,6 +9521,12 @@ fold_builtin_2 (tree fndecl, tree arg0, tree arg1, bool ignore)
CASE_FLT_FN (BUILT_IN_HYPOT):
return fold_builtin_hypot (fndecl, arg0, arg1, type);
CASE_FLT_FN (BUILT_IN_LDEXP):
return fold_builtin_load_exponent (arg0, arg1, type, /*ldexp=*/true);
CASE_FLT_FN (BUILT_IN_SCALBN):
CASE_FLT_FN (BUILT_IN_SCALBLN):
return fold_builtin_load_exponent (arg0, arg1, type, /*ldexp=*/false);
case BUILT_IN_BZERO:
return fold_builtin_bzero (arg0, arg1, ignore);
......
gcc/testsuite/ChangeLog
2007-02-18 Kaveh R. Ghazi <ghazi@caip.rutgers.edu>
* gcc.dg/torture/builtin-ldexp-1.c: New.
* gcc.dg/torture/builtin-math-2.c: Add ldexp/scalbn/scalbln cases.
2007-02-18 Roger Sayle <roger@eyesopen.com>
* gfortran.dg/array_constructor_15.f90: New test case.
gcc/testsuite/gcc.dg/torture/builtin-ldexp-1.c 0 → 100644
/* Copyright (C) 2007 Free Software Foundation.
Verify that built-in folding of ldexp et al. is correctly performed
by the compiler.
Origin: Kaveh R. Ghazi, February 17, 2007. */
/* { dg-do link } */
extern void link_error(int);
/* Return TRUE if the sign of X != sign of Y. This is important when
comparing signed zeros. */
#define CKSGN_F(X,Y) \
(__builtin_copysignf(1.0F,(X)) != __builtin_copysignf(1.0F,(Y)))
#define CKSGN(X,Y) \
(__builtin_copysign(1.0,(X)) != __builtin_copysign(1.0,(Y)))
#define CKSGN_L(X,Y) \
(__builtin_copysignl(1.0L,(X)) != __builtin_copysignl(1.0L,(Y)))
/* Test that FUNC(ARG1,ARG2) == RES. Check the sign for -0.0. */
#define TESTIT(FUNC,ARG1,ARG2,RES) do { \
if (__builtin_##FUNC##f(ARG1##f,ARG2) != RES##f \
|| CKSGN(__builtin_##FUNC##f(ARG1##f,ARG2),RES##f)) \
link_error(__LINE__); \
if (__builtin_##FUNC(ARG1,ARG2) != RES \
|| CKSGN(__builtin_##FUNC(ARG1,ARG2),RES)) \
link_error(__LINE__); \
if (__builtin_##FUNC##l(ARG1##l,ARG2) != RES##l \
|| CKSGN(__builtin_##FUNC##l(ARG1##l,ARG2),RES##l)) \
link_error(__LINE__); \
} while (0)
/* Test that (long)FUNC(ARG1,ARG2) == (long)RES. The cast is
necessary when RES is not a constant. */
#define TESTIT2(FUNC,ARG1,ARG2,RES) do { \
if ((long)__builtin_##FUNC##f(ARG1##f,ARG2) != (long)RES##f) \
link_error(__LINE__); \
if ((long)__builtin_##FUNC(ARG1,ARG2) != (long)RES) \
link_error(__LINE__); \
if ((long)__builtin_##FUNC##l(ARG1##l,ARG2) != (long)RES##l) \
link_error(__LINE__); \
} while (0)
/* Test that FUNCRES(FUNC(NEG FUNCARG(ARGARG),ARG2)) is false. Check
the sign as well. */
#define TESTIT3(FUNC,NEG,FUNCARG,ARGARG,ARG2,FUNCRES) do { \
if (!__builtin_##FUNCRES##f(__builtin_##FUNC##f(NEG __builtin_##FUNCARG##f(ARGARG),ARG2)) \
|| CKSGN(__builtin_##FUNC##f(NEG __builtin_##FUNCARG##f(ARGARG),ARG2), NEG __builtin_##FUNCARG##f(ARGARG))) \
link_error(__LINE__); \
if (!__builtin_##FUNCRES(__builtin_##FUNC(NEG __builtin_##FUNCARG(ARGARG),ARG2)) \
|| CKSGN(__builtin_##FUNC(NEG __builtin_##FUNCARG(ARGARG),ARG2), NEG __builtin_##FUNCARG(ARGARG))) \
link_error(__LINE__); \
if (!__builtin_##FUNCRES##l(__builtin_##FUNC##l(NEG __builtin_##FUNCARG##l(ARGARG),ARG2)) \
|| CKSGN(__builtin_##FUNC##l(NEG __builtin_##FUNCARG##l(ARGARG),ARG2), NEG __builtin_##FUNCARG##l(ARGARG))) \
link_error(__LINE__); \
} while (0)
/* Using foo==MIN/MAX float values, test that FUNC(foo,EXP) == foo*exp2(EXP),
and also that FUNC(foo,-EXP) == foo*exp2(-EXP). */
#define TESTIT4(FUNC,EXP) do { \
if (__builtin_##FUNC##f(__FLT_MIN__,EXP) != __FLT_MIN__*__builtin_exp2f(EXP)) \
link_error(__LINE__); \
if (__builtin_##FUNC##f(-__FLT_MIN__,EXP) != -__FLT_MIN__*__builtin_exp2f(EXP)) \
link_error(__LINE__); \
if (__builtin_##FUNC(__DBL_MIN__,EXP) != __DBL_MIN__*__builtin_exp2(EXP)) \
link_error(__LINE__); \
if (__builtin_##FUNC(-__DBL_MIN__,EXP) != -__DBL_MIN__*__builtin_exp2(EXP)) \
link_error(__LINE__); \
if (__builtin_##FUNC##l(__LDBL_MIN__,EXP) != __LDBL_MIN__*__builtin_exp2l(EXP)) \
link_error(__LINE__); \
if (__builtin_##FUNC##l(-__LDBL_MIN__,EXP) != -__LDBL_MIN__*__builtin_exp2l(EXP)) \
link_error(__LINE__); \
if (__builtin_##FUNC##f(__FLT_MAX__,-EXP) != __FLT_MAX__*__builtin_exp2f(-EXP)) \
link_error(__LINE__); \
if (__builtin_##FUNC##f(-__FLT_MAX__,-EXP) != -__FLT_MAX__*__builtin_exp2f(-EXP)) \
link_error(__LINE__); \
if (__builtin_##FUNC(__DBL_MAX__,-EXP) != __DBL_MAX__*__builtin_exp2(-EXP)) \
link_error(__LINE__); \
if (__builtin_##FUNC(-__DBL_MAX__,-EXP) != -__DBL_MAX__*__builtin_exp2(-EXP)) \
link_error(__LINE__); \
if (__builtin_##FUNC##l(__LDBL_MAX__,-EXP) != __LDBL_MAX__*__builtin_exp2l(-EXP)) \
link_error(__LINE__); \
if (__builtin_##FUNC##l(-__LDBL_MAX__,-EXP) != -__LDBL_MAX__*__builtin_exp2l(-EXP)) \
link_error(__LINE__); \
} while (0)
void __attribute__ ((__noinline__))
foo(float xf, double x, long double xl, int i, long l)
{
/* f(0.0, i) -> 0.0 and f(-0.0, i) -> -0.0. */
TESTIT (ldexp, 0.0, i, 0.0);
TESTIT (ldexp, -0.0, i, -0.0);
TESTIT (scalbn, 0.0, i, 0.0);
TESTIT (scalbn, -0.0, i, -0.0);
TESTIT (scalbln, 0.0, l, 0.0);
TESTIT (scalbln, -0.0, l, -0.0);
/* f(x,0) -> x. */
TESTIT2 (ldexp, x, 0, x);
TESTIT2 (scalbn, x, 0, x);
TESTIT2 (scalbln, x, 0, x);
/* f(Inf,i) -> Inf and f(NaN,i) -> NaN. */
TESTIT3 (ldexp, , inf, , i, isinf);
TESTIT3 (ldexp, -, inf, , i, isinf);
TESTIT3 (ldexp, , nan, "", i, isnan);
TESTIT3 (ldexp, -, nan, "", i, isnan);
TESTIT3 (scalbn, , inf, , i, isinf);
TESTIT3 (scalbn, -, inf, , i, isinf);
TESTIT3 (scalbn, , nan, "", i, isnan);
TESTIT3 (scalbn, -, nan, "", i, isnan);
TESTIT3 (scalbln, , inf, , i, isinf);
TESTIT3 (scalbln, -, inf, , i, isinf);
TESTIT3 (scalbln, , nan, "", i, isnan);
TESTIT3 (scalbln, -, nan, "", i, isnan);
/* Evaluate when both arguments are constant. */
TESTIT (ldexp, 5.0, 3, 40.0);
TESTIT (ldexp, -5.0, 3, -40.0);
TESTIT (ldexp, 5.0, -3, 0.625);
TESTIT (ldexp, -5.0, -3, -0.625);
TESTIT (ldexp, 1000.0, 5, 32000.0);
TESTIT (ldexp, -1000.0, 5, -32000.0);
TESTIT (ldexp, 1000.0, -5, 31.25);
TESTIT (ldexp, -1000.0, -5, -31.25);
/* f(x,N) -> x*exp2(N), using MIN/MAX constants for x and constant N. */
TESTIT4 (ldexp, 1);
TESTIT4 (ldexp, 2);
TESTIT4 (ldexp, 3);
TESTIT4 (ldexp, 5);
TESTIT4 (ldexp, 9);
TESTIT4 (ldexp, 10);
TESTIT4 (ldexp, 12);
TESTIT4 (ldexp, 18);
TESTIT4 (ldexp, 25);
TESTIT4 (ldexp, 50);
TESTIT4 (ldexp, 75);
TESTIT4 (ldexp, 100);
TESTIT4 (ldexp, 123);
/* These are folded when float radix is two. */
#if __FLT_RADIX__ == 2
TESTIT (scalbn, 5.0, 3, 40.0);
TESTIT (scalbn, -5.0, 3, -40.0);
TESTIT (scalbn, 5.0, -3, 0.625);
TESTIT (scalbn, -5.0, -3, -0.625);
TESTIT (scalbn, 1000.0, 5, 32000.0);
TESTIT (scalbn, -1000.0, 5, -32000.0);
TESTIT (scalbn, 1000.0, -5, 31.25);
TESTIT (scalbn, -1000.0, -5, -31.25);
TESTIT4 (scalbn, 1);
TESTIT4 (scalbn, 2);
TESTIT4 (scalbn, 3);
TESTIT4 (scalbn, 5);
TESTIT4 (scalbn, 9);
TESTIT4 (scalbn, 10);
TESTIT4 (scalbn, 12);
TESTIT4 (scalbn, 18);
TESTIT4 (scalbn, 25);
TESTIT4 (scalbn, 50);
TESTIT4 (scalbn, 75);
TESTIT4 (scalbn, 100);
TESTIT4 (scalbn, 123);
TESTIT (scalbln, 5.0, 3, 40.0);
TESTIT (scalbln, -5.0, 3, -40.0);
TESTIT (scalbln, 5.0, -3, 0.625);
TESTIT (scalbln, -5.0, -3, -0.625);
TESTIT (scalbln, 1000.0, 5, 32000.0);
TESTIT (scalbln, -1000.0, 5, -32000.0);
TESTIT (scalbln, 1000.0, -5, 31.25);
TESTIT (scalbln, -1000.0, -5, -31.25);
TESTIT4 (scalbln, 1);
TESTIT4 (scalbln, 2);
TESTIT4 (scalbln, 3);
TESTIT4 (scalbln, 5);
TESTIT4 (scalbln, 9);
TESTIT4 (scalbln, 10);
TESTIT4 (scalbln, 12);
TESTIT4 (scalbln, 18);
TESTIT4 (scalbln, 25);
TESTIT4 (scalbln, 50);
TESTIT4 (scalbln, 75);
TESTIT4 (scalbln, 100);
TESTIT4 (scalbln, 123);
#endif
}
int main()
{
foo (0, 0, 0, 0, 0);
return 0;
}
gcc/testsuite/gcc.dg/torture/builtin-math-2.c
/* Copyright (C) 2006 Free Software Foundation.
/* Copyright (C) 2006, 2007 Free Software Foundation.
Test things that should block GCC from optimizing compile-time
constants passed to a builtin transcendental function.
......@@ -24,6 +24,18 @@ extern void fool (long double);
fool (__builtin_##FUNC##l (ARG1##L, ARG2##L)); \
} while (0)
#define TESTIT2_I2ALL(FUNC, ARGF, MAXF, ARGD, MAXD, ARGLD, MAXLD) do { \
foof (__builtin_##FUNC##f (ARGF, MAXF)); \
foo (__builtin_##FUNC (ARGD, MAXD)); \
fool (__builtin_##FUNC##l (ARGLD, MAXLD)); \
} while (0)
#define TESTIT2_I2(FUNC, ARG1, ARG2) do { \
foof (__builtin_##FUNC##f (ARG1##F, ARG2)); \
foo (__builtin_##FUNC (ARG1, ARG2)); \
fool (__builtin_##FUNC##l (ARG1##L, ARG2)); \
} while (0)
void bar()
{
/* An argument of NaN is not evaluated at compile-time. */
......@@ -150,6 +162,52 @@ void bar()
TESTIT (sqrt, -0.5);
TESTIT (sqrt, -0.0);
TESTIT (sqrt, 0.0);
/* Check for overflow/underflow. */
/* These adjustments are too big. */
#define FLT_EXP_ADJ (2*(__FLT_MAX_EXP__-__FLT_MIN_EXP__)+1)
#define DBL_EXP_ADJ (2*(__DBL_MAX_EXP__-__DBL_MIN_EXP__)+1)
#define LDBL_EXP_ADJ (2*(__LDBL_MAX_EXP__-__LDBL_MIN_EXP__)+1)
TESTIT2_I2 (ldexp, 1.0, __INT_MAX__);
TESTIT2_I2 (ldexp, 1.0, -__INT_MAX__-1);
TESTIT2_I2 (ldexp, -1.0, __INT_MAX__);
TESTIT2_I2 (ldexp, -1.0, -__INT_MAX__-1);
TESTIT2_I2ALL (ldexp, __FLT_MIN__, FLT_EXP_ADJ, __DBL_MIN__,
DBL_EXP_ADJ, __LDBL_MIN__, LDBL_EXP_ADJ);
TESTIT2_I2ALL (ldexp, __FLT_MAX__, -FLT_EXP_ADJ, __DBL_MAX__,
-DBL_EXP_ADJ, __LDBL_MAX__, -LDBL_EXP_ADJ);
TESTIT2_I2ALL (ldexp, __FLT_MIN__, __FLT_MIN_EXP__, __DBL_MIN__,
__DBL_MIN_EXP__, __LDBL_MIN__, __LDBL_MIN_EXP__);
TESTIT2_I2ALL (ldexp, __FLT_MAX__, __FLT_MAX_EXP__, __DBL_MAX__,
__DBL_MAX_EXP__, __LDBL_MAX__, __LDBL_MAX_EXP__);
TESTIT2_I2 (scalbn, 1.0, __INT_MAX__);
TESTIT2_I2 (scalbn, 1.0, -__INT_MAX__-1);
TESTIT2_I2 (scalbn, -1.0, __INT_MAX__);
TESTIT2_I2 (scalbn, -1.0, -__INT_MAX__-1);
TESTIT2_I2ALL (scalbn, __FLT_MIN__, FLT_EXP_ADJ, __DBL_MIN__,
DBL_EXP_ADJ, __LDBL_MIN__, LDBL_EXP_ADJ);
TESTIT2_I2ALL (scalbn, __FLT_MAX__, -FLT_EXP_ADJ, __DBL_MAX__,
-DBL_EXP_ADJ, __LDBL_MAX__, -LDBL_EXP_ADJ);
TESTIT2_I2ALL (scalbn, __FLT_MIN__, __FLT_MIN_EXP__, __DBL_MIN__,
__DBL_MIN_EXP__, __LDBL_MIN__, __LDBL_MIN_EXP__);
TESTIT2_I2ALL (scalbn, __FLT_MAX__, __FLT_MAX_EXP__, __DBL_MAX__,
__DBL_MAX_EXP__, __LDBL_MAX__, __LDBL_MAX_EXP__);
TESTIT2_I2 (scalbln, 1.0, __LONG_MAX__);
TESTIT2_I2 (scalbln, 1.0, -__LONG_MAX__-1);
TESTIT2_I2 (scalbln, -1.0, __LONG_MAX__);
TESTIT2_I2 (scalbln, -1.0, -__LONG_MAX__-1);
TESTIT2_I2ALL (scalbln, __FLT_MIN__, FLT_EXP_ADJ, __DBL_MIN__,
DBL_EXP_ADJ, __LDBL_MIN__, LDBL_EXP_ADJ);
TESTIT2_I2ALL (scalbln, __FLT_MAX__, -FLT_EXP_ADJ, __DBL_MAX__,
-DBL_EXP_ADJ, __LDBL_MAX__, -LDBL_EXP_ADJ);
TESTIT2_I2ALL (scalbln, __FLT_MIN__, __FLT_MIN_EXP__, __DBL_MIN__,
__DBL_MIN_EXP__, __LDBL_MIN__, __LDBL_MIN_EXP__);
TESTIT2_I2ALL (scalbln, __FLT_MAX__, __FLT_MAX_EXP__, __DBL_MAX__,
__DBL_MAX_EXP__, __LDBL_MAX__, __LDBL_MAX_EXP__);
}
/* { dg-final { scan-tree-dump-times "exp2 " 9 "original" } } */
......@@ -191,4 +249,13 @@ void bar()
/* { dg-final { scan-tree-dump-times "sqrt " 1 "original" } } */
/* { dg-final { scan-tree-dump-times "sqrtf" 1 "original" } } */
/* { dg-final { scan-tree-dump-times "sqrtl" 1 "original" } } */
/* { dg-final { scan-tree-dump-times "ldexp " 8 "original" } } */
/* { dg-final { scan-tree-dump-times "ldexpf" 8 "original" } } */
/* { dg-final { scan-tree-dump-times "ldexpl" 8 "original" } } */
/* { dg-final { scan-tree-dump-times "scalbn " 8 "original" } } */
/* { dg-final { scan-tree-dump-times "scalbnf" 8 "original" } } */
/* { dg-final { scan-tree-dump-times "scalbnl" 8 "original" } } */
/* { dg-final { scan-tree-dump-times "scalbln " 8 "original" } } */
/* { dg-final { scan-tree-dump-times "scalblnf" 8 "original" } } */
/* { dg-final { scan-tree-dump-times "scalblnl" 8 "original" } } */
/* { dg-final { cleanup-tree-dump "original" } } */
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment