1 | /* Definitions of floating-point access for GNU compiler. |
---|---|

2 | Copyright (C) 1989-2017 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 | unsigned int decimal : 1; |

45 | unsigned int sign : 1; |

46 | unsigned int signalling : 1; |

47 | unsigned int canonical : 1; |

48 | unsigned int uexp : EXP_BITS; |

49 | unsigned long sig[SIGSZ]; |

50 | }; |

51 | |

52 | #define REAL_EXP(REAL) \ |

53 | ((int)((REAL)->uexp ^ (unsigned int)(1 << (EXP_BITS - 1))) \ |

54 | - (1 << (EXP_BITS - 1))) |

55 | #define SET_REAL_EXP(REAL, EXP) \ |

56 | ((REAL)->uexp = ((unsigned int)(EXP) & (unsigned int)((1 << EXP_BITS) - 1))) |

57 | |

58 | /* Various headers condition prototypes on #ifdef REAL_VALUE_TYPE, so it |

59 | needs to be a macro. We do need to continue to have a structure tag |

60 | so that other headers can forward declare it. */ |

61 | #define REAL_VALUE_TYPE struct real_value |

62 | |

63 | /* We store a REAL_VALUE_TYPE into an rtx, and we do this by putting it in |

64 | consecutive "w" slots. Moreover, we've got to compute the number of "w" |

65 | slots at preprocessor time, which means we can't use sizeof. Guess. */ |

66 | |

67 | #define REAL_VALUE_TYPE_SIZE (SIGNIFICAND_BITS + 32) |

68 | #define REAL_WIDTH \ |

69 | (REAL_VALUE_TYPE_SIZE/HOST_BITS_PER_WIDE_INT \ |

70 | + (REAL_VALUE_TYPE_SIZE%HOST_BITS_PER_WIDE_INT ? 1 : 0)) /* round up */ |

71 | |

72 | /* Verify the guess. */ |

73 | extern char test_real_width |

74 | [sizeof (REAL_VALUE_TYPE) <= REAL_WIDTH * sizeof (HOST_WIDE_INT) ? 1 : -1]; |

75 | |

76 | /* Calculate the format for CONST_DOUBLE. We need as many slots as |

77 | are necessary to overlay a REAL_VALUE_TYPE on them. This could be |

78 | as many as four (32-bit HOST_WIDE_INT, 128-bit REAL_VALUE_TYPE). |

79 | |

80 | A number of places assume that there are always at least two 'w' |

81 | slots in a CONST_DOUBLE, so we provide them even if one would suffice. */ |

82 | |

83 | #if REAL_WIDTH == 1 |

84 | # define CONST_DOUBLE_FORMAT "ww" |

85 | #else |

86 | # if REAL_WIDTH == 2 |

87 | # define CONST_DOUBLE_FORMAT "ww" |

88 | # else |

89 | # if REAL_WIDTH == 3 |

90 | # define CONST_DOUBLE_FORMAT "www" |

91 | # else |

92 | # if REAL_WIDTH == 4 |

93 | # define CONST_DOUBLE_FORMAT "wwww" |

94 | # else |

95 | # if REAL_WIDTH == 5 |

96 | # define CONST_DOUBLE_FORMAT "wwwww" |

97 | # else |

98 | # if REAL_WIDTH == 6 |

99 | # define CONST_DOUBLE_FORMAT "wwwwww" |

100 | # else |

101 | #error "REAL_WIDTH > 6 not supported" |

102 | # endif |

103 | # endif |

104 | # endif |

105 | # endif |

106 | # endif |

107 | #endif |

108 | |

109 | |

110 | /* Describes the properties of the specific target format in use. */ |

111 | struct real_format |

