1/* Definitions of floating-point access for GNU compiler. 2 Copyright (C) 1989, 1991, 1994, 1996, 1997, 1998, 1999, 3 2000, 2002, 2003, 2004, 2005 Free Software Foundation, Inc. 4 5 This file is part of GCC. 6 7 GCC is free software; you can redistribute it and/or modify it under 8 the terms of the GNU General Public License as published by the Free 9 Software Foundation; either version 2, or (at your option) any later 10 version. 11 12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY 13 WARRANTY; without even the implied warranty of MERCHANTABILITY or 14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 15 for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with GCC; see the file COPYING. If not, write to the Free 19 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 20 02110-1301, USA. */ 21 22#ifndef GCC_REAL_H 23#define GCC_REAL_H 24 25#include "machmode.h" 26 27/* An expanded form of the represented number. */ 28 29/* Enumerate the special cases of numbers that we encounter. */ 30enum real_value_class { 31 rvc_zero, 32 rvc_normal, 33 rvc_inf, 34 rvc_nan 35}; 36 37#define SIGNIFICAND_BITS (128 + HOST_BITS_PER_LONG) 38#define EXP_BITS (32 - 5) 39#define MAX_EXP ((1 << (EXP_BITS - 1)) - 1) 40#define SIGSZ (SIGNIFICAND_BITS / HOST_BITS_PER_LONG) 41#define SIG_MSB ((unsigned long)1 << (HOST_BITS_PER_LONG - 1)) 42 43struct real_value GTY(()) 44{ 45 /* Use the same underlying type for all bit-fields, so as to make 46 sure they're packed together, otherwise REAL_VALUE_TYPE_SIZE will 47 be miscomputed. */ 48 unsigned int /* ENUM_BITFIELD (real_value_class) */ cl : 2; 49 unsigned int sign : 1; 50 unsigned int signalling : 1; 51 unsigned int canonical : 1; 52 unsigned int uexp : EXP_BITS; 53 unsigned long sig[SIGSZ]; 54}; 55 56#define REAL_EXP(REAL) \ 57 ((int)((REAL)->uexp ^ (unsigned int)(1 << (EXP_BITS - 1))) \ 58 - (1 << (EXP_BITS - 1))) 59#define SET_REAL_EXP(REAL, EXP) \ 60 ((REAL)->uexp = ((unsigned int)(EXP) & (unsigned int)((1 << EXP_BITS) - 1))) 61 62/* Various headers condition prototypes on #ifdef REAL_VALUE_TYPE, so it 63 needs to be a macro. We do need to continue to have a structure tag 64 so that other headers can forward declare it. */ 65#define REAL_VALUE_TYPE struct real_value 66 67/* We store a REAL_VALUE_TYPE into an rtx, and we do this by putting it in 68 consecutive "w" slots. Moreover, we've got to compute the number of "w" 69 slots at preprocessor time, which means we can't use sizeof. Guess. */ 70 71#define REAL_VALUE_TYPE_SIZE (SIGNIFICAND_BITS + 32) 72#define REAL_WIDTH \ 73 (REAL_VALUE_TYPE_SIZE/HOST_BITS_PER_WIDE_INT \ 74 + (REAL_VALUE_TYPE_SIZE%HOST_BITS_PER_WIDE_INT ? 1 : 0)) /* round up */ 75 76/* Verify the guess. */ 77extern char test_real_width 78 [sizeof(REAL_VALUE_TYPE) <= REAL_WIDTH*sizeof(HOST_WIDE_INT) ? 1 : -1]; 79 80/* Calculate the format for CONST_DOUBLE. We need as many slots as 81 are necessary to overlay a REAL_VALUE_TYPE on them. This could be 82 as many as four (32-bit HOST_WIDE_INT, 128-bit REAL_VALUE_TYPE). 83 84 A number of places assume that there are always at least two 'w' 85 slots in a CONST_DOUBLE, so we provide them even if one would suffice. */ 86 87#if REAL_WIDTH == 1 88# define CONST_DOUBLE_FORMAT "ww" 89#else 90# if REAL_WIDTH == 2 91# define CONST_DOUBLE_FORMAT "ww" 92# else 93# if REAL_WIDTH == 3 94# define CONST_DOUBLE_FORMAT "www" 95# else 96# if REAL_WIDTH == 4 97# define CONST_DOUBLE_FORMAT "wwww" 98# else 99# if REAL_WIDTH == 5 100# define CONST_DOUBLE_FORMAT "wwwww" 101# else 102# if REAL_WIDTH == 6 103# define CONST_DOUBLE_FORMAT "wwwwww" 104# else 105 #error "REAL_WIDTH > 6 not supported" 106# endif 107# endif 108# endif 109# endif 110# endif 111#endif 112 113 114/* Describes the properties of the specific target format in use. */ 115struct real_format 116{ 117 /* Move to and from the target bytes. */ 118 void (*encode) (const struct real_format *, long *, 119 const REAL_VALUE_TYPE *); 120 void (*decode) (const struct real_format *, REAL_VALUE_TYPE *, 121 const long *); 122 123 /* The radix of the exponent and digits of the significand. */ 124 int b; 125 126 /* log2(b). */ 127 int log2_b; 128 129 /* Size of the significand in digits of radix B. */ 130 int p; 131 132 /* Size of the significant of a NaN, in digits of radix B. */ 133 int pnan; 134 135 /* The minimum negative integer, x, such that b**(x-1) is normalized. */ 136 int emin; 137 138 /* The maximum integer, x, such that b**(x-1) is representable. */ 139 int emax; 140 141 /* The bit position of the sign bit, for determining whether a value 142 is positive/negative, or -1 for a complex encoding. */ 143 int signbit_ro; 144 145 /* The bit position of the sign bit, for changing the sign of a number, 146 or -1 for a complex encoding. */ 147 int signbit_rw; 148 149 /* Properties of the format. */ 150 bool has_nans; 151 bool has_inf; 152 bool has_denorm; 153 bool has_signed_zero; 154 bool qnan_msb_set; 155}; 156 157 158/* The target format used for each floating floating point mode. 159 Indexed by MODE - QFmode. */ 160extern const struct real_format * 161 real_format_for_mode[MAX_MODE_FLOAT - MIN_MODE_FLOAT + 1]; 162 163#define REAL_MODE_FORMAT(MODE) (real_format_for_mode[(MODE) - MIN_MODE_FLOAT]) 164 165/* The following macro determines whether the floating point format is 166 composite, i.e. may contain non-consecutive mantissa bits, in which 167 case compile-time FP overflow may not model run-time overflow. */ 168#define REAL_MODE_FORMAT_COMPOSITE_P(MODE) \ 169 ((REAL_MODE_FORMAT(MODE))->pnan < (REAL_MODE_FORMAT (MODE))->p) 170 171/* Declare functions in real.c. */ 172 173/* Binary or unary arithmetic on tree_code. */ 174extern bool real_arithmetic (REAL_VALUE_TYPE *, int, const REAL_VALUE_TYPE *, 175 const REAL_VALUE_TYPE *); 176 177/* Compare reals by tree_code. */ 178extern bool real_compare (int, const REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *); 179 180/* Determine whether a floating-point value X is infinite. */ 181extern bool real_isinf (const REAL_VALUE_TYPE *); 182 183/* Determine whether a floating-point value X is a NaN. */ 184extern bool real_isnan (const REAL_VALUE_TYPE *); 185 186/* Determine whether a floating-point value X is negative. */ 187extern bool real_isneg (const REAL_VALUE_TYPE *); 188 189/* Determine whether a floating-point value X is minus zero. */ 190extern bool real_isnegzero (const REAL_VALUE_TYPE *); 191 192/* Compare two floating-point objects for bitwise identity. */ 193extern bool real_identical (const REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *); 194 195/* Extend or truncate to a new mode. */ 196extern void real_convert (REAL_VALUE_TYPE *, enum machine_mode, 197 const REAL_VALUE_TYPE *); 198 199/* Return true if truncating to NEW is exact. */ 200extern bool exact_real_truncate (enum machine_mode, const REAL_VALUE_TYPE *); 201 202/* Render R as a decimal floating point constant. */ 203extern void real_to_decimal (char *, const REAL_VALUE_TYPE *, size_t, 204 size_t, int); 205 206/* Render R as a hexadecimal floating point constant. */ 207extern void real_to_hexadecimal (char *, const REAL_VALUE_TYPE *, 208 size_t, size_t, int); 209 210/* Render R as an integer. */ 211extern HOST_WIDE_INT real_to_integer (const REAL_VALUE_TYPE *); 212extern void real_to_integer2 (HOST_WIDE_INT *, HOST_WIDE_INT *, 213 const REAL_VALUE_TYPE *); 214 215/* Initialize R from a decimal or hexadecimal string. */ 216extern void real_from_string (REAL_VALUE_TYPE *, const char *); 217 218/* Initialize R from an integer pair HIGH/LOW. */ 219extern void real_from_integer (REAL_VALUE_TYPE *, enum machine_mode, 220 unsigned HOST_WIDE_INT, HOST_WIDE_INT, int); 221 222extern long real_to_target_fmt (long *, const REAL_VALUE_TYPE *, 223 const struct real_format *); 224extern long real_to_target (long *, const REAL_VALUE_TYPE *, enum machine_mode); 225 226extern void real_from_target_fmt (REAL_VALUE_TYPE *, const long *, 227 const struct real_format *); 228extern void real_from_target (REAL_VALUE_TYPE *, const long *, 229 enum machine_mode); 230 231extern void real_inf (REAL_VALUE_TYPE *); 232 233extern bool real_nan (REAL_VALUE_TYPE *, const char *, int, enum machine_mode); 234 235extern void real_maxval (REAL_VALUE_TYPE *, int, enum machine_mode); 236 237extern void real_2expN (REAL_VALUE_TYPE *, int); 238 239extern unsigned int real_hash (const REAL_VALUE_TYPE *); 240 241 242/* Target formats defined in real.c. */ 243extern const struct real_format ieee_single_format; 244extern const struct real_format mips_single_format; 245extern const struct real_format ieee_double_format; 246extern const struct real_format mips_double_format; 247extern const struct real_format ieee_extended_motorola_format; 248extern const struct real_format ieee_extended_intel_96_format; 249extern const struct real_format ieee_extended_intel_96_round_53_format; 250extern const struct real_format ieee_extended_intel_128_format; 251extern const struct real_format ibm_extended_format; 252extern const struct real_format mips_extended_format; 253extern const struct real_format ieee_quad_format; 254extern const struct real_format mips_quad_format; 255extern const struct real_format vax_f_format; 256extern const struct real_format vax_d_format; 257extern const struct real_format vax_g_format; 258extern const struct real_format i370_single_format; 259extern const struct real_format i370_double_format; 260extern const struct real_format c4x_single_format; 261extern const struct real_format c4x_extended_format; 262extern const struct real_format real_internal_format; 263 264 265/* ====================================================================== */ 266/* Crap. */ 267 268#define REAL_ARITHMETIC(value, code, d1, d2) \ 269 real_arithmetic (&(value), code, &(d1), &(d2)) 270 271#define REAL_VALUES_IDENTICAL(x, y) real_identical (&(x), &(y)) 272#define REAL_VALUES_EQUAL(x, y) real_compare (EQ_EXPR, &(x), &(y)) 273#define REAL_VALUES_LESS(x, y) real_compare (LT_EXPR, &(x), &(y)) 274 275/* Determine whether a floating-point value X is infinite. */ 276#define REAL_VALUE_ISINF(x) real_isinf (&(x)) 277 278/* Determine whether a floating-point value X is a NaN. */ 279#define REAL_VALUE_ISNAN(x) real_isnan (&(x)) 280 281/* Determine whether a floating-point value X is negative. */ 282#define REAL_VALUE_NEGATIVE(x) real_isneg (&(x)) 283 284/* Determine whether a floating-point value X is minus zero. */ 285#define REAL_VALUE_MINUS_ZERO(x) real_isnegzero (&(x)) 286 287/* IN is a REAL_VALUE_TYPE. OUT is an array of longs. */ 288#define REAL_VALUE_TO_TARGET_LONG_DOUBLE(IN, OUT) \ 289 real_to_target (OUT, &(IN), \ 290 mode_for_size (LONG_DOUBLE_TYPE_SIZE, MODE_FLOAT, 0)) 291 292#define REAL_VALUE_TO_TARGET_DOUBLE(IN, OUT) \ 293 real_to_target (OUT, &(IN), mode_for_size (64, MODE_FLOAT, 0)) 294 295/* IN is a REAL_VALUE_TYPE. OUT is a long. */ 296#define REAL_VALUE_TO_TARGET_SINGLE(IN, OUT) \ 297 ((OUT) = real_to_target (NULL, &(IN), mode_for_size (32, MODE_FLOAT, 0))) 298 299#define REAL_VALUE_FROM_INT(r, lo, hi, mode) \ 300 real_from_integer (&(r), mode, lo, hi, 0) 301 302#define REAL_VALUE_FROM_UNSIGNED_INT(r, lo, hi, mode) \ 303 real_from_integer (&(r), mode, lo, hi, 1) 304 305extern REAL_VALUE_TYPE real_value_truncate (enum machine_mode, 306 REAL_VALUE_TYPE); 307 308#define REAL_VALUE_TO_INT(plow, phigh, r) \ 309 real_to_integer2 (plow, phigh, &(r)) 310 311extern REAL_VALUE_TYPE real_arithmetic2 (int, const REAL_VALUE_TYPE *, 312 const REAL_VALUE_TYPE *); 313 314#define REAL_VALUE_NEGATE(X) \ 315 real_arithmetic2 (NEGATE_EXPR, &(X), NULL) 316 317#define REAL_VALUE_ABS(X) \ 318 real_arithmetic2 (ABS_EXPR, &(X), NULL) 319 320extern int significand_size (enum machine_mode); 321 322extern REAL_VALUE_TYPE real_from_string2 (const char *, enum machine_mode); 323 324#define REAL_VALUE_ATOF(s, m) \ 325 real_from_string2 (s, m) 326 327#define CONST_DOUBLE_ATOF(s, m) \ 328 CONST_DOUBLE_FROM_REAL_VALUE (real_from_string2 (s, m), m) 329 330#define REAL_VALUE_FIX(r) \ 331 real_to_integer (&(r)) 332 333/* ??? Not quite right. */ 334#define REAL_VALUE_UNSIGNED_FIX(r) \ 335 real_to_integer (&(r)) 336 337/* ??? These were added for Paranoia support. */ 338 339/* Return floor log2(R). */ 340extern int real_exponent (const REAL_VALUE_TYPE *); 341 342/* R = A * 2**EXP. */ 343extern void real_ldexp (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *, int); 344 345/* **** End of software floating point emulator interface macros **** */ 346 347/* Constant real values 0, 1, 2, 3, 10, -1, -2, 0.5 and 1/3. */ 348 349extern REAL_VALUE_TYPE dconst0; 350extern REAL_VALUE_TYPE dconst1; 351extern REAL_VALUE_TYPE dconst2; 352extern REAL_VALUE_TYPE dconst3; 353extern REAL_VALUE_TYPE dconst10; 354extern REAL_VALUE_TYPE dconstm1; 355extern REAL_VALUE_TYPE dconstm2; 356extern REAL_VALUE_TYPE dconsthalf; 357extern REAL_VALUE_TYPE dconstthird; 358extern REAL_VALUE_TYPE dconstpi; 359extern REAL_VALUE_TYPE dconste; 360 361/* Function to return a real value (not a tree node) 362 from a given integer constant. */ 363REAL_VALUE_TYPE real_value_from_int_cst (tree, tree); 364 365/* Given a CONST_DOUBLE in FROM, store into TO the value it represents. */ 366#define REAL_VALUE_FROM_CONST_DOUBLE(to, from) \ 367 ((to) = *CONST_DOUBLE_REAL_VALUE (from)) 368 369/* Return a CONST_DOUBLE with value R and mode M. */ 370#define CONST_DOUBLE_FROM_REAL_VALUE(r, m) \ 371 const_double_from_real_value (r, m) 372extern rtx const_double_from_real_value (REAL_VALUE_TYPE, enum machine_mode); 373 374/* Replace R by 1/R in the given machine mode, if the result is exact. */ 375extern bool exact_real_inverse (enum machine_mode, REAL_VALUE_TYPE *); 376 377/* In tree.c: wrap up a REAL_VALUE_TYPE in a tree node. */ 378extern tree build_real (tree, REAL_VALUE_TYPE); 379 380/* Calculate R as the square root of X in the given machine mode. */ 381extern bool real_sqrt (REAL_VALUE_TYPE *, enum machine_mode, 382 const REAL_VALUE_TYPE *); 383 384/* Calculate R as X raised to the integer exponent N in mode MODE. */ 385extern bool real_powi (REAL_VALUE_TYPE *, enum machine_mode, 386 const REAL_VALUE_TYPE *, HOST_WIDE_INT); 387 388/* Standard round to integer value functions. */ 389extern void real_trunc (REAL_VALUE_TYPE *, enum machine_mode, 390 const REAL_VALUE_TYPE *); 391extern void real_floor (REAL_VALUE_TYPE *, enum machine_mode, 392 const REAL_VALUE_TYPE *); 393extern void real_ceil (REAL_VALUE_TYPE *, enum machine_mode, 394 const REAL_VALUE_TYPE *); 395extern void real_round (REAL_VALUE_TYPE *, enum machine_mode, 396 const REAL_VALUE_TYPE *); 397 398/* Set the sign of R to the sign of X. */ 399extern void real_copysign (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *); 400 401#endif /* ! GCC_REAL_H */ 402