Line data Source code
1 : /* Definitions of floating-point access for GNU compiler.
2 : Copyright (C) 1989-2023 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 : /* An expanded form of the represented number. */
24 :
25 : /* Enumerate the special cases of numbers that we encounter. */
26 : enum real_value_class {
27 : rvc_zero,
28 : rvc_normal,
29 : rvc_inf,
30 : rvc_nan
31 : };
32 :
33 : #define SIGNIFICAND_BITS (128 + HOST_BITS_PER_LONG)
34 : #define EXP_BITS (32 - 6)
35 : #define MAX_EXP ((1 << (EXP_BITS - 1)) - 1)
36 : #define SIGSZ (SIGNIFICAND_BITS / HOST_BITS_PER_LONG)
37 : #define SIG_MSB ((unsigned long)1 << (HOST_BITS_PER_LONG - 1))
38 :
39 : struct GTY(()) real_value {
40 : /* Use the same underlying type for all bit-fields, so as to make
41 : sure they're packed together, otherwise REAL_VALUE_TYPE_SIZE will
42 : be miscomputed. */
43 : unsigned int /* ENUM_BITFIELD (real_value_class) */ cl : 2;
44 : /* 1 if number is decimal floating point. */
45 : unsigned int decimal : 1;
46 : /* 1 if number is negative. */
47 : unsigned int sign : 1;
48 : /* 1 if number is signalling. */
49 : unsigned int signalling : 1;
50 : /* 1 if number is canonical
51 : All are generally used for handling cases in real.cc. */
52 : unsigned int canonical : 1;
53 : /* unbiased exponent of the number. */
54 : unsigned int uexp : EXP_BITS;
55 : /* significand of the number. */
56 : unsigned long sig[SIGSZ];
57 : };
58 :
59 : #define REAL_EXP(REAL) \
60 : ((int)((REAL)->uexp ^ (unsigned int)(1 << (EXP_BITS - 1))) \
61 : - (1 << (EXP_BITS - 1)))
62 : #define SET_REAL_EXP(REAL, EXP) \
63 : ((REAL)->uexp = ((unsigned int)(EXP) & (unsigned int)((1 << EXP_BITS) - 1)))
64 :
65 : /* Various headers condition prototypes on #ifdef REAL_VALUE_TYPE, so it
66 : needs to be a macro. We do need to continue to have a structure tag
67 : so that other headers can forward declare it. */
68 : #define REAL_VALUE_TYPE struct real_value
69 :
70 : /* We store a REAL_VALUE_TYPE into an rtx, and we do this by putting it in
71 : consecutive "w" slots. Moreover, we've got to compute the number of "w"
72 : slots at preprocessor time, which means we can't use sizeof. Guess. */
73 :
74 : #define REAL_VALUE_TYPE_SIZE (SIGNIFICAND_BITS + 32)
75 : #define REAL_WIDTH \
76 : (REAL_VALUE_TYPE_SIZE/HOST_BITS_PER_WIDE_INT \
77 : + (REAL_VALUE_TYPE_SIZE%HOST_BITS_PER_WIDE_INT ? 1 : 0)) /* round up */
78 :
79 : /* Verify the guess. */
80 : extern char test_real_width
81 : [sizeof (REAL_VALUE_TYPE) <= REAL_WIDTH * sizeof (HOST_WIDE_INT) ? 1 : -1];
82 :
83 : /* Calculate the format for CONST_DOUBLE. We need as many slots as
84 : are necessary to overlay a REAL_VALUE_TYPE on them. This could be
85 : as many as four (32-bit HOST_WIDE_INT, 128-bit REAL_VALUE_TYPE).
86 :
87 : A number of places assume that there are always at least two 'w'
88 : slots in a CONST_DOUBLE, so we provide them even if one would suffice. */
89 :
90 : #if REAL_WIDTH == 1
91 : # define CONST_DOUBLE_FORMAT "ww"
92 : #else
93 : # if REAL_WIDTH == 2
94 : # define CONST_DOUBLE_FORMAT "ww"
95 : # else
96 : # if REAL_WIDTH == 3
97 : # define CONST_DOUBLE_FORMAT "www"
98 : # else
99 : # if REAL_WIDTH == 4
100 : # define CONST_DOUBLE_FORMAT "wwww"
101 : # else
102 : # if REAL_WIDTH == 5
103 : # define CONST_DOUBLE_FORMAT "wwwww"
104 : # else
105 : # if REAL_WIDTH == 6
106 : # define CONST_DOUBLE_FORMAT "wwwwww"
107 : # else
108 : #error "REAL_WIDTH > 6 not supported"
109 : # endif
110 : # endif
111 : # endif
112 : # endif
113 : # endif
114 : #endif
115 :
116 :
117 : /* Describes the properties of the specific target format in use. */
118 : struct real_format
119 : {
120 : /* Move to and from the target bytes. */
121 : void (*encode) (const struct real_format *, long *,
122 : const REAL_VALUE_TYPE *);
123 : void (*decode) (const struct real_format *, REAL_VALUE_TYPE *,
124 : const long *);
125 :
126 : /* The radix of the exponent and digits of the significand. */
127 : int 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 : /* If this is an IEEE interchange format, the number of bits in the
150 : format; otherwise, if it is an IEEE extended format, one more
151 : than the greatest number of bits in an interchange format it
152 : extends; otherwise 0. Formats need not follow the IEEE 754-2008
153 : recommended practice regarding how signaling NaNs are identified,
154 : and may vary in the choice of default NaN, but must follow other
155 : IEEE practice regarding having NaNs, infinities and subnormal
156 : values, and the relation of minimum and maximum exponents, and,
157 : for interchange formats, the details of the encoding. */
158 : int ieee_bits;
159 :
160 : /* Default rounding mode for operations on this format. */
161 : bool round_towards_zero;
162 : bool has_sign_dependent_rounding;
163 :
164 : /* Properties of the format. */
165 : bool has_nans;
166 : bool has_inf;
167 : bool has_denorm;
168 : bool has_signed_zero;
169 : bool qnan_msb_set;
170 : bool canonical_nan_lsbs_set;
171 : const char *name;
172 : };
173 :
174 :
175 : /* The target format used for each floating point mode.
176 : Float modes are followed by decimal float modes, with entries for
177 : float modes indexed by (MODE - first float mode), and entries for
178 : decimal float modes indexed by (MODE - first decimal float mode) +
179 : the number of float modes. */
180 : extern const struct real_format *
181 : real_format_for_mode[NUM_MODE_FLOAT + NUM_MODE_DECIMAL_FLOAT];
182 :
183 : #define REAL_MODE_FORMAT(MODE) \
184 : (real_format_for_mode[DECIMAL_FLOAT_MODE_P (MODE) \
185 : ? (((MODE) - MIN_MODE_DECIMAL_FLOAT) \
186 : + NUM_MODE_FLOAT) \
187 : : GET_MODE_CLASS (MODE) == MODE_FLOAT \
188 : ? ((MODE) - MIN_MODE_FLOAT) \
189 : : (gcc_unreachable (), 0)])
190 :
191 : #define FLOAT_MODE_FORMAT(MODE) \
192 : (REAL_MODE_FORMAT (as_a <scalar_float_mode> (GET_MODE_INNER (MODE))))
193 :
194 : /* The following macro determines whether the floating point format is
195 : composite, i.e. may contain non-consecutive mantissa bits, in which
196 : case compile-time FP overflow may not model run-time overflow. */
197 : #define MODE_COMPOSITE_P(MODE) \
198 : (FLOAT_MODE_P (MODE) \
199 : && FLOAT_MODE_FORMAT (MODE)->pnan < FLOAT_MODE_FORMAT (MODE)->p)
200 :
201 : /* Accessor macros for format properties. */
202 : #define MODE_HAS_NANS(MODE) \
203 : (FLOAT_MODE_P (MODE) && FLOAT_MODE_FORMAT (MODE)->has_nans)
204 : #define MODE_HAS_INFINITIES(MODE) \
205 : (FLOAT_MODE_P (MODE) && FLOAT_MODE_FORMAT (MODE)->has_inf)
206 : #define MODE_HAS_SIGNED_ZEROS(MODE) \
207 : (FLOAT_MODE_P (MODE) && FLOAT_MODE_FORMAT (MODE)->has_signed_zero)
208 : #define MODE_HAS_SIGN_DEPENDENT_ROUNDING(MODE) \
209 : (FLOAT_MODE_P (MODE) \
210 : && FLOAT_MODE_FORMAT (MODE)->has_sign_dependent_rounding)
211 :
212 : /* This class allows functions in this file to accept a floating-point
213 : format as either a mode or an explicit real_format pointer. In the
214 : former case the mode must be VOIDmode (which means "no particular
215 : format") or must satisfy SCALAR_FLOAT_MODE_P. */
216 : class format_helper
217 : {
218 : public:
219 : format_helper (const real_format *format) : m_format (format) {}
220 : template<typename T> format_helper (const T &);
221 : const real_format *operator-> () const { return m_format; }
222 : operator const real_format *() const { return m_format; }
223 :
224 : bool decimal_p () const { return m_format && m_format->b == 10; }
225 : bool can_represent_integral_type_p (tree type) const;
226 :
227 : private:
228 : const real_format *m_format;
229 : };
230 :
231 : template<typename T>
232 5698 : inline format_helper::format_helper (const T &m)
233 5698 : : m_format (m == VOIDmode ? 0 : REAL_MODE_FORMAT (m))
234 5698 : {}
235 :
236 : /* Declare functions in real.cc. */
237 :
238 : /* True if the given mode has a NaN representation and the treatment of
239 : NaN operands is important. Certain optimizations, such as folding
240 : x * 0 into 0, are not correct for NaN operands, and are normally
241 : disabled for modes with NaNs. The user can ask for them to be
242 : done anyway using the -funsafe-math-optimizations switch. */
243 : extern bool HONOR_NANS (machine_mode);
244 : extern bool HONOR_NANS (const_tree);
245 : extern bool HONOR_NANS (const_rtx);
246 :
247 : /* Like HONOR_NANs, but true if we honor signaling NaNs (or sNaNs). */
248 : extern bool HONOR_SNANS (machine_mode);
249 : extern bool HONOR_SNANS (const_tree);
250 : extern bool HONOR_SNANS (const_rtx);
251 :
252 : /* As for HONOR_NANS, but true if the mode can represent infinity and
253 : the treatment of infinite values is important. */
254 : extern bool HONOR_INFINITIES (machine_mode);
255 : extern bool HONOR_INFINITIES (const_tree);
256 : extern bool HONOR_INFINITIES (const_rtx);
257 :
258 : /* Like HONOR_NANS, but true if the given mode distinguishes between
259 : positive and negative zero, and the sign of zero is important. */
260 : extern bool HONOR_SIGNED_ZEROS (machine_mode);
261 : extern bool HONOR_SIGNED_ZEROS (const_tree);
262 : extern bool HONOR_SIGNED_ZEROS (const_rtx);
263 :
264 : /* Like HONOR_NANS, but true if given mode supports sign-dependent rounding,
265 : and the rounding mode is important. */
266 : extern bool HONOR_SIGN_DEPENDENT_ROUNDING (machine_mode);
267 : extern bool HONOR_SIGN_DEPENDENT_ROUNDING (const_tree);
268 : extern bool HONOR_SIGN_DEPENDENT_ROUNDING (const_rtx);
269 :
270 : /* Binary or unary arithmetic on tree_code. */
271 : extern bool real_arithmetic (REAL_VALUE_TYPE *, int, const REAL_VALUE_TYPE *,
272 : const REAL_VALUE_TYPE *);
273 :
274 : /* Compare reals by tree_code. */
275 : extern bool real_compare (int, const REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *);
276 :
277 : /* Determine whether a floating-point value X is infinite. */
278 : extern bool real_isinf (const REAL_VALUE_TYPE *);
279 :
280 : /* Determine whether a floating-point value X is infinite with SIGN. */
281 : extern bool real_isinf (const REAL_VALUE_TYPE *, bool sign);
282 :
283 : /* Determine whether a floating-point value X is a NaN. */
284 : extern bool real_isnan (const REAL_VALUE_TYPE *);
285 :
286 : /* Determine whether a floating-point value X is a signaling NaN. */
287 : extern bool real_issignaling_nan (const REAL_VALUE_TYPE *);
288 :
289 : /* Determine whether floating-point value R is a denormal. This
290 : function is only valid for normalized values. */
291 : inline bool
292 : real_isdenormal (const REAL_VALUE_TYPE *r, machine_mode mode)
293 : {
294 : return r->cl == rvc_normal && REAL_EXP (r) < REAL_MODE_FORMAT (mode)->emin;
295 : }
296 :
297 : /* Determine whether a floating-point value X is finite. */
298 : extern bool real_isfinite (const REAL_VALUE_TYPE *);
299 :
300 : /* Determine whether a floating-point value X is negative. */
301 : extern bool real_isneg (const REAL_VALUE_TYPE *);
302 :
303 : /* Determine whether a floating-point value X is minus zero. */
304 : extern bool real_isnegzero (const REAL_VALUE_TYPE *);
305 :
306 : /* Determine whether a floating-point value X is plus or minus zero. */
307 : extern bool real_iszero (const REAL_VALUE_TYPE *);
308 :
309 : /* Determine whether a floating-point value X is zero with SIGN. */
310 : extern bool real_iszero (const REAL_VALUE_TYPE *, bool sign);
311 :
312 : /* Test relationships between reals. */
313 : extern bool real_identical (const REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *);
314 : extern bool real_equal (const REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *);
315 : extern bool real_less (const REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *);
316 :
317 : /* Extend or truncate to a new format. */
318 : extern void real_convert (REAL_VALUE_TYPE *, format_helper,
319 : const REAL_VALUE_TYPE *);
320 :
321 : /* Return true if truncating to NEW is exact. */
322 : extern bool exact_real_truncate (format_helper, const REAL_VALUE_TYPE *);
323 :
324 : /* Render R as a decimal floating point constant. */
325 : extern void real_to_decimal (char *, const REAL_VALUE_TYPE *, size_t,
326 : size_t, int);
327 :
328 : /* Render R as a decimal floating point constant, rounded so as to be
329 : parsed back to the same value when interpreted in mode MODE. */
330 : extern void real_to_decimal_for_mode (char *, const REAL_VALUE_TYPE *, size_t,
331 : size_t, int, machine_mode);
332 :
333 : /* Render R as a hexadecimal floating point constant. */
334 : extern void real_to_hexadecimal (char *, const REAL_VALUE_TYPE *,
335 : size_t, size_t, int);
336 :
337 : /* Render R as an integer. */
338 : extern HOST_WIDE_INT real_to_integer (const REAL_VALUE_TYPE *);
339 :
340 : /* Initialize R from a decimal or hexadecimal string. Return -1 if
341 : the value underflows, +1 if overflows, and 0 otherwise. */
342 : extern int real_from_string (REAL_VALUE_TYPE *, const char *);
343 : /* Wrapper to allow different internal representation for decimal floats. */
344 : extern void real_from_string3 (REAL_VALUE_TYPE *, const char *, format_helper);
345 :
346 : extern long real_to_target (long *, const REAL_VALUE_TYPE *, format_helper);
347 :
348 : extern void real_from_target (REAL_VALUE_TYPE *, const long *,
349 : format_helper);
350 :
351 : extern void real_inf (REAL_VALUE_TYPE *, bool sign = false);
352 :
353 : extern bool real_nan (REAL_VALUE_TYPE *, const char *, int, format_helper);
354 :
355 : extern void real_maxval (REAL_VALUE_TYPE *, int, machine_mode);
356 :
357 : extern void real_2expN (REAL_VALUE_TYPE *, int, format_helper);
358 :
359 : extern unsigned int real_hash (const REAL_VALUE_TYPE *);
360 :
361 :
362 : /* Target formats defined in real.cc. */
363 : extern const struct real_format ieee_single_format;
364 : extern const struct real_format mips_single_format;
365 : extern const struct real_format motorola_single_format;
366 : extern const struct real_format spu_single_format;
367 : extern const struct real_format ieee_double_format;
368 : extern const struct real_format mips_double_format;
369 : extern const struct real_format motorola_double_format;
370 : extern const struct real_format ieee_extended_motorola_format;
371 : extern const struct real_format ieee_extended_intel_96_format;
372 : extern const struct real_format ieee_extended_intel_96_round_53_format;
373 : extern const struct real_format ieee_extended_intel_128_format;
374 : extern const struct real_format ibm_extended_format;
375 : extern const struct real_format mips_extended_format;
376 : extern const struct real_format ieee_quad_format;
377 : extern const struct real_format mips_quad_format;
378 : extern const struct real_format vax_f_format;
379 : extern const struct real_format vax_d_format;
380 : extern const struct real_format vax_g_format;
381 : extern const struct real_format real_internal_format;
382 : extern const struct real_format decimal_single_format;
383 : extern const struct real_format decimal_double_format;
384 : extern const struct real_format decimal_quad_format;
385 : extern const struct real_format ieee_half_format;
386 : extern const struct real_format arm_half_format;
387 : extern const struct real_format arm_bfloat_half_format;
388 :
389 :
390 : /* ====================================================================== */
391 : /* Crap. */
392 :
393 : /* Determine whether a floating-point value X is infinite. */
394 : #define REAL_VALUE_ISINF(x) real_isinf (&(x))
395 :
396 : /* Determine whether a floating-point value X is a NaN. */
397 : #define REAL_VALUE_ISNAN(x) real_isnan (&(x))
398 :
399 : /* Determine whether a floating-point value X is a signaling NaN. */
400 : #define REAL_VALUE_ISSIGNALING_NAN(x) real_issignaling_nan (&(x))
401 :
402 : /* Determine whether a floating-point value X is negative. */
403 : #define REAL_VALUE_NEGATIVE(x) real_isneg (&(x))
404 :
405 : /* Determine whether a floating-point value X is minus zero. */
406 : #define REAL_VALUE_MINUS_ZERO(x) real_isnegzero (&(x))
407 :
408 : /* IN is a REAL_VALUE_TYPE. OUT is an array of longs. */
409 : #define REAL_VALUE_TO_TARGET_LONG_DOUBLE(IN, OUT) \
410 : real_to_target (OUT, &(IN), \
411 : float_mode_for_size (LONG_DOUBLE_TYPE_SIZE).require ())
412 :
413 : #define REAL_VALUE_TO_TARGET_DOUBLE(IN, OUT) \
414 : real_to_target (OUT, &(IN), float_mode_for_size (64).require ())
415 :
416 : /* IN is a REAL_VALUE_TYPE. OUT is a long. */
417 : #define REAL_VALUE_TO_TARGET_SINGLE(IN, OUT) \
418 : ((OUT) = real_to_target (NULL, &(IN), float_mode_for_size (32).require ()))
419 :
420 : /* Real values to IEEE 754 decimal floats. */
421 :
422 : /* IN is a REAL_VALUE_TYPE. OUT is an array of longs. */
423 : #define REAL_VALUE_TO_TARGET_DECIMAL128(IN, OUT) \
424 : real_to_target (OUT, &(IN), decimal_float_mode_for_size (128).require ())
425 :
426 : #define REAL_VALUE_TO_TARGET_DECIMAL64(IN, OUT) \
427 : real_to_target (OUT, &(IN), decimal_float_mode_for_size (64).require ())
428 :
429 : /* IN is a REAL_VALUE_TYPE. OUT is a long. */
430 : #define REAL_VALUE_TO_TARGET_DECIMAL32(IN, OUT) \
431 : ((OUT) = real_to_target (NULL, &(IN), \
432 : decimal_float_mode_for_size (32).require ()))
433 :
434 : extern REAL_VALUE_TYPE real_value_truncate (format_helper, REAL_VALUE_TYPE);
435 :
436 : extern REAL_VALUE_TYPE real_value_negate (const REAL_VALUE_TYPE *);
437 : extern REAL_VALUE_TYPE real_value_abs (const REAL_VALUE_TYPE *);
438 :
439 : extern int significand_size (format_helper);
440 :
441 : extern REAL_VALUE_TYPE real_from_string2 (const char *, format_helper);
442 :
443 : #define REAL_VALUE_ATOF(s, m) \
444 : real_from_string2 (s, m)
445 :
446 : #define CONST_DOUBLE_ATOF(s, m) \
447 : const_double_from_real_value (real_from_string2 (s, m), m)
448 :
449 : #define REAL_VALUE_FIX(r) \
450 : real_to_integer (&(r))
451 :
452 : /* ??? Not quite right. */
453 : #define REAL_VALUE_UNSIGNED_FIX(r) \
454 : real_to_integer (&(r))
455 :
456 : /* ??? These were added for Paranoia support. */
457 :
458 : /* Return floor log2(R). */
459 : extern int real_exponent (const REAL_VALUE_TYPE *);
460 :
461 : /* R = A * 2**EXP. */
462 : extern void real_ldexp (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *, int);
463 :
464 : /* **** End of software floating point emulator interface macros **** */
465 :
466 : /* Constant real values 0, 1, 2, -1 and 0.5. */
467 :
468 : extern REAL_VALUE_TYPE dconst0;
469 : extern REAL_VALUE_TYPE dconst1;
470 : extern REAL_VALUE_TYPE dconst2;
471 : extern REAL_VALUE_TYPE dconstm0;
472 : extern REAL_VALUE_TYPE dconstm1;
473 : extern REAL_VALUE_TYPE dconsthalf;
474 : extern REAL_VALUE_TYPE dconstinf;
475 : extern REAL_VALUE_TYPE dconstninf;
476 :
477 : #define dconst_e() (*dconst_e_ptr ())
478 : #define dconst_third() (*dconst_third_ptr ())
479 : #define dconst_quarter() (*dconst_quarter_ptr ())
480 : #define dconst_sixth() (*dconst_sixth_ptr ())
481 : #define dconst_ninth() (*dconst_ninth_ptr ())
482 : #define dconst_sqrt2() (*dconst_sqrt2_ptr ())
483 : #define dconst_pi() (*dconst_pi_ptr ())
484 :
485 : /* Function to return the real value special constant 'e'. */
486 : extern const REAL_VALUE_TYPE *dconst_e_ptr (void);
487 :
488 : /* Function to return the real value special constant 'pi'. */
489 : extern const REAL_VALUE_TYPE *dconst_pi_ptr (void);
490 :
491 : /* Returns a cached REAL_VALUE_TYPE corresponding to 1/n, for various n. */
492 : extern const REAL_VALUE_TYPE *dconst_third_ptr (void);
493 : extern const REAL_VALUE_TYPE *dconst_quarter_ptr (void);
494 : extern const REAL_VALUE_TYPE *dconst_sixth_ptr (void);
495 : extern const REAL_VALUE_TYPE *dconst_ninth_ptr (void);
496 :
497 : /* Returns the special REAL_VALUE_TYPE corresponding to sqrt(2). */
498 : extern const REAL_VALUE_TYPE * dconst_sqrt2_ptr (void);
499 :
500 : /* Function to return a real value (not a tree node)
501 : from a given integer constant. */
502 : REAL_VALUE_TYPE real_value_from_int_cst (const_tree, const_tree);
503 :
504 : /* Return a CONST_DOUBLE with value R and mode M. */
505 : extern rtx const_double_from_real_value (REAL_VALUE_TYPE, machine_mode);
506 :
507 : /* Replace R by 1/R in the given format, if the result is exact. */
508 : extern bool exact_real_inverse (format_helper, REAL_VALUE_TYPE *);
509 :
510 : /* Return true if arithmetic on values in IMODE that were promoted
511 : from values in TMODE is equivalent to direct arithmetic on values
512 : in TMODE. */
513 : bool real_can_shorten_arithmetic (machine_mode, machine_mode);
514 :
515 : /* In tree.cc: wrap up a REAL_VALUE_TYPE in a tree node. */
516 : extern tree build_real (tree, REAL_VALUE_TYPE);
517 :
518 : /* Likewise, but first truncate the value to the type. */
519 : extern tree build_real_truncate (tree, REAL_VALUE_TYPE);
520 :
521 : /* Calculate R as X raised to the integer exponent N in format FMT. */
522 : extern bool real_powi (REAL_VALUE_TYPE *, format_helper,
523 : const REAL_VALUE_TYPE *, HOST_WIDE_INT);
524 :
525 : /* Standard round to integer value functions. */
526 : extern void real_trunc (REAL_VALUE_TYPE *, format_helper,
527 : const REAL_VALUE_TYPE *);
528 : extern void real_floor (REAL_VALUE_TYPE *, format_helper,
529 : const REAL_VALUE_TYPE *);
530 : extern void real_ceil (REAL_VALUE_TYPE *, format_helper,
531 : const REAL_VALUE_TYPE *);
532 : extern void real_round (REAL_VALUE_TYPE *, format_helper,
533 : const REAL_VALUE_TYPE *);
534 : extern void real_roundeven (REAL_VALUE_TYPE *, format_helper,
535 : const REAL_VALUE_TYPE *);
536 :
537 : /* Set the sign of R to the sign of X. */
538 : extern void real_copysign (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *);
539 :
540 : /* Check whether the real constant value given is an integer. */
541 : extern bool real_isinteger (const REAL_VALUE_TYPE *, format_helper);
542 : extern bool real_isinteger (const REAL_VALUE_TYPE *, HOST_WIDE_INT *);
543 :
544 : /* Calculate nextafter (X, Y) in format FMT. */
545 : extern bool real_nextafter (REAL_VALUE_TYPE *, format_helper,
546 : const REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *);
547 :
548 : /* Write into BUF the maximum representable finite floating-point
549 : number, (1 - b**-p) * b**emax for a given FP format FMT as a hex
550 : float string. BUF must be large enough to contain the result. */
551 : extern void get_max_float (const struct real_format *, char *, size_t, bool);
552 :
553 : #ifndef GENERATOR_FILE
554 : /* real related routines. */
555 : extern wide_int real_to_integer (const REAL_VALUE_TYPE *, bool *, int);
556 : extern void real_from_integer (REAL_VALUE_TYPE *, format_helper,
557 : const wide_int_ref &, signop);
558 : #endif
559 :
560 : /* Fills r with the largest value such that 1 + r*r won't overflow.
561 : This is used in both sin (atan (x)) and cos (atan(x)) optimizations. */
562 : extern void build_sinatan_real (REAL_VALUE_TYPE *, tree);
563 :
564 : #endif /* ! GCC_REAL_H */
|