112 | { |

113 | /* Move to and from the target bytes. */ |

114 | void (*encode) (const struct real_format *, long *, |

115 | const REAL_VALUE_TYPE *); |

116 | void (*decode) (const struct real_format *, REAL_VALUE_TYPE *, |

117 | const long *); |

118 | |

119 | /* The radix of the exponent and digits of the significand. */ |

120 | int b; |

121 | |

122 | /* Size of the significand in digits of radix B. */ |

123 | int p; |

124 | |

125 | /* Size of the significant of a NaN, in digits of radix B. */ |

126 | int pnan; |

127 | |

128 | /* The minimum negative integer, x, such that b**(x-1) is normalized. */ |

129 | int emin; |

130 | |

131 | /* The maximum integer, x, such that b**(x-1) is representable. */ |

132 | int emax; |

133 | |

134 | /* The bit position of the sign bit, for determining whether a value |

135 | is positive/negative, or -1 for a complex encoding. */ |

136 | int signbit_ro; |

137 | |

138 | /* The bit position of the sign bit, for changing the sign of a number, |

139 | or -1 for a complex encoding. */ |

140 | int signbit_rw; |

141 | |

142 | /* If this is an IEEE interchange format, the number of bits in the |

143 | format; otherwise, if it is an IEEE extended format, one more |

144 | than the greatest number of bits in an interchange format it |

145 | extends; otherwise 0. Formats need not follow the IEEE 754-2008 |

146 | recommended practice regarding how signaling NaNs are identified, |

147 | and may vary in the choice of default NaN, but must follow other |

148 | IEEE practice regarding having NaNs, infinities and subnormal |

149 | values, and the relation of minimum and maximum exponents, and, |

150 | for interchange formats, the details of the encoding. */ |

151 | int ieee_bits; |

152 | |

153 | /* Default rounding mode for operations on this format. */ |

154 | bool round_towards_zero; |

155 | bool has_sign_dependent_rounding; |

156 | |

157 | /* Properties of the format. */ |

158 | bool has_nans; |

159 | bool has_inf; |

160 | bool has_denorm; |

161 | bool has_signed_zero; |

162 | bool qnan_msb_set; |

163 | bool canonical_nan_lsbs_set; |

164 | const char *name; |

165 | }; |

166 | |

167 | |

168 | /* The target format used for each floating point mode. |

169 | Float modes are followed by decimal float modes, with entries for |

170 | float modes indexed by (MODE - first float mode), and entries for |

171 | decimal float modes indexed by (MODE - first decimal float mode) + |

172 | the number of float modes. */ |

173 | extern const struct real_format * |

174 | real_format_for_mode[MAX_MODE_FLOAT - MIN_MODE_FLOAT + 1 |

175 | + MAX_MODE_DECIMAL_FLOAT - MIN_MODE_DECIMAL_FLOAT + 1]; |

176 | |

177 | #define REAL_MODE_FORMAT(MODE) \ |

178 | (real_format_for_mode[DECIMAL_FLOAT_MODE_P (MODE) \ |

179 | ? (((MODE) - MIN_MODE_DECIMAL_FLOAT) \ |

180 | + (MAX_MODE_FLOAT - MIN_MODE_FLOAT + 1)) \ |

181 | : GET_MODE_CLASS (MODE) == MODE_FLOAT \ |

182 | ? ((MODE) - MIN_MODE_FLOAT) \ |

183 | : (gcc_unreachable (), 0)]) |

184 | |

185 | #define FLOAT_MODE_FORMAT(MODE) \ |

186 | (REAL_MODE_FORMAT (as_a <scalar_float_mode> (GET_MODE_INNER (MODE)))) |

187 | |

188 | /* The following macro determines whether the floating point format is |

189 | composite, i.e. may contain non-consecutive mantissa bits, in which |

190 | case compile-time FP overflow may not model run-time overflow. */ |

191 | #define MODE_COMPOSITE_P(MODE) \ |

192 | (FLOAT_MODE_P (MODE) \ |

193 | && FLOAT_MODE_FORMAT (MODE)->pnan < FLOAT_MODE_FORMAT (MODE)->p) |

194 | |

195 | /* Accessor macros for format properties. */ |

196 | #define MODE_HAS_NANS(MODE) \ |

197 | (FLOAT_MODE_P (MODE) && FLOAT_MODE_FORMAT (MODE)->has_nans) |

198 | #define MODE_HAS_INFINITIES(MODE) \ |

199 | (FLOAT_MODE_P (MODE) && FLOAT_MODE_FORMAT (MODE)->has_inf) |

200 | #define MODE_HAS_SIGNED_ZEROS(MODE) \ |

201 | (FLOAT_MODE_P (MODE) && FLOAT_MODE_FORMAT (MODE)->has_signed_zero) |

202 | #define MODE_HAS_SIGN_DEPENDENT_ROUNDING(MODE) \ |

203 | (FLOAT_MODE_P (MODE) \ |

204 | && FLOAT_MODE_FORMAT (MODE)->has_sign_dependent_rounding) |

205 | |

