real.h revision 132718
1/* Definitions of floating-point access for GNU compiler. 2 Copyright (C) 1989, 1991, 1994, 1996, 1997, 1998, 1999, 3 2000, 2002, 2003 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, 59 Temple Place - Suite 330, Boston, MA 20 02111-1307, 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 ENUM_BITFIELD (real_value_class) class : 2; 46 unsigned int sign : 1; 47 unsigned int signalling : 1; 48 unsigned int canonical : 1; 49 signed int exp : EXP_BITS; 50 unsigned long sig[SIGSZ]; 51}; 52 53/* Various headers condition prototypes on #ifdef REAL_VALUE_TYPE, so it 54 needs to be a macro. We do need to continue to have a structure tag 55 so that other headers can forward declare it. */ 56#define REAL_VALUE_TYPE struct real_value 57 58/* We store a REAL_VALUE_TYPE into an rtx, and we do this by putting it in 59 consecutive "w" slots. Moreover, we've got to compute the number of "w" 60 slots at preprocessor time, which means we can't use sizeof. Guess. */ 61 62#define REAL_VALUE_TYPE_SIZE (SIGNIFICAND_BITS + 32) 63#define REAL_WIDTH \ 64 (REAL_VALUE_TYPE_SIZE/HOST_BITS_PER_WIDE_INT \ 65 + (REAL_VALUE_TYPE_SIZE%HOST_BITS_PER_WIDE_INT ? 1 : 0)) /* round up */ 66 67/* Verify the guess. */ 68extern char test_real_width 69 [sizeof(REAL_VALUE_TYPE) <= REAL_WIDTH*sizeof(HOST_WIDE_INT) ? 1 : -1]; 70 71/* Calculate the format for CONST_DOUBLE. We need as many slots as 72 are necessary to overlay a REAL_VALUE_TYPE on them. This could be 73 as many as four (32-bit HOST_WIDE_INT, 128-bit REAL_VALUE_TYPE). 74 75 A number of places assume that there are always at least two 'w' 76 slots in a CONST_DOUBLE, so we provide them even if one would suffice. */ 77 78#if REAL_WIDTH == 1 79# define CONST_DOUBLE_FORMAT "ww" 80#else 81# if REAL_WIDTH == 2 82# define CONST_DOUBLE_FORMAT "ww" 83# else 84# if REAL_WIDTH == 3 85# define CONST_DOUBLE_FORMAT "www" 86# else 87# if REAL_WIDTH == 4 88# define CONST_DOUBLE_FORMAT "wwww" 89# else 90# if REAL_WIDTH == 5 91# define CONST_DOUBLE_FORMAT "wwwww" 92# else 93# if REAL_WIDTH == 6 94# define CONST_DOUBLE_FORMAT "wwwwww" 95# else 96 #error "REAL_WIDTH > 6 not supported" 97# endif 98# endif 99# endif 100# endif 101# endif 102#endif 103 104 105/* Describes the properties of the specific target format in use. */ 106struct real_format 107{ 108 /* Move to and from the target bytes. */ 109 void (*encode) (const struct real_format *, long *, 110 const REAL_VALUE_TYPE *); 111 void (*decode) (const struct real_format *, REAL_VALUE_TYPE *, 112 const long *); 113 114 /* The radix of the exponent and digits of the significand. */ 115 int b; 116 117 /* log2(b). */ 118 int log2_b; 119 120 /* Size of the significand in digits of radix B. */ 121 int p; 122 123 /* Size of the significant of a NaN, in digits of radix B. */ 124 int pnan; 125 126 /* The minimum negative integer, x, such that b**(x-1) is normalized. */ 127 int emin; 128 129 /* The maximum integer, x, such that b**(x-1) is representable. */ 130 int emax; 131 132 /* The bit position of the sign bit, or -1 for a complex encoding. */ 133 int signbit; 134 135 /* Properties of the format. */ 136 bool has_nans; 137 bool has_inf; 138 bool has_denorm; 139 bool has_signed_zero; 140 bool qnan_msb_set; 141}; 142 143 144/* The target format used for each floating floating point mode. 145 Indexed by MODE - QFmode. */ 146extern const struct real_format * 147 real_format_for_mode[MAX_MODE_FLOAT - MIN_MODE_FLOAT + 1]; 148 149#define REAL_MODE_FORMAT(MODE) (real_format_for_mode[(MODE) - MIN_MODE_FLOAT]) 150 151/* Declare functions in real.c. */ 152 153/* Binary or unary arithmetic on tree_code. */ 154extern void real_arithmetic (REAL_VALUE_TYPE *, int, const REAL_VALUE_TYPE *, 155 const REAL_VALUE_TYPE *); 156 157/* Compare reals by tree_code. */ 158extern bool real_compare (int, const REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *); 159 160/* Determine whether a floating-point value X is infinite. */ 161extern bool real_isinf (const REAL_VALUE_TYPE *); 162 163/* Determine whether a floating-point value X is a NaN. */ 164extern bool real_isnan (const REAL_VALUE_TYPE *); 165 166/* Determine whether a floating-point value X is negative. */ 167extern bool real_isneg (const REAL_VALUE_TYPE *); 168 169/* Determine whether a floating-point value X is minus zero. */ 170extern bool real_isnegzero (const REAL_VALUE_TYPE *); 171 172/* Compare two floating-point objects for bitwise identity. */ 173extern bool real_identical (const REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *); 174 175/* Extend or truncate to a new mode. */ 176extern void real_convert (REAL_VALUE_TYPE *, enum machine_mode, 177 const REAL_VALUE_TYPE *); 178 179/* Return true if truncating to NEW is exact. */ 180extern bool exact_real_truncate (enum machine_mode, const REAL_VALUE_TYPE *); 181 182/* Render R as a decimal floating point constant. */ 183extern void real_to_decimal (char *, const REAL_VALUE_TYPE *, size_t, 184 size_t, int); 185 186/* Render R as a hexadecimal floating point constant. */ 187extern void real_to_hexadecimal (char *, const REAL_VALUE_TYPE *, 188 size_t, size_t, int); 189 190/* Render R as an integer. */ 191extern HOST_WIDE_INT real_to_integer (const REAL_VALUE_TYPE *); 192extern void real_to_integer2 (HOST_WIDE_INT *, HOST_WIDE_INT *, 193 const REAL_VALUE_TYPE *); 194 195/* Initialize R from a decimal or hexadecimal string. */ 196extern void real_from_string (REAL_VALUE_TYPE *, const char *); 197 198/* Initialize R from an integer pair HIGH/LOW. */ 199extern void real_from_integer (REAL_VALUE_TYPE *, enum machine_mode, 200 unsigned HOST_WIDE_INT, HOST_WIDE_INT, int); 201 202extern long real_to_target_fmt (long *, const REAL_VALUE_TYPE *, 203 const struct real_format *); 204extern long real_to_target (long *, const REAL_VALUE_TYPE *, enum machine_mode); 205 206extern void real_from_target_fmt (REAL_VALUE_TYPE *, const long *, 207 const struct real_format *); 208extern void real_from_target (REAL_VALUE_TYPE *, const long *, 209 enum machine_mode); 210 211extern void real_inf (REAL_VALUE_TYPE *); 212 213extern bool real_nan (REAL_VALUE_TYPE *, const char *, int, enum machine_mode); 214 215extern void real_maxval (REAL_VALUE_TYPE *, int, enum machine_mode); 216 217extern void real_2expN (REAL_VALUE_TYPE *, int); 218 219extern unsigned int real_hash (const REAL_VALUE_TYPE *); 220 221 222/* Target formats defined in real.c. */ 223extern const struct real_format ieee_single_format; 224extern const struct real_format mips_single_format; 225extern const struct real_format ieee_double_format; 226extern const struct real_format mips_double_format; 227extern const struct real_format ieee_extended_motorola_format; 228extern const struct real_format ieee_extended_intel_96_format; 229extern const struct real_format ieee_extended_intel_96_round_53_format; 230extern const struct real_format ieee_extended_intel_128_format; 231extern const struct real_format ibm_extended_format; 232extern const struct real_format mips_extended_format; 233extern const struct real_format ieee_quad_format; 234extern const struct real_format mips_quad_format; 235extern const struct real_format vax_f_format; 236extern const struct real_format vax_d_format; 237extern const struct real_format vax_g_format; 238extern const struct real_format i370_single_format; 239extern const struct real_format i370_double_format; 240extern const struct real_format c4x_single_format; 241extern const struct real_format c4x_extended_format; 242extern const struct real_format real_internal_format; 243 244 245/* ====================================================================== */ 246/* Crap. */ 247 248#define REAL_ARITHMETIC(value, code, d1, d2) \ 249 real_arithmetic (&(value), code, &(d1), &(d2)) 250 251#define REAL_VALUES_IDENTICAL(x, y) real_identical (&(x), &(y)) 252#define REAL_VALUES_EQUAL(x, y) real_compare (EQ_EXPR, &(x), &(y)) 253#define REAL_VALUES_LESS(x, y) real_compare (LT_EXPR, &(x), &(y)) 254 255/* Determine whether a floating-point value X is infinite. */ 256#define REAL_VALUE_ISINF(x) real_isinf (&(x)) 257 258/* Determine whether a floating-point value X is a NaN. */ 259#define REAL_VALUE_ISNAN(x) real_isnan (&(x)) 260 261/* Determine whether a floating-point value X is negative. */ 262#define REAL_VALUE_NEGATIVE(x) real_isneg (&(x)) 263 264/* Determine whether a floating-point value X is minus zero. */ 265#define REAL_VALUE_MINUS_ZERO(x) real_isnegzero (&(x)) 266 267/* IN is a REAL_VALUE_TYPE. OUT is an array of longs. */ 268#define REAL_VALUE_TO_TARGET_LONG_DOUBLE(IN, OUT) \ 269 real_to_target (OUT, &(IN), \ 270 mode_for_size (LONG_DOUBLE_TYPE_SIZE, MODE_FLOAT, 0)) 271 272#define REAL_VALUE_TO_TARGET_DOUBLE(IN, OUT) \ 273 real_to_target (OUT, &(IN), mode_for_size (64, MODE_FLOAT, 0)) 274 275/* IN is a REAL_VALUE_TYPE. OUT is a long. */ 276#define REAL_VALUE_TO_TARGET_SINGLE(IN, OUT) \ 277 ((OUT) = real_to_target (NULL, &(IN), mode_for_size (32, MODE_FLOAT, 0))) 278 279#define REAL_VALUE_FROM_INT(r, lo, hi, mode) \ 280 real_from_integer (&(r), mode, lo, hi, 0) 281 282#define REAL_VALUE_FROM_UNSIGNED_INT(r, lo, hi, mode) \ 283 real_from_integer (&(r), mode, lo, hi, 1) 284 285extern REAL_VALUE_TYPE real_value_truncate (enum machine_mode, 286 REAL_VALUE_TYPE); 287 288#define REAL_VALUE_TO_INT(plow, phigh, r) \ 289 real_to_integer2 (plow, phigh, &(r)) 290 291extern REAL_VALUE_TYPE real_arithmetic2 (int, const REAL_VALUE_TYPE *, 292 const REAL_VALUE_TYPE *); 293 294#define REAL_VALUE_NEGATE(X) \ 295 real_arithmetic2 (NEGATE_EXPR, &(X), NULL) 296 297#define REAL_VALUE_ABS(X) \ 298 real_arithmetic2 (ABS_EXPR, &(X), NULL) 299 300extern int significand_size (enum machine_mode); 301 302extern REAL_VALUE_TYPE real_from_string2 (const char *, enum machine_mode); 303 304#define REAL_VALUE_ATOF(s, m) \ 305 real_from_string2 (s, m) 306 307#define CONST_DOUBLE_ATOF(s, m) \ 308 CONST_DOUBLE_FROM_REAL_VALUE (real_from_string2 (s, m), m) 309 310#define REAL_VALUE_FIX(r) \ 311 real_to_integer (&(r)) 312 313/* ??? Not quite right. */ 314#define REAL_VALUE_UNSIGNED_FIX(r) \ 315 real_to_integer (&(r)) 316 317/* ??? These were added for Paranoia support. */ 318 319/* Return floor log2(R). */ 320extern int real_exponent (const REAL_VALUE_TYPE *); 321 322/* R = A * 2**EXP. */ 323extern void real_ldexp (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *, int); 324 325/* **** End of software floating point emulator interface macros **** */ 326 327/* Constant real values 0, 1, 2, 3, 10, -1, -2, 0.5 and 1/3. */ 328 329extern REAL_VALUE_TYPE dconst0; 330extern REAL_VALUE_TYPE dconst1; 331extern REAL_VALUE_TYPE dconst2; 332extern REAL_VALUE_TYPE dconst3; 333extern REAL_VALUE_TYPE dconst10; 334extern REAL_VALUE_TYPE dconstm1; 335extern REAL_VALUE_TYPE dconstm2; 336extern REAL_VALUE_TYPE dconsthalf; 337extern REAL_VALUE_TYPE dconstthird; 338extern REAL_VALUE_TYPE dconstpi; 339extern REAL_VALUE_TYPE dconste; 340 341/* Function to return a real value (not a tree node) 342 from a given integer constant. */ 343REAL_VALUE_TYPE real_value_from_int_cst (tree, tree); 344 345/* Given a CONST_DOUBLE in FROM, store into TO the value it represents. */ 346#define REAL_VALUE_FROM_CONST_DOUBLE(to, from) \ 347 memcpy (&(to), &CONST_DOUBLE_LOW ((from)), sizeof (REAL_VALUE_TYPE)) 348 349/* Return a CONST_DOUBLE with value R and mode M. */ 350#define CONST_DOUBLE_FROM_REAL_VALUE(r, m) \ 351 const_double_from_real_value (r, m) 352extern rtx const_double_from_real_value (REAL_VALUE_TYPE, enum machine_mode); 353 354/* Replace R by 1/R in the given machine mode, if the result is exact. */ 355extern bool exact_real_inverse (enum machine_mode, REAL_VALUE_TYPE *); 356 357/* In tree.c: wrap up a REAL_VALUE_TYPE in a tree node. */ 358extern tree build_real (tree, REAL_VALUE_TYPE); 359 360/* Calculate R as the square root of X in the given machine mode. */ 361extern bool real_sqrt (REAL_VALUE_TYPE *, enum machine_mode, 362 const REAL_VALUE_TYPE *); 363 364/* Calculate R as X raised to the integer exponent N in mode MODE. */ 365extern bool real_powi (REAL_VALUE_TYPE *, enum machine_mode, 366 const REAL_VALUE_TYPE *, HOST_WIDE_INT); 367 368/* Standard round to integer value functions. */ 369extern void real_trunc (REAL_VALUE_TYPE *, enum machine_mode, 370 const REAL_VALUE_TYPE *); 371extern void real_floor (REAL_VALUE_TYPE *, enum machine_mode, 372 const REAL_VALUE_TYPE *); 373extern void real_ceil (REAL_VALUE_TYPE *, enum machine_mode, 374 const REAL_VALUE_TYPE *); 375 376#endif /* ! GCC_REAL_H */ 377