Branch data Line data Source code
1 : : /* Definitions of floating-point access for GNU compiler.
2 : : Copyright (C) 1989-2024 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 : 1379253 : format_helper (const real_format *format) : m_format (format) {}
220 : : template<typename T> format_helper (const T &);
221 : 54164489 : const real_format *operator-> () const { return m_format; }
222 : 2516673 : operator const real_format *() const { return m_format; }
223 : :
224 : 29413896 : 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 : 55164885 : inline format_helper::format_helper (const T &m)
233 : 55164885 : : m_format (m == VOIDmode ? 0 : REAL_MODE_FORMAT (m))
234 : 55164885 : {}
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 : 11613150 : real_isdenormal (const REAL_VALUE_TYPE *r, machine_mode mode)
293 : : {
294 : 11613150 : 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 */
|