206 | /* This class allows functions in this file to accept a floating-point |

207 | format as either a mode or an explicit real_format pointer. In the |

208 | former case the mode must be VOIDmode (which means "no particular |

209 | format") or must satisfy SCALAR_FLOAT_MODE_P. */ |

210 | class format_helper |

211 | { |

212 | public: |

213 | format_helper (const real_format *format) : m_format (format) {} |

214 | template<typename T> format_helper (const T &); |

215 | const real_format *operator-> () const { return m_format; } |

216 | operator const real_format *() const { return m_format; } |

217 | |

218 | bool decimal_p () const { return m_format && m_format->b == 10; } |

219 | |

220 | private: |

221 | const real_format *m_format; |

222 | }; |

223 | |

224 | template<typename T> |

225 | inline format_helper::format_helper (const T &m) |

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

227 | {} |

228 | |

229 | /* Declare functions in real.c. */ |

230 | |

231 | /* True if the given mode has a NaN representation and the treatment of |

232 | NaN operands is important. Certain optimizations, such as folding |

233 | x * 0 into 0, are not correct for NaN operands, and are normally |

234 | disabled for modes with NaNs. The user can ask for them to be |

235 | done anyway using the -funsafe-math-optimizations switch. */ |

236 | extern bool HONOR_NANS (machine_mode); |

237 | extern bool HONOR_NANS (const_tree); |

238 | extern bool HONOR_NANS (const_rtx); |

239 | |

240 | /* Like HONOR_NANs, but true if we honor signaling NaNs (or sNaNs). */ |

241 | extern bool HONOR_SNANS (machine_mode); |

242 | extern bool HONOR_SNANS (const_tree); |

243 | extern bool HONOR_SNANS (const_rtx); |

244 | |

245 | /* As for HONOR_NANS, but true if the mode can represent infinity and |

246 | the treatment of infinite values is important. */ |

247 | extern bool HONOR_INFINITIES (machine_mode); |

248 | extern bool HONOR_INFINITIES (const_tree); |

249 | extern bool HONOR_INFINITIES (const_rtx); |

250 | |

251 | /* Like HONOR_NANS, but true if the given mode distinguishes between |

252 | positive and negative zero, and the sign of zero is important. */ |

253 | extern bool HONOR_SIGNED_ZEROS (machine_mode); |

254 | extern bool HONOR_SIGNED_ZEROS (const_tree); |

255 | extern bool HONOR_SIGNED_ZEROS (const_rtx); |

256 | |

257 | /* Like HONOR_NANS, but true if given mode supports sign-dependent rounding, |

258 | and the rounding mode is important. */ |

259 | extern bool HONOR_SIGN_DEPENDENT_ROUNDING (machine_mode); |

260 | extern bool HONOR_SIGN_DEPENDENT_ROUNDING (const_tree); |

261 | extern bool HONOR_SIGN_DEPENDENT_ROUNDING (const_rtx); |

262 | |

263 | /* Binary or unary arithmetic on tree_code. */ |

264 | extern bool real_arithmetic (REAL_VALUE_TYPE *, int, const REAL_VALUE_TYPE *, |

265 | const REAL_VALUE_TYPE *); |

266 | |

267 | /* Compare reals by tree_code. */ |

268 | extern bool real_compare (int, const REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *); |

269 | |

270 | /* Determine whether a floating-point value X is infinite. */ |

271 | extern bool real_isinf (const REAL_VALUE_TYPE *); |

272 | |

273 | /* Determine whether a floating-point value X is a NaN. */ |

274 | extern bool real_isnan (const REAL_VALUE_TYPE *); |

275 | |

276 | /* Determine whether a floating-point value X is a signaling NaN. */ |

277 | extern bool real_issignaling_nan (const REAL_VALUE_TYPE *); |

278 | |

279 | /* Determine whether a floating-point value X is finite. */ |

280 | extern bool real_isfinite (const REAL_VALUE_TYPE *); |

281 | |

282 | /* Determine whether a floating-point value X is negative. */ |

283 | extern bool real_isneg (const REAL_VALUE_TYPE *); |

284 | |

285 | /* Determine whether a floating-point value X is minus zero. */ |

286 | extern bool real_isnegzero (const REAL_VALUE_TYPE *); |

287 | |

288 | /* Test relationships between reals. */ |

289 | extern bool real_identical (const REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *); |

