gcc/real.h

   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.  */
  30 enum 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
  43 struct 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.  */
  77 extern 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.  */
 115 struct 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.  */
 160 extern 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.  */
 174 extern bool real_arithmetic (REAL_VALUE_TYPE *, int, const REAL_VALUE_TYPE *,
 175                              const REAL_VALUE_TYPE *);
 176
 177 /* Compare reals by tree_code.  */
 178 extern bool real_compare (int, const REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *);
 179
 180 /* Determine whether a floating-point value X is infinite.  */
 181 extern bool real_isinf (const REAL_VALUE_TYPE *);
 182
 183 /* Determine whether a floating-point value X is a NaN.  */
 184 extern bool real_isnan (const REAL_VALUE_TYPE *);
 185
 186 /* Determine whether a floating-point value X is negative.  */
 187 extern bool real_isneg (const REAL_VALUE_TYPE *);
 188
 189 /* Determine whether a floating-point value X is minus zero.  */
 190 extern bool real_isnegzero (const REAL_VALUE_TYPE *);
 191
 192 /* Compare two floating-point objects for bitwise identity.  */
 193 extern bool real_identical (const REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *);
 194
 195 /* Extend or truncate to a new mode.  */
 196 extern void real_convert (REAL_VALUE_TYPE *, enum machine_mode,
 197                           const REAL_VALUE_TYPE *);
 198
 199 /* Return true if truncating to NEW is exact.  */
 200 extern bool exact_real_truncate (enum machine_mode, const REAL_VALUE_TYPE *);
 201
 202 /* Render R as a decimal floating point constant.  */
 203 extern 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.  */
 207 extern void real_to_hexadecimal (char *, const REAL_VALUE_TYPE *,
 208                                  size_t, size_t, int);
 209
 210 /* Render R as an integer.  */
 211 extern HOST_WIDE_INT real_to_integer (const REAL_VALUE_TYPE *);
 212 extern 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.  */
 216 extern void real_from_string (REAL_VALUE_TYPE *, const char *);
 217
 218 /* Initialize R from an integer pair HIGH/LOW.  */
 219 extern void real_from_integer (REAL_VALUE_TYPE *, enum machine_mode,
 220                                unsigned HOST_WIDE_INT, HOST_WIDE_INT, int);
 221
 222 extern long real_to_target_fmt (long *, const REAL_VALUE_TYPE *,
 223                                 const struct real_format *);
 224 extern long real_to_target (long *, const REAL_VALUE_TYPE *, enum machine_mode);
 225
 226 extern void real_from_target_fmt (REAL_VALUE_TYPE *, const long *,
 227                                   const struct real_format *);
 228 extern void real_from_target (REAL_VALUE_TYPE *, const long *,
 229                               enum machine_mode);
 230
 231 extern void real_inf (REAL_VALUE_TYPE *);
 232
 233 extern bool real_nan (REAL_VALUE_TYPE *, const char *, int, enum machine_mode);
 234
 235 extern void real_maxval (REAL_VALUE_TYPE *, int, enum machine_mode);
 236
 237 extern void real_2expN (REAL_VALUE_TYPE *, int);
 238
 239 extern unsigned int real_hash (const REAL_VALUE_TYPE *);
 240
 241
 242 /* Target formats defined in real.c.  */
 243 extern const struct real_format ieee_single_format;
 244 extern const struct real_format mips_single_format;
 245 extern const struct real_format ieee_double_format;
 246 extern const struct real_format mips_double_format;
 247 extern const struct real_format ieee_extended_motorola_format;
 248 extern const struct real_format ieee_extended_intel_96_format;
 249 extern const struct real_format ieee_extended_intel_96_round_53_format;
 250 extern const struct real_format ieee_extended_intel_128_format;
 251 extern const struct real_format ibm_extended_format;
 252 extern const struct real_format mips_extended_format;
 253 extern const struct real_format ieee_quad_format;
 254 extern const struct real_format mips_quad_format;
 255 extern const struct real_format vax_f_format;
 256 extern const struct real_format vax_d_format;
 257 extern const struct real_format vax_g_format;
 258 extern const struct real_format i370_single_format;
 259 extern const struct real_format i370_double_format;
 260 extern const struct real_format c4x_single_format;
 261 extern const struct real_format c4x_extended_format;
 262 extern 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
 305 extern 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
 311 extern 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
 320 extern int significand_size (enum machine_mode);
 321
 322 extern 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).  */
 340 extern int real_exponent (const REAL_VALUE_TYPE *);
 341
 342 /* R = A * 2**EXP.  */
 343 extern void real_ldexp (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *, int);
 344
 345 /* **** End of software floating point emulator interface macros **** */
 346 \f
 347 /* Constant real values 0, 1, 2, 3, 10, -1, -2, 0.5 and 1/3.  */
 348
 349 extern REAL_VALUE_TYPE dconst0;
 350 extern REAL_VALUE_TYPE dconst1;
 351 extern REAL_VALUE_TYPE dconst2;
 352 extern REAL_VALUE_TYPE dconst3;
 353 extern REAL_VALUE_TYPE dconst10;
 354 extern REAL_VALUE_TYPE dconstm1;
 355 extern REAL_VALUE_TYPE dconstm2;
 356 extern REAL_VALUE_TYPE dconsthalf;
 357 extern REAL_VALUE_TYPE dconstthird;
 358 extern REAL_VALUE_TYPE dconstpi;
 359 extern REAL_VALUE_TYPE dconste;
 360
 361 /* Function to return a real value (not a tree node)
 362    from a given integer constant.  */
 363 REAL_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)
 372 extern 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.  */
 375 extern 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.  */
 378 extern tree build_real (tree, REAL_VALUE_TYPE);
 379
 380 /* Calculate R as the square root of X in the given machine mode.  */
 381 extern 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.  */
 385 extern 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.  */
 389 extern void real_trunc (REAL_VALUE_TYPE *, enum machine_mode,
 390                         const REAL_VALUE_TYPE *);
 391 extern void real_floor (REAL_VALUE_TYPE *, enum machine_mode,
 392                         const REAL_VALUE_TYPE *);
 393 extern void real_ceil (REAL_VALUE_TYPE *, enum machine_mode,
 394                        const REAL_VALUE_TYPE *);
 395 extern 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.  */
 399 extern void real_copysign (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *);
 400
 401 #endif /* ! GCC_REAL_H */