1/* Definitions of floating-point access for GNU compiler.
2   Copyright (C) 1989, 1991, 1994, 1996, 1997, 1998, 1999,
3   2000, 2002, 2003, 2004, 2005 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, 51 Franklin Street, Fifth Floor, Boston, MA
20   02110-1301, USA.  */
21
22#ifndef GCC_REAL_H
23#define GCC_REAL_H
24
25#include "machmode.h"
26
27/* An expanded form of the represented number.  */
28
29/* Enumerate the special cases of numbers that we encounter.  */
30enum real_value_class {
31  rvc_zero,
32  rvc_normal,
33  rvc_inf,
34  rvc_nan
35};
36
37#define SIGNIFICAND_BITS	(128 + HOST_BITS_PER_LONG)
38#define EXP_BITS		(32 - 5)
39#define MAX_EXP			((1 << (EXP_BITS - 1)) - 1)
40#define SIGSZ			(SIGNIFICAND_BITS / HOST_BITS_PER_LONG)
41#define SIG_MSB			((unsigned long)1 << (HOST_BITS_PER_LONG - 1))
42
43struct real_value GTY(())
44{
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 sign : 1;
50  unsigned int signalling : 1;
51  unsigned int canonical : 1;
52  unsigned int uexp : EXP_BITS;
53  unsigned long sig[SIGSZ];
54};
55
56#define REAL_EXP(REAL) \
57  ((int)((REAL)->uexp ^ (unsigned int)(1 << (EXP_BITS - 1))) \
58   - (1 << (EXP_BITS - 1)))
59#define SET_REAL_EXP(REAL, EXP) \
60  ((REAL)->uexp = ((unsigned int)(EXP) & (unsigned int)((1 << EXP_BITS) - 1)))
61
62/* Various headers condition prototypes on #ifdef REAL_VALUE_TYPE, so it
63   needs to be a macro.  We do need to continue to have a structure tag
64   so that other headers can forward declare it.  */
65#define REAL_VALUE_TYPE struct real_value
66
67/* We store a REAL_VALUE_TYPE into an rtx, and we do this by putting it in
68   consecutive "w" slots.  Moreover, we've got to compute the number of "w"
69   slots at preprocessor time, which means we can't use sizeof.  Guess.  */
70
71#define REAL_VALUE_TYPE_SIZE (SIGNIFICAND_BITS + 32)
72#define REAL_WIDTH \
73  (REAL_VALUE_TYPE_SIZE/HOST_BITS_PER_WIDE_INT \
74   + (REAL_VALUE_TYPE_SIZE%HOST_BITS_PER_WIDE_INT ? 1 : 0)) /* round up */
75
76/* Verify the guess.  */
77extern char test_real_width
78  [sizeof(REAL_VALUE_TYPE) <= REAL_WIDTH*sizeof(HOST_WIDE_INT) ? 1 : -1];
79
80/* Calculate the format for CONST_DOUBLE.  We need as many slots as
81   are necessary to overlay a REAL_VALUE_TYPE on them.  This could be
82   as many as four (32-bit HOST_WIDE_INT, 128-bit REAL_VALUE_TYPE).
83
84   A number of places assume that there are always at least two 'w'
85   slots in a CONST_DOUBLE, so we provide them even if one would suffice.  */
86
87#if REAL_WIDTH == 1
88# define CONST_DOUBLE_FORMAT	 "ww"
89#else
90# if REAL_WIDTH == 2
91#  define CONST_DOUBLE_FORMAT	 "ww"
92# else
93#  if REAL_WIDTH == 3
94#   define CONST_DOUBLE_FORMAT	 "www"
95#  else
96#   if REAL_WIDTH == 4
97#    define CONST_DOUBLE_FORMAT	 "wwww"
98#   else
99#    if REAL_WIDTH == 5
100#     define CONST_DOUBLE_FORMAT "wwwww"
101#    else
102#     if REAL_WIDTH == 6
103#      define CONST_DOUBLE_FORMAT "wwwwww"
104#     else
105       #error "REAL_WIDTH > 6 not supported"
106#     endif
107#    endif
108#   endif
109#  endif
110# endif
111#endif
112
113
114/* Describes the properties of the specific target format in use.  */
115struct real_format
116{
117  /* Move to and from the target bytes.  */
118  void (*encode) (const struct real_format *, long *,
119		  const REAL_VALUE_TYPE *);
120  void (*decode) (const struct real_format *, REAL_VALUE_TYPE *,
121		  const long *);
122
123  /* The radix of the exponent and digits of the significand.  */
124  int b;
125
126  /* log2(b).  */
127  int log2_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  /* Properties of the format.  */
150  bool has_nans;
151  bool has_inf;
152  bool has_denorm;
153  bool has_signed_zero;
154  bool qnan_msb_set;
155};
156
157
158/* The target format used for each floating floating point mode.
159   Indexed by MODE - QFmode.  */
160extern const struct real_format *
161  real_format_for_mode[MAX_MODE_FLOAT - MIN_MODE_FLOAT + 1];
162
163#define REAL_MODE_FORMAT(MODE) (real_format_for_mode[(MODE) - MIN_MODE_FLOAT])
164
165/* The following macro determines whether the floating point format is
166   composite, i.e. may contain non-consecutive mantissa bits, in which
167   case compile-time FP overflow may not model run-time overflow.  */
168#define REAL_MODE_FORMAT_COMPOSITE_P(MODE) \
169	((REAL_MODE_FORMAT(MODE))->pnan < (REAL_MODE_FORMAT (MODE))->p)
170
171/* Declare functions in real.c.  */
172
173/* Binary or unary arithmetic on tree_code.  */
174extern bool real_arithmetic (REAL_VALUE_TYPE *, int, const REAL_VALUE_TYPE *,
175			     const REAL_VALUE_TYPE *);
176
177/* Compare reals by tree_code.  */
178extern bool real_compare (int, const REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *);
179
180/* Determine whether a floating-point value X is infinite.  */
181extern bool real_isinf (const REAL_VALUE_TYPE *);
182
183/* Determine whether a floating-point value X is a NaN.  */
184extern bool real_isnan (const REAL_VALUE_TYPE *);
185
186/* Determine whether a floating-point value X is negative.  */
187extern bool real_isneg (const REAL_VALUE_TYPE *);
188
189/* Determine whether a floating-point value X is minus zero.  */
190extern bool real_isnegzero (const REAL_VALUE_TYPE *);
191
192/* Compare two floating-point objects for bitwise identity.  */
193extern bool real_identical (const REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *);
194
195/* Extend or truncate to a new mode.  */
196extern void real_convert (REAL_VALUE_TYPE *, enum machine_mode,
197			  const REAL_VALUE_TYPE *);
198
199/* Return true if truncating to NEW is exact.  */
200extern bool exact_real_truncate (enum machine_mode, const REAL_VALUE_TYPE *);
201
202/* Render R as a decimal floating point constant.  */
203extern void real_to_decimal (char *, const REAL_VALUE_TYPE *, size_t,
204			     size_t, int);
205
206/* Render R as a hexadecimal floating point constant.  */
207extern void real_to_hexadecimal (char *, const REAL_VALUE_TYPE *,
208				 size_t, size_t, int);
209
210/* Render R as an integer.  */
211extern HOST_WIDE_INT real_to_integer (const REAL_VALUE_TYPE *);
212extern void real_to_integer2 (HOST_WIDE_INT *, HOST_WIDE_INT *,
213			      const REAL_VALUE_TYPE *);
214
215/* Initialize R from a decimal or hexadecimal string.  */
216extern void real_from_string (REAL_VALUE_TYPE *, const char *);
217
218/* Initialize R from an integer pair HIGH/LOW.  */
219extern void real_from_integer (REAL_VALUE_TYPE *, enum machine_mode,
220			       unsigned HOST_WIDE_INT, HOST_WIDE_INT, int);
221
222extern long real_to_target_fmt (long *, const REAL_VALUE_TYPE *,
223				const struct real_format *);
224extern long real_to_target (long *, const REAL_VALUE_TYPE *, enum machine_mode);
225
226extern void real_from_target_fmt (REAL_VALUE_TYPE *, const long *,
227				  const struct real_format *);
228extern void real_from_target (REAL_VALUE_TYPE *, const long *,
229			      enum machine_mode);
230
231extern void real_inf (REAL_VALUE_TYPE *);
232
233extern bool real_nan (REAL_VALUE_TYPE *, const char *, int, enum machine_mode);
234
235extern void real_maxval (REAL_VALUE_TYPE *, int, enum machine_mode);
236
237extern void real_2expN (REAL_VALUE_TYPE *, int);
238
239extern unsigned int real_hash (const REAL_VALUE_TYPE *);
240
241
242/* Target formats defined in real.c.  */
243extern const struct real_format ieee_single_format;
244extern const struct real_format mips_single_format;
245extern const struct real_format ieee_double_format;
246extern const struct real_format mips_double_format;
247extern const struct real_format ieee_extended_motorola_format;
248extern const struct real_format ieee_extended_intel_96_format;
249extern const struct real_format ieee_extended_intel_96_round_53_format;
250extern const struct real_format ieee_extended_intel_128_format;
251extern const struct real_format ibm_extended_format;
252extern const struct real_format mips_extended_format;
253extern const struct real_format ieee_quad_format;
254extern const struct real_format mips_quad_format;
255extern const struct real_format vax_f_format;
256extern const struct real_format vax_d_format;
257extern const struct real_format vax_g_format;
258extern const struct real_format i370_single_format;
259extern const struct real_format i370_double_format;
260extern const struct real_format c4x_single_format;
261extern const struct real_format c4x_extended_format;
262extern const struct real_format real_internal_format;
263
264
265/* ====================================================================== */
266/* Crap.  */
267
268#define REAL_ARITHMETIC(value, code, d1, d2) \
269  real_arithmetic (&(value), code, &(d1), &(d2))
270
271#define REAL_VALUES_IDENTICAL(x, y)	real_identical (&(x), &(y))
272#define REAL_VALUES_EQUAL(x, y)		real_compare (EQ_EXPR, &(x), &(y))
273#define REAL_VALUES_LESS(x, y)		real_compare (LT_EXPR, &(x), &(y))
274
275/* Determine whether a floating-point value X is infinite.  */
276#define REAL_VALUE_ISINF(x)		real_isinf (&(x))
277
278/* Determine whether a floating-point value X is a NaN.  */
279#define REAL_VALUE_ISNAN(x)		real_isnan (&(x))
280
281/* Determine whether a floating-point value X is negative.  */
282#define REAL_VALUE_NEGATIVE(x)		real_isneg (&(x))
283
284/* Determine whether a floating-point value X is minus zero.  */
285#define REAL_VALUE_MINUS_ZERO(x)	real_isnegzero (&(x))
286
287/* IN is a REAL_VALUE_TYPE.  OUT is an array of longs.  */
288#define REAL_VALUE_TO_TARGET_LONG_DOUBLE(IN, OUT)			\
289  real_to_target (OUT, &(IN),						\
290		  mode_for_size (LONG_DOUBLE_TYPE_SIZE, MODE_FLOAT, 0))
291
292#define REAL_VALUE_TO_TARGET_DOUBLE(IN, OUT) \
293  real_to_target (OUT, &(IN), mode_for_size (64, MODE_FLOAT, 0))
294
295/* IN is a REAL_VALUE_TYPE.  OUT is a long.  */
296#define REAL_VALUE_TO_TARGET_SINGLE(IN, OUT) \
297  ((OUT) = real_to_target (NULL, &(IN), mode_for_size (32, MODE_FLOAT, 0)))
298
299#define REAL_VALUE_FROM_INT(r, lo, hi, mode) \
300  real_from_integer (&(r), mode, lo, hi, 0)
301
302#define REAL_VALUE_FROM_UNSIGNED_INT(r, lo, hi, mode) \
303  real_from_integer (&(r), mode, lo, hi, 1)
304
305extern REAL_VALUE_TYPE real_value_truncate (enum machine_mode,
306					    REAL_VALUE_TYPE);
307
308#define REAL_VALUE_TO_INT(plow, phigh, r) \
309  real_to_integer2 (plow, phigh, &(r))
310
311extern REAL_VALUE_TYPE real_arithmetic2 (int, const REAL_VALUE_TYPE *,
312					 const REAL_VALUE_TYPE *);
313
314#define REAL_VALUE_NEGATE(X) \
315  real_arithmetic2 (NEGATE_EXPR, &(X), NULL)
316
317#define REAL_VALUE_ABS(X) \
318  real_arithmetic2 (ABS_EXPR, &(X), NULL)
319
320extern int significand_size (enum machine_mode);
321
322extern REAL_VALUE_TYPE real_from_string2 (const char *, enum machine_mode);
323
324#define REAL_VALUE_ATOF(s, m) \
325  real_from_string2 (s, m)
326
327#define CONST_DOUBLE_ATOF(s, m) \
328  CONST_DOUBLE_FROM_REAL_VALUE (real_from_string2 (s, m), m)
329
330#define REAL_VALUE_FIX(r) \
331  real_to_integer (&(r))
332
333/* ??? Not quite right.  */
334#define REAL_VALUE_UNSIGNED_FIX(r) \
335  real_to_integer (&(r))
336
337/* ??? These were added for Paranoia support.  */
338
339/* Return floor log2(R).  */
340extern int real_exponent (const REAL_VALUE_TYPE *);
341
342/* R = A * 2**EXP.  */
343extern void real_ldexp (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *, int);
344
345/* **** End of software floating point emulator interface macros **** */
346
347/* Constant real values 0, 1, 2, 3, 10, -1, -2, 0.5 and 1/3.  */
348
349extern REAL_VALUE_TYPE dconst0;
350extern REAL_VALUE_TYPE dconst1;
351extern REAL_VALUE_TYPE dconst2;
352extern REAL_VALUE_TYPE dconst3;
353extern REAL_VALUE_TYPE dconst10;
354extern REAL_VALUE_TYPE dconstm1;
355extern REAL_VALUE_TYPE dconstm2;
356extern REAL_VALUE_TYPE dconsthalf;
357extern REAL_VALUE_TYPE dconstthird;
358extern REAL_VALUE_TYPE dconstpi;
359extern REAL_VALUE_TYPE dconste;
360
361/* Function to return a real value (not a tree node)
362   from a given integer constant.  */
363REAL_VALUE_TYPE real_value_from_int_cst (tree, tree);
364
365/* Given a CONST_DOUBLE in FROM, store into TO the value it represents.  */
366#define REAL_VALUE_FROM_CONST_DOUBLE(to, from) \
367  ((to) = *CONST_DOUBLE_REAL_VALUE (from))
368
369/* Return a CONST_DOUBLE with value R and mode M.  */
370#define CONST_DOUBLE_FROM_REAL_VALUE(r, m) \
371  const_double_from_real_value (r, m)
372extern rtx const_double_from_real_value (REAL_VALUE_TYPE, enum machine_mode);
373
374/* Replace R by 1/R in the given machine mode, if the result is exact.  */
375extern bool exact_real_inverse (enum machine_mode, REAL_VALUE_TYPE *);
376
377/* In tree.c: wrap up a REAL_VALUE_TYPE in a tree node.  */
378extern tree build_real (tree, REAL_VALUE_TYPE);
379
380/* Calculate R as the square root of X in the given machine mode.  */
381extern bool real_sqrt (REAL_VALUE_TYPE *, enum machine_mode,
382		       const REAL_VALUE_TYPE *);
383
384/* Calculate R as X raised to the integer exponent N in mode MODE.  */
385extern bool real_powi (REAL_VALUE_TYPE *, enum machine_mode,
386		       const REAL_VALUE_TYPE *, HOST_WIDE_INT);
387
388/* Standard round to integer value functions.  */
389extern void real_trunc (REAL_VALUE_TYPE *, enum machine_mode,
390			const REAL_VALUE_TYPE *);
391extern void real_floor (REAL_VALUE_TYPE *, enum machine_mode,
392			const REAL_VALUE_TYPE *);
393extern void real_ceil (REAL_VALUE_TYPE *, enum machine_mode,
394		       const REAL_VALUE_TYPE *);
395extern void real_round (REAL_VALUE_TYPE *, enum machine_mode,
396			const REAL_VALUE_TYPE *);
397
398/* Set the sign of R to the sign of X.  */
399extern void real_copysign (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *);
400
401#endif /* ! GCC_REAL_H */
402