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 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.  */
  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   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.  */
  68 extern 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.  */
 106 struct 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.  */
 146 extern 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.  */
 154 extern void real_arithmetic (REAL_VALUE_TYPE *, int, const REAL_VALUE_TYPE *,
 155                              const REAL_VALUE_TYPE *);
 156
 157 /* Compare reals by tree_code.  */
 158 extern bool real_compare (int, const REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *);
 159
 160 /* Determine whether a floating-point value X is infinite.  */
 161 extern bool real_isinf (const REAL_VALUE_TYPE *);
 162
 163 /* Determine whether a floating-point value X is a NaN.  */
 164 extern bool real_isnan (const REAL_VALUE_TYPE *);
 165
 166 /* Determine whether a floating-point value X is negative.  */
 167 extern bool real_isneg (const REAL_VALUE_TYPE *);
 168
 169 /* Determine whether a floating-point value X is minus zero.  */
 170 extern bool real_isnegzero (const REAL_VALUE_TYPE *);
 171
 172 /* Compare two floating-point objects for bitwise identity.  */
 173 extern bool real_identical (const REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *);
 174
 175 /* Extend or truncate to a new mode.  */
 176 extern void real_convert (REAL_VALUE_TYPE *, enum machine_mode,
 177                           const REAL_VALUE_TYPE *);
 178
 179 /* Return true if truncating to NEW is exact.  */
 180 extern bool exact_real_truncate (enum machine_mode, const REAL_VALUE_TYPE *);
 181
 182 /* Render R as a decimal floating point constant.  */
 183 extern 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.  */
 187 extern void real_to_hexadecimal (char *, const REAL_VALUE_TYPE *,
 188                                  size_t, size_t, int);
 189
 190 /* Render R as an integer.  */
 191 extern HOST_WIDE_INT real_to_integer (const REAL_VALUE_TYPE *);
 192 extern 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.  */
 196 extern void real_from_string (REAL_VALUE_TYPE *, const char *);
 197
 198 /* Initialize R from an integer pair HIGH/LOW.  */
 199 extern void real_from_integer (REAL_VALUE_TYPE *, enum machine_mode,
 200                                unsigned HOST_WIDE_INT, HOST_WIDE_INT, int);
 201
 202 extern long real_to_target_fmt (long *, const REAL_VALUE_TYPE *,
 203                                 const struct real_format *);
 204 extern long real_to_target (long *, const REAL_VALUE_TYPE *, enum machine_mode);
 205
 206 extern void real_from_target_fmt (REAL_VALUE_TYPE *, const long *,
 207                                   const struct real_format *);
 208 extern void real_from_target (REAL_VALUE_TYPE *, const long *,
 209                               enum machine_mode);
 210
 211 extern void real_inf (REAL_VALUE_TYPE *);
 212
 213 extern bool real_nan (REAL_VALUE_TYPE *, const char *, int, enum machine_mode);
 214
 215 extern void real_maxval (REAL_VALUE_TYPE *, int, enum machine_mode);
 216
 217 extern void real_2expN (REAL_VALUE_TYPE *, int);
 218
 219 extern unsigned int real_hash (const REAL_VALUE_TYPE *);
 220
 221
 222 /* Target formats defined in real.c.  */
 223 extern const struct real_format ieee_single_format;
 224 extern const struct real_format mips_single_format;
 225 extern const struct real_format ieee_double_format;
 226 extern const struct real_format mips_double_format;
 227 extern const struct real_format ieee_extended_motorola_format;
 228 extern const struct real_format ieee_extended_intel_96_format;
 229 extern const struct real_format ieee_extended_intel_96_round_53_format;
 230 extern const struct real_format ieee_extended_intel_128_format;
 231 extern const struct real_format ibm_extended_format;
 232 extern const struct real_format mips_extended_format;
 233 extern const struct real_format ieee_quad_format;
 234 extern const struct real_format mips_quad_format;
 235 extern const struct real_format vax_f_format;
 236 extern const struct real_format vax_d_format;
 237 extern const struct real_format vax_g_format;
 238 extern const struct real_format i370_single_format;
 239 extern const struct real_format i370_double_format;
 240 extern const struct real_format c4x_single_format;
 241 extern const struct real_format c4x_extended_format;
 242 extern 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
 285 extern 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
 291 extern 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
 300 extern int significand_size (enum machine_mode);
 301
 302 extern 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).  */
 320 extern int real_exponent (const REAL_VALUE_TYPE *);
 321
 322 /* R = A * 2**EXP.  */
 323 extern void real_ldexp (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *, int);
 324
 325 /* **** End of software floating point emulator interface macros **** */
 326 \f
 327 /* Constant real values 0, 1, 2, 3, 10, -1, -2, 0.5 and 1/3.  */
 328
 329 extern REAL_VALUE_TYPE dconst0;
 330 extern REAL_VALUE_TYPE dconst1;
 331 extern REAL_VALUE_TYPE dconst2;
 332 extern REAL_VALUE_TYPE dconst3;
 333 extern REAL_VALUE_TYPE dconst10;
 334 extern REAL_VALUE_TYPE dconstm1;
 335 extern REAL_VALUE_TYPE dconstm2;
 336 extern REAL_VALUE_TYPE dconsthalf;
 337 extern REAL_VALUE_TYPE dconstthird;
 338 extern REAL_VALUE_TYPE dconstpi;
 339 extern REAL_VALUE_TYPE dconste;
 340
 341 /* Function to return a real value (not a tree node)
 342    from a given integer constant.  */
 343 REAL_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)
 352 extern 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.  */
 355 extern 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.  */
 358 extern tree build_real (tree, REAL_VALUE_TYPE);
 359
 360 /* Calculate R as the square root of X in the given machine mode.  */
 361 extern 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.  */
 365 extern 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.  */
 369 extern void real_trunc (REAL_VALUE_TYPE *, enum machine_mode,
 370                         const REAL_VALUE_TYPE *);
 371 extern void real_floor (REAL_VALUE_TYPE *, enum machine_mode,
 372                         const REAL_VALUE_TYPE *);
 373 extern void real_ceil (REAL_VALUE_TYPE *, enum machine_mode,
 374                        const REAL_VALUE_TYPE *);
 375
 376 #endif /* ! GCC_REAL_H */