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