OpenE2K/gcc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

convert.c (convert_to_integer): Convert (long)round -> lround, etc.

Browse Source 
* convert.c (convert_to_integer): Convert (long)round -> lround,
	etc.

testsuite:
	* gcc.dg/torture/builtin-convert-2.c: New test.

From-SVN: r81269
This commit is contained in:
Kaveh R. Ghazi 2004-04-29 00:36:20 +00:00 committed by Kaveh Ghazi
parent b5bfe58403
commit 332d782c3d
4 changed files with 134 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
gcc/ChangeLog
View File

@ -1,3 +1,8 @@
2004-04-28 Kaveh R. Ghazi <ghazi@caip.rutgers.edu>
* convert.c (convert_to_integer): Convert (long)round -> lround,
etc.
2004-04-28 Andrew Pinski <pinskia@physics.uc.edu>
* config/rs6000/rs6000.c (registers_ok_for_quad_peep):

46
gcc/convert.c
View File

@ -332,6 +332,52 @@ convert_to_integer (tree type, tree expr)
return error_mark_node;
}
/* Convert e.g. (long)round(d) -> lround(d). */
/* If we're converting to char, we may encounter differing behavior
between converting from double->char vs double->long->char.
We're in "undefined" territory but we prefer to be conservative,
so only proceed in "unsafe" math mode. */
if (optimize
&& (flag_unsafe_math_optimizations
|| outprec >= TYPE_PRECISION (long_integer_type_node)))
{
tree s_expr = strip_float_extensions (expr);
tree s_intype = TREE_TYPE (s_expr);
const enum built_in_function fcode = builtin_mathfn_code (s_expr);
tree fn = 0;
switch (fcode)
{
case BUILT_IN_ROUND: case BUILT_IN_ROUNDF: case BUILT_IN_ROUNDL:
if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (long_long_integer_type_node))
fn = mathfn_built_in (s_intype, BUILT_IN_LLROUND);
else
fn = mathfn_built_in (s_intype, BUILT_IN_LROUND);
break;
case BUILT_IN_RINT: case BUILT_IN_RINTF: case BUILT_IN_RINTL:
/* Only convert rint* if we can ignore math exceptions. */
if (flag_trapping_math)
break;
/* ... Fall through ... */
case BUILT_IN_NEARBYINT: case BUILT_IN_NEARBYINTF: case BUILT_IN_NEARBYINTL:
if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (long_long_integer_type_node))
fn = mathfn_built_in (s_intype, BUILT_IN_LLRINT);
else
fn = mathfn_built_in (s_intype, BUILT_IN_LRINT);
break;
default:
break;
}
if (fn)
{
tree arglist = TREE_OPERAND (s_expr, 1);
tree newexpr = build_function_call_expr (fn, arglist);
return convert_to_integer (type, newexpr);
}
}
switch (TREE_CODE (intype))
{
case POINTER_TYPE:

4
gcc/testsuite/ChangeLog
View File

@ -1,3 +1,7 @@
2004-04-28 Kaveh R. Ghazi <ghazi@caip.rutgers.edu>
* gcc.dg/torture/builtin-convert-2.c: New test.
2004-04-28 Andrew Pinski <pinskia@physics.uc.edu>
* gcc.dg/rs6000-power2-1.c: New test.

79
gcc/testsuite/gcc.dg/torture/builtin-convert-2.c Normal file
View File

@ -0,0 +1,79 @@
/* Copyright (C) 2004 Free Software Foundation.
Verify that built-in math function conversion into integer rounding
functions is correctly performed by the compiler.
Written by Kaveh ghazi, 2004-04-26. */
/* { dg-do link } */
/* { dg-options "-ffast-math" } */
#include "./builtins-config.h"
#define PROTOTYPE(FN) extern double FN(double); \
extern float FN##f(float); \
extern long double FN##l(long double);
#define PROTOTYPE_RET(FN, RET) extern RET FN(double); \
extern RET FN##f(float); \
extern RET FN##l(long double);
/* Macro to do all FP type combinations. The second half tests
narrowing the FP type. */
#define TEST_FP2FIXED(FN1, FN2) \
PROTOTYPE(FN1) \
PROTOTYPE_RET(FN2, long) \
PROTOTYPE_RET(l##FN2, long long) \
extern void link_error_##FN1##_##FN2(void); \
extern void link_error_##FN1##f_##FN2##f(void); \
extern void link_error_##FN1##l_##FN2##l(void); \
extern void link_error_##FN1##_l##FN2(void); \
extern void link_error_##FN1##f_l##FN2##f(void); \
extern void link_error_##FN1##l_l##FN2##l(void); \
if ((long)FN1(d) != FN2(d)) \
link_error_##FN1##_##FN2(); \
if ((long)FN1##f(f) != FN2##f(f)) \
link_error_##FN1##f_##FN2##f(); \
if ((long)FN1##l(ld) != FN2##l(ld)) \
link_error_##FN1##l_##FN2##l(); \
if ((long long)FN1(d) != l##FN2(d)) \
link_error_##FN1##_l##FN2(); \
if ((long long)FN1##f(f) != l##FN2##f(f)) \
link_error_##FN1##f_l##FN2##f(); \
if ((long long)FN1##l(ld) != l##FN2##l(ld)) \
link_error_##FN1##l_l##FN2##l(); \
extern void link_error_##FN1##_##FN2##f(void); \
extern void link_error_##FN1##l_##FN2(void); \
extern void link_error_##FN1##l_##FN2##f(void); \
extern void link_error_##FN1##_l##FN2##f(void); \
extern void link_error_##FN1##l_l##FN2(void); \
extern void link_error_##FN1##l_l##FN2##f(void); \
if (sizeof(double) > sizeof(float) && (long)FN1(f) != FN2##f(f)) \
link_error_##FN1##_##FN2##f(); \
if (sizeof(long double) > sizeof(double) && (long)FN1##l(d) != FN2(d)) \
link_error_##FN1##l_##FN2(); \
if (sizeof(long double) > sizeof(float) && (long)FN1##l(f) != FN2##f(f)) \
link_error_##FN1##l_##FN2##f(); \
if (sizeof(double) > sizeof(float) && (long long)FN1(f) != l##FN2##f(f)) \
link_error_##FN1##_l##FN2##f(); \
if (sizeof(long double) > sizeof(double) && (long long)FN1##l(d) != l##FN2(d)) \
link_error_##FN1##l_l##FN2(); \
if (sizeof(long double) > sizeof(float) && (long long)FN1##l(f) != l##FN2##f(f)) \
link_error_##FN1##l_l##FN2##f()
void __attribute__ ((__noinline__)) foo (double d, float f, long double ld)
{
#ifdef __OPTIMIZE__
# ifdef HAVE_C99_RUNTIME
/* The resulting transformation functions are all C99. */
TEST_FP2FIXED (round, lround);
TEST_FP2FIXED (nearbyint, lrint);
TEST_FP2FIXED (rint, lrint);
# endif
#endif
}
int main()
{
foo (1.0, 2.0, 3.0);
return 0;
}