gcc/real.h

   1 /* Definitions of floating-point access for GNU compiler.
   2    Copyright (C) 1989, 1991, 1994, 1996, 1997, 1998,
   3    1999, 2000, 2002 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 /* REAL_VALUE_TYPE is an array of the minimum number of HOST_WIDE_INTs
  28    required to hold a 128-bit floating point type.  This is true even
  29    if the maximum precision floating point type on the target is smaller.
  30
  31    The extra 32 bits are for storing the mode of the float.  Ideally
  32    we'd keep this elsewhere, but that's too drastic a change all at once.  */
  33
  34 #define REAL_VALUE_TYPE_SIZE (128 + 32)
  35 #define REAL_WIDTH \
  36   (REAL_VALUE_TYPE_SIZE/HOST_BITS_PER_WIDE_INT \
  37    + (REAL_VALUE_TYPE_SIZE%HOST_BITS_PER_WIDE_INT ? 1 : 0)) /* round up */
  38
  39 struct realvaluetype GTY(()) {
  40   HOST_WIDE_INT r[REAL_WIDTH];
  41 };
  42
  43 /* Various headers condition prototypes on #ifdef REAL_VALUE_TYPE, so it needs
  44    to be a macro.  realvaluetype cannot be a typedef as this interferes with
  45    other headers declaring opaque pointers to it.  */
  46 #define REAL_VALUE_TYPE struct realvaluetype
  47
  48 /* Calculate the format for CONST_DOUBLE.  We need as many slots as
  49    are necessary to overlay a REAL_VALUE_TYPE on them.  This could be
  50    as many as four (32-bit HOST_WIDE_INT, 128-bit REAL_VALUE_TYPE).
  51
  52    A number of places assume that there are always at least two 'w'
  53    slots in a CONST_DOUBLE, so we provide them even if one would suffice.  */
  54
  55 #if REAL_WIDTH == 1
  56 # define CONST_DOUBLE_FORMAT     "ww"
  57 #else
  58 # if REAL_WIDTH == 2
  59 #  define CONST_DOUBLE_FORMAT    "ww"
  60 # else
  61 #  if REAL_WIDTH == 3
  62 #   define CONST_DOUBLE_FORMAT   "www"
  63 #  else
  64 #   if REAL_WIDTH == 4
  65 #    define CONST_DOUBLE_FORMAT  "wwww"
  66 #   else
  67 #    if REAL_WIDTH == 5
  68 #     define CONST_DOUBLE_FORMAT "wwwww"
  69 #    else
  70       #error "REAL_WIDTH > 5 not supported"
  71 #    endif
  72 #   endif
  73 #  endif
  74 # endif
  75 #endif
  76
  77 /* Declare functions in real.c.  */
  78
  79 /* Initialize the emulator.  */
  80 extern void init_real_once      PARAMS ((void));
  81
  82 /* Binary or unary arithmetic on tree_code.  */
  83 extern void real_arithmetic     PARAMS ((REAL_VALUE_TYPE *, int,
  84                                          const REAL_VALUE_TYPE *,
  85                                          const REAL_VALUE_TYPE *));
  86
  87 /* Compare reals by tree_code.  */
  88 extern bool real_compare        PARAMS ((int, const REAL_VALUE_TYPE *,
  89                                          const REAL_VALUE_TYPE *));
  90
  91 /* Determine whether a floating-point value X is infinite.  */
  92 extern bool real_isinf          PARAMS ((const REAL_VALUE_TYPE *));
  93
  94 /* Determine whether a floating-point value X is a NaN.  */
  95 extern bool real_isnan          PARAMS ((const REAL_VALUE_TYPE *));
  96
  97 /* Determine whether a floating-point value X is negative.  */
  98 extern bool real_isneg          PARAMS ((const REAL_VALUE_TYPE *));
  99
 100 /* Determine whether a floating-point value X is minus zero.  */
 101 extern bool real_isnegzero      PARAMS ((const REAL_VALUE_TYPE *));
 102
 103 /* Compare two floating-point objects for bitwise identity.  */
 104 extern bool real_identical      PARAMS ((const REAL_VALUE_TYPE *,
 105                                          const REAL_VALUE_TYPE *));
 106
 107 /* Extend or truncate to a new mode.  */
 108 extern void real_convert        PARAMS ((REAL_VALUE_TYPE *,
 109                                          enum machine_mode,
 110                                          const REAL_VALUE_TYPE *));
 111
 112 /* Return true if truncating to NEW is exact.  */
 113 extern bool exact_real_truncate PARAMS ((enum machine_mode,
 114                                          const REAL_VALUE_TYPE *));
 115
 116 /* Render R as a decimal floating point constant.  */
 117 extern void real_to_decimal     PARAMS ((char *, const REAL_VALUE_TYPE *,
 118                                          int));
 119
 120 /* Render R as a hexadecimal floating point constant.  */
 121 extern void real_to_hexadecimal PARAMS ((char *, const REAL_VALUE_TYPE *,
 122                                          int));
 123
 124 /* Render R as an integer.  */
 125 extern HOST_WIDE_INT real_to_integer PARAMS ((const REAL_VALUE_TYPE *));
 126 extern void real_to_integer2 PARAMS ((HOST_WIDE_INT *, HOST_WIDE_INT *,
 127                                       const REAL_VALUE_TYPE *));
 128
 129 /* Initialize R from a decimal or hexadecimal string.  */
 130 extern void real_from_string    PARAMS ((REAL_VALUE_TYPE *, const char *));
 131
 132 /* Initialize R from an integer pair HIGH/LOW.  */
 133 extern void real_from_integer   PARAMS ((REAL_VALUE_TYPE *,
 134                                          enum machine_mode,
 135                                          unsigned HOST_WIDE_INT,
 136                                          HOST_WIDE_INT, int));
 137
 138 extern long real_to_target      PARAMS ((long *, const REAL_VALUE_TYPE *,
 139                                          enum machine_mode));
 140
 141 extern void real_from_target    PARAMS ((REAL_VALUE_TYPE *, const long *,
 142                                          enum machine_mode));
 143
 144 extern void real_inf            PARAMS ((REAL_VALUE_TYPE *));
 145
 146 extern bool real_nan            PARAMS ((REAL_VALUE_TYPE *, const char *,
 147                                          int, enum machine_mode));
 148
 149 extern void real_2expN          PARAMS ((REAL_VALUE_TYPE *, int));
 150
 151 /* ====================================================================== */
 152 /* Crap.  */
 153
 154 /* Define codes for all the float formats that we know of.  */
 155 #define UNKNOWN_FLOAT_FORMAT 0
 156 #define IEEE_FLOAT_FORMAT 1
 157 #define VAX_FLOAT_FORMAT 2
 158 #define IBM_FLOAT_FORMAT 3
 159 #define C4X_FLOAT_FORMAT 4
 160
 161 /* Default to IEEE float if not specified.  Nearly all machines use it.  */
 162
 163 #ifndef TARGET_FLOAT_FORMAT
 164 #define TARGET_FLOAT_FORMAT     IEEE_FLOAT_FORMAT
 165 #endif
 166
 167 #define REAL_ARITHMETIC(value, code, d1, d2) \
 168   real_arithmetic (&(value), code, &(d1), &(d2))
 169
 170 #define REAL_VALUES_IDENTICAL(x, y)     real_identical (&(x), &(y))
 171 #define REAL_VALUES_EQUAL(x, y)         real_compare (EQ_EXPR, &(x), &(y))
 172 #define REAL_VALUES_LESS(x, y)          real_compare (LT_EXPR, &(x), &(y))
 173
 174 /* Determine whether a floating-point value X is infinite.  */
 175 #define REAL_VALUE_ISINF(x)             real_isinf (&(x))
 176
 177 /* Determine whether a floating-point value X is a NaN.  */
 178 #define REAL_VALUE_ISNAN(x)             real_isnan (&(x))
 179
 180 /* Determine whether a floating-point value X is negative.  */
 181 #define REAL_VALUE_NEGATIVE(x)          real_isneg (&(x))
 182
 183 /* Determine whether a floating-point value X is minus zero.  */
 184 #define REAL_VALUE_MINUS_ZERO(x)        real_isnegzero (&(x))
 185
 186 /* IN is a REAL_VALUE_TYPE.  OUT is an array of longs.  */
 187 #define REAL_VALUE_TO_TARGET_LONG_DOUBLE(IN, OUT)                       \
 188   real_to_target (OUT, &(IN),                                           \
 189                   mode_for_size (LONG_DOUBLE_TYPE_SIZE, MODE_FLOAT, 0))
 190
 191 #define REAL_VALUE_TO_TARGET_DOUBLE(IN, OUT) \
 192   real_to_target (OUT, &(IN), mode_for_size (64, MODE_FLOAT, 0))
 193
 194 /* IN is a REAL_VALUE_TYPE.  OUT is a long.  */
 195 #define REAL_VALUE_TO_TARGET_SINGLE(IN, OUT) \
 196   ((OUT) = real_to_target (NULL, &(IN), mode_for_size (32, MODE_FLOAT, 0)))
 197
 198 #define REAL_VALUE_TO_DECIMAL(r, s, dig) \
 199   real_to_decimal (s, &(r), dig)
 200
 201 #define REAL_VALUE_FROM_INT(r, lo, hi, mode) \
 202   real_from_integer (&(r), mode, lo, hi, 0)
 203
 204 #define REAL_VALUE_FROM_UNSIGNED_INT(r, lo, hi, mode) \
 205   real_from_integer (&(r), mode, lo, hi, 1)
 206
 207 extern REAL_VALUE_TYPE real_value_truncate PARAMS ((enum machine_mode,
 208                                                     REAL_VALUE_TYPE));
 209
 210 #define REAL_VALUE_TO_INT(plow, phigh, r) \
 211   real_to_integer2 (plow, phigh, &(r))
 212
 213 extern REAL_VALUE_TYPE real_arithmetic2 PARAMS ((int, const REAL_VALUE_TYPE *,
 214                                                  const REAL_VALUE_TYPE *));
 215
 216 #define REAL_VALUE_NEGATE(X) \
 217   real_arithmetic2 (NEGATE_EXPR, &(X), NULL)
 218
 219 #define REAL_VALUE_ABS(X) \
 220   real_arithmetic2 (ABS_EXPR, &(X), NULL)
 221
 222 extern int significand_size PARAMS ((enum machine_mode));
 223
 224 extern REAL_VALUE_TYPE real_from_string2 PARAMS ((const char *,
 225                                                   enum machine_mode));
 226
 227 #define REAL_VALUE_ATOF(s, m) \
 228   real_from_string2 (s, m)
 229
 230 #define CONST_DOUBLE_ATOF(s, m) \
 231   CONST_DOUBLE_FROM_REAL_VALUE (real_from_string2 (s, m), m)
 232
 233 #define REAL_VALUE_FIX(r) \
 234   real_to_integer (&(r))
 235
 236 /* ??? Not quite right.  */
 237 #define REAL_VALUE_UNSIGNED_FIX(r) \
 238   real_to_integer (&(r))
 239
 240 /* ??? These were added for Paranoia support.  */
 241
 242 /* Return floor log2(R).  */
 243 extern int real_exponent        PARAMS ((const REAL_VALUE_TYPE *));
 244
 245 /* R = A * 2**EXP.  */
 246 extern void real_ldexp          PARAMS ((REAL_VALUE_TYPE *,
 247                                          const REAL_VALUE_TYPE *, int));
 248
 249 /* **** End of software floating point emulator interface macros **** */
 250 \f
 251 /* Constant real values 0, 1, 2, and -1.  */
 252
 253 extern REAL_VALUE_TYPE dconst0;
 254 extern REAL_VALUE_TYPE dconst1;
 255 extern REAL_VALUE_TYPE dconst2;
 256 extern REAL_VALUE_TYPE dconstm1;
 257
 258 /* Function to return a real value (not a tree node)
 259    from a given integer constant.  */
 260 REAL_VALUE_TYPE real_value_from_int_cst PARAMS ((union tree_node *,
 261                                                  union tree_node *));
 262
 263 /* Given a CONST_DOUBLE in FROM, store into TO the value it represents.  */
 264 #define REAL_VALUE_FROM_CONST_DOUBLE(to, from) \
 265   memcpy (&(to), &CONST_DOUBLE_LOW ((from)), sizeof (REAL_VALUE_TYPE))
 266
 267 /* Return a CONST_DOUBLE with value R and mode M.  */
 268 #define CONST_DOUBLE_FROM_REAL_VALUE(r, m) \
 269   const_double_from_real_value (r, m)
 270 extern rtx const_double_from_real_value PARAMS ((REAL_VALUE_TYPE,
 271                                                  enum machine_mode));
 272
 273 /* Replace R by 1/R in the given machine mode, if the result is exact.  */
 274 extern bool exact_real_inverse  PARAMS ((enum machine_mode, REAL_VALUE_TYPE *));
 275
 276 /* In tree.c: wrap up a REAL_VALUE_TYPE in a tree node.  */
 277 extern tree build_real                  PARAMS ((tree, REAL_VALUE_TYPE));
 278
 279
 280 #endif /* ! GCC_REAL_H */