#ifndef REAL_H_INCLUDED
#define REAL_H_INCLUDED
#define UNKNOWN_FLOAT_FORMAT 0
#define IEEE_FLOAT_FORMAT 1
#define VAX_FLOAT_FORMAT 2
#define IBM_FLOAT_FORMAT 3
#define C4X_FLOAT_FORMAT 4
#ifndef TARGET_FLOAT_FORMAT
#define TARGET_FLOAT_FORMAT IEEE_FLOAT_FORMAT
#endif
#ifndef HOST_FLOAT_FORMAT
#define HOST_FLOAT_FORMAT IEEE_FLOAT_FORMAT
#endif
#if TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT
#define REAL_INFINITY
#endif
#ifndef FLOAT_WORDS_BIG_ENDIAN
#define FLOAT_WORDS_BIG_ENDIAN WORDS_BIG_ENDIAN
#endif
#ifndef HOST_FLOAT_WORDS_BIG_ENDIAN
#ifdef HOST_WORDS_BIG_ENDIAN
#define HOST_FLOAT_WORDS_BIG_ENDIAN 1
#else
#define HOST_FLOAT_WORDS_BIG_ENDIAN 0
#endif
#endif
#ifndef LONG_DOUBLE_TYPE_SIZE
#define LONG_DOUBLE_TYPE_SIZE 64
#endif
#if (LONG_DOUBLE_TYPE_SIZE == 96) || (LONG_DOUBLE_TYPE_SIZE == 128)
#ifndef REAL_ARITHMETIC
#define REAL_ARITHMETIC
#endif
#endif
#ifdef REAL_ARITHMETIC
#if (LONG_DOUBLE_TYPE_SIZE == 96)
#define REAL_IS_NOT_DOUBLE
#define REAL_ARITHMETIC
typedef struct {
HOST_WIDE_INT r[(11 + sizeof (HOST_WIDE_INT))/(sizeof (HOST_WIDE_INT))];
} realvaluetype;
#define REAL_VALUE_TYPE realvaluetype
#else
#if (LONG_DOUBLE_TYPE_SIZE == 128)
#define REAL_IS_NOT_DOUBLE
#define REAL_ARITHMETIC
typedef struct {
HOST_WIDE_INT r[(19 + sizeof (HOST_WIDE_INT))/(sizeof (HOST_WIDE_INT))];
} realvaluetype;
#define REAL_VALUE_TYPE realvaluetype
#else
#if HOST_FLOAT_FORMAT != TARGET_FLOAT_FORMAT
#define REAL_IS_NOT_DOUBLE
typedef struct {
HOST_WIDE_INT r[(7 + sizeof (HOST_WIDE_INT))/(sizeof (HOST_WIDE_INT))];
} realvaluetype;
#define REAL_VALUE_TYPE realvaluetype
#else
#define REAL_VALUE_TYPE double
#endif
#endif
#endif
extern int significand_size PROTO((enum machine_mode));
#ifdef REAL_ARITHMETIC
#undef REAL_ARITHMETIC
#define REAL_ARITHMETIC(value, code, d1, d2) \
earith (&(value), (code), &(d1), &(d2))
extern void earith PROTO((REAL_VALUE_TYPE *, int,
REAL_VALUE_TYPE *, REAL_VALUE_TYPE *));
extern REAL_VALUE_TYPE etrunci PROTO((REAL_VALUE_TYPE));
extern REAL_VALUE_TYPE etruncui PROTO((REAL_VALUE_TYPE));
extern REAL_VALUE_TYPE ereal_atof PROTO((const char *, enum machine_mode));
extern REAL_VALUE_TYPE ereal_negate PROTO((REAL_VALUE_TYPE));
extern HOST_WIDE_INT efixi PROTO((REAL_VALUE_TYPE));
extern unsigned HOST_WIDE_INT efixui PROTO((REAL_VALUE_TYPE));
extern void ereal_from_int PROTO((REAL_VALUE_TYPE *,
HOST_WIDE_INT, HOST_WIDE_INT,
enum machine_mode));
extern void ereal_from_uint PROTO((REAL_VALUE_TYPE *,
unsigned HOST_WIDE_INT,
unsigned HOST_WIDE_INT,
enum machine_mode));
extern void ereal_to_int PROTO((HOST_WIDE_INT *, HOST_WIDE_INT *,
REAL_VALUE_TYPE));
extern REAL_VALUE_TYPE ereal_ldexp PROTO((REAL_VALUE_TYPE, int));
extern void etartdouble PROTO((REAL_VALUE_TYPE, long *));
extern void etarldouble PROTO((REAL_VALUE_TYPE, long *));
extern void etardouble PROTO((REAL_VALUE_TYPE, long *));
extern long etarsingle PROTO((REAL_VALUE_TYPE));
extern void ereal_to_decimal PROTO((REAL_VALUE_TYPE, char *));
extern int ereal_cmp PROTO((REAL_VALUE_TYPE, REAL_VALUE_TYPE));
extern int ereal_isneg PROTO((REAL_VALUE_TYPE));
extern REAL_VALUE_TYPE ereal_unto_float PROTO((long));
extern REAL_VALUE_TYPE ereal_unto_double PROTO((long *));
extern REAL_VALUE_TYPE ereal_from_float PROTO((HOST_WIDE_INT));
extern REAL_VALUE_TYPE ereal_from_double PROTO((HOST_WIDE_INT *));
#define REAL_VALUES_EQUAL(x, y) (ereal_cmp ((x), (y)) == 0)
#define REAL_VALUES_LESS(x, y) (ereal_cmp ((x), (y)) == -1)
#define REAL_VALUE_LDEXP(x, n) ereal_ldexp (x, n)
#define REAL_VALUE_RNDZINT(x) (etrunci (x))
#define REAL_VALUE_UNSIGNED_RNDZINT(x) (etruncui (x))
extern REAL_VALUE_TYPE real_value_truncate PROTO ((enum machine_mode,
REAL_VALUE_TYPE));
#define REAL_VALUE_TRUNCATE(mode, x) real_value_truncate (mode, x)
#define REAL_VALUE_FIX(x) (efixi (x))
#define REAL_VALUE_UNSIGNED_FIX(x) (efixui (x))
#define REAL_VALUE_ATOF ereal_atof
#define REAL_VALUE_HTOF ereal_atof
#define REAL_VALUE_NEGATE ereal_negate
#define REAL_VALUE_MINUS_ZERO(x) \
((ereal_cmp (x, dconst0) == 0) && (ereal_isneg (x) != 0 ))
#define REAL_VALUE_TO_INT ereal_to_int
#define REAL_VALUE_FROM_INT(d, lo, hi, mode) \
ereal_from_int (&d, (HOST_WIDE_INT) (lo), (HOST_WIDE_INT) (hi), mode)
#define REAL_VALUE_FROM_UNSIGNED_INT(d, lo, hi, mode) \
ereal_from_uint (&d, lo, hi, mode)
#if LONG_DOUBLE_TYPE_SIZE == 96
#define REAL_VALUE_TO_TARGET_LONG_DOUBLE(IN, OUT) (etarldouble ((IN), (OUT)))
#else
#define REAL_VALUE_TO_TARGET_LONG_DOUBLE(IN, OUT) (etartdouble ((IN), (OUT)))
#endif
#define REAL_VALUE_TO_TARGET_DOUBLE(IN, OUT) (etardouble ((IN), (OUT)))
#define REAL_VALUE_TO_TARGET_SINGLE(IN, OUT) ((OUT) = etarsingle ((IN)))
#define REAL_VALUE_UNTO_TARGET_DOUBLE(d) (ereal_unto_double (d))
#define REAL_VALUE_UNTO_TARGET_SINGLE(f) (ereal_unto_float (f))
#define REAL_VALUE_FROM_TARGET_DOUBLE(d) (ereal_from_double (d))
#define REAL_VALUE_FROM_TARGET_SINGLE(f) (ereal_from_float (f))
#define REAL_VALUE_TO_DECIMAL(r, fmt, s) (ereal_to_decimal (r, s))
#endif
#else
#ifdef REAL_ARITHMETIC
#if HOST_FLOAT_FORMAT != TARGET_FLOAT_FORMAT
#define REAL_IS_NOT_DOUBLE
#ifndef REAL_VALUE_TYPE
typedef struct {
HOST_WIDE_INT r[sizeof (double)/sizeof (HOST_WIDE_INT)];
} realvaluetype;
#define REAL_VALUE_TYPE realvaluetype
#endif
#endif
#endif
#endif
#ifndef REAL_VALUE_TYPE
#define REAL_VALUE_TYPE double
#else
#define REAL_IS_NOT_DOUBLE
#endif
#if HOST_FLOAT_FORMAT == TARGET_FLOAT_FORMAT
#ifndef REAL_VALUE_TO_TARGET_SINGLE
#define REAL_VALUE_TO_TARGET_SINGLE(IN, OUT) \
do { \
union { \
float f; \
HOST_WIDE_INT l; \
} u; \
if (sizeof(HOST_WIDE_INT) < sizeof(float)) \
abort(); \
u.l = 0; \
u.f = (IN); \
(OUT) = u.l; \
} while (0)
#endif
#ifndef REAL_VALUE_TO_TARGET_DOUBLE
#define REAL_VALUE_TO_TARGET_DOUBLE(IN, OUT) \
do { \
union { \
REAL_VALUE_TYPE f; \
HOST_WIDE_INT l[2]; \
} u; \
if (sizeof(HOST_WIDE_INT) * 2 < sizeof(REAL_VALUE_TYPE)) \
abort(); \
u.l[0] = u.l[1] = 0; \
u.f = (IN); \
if (HOST_FLOAT_WORDS_BIG_ENDIAN == FLOAT_WORDS_BIG_ENDIAN) \
(OUT)[0] = u.l[0], (OUT)[1] = u.l[1]; \
else \
(OUT)[1] = u.l[0], (OUT)[0] = u.l[1]; \
} while (0)
#endif
#endif
#ifndef REAL_VALUE_TO_TARGET_LONG_DOUBLE
#define REAL_VALUE_TO_TARGET_LONG_DOUBLE(a, b) REAL_VALUE_TO_TARGET_DOUBLE (a, b)
#endif
#define REAL_VALUES_IDENTICAL(x, y) \
(!bcmp ((char *) &(x), (char *) &(y), sizeof (REAL_VALUE_TYPE)))
#ifndef REAL_VALUES_EQUAL
#define REAL_VALUES_EQUAL(x, y) ((x) == (y))
#endif
#ifndef REAL_VALUES_LESS
#define REAL_VALUES_LESS(x, y) ((x) < (y))
#endif
#ifndef REAL_VALUE_RNDZINT
#define REAL_VALUE_RNDZINT(x) ((double) ((int) (x)))
#endif
#ifndef REAL_VALUE_UNSIGNED_RNDZINT
#define REAL_VALUE_UNSIGNED_RNDZINT(x) ((double) ((unsigned int) (x)))
#endif
#ifndef REAL_VALUE_FIX
#define REAL_VALUE_FIX(x) ((int) (x))
#endif
#ifndef REAL_VALUE_UNSIGNED_FIX
#define REAL_VALUE_UNSIGNED_FIX(x) ((unsigned int) (x))
#endif
#ifndef REAL_VALUE_LDEXP
#define REAL_VALUE_LDEXP(x, y) ldexp (x, y)
extern double ldexp ();
#endif
#ifndef REAL_VALUE_ATOF
#if 1
REAL_VALUE_TYPE ereal_atof ();
#define REAL_VALUE_ATOF(x, s) ereal_atof (x, s)
#else
#define REAL_VALUE_ATOF(x, s) atof (x)
#if defined (MIPSEL) || defined (MIPSEB)
extern double atof ();
#else
extern double (atof) ();
#endif
#endif
#endif
#ifndef REAL_VALUE_HTOF
extern REAL_VALUE_TYPE real_hex_to_f PROTO((char *, enum machine_mode));
#define REAL_VALUE_HTOF(s,m) real_hex_to_f(s,m)
#endif
#ifndef REAL_VALUE_NEGATE
#define REAL_VALUE_NEGATE(x) (- (x))
#endif
extern REAL_VALUE_TYPE real_value_truncate PROTO((enum machine_mode, REAL_VALUE_TYPE));
#ifndef REAL_VALUE_TRUNCATE
#define REAL_VALUE_TRUNCATE(mode, x) \
(GET_MODE_BITSIZE (mode) == sizeof (float) * HOST_BITS_PER_CHAR \
? (float) (x) : (x))
#endif
#ifndef REAL_VALUE_ISINF
#define REAL_VALUE_ISINF(x) (target_isinf (x))
#endif
#ifndef REAL_VALUE_ISNAN
#define REAL_VALUE_ISNAN(x) (target_isnan (x))
#endif
#ifndef REAL_VALUE_NEGATIVE
#define REAL_VALUE_NEGATIVE(x) (target_negative (x))
#endif
extern int target_isnan PROTO ((REAL_VALUE_TYPE));
extern int target_isinf PROTO ((REAL_VALUE_TYPE));
extern int target_negative PROTO ((REAL_VALUE_TYPE));
#ifndef REAL_VALUE_MINUS_ZERO
#define REAL_VALUE_MINUS_ZERO(x) ((x) == 0 && REAL_VALUE_NEGATIVE (x))
#endif
extern REAL_VALUE_TYPE dconst0;
extern REAL_VALUE_TYPE dconst1;
extern REAL_VALUE_TYPE dconst2;
extern REAL_VALUE_TYPE dconstm1;
union real_extract
{
REAL_VALUE_TYPE d;
HOST_WIDE_INT i[sizeof (REAL_VALUE_TYPE) / sizeof (HOST_WIDE_INT)];
};
#define CONST_DOUBLE_LOW(r) XWINT (r, 2)
#define CONST_DOUBLE_HIGH(r) XWINT (r, 3)
#define CONST_DOUBLE_CHAIN(r) XEXP (r, 1)
#define CONST_DOUBLE_MEM(r) XEXP (r, 0)
union tree_node;
REAL_VALUE_TYPE real_value_from_int_cst PROTO ((union tree_node *,
union tree_node *));
#define REAL_VALUE_FROM_CONST_DOUBLE(to, from) \
do { union real_extract u; \
bcopy ((char *) &CONST_DOUBLE_LOW ((from)), (char *) &u, sizeof u); \
to = u.d; } while (0)
#define CONST_DOUBLE_FROM_REAL_VALUE(r, m) immed_real_const_1 (r, m)
extern struct rtx_def *immed_real_const_1 PROTO((REAL_VALUE_TYPE,
enum machine_mode));
#define CONST_VECTOR_0(r) XWINT (r, 2)
#define CONST_VECTOR_1(r) XWINT (r, 3)
#define CONST_VECTOR_2(r) XWINT (r, 4)
#define CONST_VECTOR_3(r) XWINT (r, 5)
#define CONST_VECTOR_CHAIN(r) XEXP (r, 1)
#define CONST_VECTOR_MEM(r) XEXP (r, 0)
#ifndef REAL_VALUE_TO_DECIMAL
#define REAL_VALUE_TO_DECIMAL(r, fmt, s) (sprintf (s, fmt, r))
#endif
extern int exact_real_inverse PROTO((enum machine_mode, REAL_VALUE_TYPE *));
extern void debug_real PROTO ((REAL_VALUE_TYPE));
extern void assemble_real PROTO ((REAL_VALUE_TYPE,
enum machine_mode));
#endif