290 | extern bool real_equal (const REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *); |

291 | extern bool real_less (const REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *); |

292 | |

293 | /* Extend or truncate to a new format. */ |

294 | extern void real_convert (REAL_VALUE_TYPE *, format_helper, |

295 | const REAL_VALUE_TYPE *); |

296 | |

297 | /* Return true if truncating to NEW is exact. */ |

298 | extern bool exact_real_truncate (format_helper, const REAL_VALUE_TYPE *); |

299 | |

300 | /* Render R as a decimal floating point constant. */ |

301 | extern void real_to_decimal (char *, const REAL_VALUE_TYPE *, size_t, |

302 | size_t, int); |

303 | |

304 | /* Render R as a decimal floating point constant, rounded so as to be |

305 | parsed back to the same value when interpreted in mode MODE. */ |

306 | extern void real_to_decimal_for_mode (char *, const REAL_VALUE_TYPE *, size_t, |

307 | size_t, int, machine_mode); |

308 | |

309 | /* Render R as a hexadecimal floating point constant. */ |

310 | extern void real_to_hexadecimal (char *, const REAL_VALUE_TYPE *, |

311 | size_t, size_t, int); |

312 | |

313 | /* Render R as an integer. */ |

314 | extern HOST_WIDE_INT real_to_integer (const REAL_VALUE_TYPE *); |

315 | |

316 | /* Initialize R from a decimal or hexadecimal string. Return -1 if |

317 | the value underflows, +1 if overflows, and 0 otherwise. */ |

318 | extern int real_from_string (REAL_VALUE_TYPE *, const char *); |

319 | /* Wrapper to allow different internal representation for decimal floats. */ |

320 | extern void real_from_string3 (REAL_VALUE_TYPE *, const char *, format_helper); |

321 | |

322 | extern long real_to_target (long *, const REAL_VALUE_TYPE *, format_helper); |

323 | |

324 | extern void real_from_target (REAL_VALUE_TYPE *, const long *, |

325 | format_helper); |

326 | |

327 | extern void real_inf (REAL_VALUE_TYPE *); |

328 | |

329 | extern bool real_nan (REAL_VALUE_TYPE *, const char *, int, format_helper); |

330 | |

331 | extern void real_maxval (REAL_VALUE_TYPE *, int, machine_mode); |

332 | |

333 | extern void real_2expN (REAL_VALUE_TYPE *, int, format_helper); |

334 | |

335 | extern unsigned int real_hash (const REAL_VALUE_TYPE *); |

336 | |

337 | |

338 | /* Target formats defined in real.c. */ |

339 | extern const struct real_format ieee_single_format; |

340 | extern const struct real_format mips_single_format; |

341 | extern const struct real_format motorola_single_format; |

342 | extern const struct real_format spu_single_format; |

343 | extern const struct real_format ieee_double_format; |

344 | extern const struct real_format mips_double_format; |

345 | extern const struct real_format motorola_double_format; |

346 | extern const struct real_format ieee_extended_motorola_format; |

347 | extern const struct real_format ieee_extended_intel_96_format; |

348 | extern const struct real_format ieee_extended_intel_96_round_53_format; |

349 | extern const struct real_format ieee_extended_intel_128_format; |

350 | extern const struct real_format ibm_extended_format; |

351 | extern const struct real_format mips_extended_format; |

352 | extern const struct real_format ieee_quad_format; |

353 | extern const struct real_format mips_quad_format; |

354 | extern const struct real_format vax_f_format; |

355 | extern const struct real_format vax_d_format; |

356 | extern const struct real_format vax_g_format; |

357 | extern const struct real_format real_internal_format; |

358 | extern const struct real_format decimal_single_format; |

359 | extern const struct real_format decimal_double_format; |

360 | extern const struct real_format decimal_quad_format; |

361 | extern const struct real_format ieee_half_format; |

362 | extern const struct real_format arm_half_format; |

363 | |

364 | |

365 | /* ====================================================================== */ |

366 | /* Crap. */ |

367 | |

368 | /* Determine whether a floating-point value X is infinite. */ |

369 | #define REAL_VALUE_ISINF(x) real_isinf (&(x)) |

370 | |

371 | /* Determine whether a floating-point value X is a NaN. */ |

372 | #define REAL_VALUE_ISNAN(x) real_isnan (&(x)) |

373 | |

