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 | 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 | inline format_helper::format_helper (const T &m) |

233 | : m_format (m == VOIDmode ? 0 : REAL_MODE_FORMAT (m)) |

234 | {} |

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 */ |

565 |