1/* Definitions of floating-point access for GNU compiler. 2 Copyright (C) 1989-2015 Free Software Foundation, Inc. 3 4 This file is part of GCC. 5 6 GCC is free software; you can redistribute it and/or modify it under 7 the terms of the GNU General Public License as published by the Free 8 Software Foundation; either version 3, or (at your option) any later 9 version. 10 11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY 12 WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with GCC; see the file COPYING3. If not see 18 <http://www.gnu.org/licenses/>. */ 19 20#ifndef GCC_REAL_H 21#define GCC_REAL_H 22 23#include "machmode.h" 24#include "signop.h" 25#include "wide-int.h" 26#include "insn-modes.h" 27 28/* An expanded form of the represented number. */ 29 30/* Enumerate the special cases of numbers that we encounter. */ 31enum real_value_class { 32 rvc_zero, 33 rvc_normal, 34 rvc_inf, 35 rvc_nan 36}; 37 38#define SIGNIFICAND_BITS (128 + HOST_BITS_PER_LONG) 39#define EXP_BITS (32 - 6) 40#define MAX_EXP ((1 << (EXP_BITS - 1)) - 1) 41#define SIGSZ (SIGNIFICAND_BITS / HOST_BITS_PER_LONG) 42#define SIG_MSB ((unsigned long)1 << (HOST_BITS_PER_LONG - 1)) 43 44struct GTY(()) real_value { 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 decimal : 1; 50 unsigned int sign : 1; 51 unsigned int signalling : 1; 52 unsigned int canonical : 1; 53 unsigned int uexp : EXP_BITS; 54 unsigned long sig[SIGSZ]; 55}; 56 57#define REAL_EXP(REAL) \ 58 ((int)((REAL)->uexp ^ (unsigned int)(1 << (EXP_BITS - 1))) \ 59 - (1 << (EXP_BITS - 1))) 60#define SET_REAL_EXP(REAL, EXP) \ 61 ((REAL)->uexp = ((unsigned int)(EXP) & (unsigned int)((1 << EXP_BITS) - 1))) 62 63/* Various headers condition prototypes on #ifdef REAL_VALUE_TYPE, so it 64 needs to be a macro. We do need to continue to have a structure tag 65 so that other headers can forward declare it. */ 66#define REAL_VALUE_TYPE struct real_value 67 68/* We store a REAL_VALUE_TYPE into an rtx, and we do this by putting it in 69 consecutive "w" slots. Moreover, we've got to compute the number of "w" 70 slots at preprocessor time, which means we can't use sizeof. Guess. */ 71 72#define REAL_VALUE_TYPE_SIZE (SIGNIFICAND_BITS + 32) 73#define REAL_WIDTH \ 74 (REAL_VALUE_TYPE_SIZE/HOST_BITS_PER_WIDE_INT \ 75 + (REAL_VALUE_TYPE_SIZE%HOST_BITS_PER_WIDE_INT ? 1 : 0)) /* round up */ 76 77/* Verify the guess. */ 78extern char test_real_width 79 [sizeof (REAL_VALUE_TYPE) <= REAL_WIDTH * sizeof (HOST_WIDE_INT) ? 1 : -1]; 80 81/* Calculate the format for CONST_DOUBLE. We need as many slots as 82 are necessary to overlay a REAL_VALUE_TYPE on them. This could be 83 as many as four (32-bit HOST_WIDE_INT, 128-bit REAL_VALUE_TYPE). 84 85 A number of places assume that there are always at least two 'w' 86 slots in a CONST_DOUBLE, so we provide them even if one would suffice. */ 87 88#if REAL_WIDTH == 1 89# define CONST_DOUBLE_FORMAT "ww" 90#else 91# if REAL_WIDTH == 2 92# define CONST_DOUBLE_FORMAT "ww" 93# else 94# if REAL_WIDTH == 3 95# define CONST_DOUBLE_FORMAT "www" 96# else 97# if REAL_WIDTH == 4 98# define CONST_DOUBLE_FORMAT "wwww" 99# else 100# if REAL_WIDTH == 5 101# define CONST_DOUBLE_FORMAT "wwwww" 102# else 103# if REAL_WIDTH == 6 104# define CONST_DOUBLE_FORMAT "wwwwww" 105# else 106 #error "REAL_WIDTH > 6 not supported" 107# endif 108# endif 109# endif 110# endif 111# endif 112#endif 113 114 115/* Describes the properties of the specific target format in use. */ 116struct real_format 117{ 118 /* Move to and from the target bytes. */ 119 void (*encode) (const struct real_format *, long *, 120 const REAL_VALUE_TYPE *); 121 void (*decode) (const struct real_format *, REAL_VALUE_TYPE *, 122 const long *); 123 124 /* The radix of the exponent and digits of the significand. */ 125 int b; 126 127 /* Size of the significand in digits of radix B. */ 128 int p; 129 130 /* Size of the significant of a NaN, in digits of radix B. */ 131 int pnan; 132 133 /* The minimum negative integer, x, such that b**(x-1) is normalized. */ 134 int emin; 135 136 /* The maximum integer, x, such that b**(x-1) is representable. */ 137 int emax; 138 139 /* The bit position of the sign bit, for determining whether a value 140 is positive/negative, or -1 for a complex encoding. */ 141 int signbit_ro; 142 143 /* The bit position of the sign bit, for changing the sign of a number, 144 or -1 for a complex encoding. */ 145 int signbit_rw; 146 147 /* Default rounding mode for operations on this format. */ 148 bool round_towards_zero; 149 bool has_sign_dependent_rounding; 150 151 /* Properties of the format. */ 152 bool has_nans; 153 bool has_inf; 154 bool has_denorm; 155 bool has_signed_zero; 156 bool qnan_msb_set; 157 bool canonical_nan_lsbs_set; 158 const char *name; 159}; 160 161 162/* The target format used for each floating point mode. 163 Float modes are followed by decimal float modes, with entries for 164 float modes indexed by (MODE - first float mode), and entries for 165 decimal float modes indexed by (MODE - first decimal float mode) + 166 the number of float modes. */ 167extern const struct real_format * 168 real_format_for_mode[MAX_MODE_FLOAT - MIN_MODE_FLOAT + 1 169 + MAX_MODE_DECIMAL_FLOAT - MIN_MODE_DECIMAL_FLOAT + 1]; 170 171#define REAL_MODE_FORMAT(MODE) \ 172 (real_format_for_mode[DECIMAL_FLOAT_MODE_P (MODE) \ 173 ? (((MODE) - MIN_MODE_DECIMAL_FLOAT) \ 174 + (MAX_MODE_FLOAT - MIN_MODE_FLOAT + 1)) \ 175 : ((MODE) - MIN_MODE_FLOAT)]) 176 177#define FLOAT_MODE_FORMAT(MODE) \ 178 (REAL_MODE_FORMAT (SCALAR_FLOAT_MODE_P (MODE)? (MODE) \ 179 : GET_MODE_INNER (MODE))) 180 181/* The following macro determines whether the floating point format is 182 composite, i.e. may contain non-consecutive mantissa bits, in which 183 case compile-time FP overflow may not model run-time overflow. */ 184#define MODE_COMPOSITE_P(MODE) \ 185 (FLOAT_MODE_P (MODE) \ 186 && FLOAT_MODE_FORMAT (MODE)->pnan < FLOAT_MODE_FORMAT (MODE)->p) 187 188/* Accessor macros for format properties. */ 189#define MODE_HAS_NANS(MODE) \ 190 (FLOAT_MODE_P (MODE) && FLOAT_MODE_FORMAT (MODE)->has_nans) 191#define MODE_HAS_INFINITIES(MODE) \ 192 (FLOAT_MODE_P (MODE) && FLOAT_MODE_FORMAT (MODE)->has_inf) 193#define MODE_HAS_SIGNED_ZEROS(MODE) \ 194 (FLOAT_MODE_P (MODE) && FLOAT_MODE_FORMAT (MODE)->has_signed_zero) 195#define MODE_HAS_SIGN_DEPENDENT_ROUNDING(MODE) \ 196 (FLOAT_MODE_P (MODE) \ 197 && FLOAT_MODE_FORMAT (MODE)->has_sign_dependent_rounding) 198 199/* Declare functions in real.c. */ 200 201/* True if the given mode has a NaN representation and the treatment of 202 NaN operands is important. Certain optimizations, such as folding 203 x * 0 into 0, are not correct for NaN operands, and are normally 204 disabled for modes with NaNs. The user can ask for them to be 205 done anyway using the -funsafe-math-optimizations switch. */ 206extern bool HONOR_NANS (machine_mode); 207extern bool HONOR_NANS (const_tree); 208extern bool HONOR_NANS (const_rtx); 209 210/* Like HONOR_NANs, but true if we honor signaling NaNs (or sNaNs). */ 211extern bool HONOR_SNANS (machine_mode); 212extern bool HONOR_SNANS (const_tree); 213extern bool HONOR_SNANS (const_rtx); 214 215/* As for HONOR_NANS, but true if the mode can represent infinity and 216 the treatment of infinite values is important. */ 217extern bool HONOR_INFINITIES (machine_mode); 218extern bool HONOR_INFINITIES (const_tree); 219extern bool HONOR_INFINITIES (const_rtx); 220 221/* Like HONOR_NANS, but true if the given mode distinguishes between 222 positive and negative zero, and the sign of zero is important. */ 223extern bool HONOR_SIGNED_ZEROS (machine_mode); 224extern bool HONOR_SIGNED_ZEROS (const_tree); 225extern bool HONOR_SIGNED_ZEROS (const_rtx); 226 227/* Like HONOR_NANS, but true if given mode supports sign-dependent rounding, 228 and the rounding mode is important. */ 229extern bool HONOR_SIGN_DEPENDENT_ROUNDING (machine_mode); 230extern bool HONOR_SIGN_DEPENDENT_ROUNDING (const_tree); 231extern bool HONOR_SIGN_DEPENDENT_ROUNDING (const_rtx); 232 233/* Binary or unary arithmetic on tree_code. */ 234extern bool real_arithmetic (REAL_VALUE_TYPE *, int, const REAL_VALUE_TYPE *, 235 const REAL_VALUE_TYPE *); 236 237/* Compare reals by tree_code. */ 238extern bool real_compare (int, const REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *); 239 240/* Determine whether a floating-point value X is infinite. */ 241extern bool real_isinf (const REAL_VALUE_TYPE *); 242 243/* Determine whether a floating-point value X is a NaN. */ 244extern bool real_isnan (const REAL_VALUE_TYPE *); 245 246/* Determine whether a floating-point value X is finite. */ 247extern bool real_isfinite (const REAL_VALUE_TYPE *); 248 249/* Determine whether a floating-point value X is negative. */ 250extern bool real_isneg (const REAL_VALUE_TYPE *); 251 252/* Determine whether a floating-point value X is minus zero. */ 253extern bool real_isnegzero (const REAL_VALUE_TYPE *); 254 255/* Compare two floating-point objects for bitwise identity. */ 256extern bool real_identical (const REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *); 257 258/* Extend or truncate to a new mode. */ 259extern void real_convert (REAL_VALUE_TYPE *, machine_mode, 260 const REAL_VALUE_TYPE *); 261 262/* Return true if truncating to NEW is exact. */ 263extern bool exact_real_truncate (machine_mode, const REAL_VALUE_TYPE *); 264 265/* Render R as a decimal floating point constant. */ 266extern void real_to_decimal (char *, const REAL_VALUE_TYPE *, size_t, 267 size_t, int); 268 269/* Render R as a decimal floating point constant, rounded so as to be 270 parsed back to the same value when interpreted in mode MODE. */ 271extern void real_to_decimal_for_mode (char *, const REAL_VALUE_TYPE *, size_t, 272 size_t, int, machine_mode); 273 274/* Render R as a hexadecimal floating point constant. */ 275extern void real_to_hexadecimal (char *, const REAL_VALUE_TYPE *, 276 size_t, size_t, int); 277 278/* Render R as an integer. */ 279extern HOST_WIDE_INT real_to_integer (const REAL_VALUE_TYPE *); 280 281/* Initialize R from a decimal or hexadecimal string. Return -1 if 282 the value underflows, +1 if overflows, and 0 otherwise. */ 283extern int real_from_string (REAL_VALUE_TYPE *, const char *); 284/* Wrapper to allow different internal representation for decimal floats. */ 285extern void real_from_string3 (REAL_VALUE_TYPE *, const char *, machine_mode); 286 287extern long real_to_target_fmt (long *, const REAL_VALUE_TYPE *, 288 const struct real_format *); 289extern long real_to_target (long *, const REAL_VALUE_TYPE *, machine_mode); 290 291extern void real_from_target_fmt (REAL_VALUE_TYPE *, const long *, 292 const struct real_format *); 293extern void real_from_target (REAL_VALUE_TYPE *, const long *, 294 machine_mode); 295 296extern void real_inf (REAL_VALUE_TYPE *); 297 298extern bool real_nan (REAL_VALUE_TYPE *, const char *, int, machine_mode); 299 300extern void real_maxval (REAL_VALUE_TYPE *, int, machine_mode); 301 302extern void real_2expN (REAL_VALUE_TYPE *, int, machine_mode); 303 304extern unsigned int real_hash (const REAL_VALUE_TYPE *); 305 306 307/* Target formats defined in real.c. */ 308extern const struct real_format ieee_single_format; 309extern const struct real_format mips_single_format; 310extern const struct real_format motorola_single_format; 311extern const struct real_format spu_single_format; 312extern const struct real_format ieee_double_format; 313extern const struct real_format mips_double_format; 314extern const struct real_format motorola_double_format; 315extern const struct real_format ieee_extended_motorola_format; 316extern const struct real_format ieee_extended_intel_96_format; 317extern const struct real_format ieee_extended_intel_96_round_53_format; 318extern const struct real_format ieee_extended_intel_128_format; 319extern const struct real_format ibm_extended_format; 320extern const struct real_format mips_extended_format; 321extern const struct real_format ieee_quad_format; 322extern const struct real_format mips_quad_format; 323extern const struct real_format vax_f_format; 324extern const struct real_format vax_d_format; 325extern const struct real_format vax_g_format; 326extern const struct real_format real_internal_format; 327extern const struct real_format decimal_single_format; 328extern const struct real_format decimal_double_format; 329extern const struct real_format decimal_quad_format; 330extern const struct real_format ieee_half_format; 331extern const struct real_format arm_half_format; 332 333 334/* ====================================================================== */ 335/* Crap. */ 336 337#define REAL_ARITHMETIC(value, code, d1, d2) \ 338 real_arithmetic (&(value), code, &(d1), &(d2)) 339 340#define REAL_VALUES_IDENTICAL(x, y) real_identical (&(x), &(y)) 341#define REAL_VALUES_EQUAL(x, y) real_compare (EQ_EXPR, &(x), &(y)) 342#define REAL_VALUES_LESS(x, y) real_compare (LT_EXPR, &(x), &(y)) 343 344/* Determine whether a floating-point value X is infinite. */ 345#define REAL_VALUE_ISINF(x) real_isinf (&(x)) 346 347/* Determine whether a floating-point value X is a NaN. */ 348#define REAL_VALUE_ISNAN(x) real_isnan (&(x)) 349 350/* Determine whether a floating-point value X is negative. */ 351#define REAL_VALUE_NEGATIVE(x) real_isneg (&(x)) 352 353/* Determine whether a floating-point value X is minus zero. */ 354#define REAL_VALUE_MINUS_ZERO(x) real_isnegzero (&(x)) 355 356/* IN is a REAL_VALUE_TYPE. OUT is an array of longs. */ 357#define REAL_VALUE_TO_TARGET_LONG_DOUBLE(IN, OUT) \ 358 real_to_target (OUT, &(IN), \ 359 mode_for_size (LONG_DOUBLE_TYPE_SIZE, MODE_FLOAT, 0)) 360 361#define REAL_VALUE_TO_TARGET_DOUBLE(IN, OUT) \ 362 real_to_target (OUT, &(IN), mode_for_size (64, MODE_FLOAT, 0)) 363 364/* IN is a REAL_VALUE_TYPE. OUT is a long. */ 365#define REAL_VALUE_TO_TARGET_SINGLE(IN, OUT) \ 366 ((OUT) = real_to_target (NULL, &(IN), mode_for_size (32, MODE_FLOAT, 0))) 367 368/* Real values to IEEE 754 decimal floats. */ 369 370/* IN is a REAL_VALUE_TYPE. OUT is an array of longs. */ 371#define REAL_VALUE_TO_TARGET_DECIMAL128(IN, OUT) \ 372 real_to_target (OUT, &(IN), mode_for_size (128, MODE_DECIMAL_FLOAT, 0)) 373 374#define REAL_VALUE_TO_TARGET_DECIMAL64(IN, OUT) \ 375 real_to_target (OUT, &(IN), mode_for_size (64, MODE_DECIMAL_FLOAT, 0)) 376 377/* IN is a REAL_VALUE_TYPE. OUT is a long. */ 378#define REAL_VALUE_TO_TARGET_DECIMAL32(IN, OUT) \ 379 ((OUT) = real_to_target (NULL, &(IN), mode_for_size (32, MODE_DECIMAL_FLOAT, 0))) 380 381extern REAL_VALUE_TYPE real_value_truncate (machine_mode, 382 REAL_VALUE_TYPE); 383 384extern REAL_VALUE_TYPE real_value_negate (const REAL_VALUE_TYPE *); 385extern REAL_VALUE_TYPE real_value_abs (const REAL_VALUE_TYPE *); 386 387extern int significand_size (machine_mode); 388 389extern REAL_VALUE_TYPE real_from_string2 (const char *, machine_mode); 390 391#define REAL_VALUE_ATOF(s, m) \ 392 real_from_string2 (s, m) 393 394#define CONST_DOUBLE_ATOF(s, m) \ 395 CONST_DOUBLE_FROM_REAL_VALUE (real_from_string2 (s, m), m) 396 397#define REAL_VALUE_FIX(r) \ 398 real_to_integer (&(r)) 399 400/* ??? Not quite right. */ 401#define REAL_VALUE_UNSIGNED_FIX(r) \ 402 real_to_integer (&(r)) 403 404/* ??? These were added for Paranoia support. */ 405 406/* Return floor log2(R). */ 407extern int real_exponent (const REAL_VALUE_TYPE *); 408 409/* R = A * 2**EXP. */ 410extern void real_ldexp (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *, int); 411 412/* **** End of software floating point emulator interface macros **** */ 413 414/* Constant real values 0, 1, 2, -1 and 0.5. */ 415 416extern REAL_VALUE_TYPE dconst0; 417extern REAL_VALUE_TYPE dconst1; 418extern REAL_VALUE_TYPE dconst2; 419extern REAL_VALUE_TYPE dconstm1; 420extern REAL_VALUE_TYPE dconsthalf; 421 422#define dconst_e() (*dconst_e_ptr ()) 423#define dconst_third() (*dconst_third_ptr ()) 424#define dconst_sqrt2() (*dconst_sqrt2_ptr ()) 425 426/* Function to return the real value special constant 'e'. */ 427extern const REAL_VALUE_TYPE * dconst_e_ptr (void); 428 429/* Returns the special REAL_VALUE_TYPE corresponding to 1/3. */ 430extern const REAL_VALUE_TYPE * dconst_third_ptr (void); 431 432/* Returns the special REAL_VALUE_TYPE corresponding to sqrt(2). */ 433extern const REAL_VALUE_TYPE * dconst_sqrt2_ptr (void); 434 435/* Function to return a real value (not a tree node) 436 from a given integer constant. */ 437REAL_VALUE_TYPE real_value_from_int_cst (const_tree, const_tree); 438 439/* Given a CONST_DOUBLE in FROM, store into TO the value it represents. */ 440#define REAL_VALUE_FROM_CONST_DOUBLE(to, from) \ 441 ((to) = *CONST_DOUBLE_REAL_VALUE (from)) 442 443/* Return a CONST_DOUBLE with value R and mode M. */ 444#define CONST_DOUBLE_FROM_REAL_VALUE(r, m) \ 445 const_double_from_real_value (r, m) 446extern rtx const_double_from_real_value (REAL_VALUE_TYPE, machine_mode); 447 448/* Replace R by 1/R in the given machine mode, if the result is exact. */ 449extern bool exact_real_inverse (machine_mode, REAL_VALUE_TYPE *); 450 451/* Return true if arithmetic on values in IMODE that were promoted 452 from values in TMODE is equivalent to direct arithmetic on values 453 in TMODE. */ 454bool real_can_shorten_arithmetic (machine_mode, machine_mode); 455 456/* In tree.c: wrap up a REAL_VALUE_TYPE in a tree node. */ 457extern tree build_real (tree, REAL_VALUE_TYPE); 458 459/* Calculate R as X raised to the integer exponent N in mode MODE. */ 460extern bool real_powi (REAL_VALUE_TYPE *, machine_mode, 461 const REAL_VALUE_TYPE *, HOST_WIDE_INT); 462 463/* Standard round to integer value functions. */ 464extern void real_trunc (REAL_VALUE_TYPE *, machine_mode, 465 const REAL_VALUE_TYPE *); 466extern void real_floor (REAL_VALUE_TYPE *, machine_mode, 467 const REAL_VALUE_TYPE *); 468extern void real_ceil (REAL_VALUE_TYPE *, machine_mode, 469 const REAL_VALUE_TYPE *); 470extern void real_round (REAL_VALUE_TYPE *, machine_mode, 471 const REAL_VALUE_TYPE *); 472 473/* Set the sign of R to the sign of X. */ 474extern void real_copysign (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *); 475 476/* Check whether the real constant value given is an integer. */ 477extern bool real_isinteger (const REAL_VALUE_TYPE *c, machine_mode mode); 478 479/* Write into BUF the maximum representable finite floating-point 480 number, (1 - b**-p) * b**emax for a given FP format FMT as a hex 481 float string. BUF must be large enough to contain the result. */ 482extern void get_max_float (const struct real_format *, char *, size_t); 483 484#ifndef GENERATOR_FILE 485/* real related routines. */ 486extern wide_int real_to_integer (const REAL_VALUE_TYPE *, bool *, int); 487extern void real_from_integer (REAL_VALUE_TYPE *, machine_mode, 488 const wide_int_ref &, signop); 489#endif 490 491#endif /* ! GCC_REAL_H */ 492