374 | /* Determine whether a floating-point value X is a signaling NaN. */ |

375 | #define REAL_VALUE_ISSIGNALING_NAN(x) real_issignaling_nan (&(x)) |

376 | |

377 | /* Determine whether a floating-point value X is negative. */ |

378 | #define REAL_VALUE_NEGATIVE(x) real_isneg (&(x)) |

379 | |

380 | /* Determine whether a floating-point value X is minus zero. */ |

381 | #define REAL_VALUE_MINUS_ZERO(x) real_isnegzero (&(x)) |

382 | |

383 | /* IN is a REAL_VALUE_TYPE. OUT is an array of longs. */ |

384 | #define REAL_VALUE_TO_TARGET_LONG_DOUBLE(IN, OUT) \ |

385 | real_to_target (OUT, &(IN), \ |

386 | float_mode_for_size (LONG_DOUBLE_TYPE_SIZE).require ()) |

387 | |

388 | #define REAL_VALUE_TO_TARGET_DOUBLE(IN, OUT) \ |

389 | real_to_target (OUT, &(IN), float_mode_for_size (64).require ()) |

390 | |

391 | /* IN is a REAL_VALUE_TYPE. OUT is a long. */ |

392 | #define REAL_VALUE_TO_TARGET_SINGLE(IN, OUT) \ |

393 | ((OUT) = real_to_target (NULL, &(IN), float_mode_for_size (32).require ())) |

394 | |

395 | /* Real values to IEEE 754 decimal floats. */ |

396 | |

397 | /* IN is a REAL_VALUE_TYPE. OUT is an array of longs. */ |

398 | #define REAL_VALUE_TO_TARGET_DECIMAL128(IN, OUT) \ |

399 | real_to_target (OUT, &(IN), decimal_float_mode_for_size (128).require ()) |

400 | |

401 | #define REAL_VALUE_TO_TARGET_DECIMAL64(IN, OUT) \ |

402 | real_to_target (OUT, &(IN), decimal_float_mode_for_size (64).require ()) |

403 | |

404 | /* IN is a REAL_VALUE_TYPE. OUT is a long. */ |

405 | #define REAL_VALUE_TO_TARGET_DECIMAL32(IN, OUT) \ |

406 | ((OUT) = real_to_target (NULL, &(IN), \ |

407 | decimal_float_mode_for_size (32).require ())) |

408 | |

409 | extern REAL_VALUE_TYPE real_value_truncate (format_helper, REAL_VALUE_TYPE); |

410 | |

411 | extern REAL_VALUE_TYPE real_value_negate (const REAL_VALUE_TYPE *); |

412 | extern REAL_VALUE_TYPE real_value_abs (const REAL_VALUE_TYPE *); |

413 | |

414 | extern int significand_size (format_helper); |

415 | |

416 | extern REAL_VALUE_TYPE real_from_string2 (const char *, format_helper); |

417 | |

418 | #define REAL_VALUE_ATOF(s, m) \ |

419 | real_from_string2 (s, m) |

420 | |

421 | #define CONST_DOUBLE_ATOF(s, m) \ |

422 | const_double_from_real_value (real_from_string2 (s, m), m) |

423 | |

424 | #define REAL_VALUE_FIX(r) \ |

425 | real_to_integer (&(r)) |

426 | |

427 | /* ??? Not quite right. */ |

428 | #define REAL_VALUE_UNSIGNED_FIX(r) \ |

429 | real_to_integer (&(r)) |

430 | |

431 | /* ??? These were added for Paranoia support. */ |

432 | |

433 | /* Return floor log2(R). */ |

434 | extern int real_exponent (const REAL_VALUE_TYPE *); |

435 | |

436 | /* R = A * 2**EXP. */ |

437 | extern void real_ldexp (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *, int); |

438 | |

439 | /* **** End of software floating point emulator interface macros **** */ |

440 | |

441 | /* Constant real values 0, 1, 2, -1 and 0.5. */ |

442 | |

443 | extern REAL_VALUE_TYPE dconst0; |

444 | extern REAL_VALUE_TYPE dconst1; |

445 | extern REAL_VALUE_TYPE dconst2; |

446 | extern REAL_VALUE_TYPE dconstm1; |

447 | extern REAL_VALUE_TYPE dconsthalf; |

448 | |

449 | #define dconst_e() (*dconst_e_ptr ()) |

450 | #define dconst_third() (*dconst_third_ptr ()) |

451 | #define dconst_quarter() (*dconst_quarter_ptr ()) |

452 | #define dconst_sixth() (*dconst_sixth_ptr ()) |

453 | #define dconst_ninth() (*dconst_ninth_ptr ()) |

454 | #define dconst_sqrt2() (*dconst_sqrt2_ptr ()) |

455 | |

456 | /* Function to return the real value special constant 'e'. */ |

457 | extern const REAL_VALUE_TYPE * dconst_e_ptr (void); |

458 | |

459 | /* Returns a cached REAL_VALUE_TYPE corresponding to 1/n, for various n. */ |

460 | extern const REAL_VALUE_TYPE *dconst_third_ptr (void); |

461 | extern const REAL_VALUE_TYPE *dconst_quarter_ptr (void); |

462 | extern const REAL_VALUE_TYPE *dconst_sixth_ptr (void); |

463 | extern const REAL_VALUE_TYPE *dconst_ninth_ptr (void); |

464 | |

465 | /* Returns the special REAL_VALUE_TYPE corresponding to sqrt(2). */ |

466 | extern const REAL_VALUE_TYPE * dconst_sqrt2_ptr (void); |

467 | |

468 | /* Function to return a real value (not a tree node) |

469 | from a given integer constant. */ |

470 | REAL_VALUE_TYPE real_value_from_int_cst (const_tree, const_tree); |

471 | |

472 | /* Return a CONST_DOUBLE with value R and mode M. */ |

473 | extern rtx const_double_from_real_value (REAL_VALUE_TYPE, machine_mode); |

474 | |

475 | /* Replace R by 1/R in the given format, if the result is exact. */ |

476 | extern bool exact_real_inverse (format_helper, REAL_VALUE_TYPE *); |

477 | |

478 | /* Return true if arithmetic on values in IMODE that were promoted |

479 | from values in TMODE is equivalent to direct arithmetic on values |

480 | in TMODE. */ |

481 | bool real_can_shorten_arithmetic (machine_mode, machine_mode); |

482 | |

483 | /* In tree.c: wrap up a REAL_VALUE_TYPE in a tree node. */ |

484 | extern tree build_real (tree, REAL_VALUE_TYPE); |

485 | |

486 | /* Likewise, but first truncate the value to the type. */ |

487 | extern tree build_real_truncate (tree, REAL_VALUE_TYPE); |

488 | |

489 | /* Calculate R as X raised to the integer exponent N in format FMT. */ |

490 | extern bool real_powi (REAL_VALUE_TYPE *, format_helper, |

491 | const REAL_VALUE_TYPE *, HOST_WIDE_INT); |

492 | |

493 | /* Standard round to integer value functions. */ |

494 | extern void real_trunc (REAL_VALUE_TYPE *, format_helper, |

495 | const REAL_VALUE_TYPE *); |

496 | extern void real_floor (REAL_VALUE_TYPE *, format_helper, |

497 | const REAL_VALUE_TYPE *); |

498 | extern void real_ceil (REAL_VALUE_TYPE *, format_helper, |

499 | const REAL_VALUE_TYPE *); |

500 | extern void real_round (REAL_VALUE_TYPE *, format_helper, |

501 | const REAL_VALUE_TYPE *); |

502 | |

503 | /* Set the sign of R to the sign of X. */ |

504 | extern void real_copysign (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *); |

505 | |

506 | /* Check whether the real constant value given is an integer. */ |

507 | extern bool real_isinteger (const REAL_VALUE_TYPE *, format_helper); |

508 | extern bool real_isinteger (const REAL_VALUE_TYPE *, HOST_WIDE_INT *); |

509 | |

510 | /* Write into BUF the maximum representable finite floating-point |

511 | number, (1 - b**-p) * b**emax for a given FP format FMT as a hex |

512 | float string. BUF must be large enough to contain the result. */ |

513 | extern void get_max_float (const struct real_format *, char *, size_t); |

514 | |

515 | #ifndef GENERATOR_FILE |

516 | /* real related routines. */ |

517 | extern wide_int real_to_integer (const REAL_VALUE_TYPE *, bool *, int); |

518 | extern void real_from_integer (REAL_VALUE_TYPE *, format_helper, |

519 | const wide_int_ref &, signop); |

520 | #endif |

521 | |

522 | #endif /* ! GCC_REAL_H */ |

523 |