Go to the source code of this file.
Data Structures | |
| struct | real_value |
| struct | real_format |
| class | format_helper |
Enumerations | |
| enum | real_value_class { rvc_zero , rvc_normal , rvc_inf , rvc_nan } |
Macro Definition Documentation
◆ CONST_DOUBLE_ATOF
| #define CONST_DOUBLE_ATOF | ( | s, | |
| m ) const_double_from_real_value (real_from_string2 (s, m), m) |
◆ dconst_e
| #define dconst_e | ( | ) | (*dconst_e_ptr ()) |
◆ dconst_ninth
| #define dconst_ninth | ( | ) | (*dconst_ninth_ptr ()) |
◆ dconst_pi
| #define dconst_pi | ( | ) | (*dconst_pi_ptr ()) |
Referenced by cfn_sincos::fold_range().
◆ dconst_quarter
| #define dconst_quarter | ( | ) | (*dconst_quarter_ptr ()) |
◆ dconst_sixth
| #define dconst_sixth | ( | ) | (*dconst_sixth_ptr ()) |
◆ dconst_sqrt2
| #define dconst_sqrt2 | ( | ) | (*dconst_sqrt2_ptr ()) |
◆ dconst_third
| #define dconst_third | ( | ) | (*dconst_third_ptr ()) |
Referenced by gimple_expand_builtin_pow().
◆ EXP_BITS
| #define EXP_BITS (32 - 6) |
Referenced by bp_pack_real_value(), bp_unpack_real_value(), ten_to_mptwo(), and ten_to_ptwo().
◆ FLOAT_MODE_FORMAT
| #define FLOAT_MODE_FORMAT | ( | MODE | ) | (REAL_MODE_FORMAT (as_a <scalar_float_mode> (GET_MODE_INNER (MODE)))) |
Referenced by float_widen_lhs_range().
◆ MAX_EXP
| #define MAX_EXP ((1 << (EXP_BITS - 1)) - 1) |
Referenced by do_add(), do_divide(), do_multiply(), normalize(), real_2expN(), real_from_string(), and real_ldexp().
◆ MODE_COMPOSITE_P
| #define MODE_COMPOSITE_P | ( | MODE | ) |
The following macro determines whether the floating point format is composite, i.e. may contain non-consecutive mantissa bits, in which case compile-time FP overflow may not model run-time overflow.
Referenced by build_gt(), build_lt(), const_binop(), expand_builtin_issignaling(), float_widen_lhs_range(), fold_builtin_classify(), fold_builtin_interclass_mathfn(), frange_arithmetic(), frange_mpfr_arg1(), frange_nextafter(), frange::internal_singleton_p(), long_double_as_float128(), real_can_shorten_arithmetic(), simplify_const_binary_operation(), and simplify_context::simplify_gen_subreg().
◆ MODE_HAS_INFINITIES
| #define MODE_HAS_INFINITIES | ( | MODE | ) | (FLOAT_MODE_P (MODE) && FLOAT_MODE_FORMAT (MODE)->has_inf) |
◆ MODE_HAS_NANS
| #define MODE_HAS_NANS | ( | MODE | ) | (FLOAT_MODE_P (MODE) && FLOAT_MODE_FORMAT (MODE)->has_nans) |
Accessor macros for format properties.
Referenced by const_binop(), fold_convert_const_real_from_real(), and HONOR_NANS().
◆ MODE_HAS_SIGN_DEPENDENT_ROUNDING
| #define MODE_HAS_SIGN_DEPENDENT_ROUNDING | ( | MODE | ) |
Referenced by HONOR_SIGN_DEPENDENT_ROUNDING().
◆ MODE_HAS_SIGNED_ZEROS
| #define MODE_HAS_SIGNED_ZEROS | ( | MODE | ) | (FLOAT_MODE_P (MODE) && FLOAT_MODE_FORMAT (MODE)->has_signed_zero) |
Referenced by HONOR_SIGNED_ZEROS(), insert_var_expansion_initialization(), and frange::set().
◆ REAL_EXP
| #define REAL_EXP | ( | REAL | ) |
Referenced by acceptable_pow_call(), inchash::hash::add_real_value(), decimal_integer_string(), do_add(), do_compare(), do_divide(), do_fix_trunc(), do_multiply(), encode_arm_bfloat_half(), encode_ieee_double(), encode_ieee_extended(), encode_ieee_half(), encode_ieee_quad(), encode_ieee_single(), encode_vax_d(), encode_vax_f(), encode_vax_g(), exact_real_truncate(), fold_builtin_frexp(), fold_const_call_ss(), fold_const_logb(), frange_arithmetic(), gimple_expand_builtin_pow(), init_emit_once(), is_even(), is_halfway_below(), normalize(), real_exponent(), real_hash(), real_identical(), real_isdenormal(), real_ldexp(), real_nextafter(), real_roundeven(), real_to_decimal_for_mode(), real_to_hexadecimal(), real_to_integer(), real_to_integer(), round_for_format(), rtd_divmod(), and ubsan_instrument_float_cast().
◆ REAL_MODE_FORMAT
| #define REAL_MODE_FORMAT | ( | MODE | ) |
Referenced by associated_internal_fn(), build_common_tree_nodes(), build_real(), build_sinatan_real(), check_target_format(), clear_padding_real_needs_padding_p(), convert_mode_scalar(), convert_to_real_1(), default_floatn_mode(), do_compile(), do_mpc_arg2(), do_mpfr_lgamma_r(), do_mpfr_remquo(), expand_absneg_bit(), expand_builtin_issignaling(), expand_builtin_signbit(), expand_copysign(), expand_fix(), fold_builtin_fpclassify(), fold_builtin_interclass_mathfn(), fold_const_call_1(), fold_const_call_1(), fold_const_call_1(), frange_arithmetic(), frange_mpfr_arg1(), frange_nextafter(), gen_trunc_conv_libfunc(), get_no_error_domain(), glibc_linux_libm_function_max_error(), lto_input_mode_table(), lto_write_mode_table(), real_can_shorten_arithmetic(), real_from_mpfr(), real_isdenormal(), real_max_representable(), real_maxval(), real_to_decimal_for_mode(), round_for_format(), sign_mask_for(), and ubsan_instrument_float_cast().
◆ REAL_VALUE_ATOF
| #define REAL_VALUE_ATOF | ( | s, | |
| m ) real_from_string2 (s, m) |
◆ REAL_VALUE_FIX
| #define REAL_VALUE_FIX | ( | r | ) | real_to_integer (&(r)) |
◆ REAL_VALUE_ISINF
| #define REAL_VALUE_ISINF | ( | x | ) | real_isinf (&(x)) |
======================================================================
Crap.
Determine whether a floating-point value X is infinite.
Referenced by const_binop(), dump_generic_node(), fold_convert_const_real_from_real(), print_real_cst(), and simplify_const_binary_operation().
◆ REAL_VALUE_ISNAN
| #define REAL_VALUE_ISNAN | ( | x | ) | real_isnan (&(x)) |
Determine whether a floating-point value X is a NaN.
Referenced by const_binop(), dump_generic_node(), fold_convert_const_int_from_real(), fold_convert_const_real_from_real(), print_real_cst(), simplify_const_relational_operation(), simplify_const_unary_operation(), and valid_lattice_transition().
◆ REAL_VALUE_ISSIGNALING_NAN
| #define REAL_VALUE_ISSIGNALING_NAN | ( | x | ) | real_issignaling_nan (&(x)) |
Determine whether a floating-point value X is a signaling NaN.
Referenced by const_binop(), const_unop(), fold_const_builtin_load_exponent(), fold_const_call_ss(), fold_const_call_sss(), fold_const_nextafter(), fold_const_pow(), fold_convert_const_real_from_real(), gimple_expand_builtin_pow(), simplify_const_binary_operation(), and simplify_const_unary_operation().
◆ REAL_VALUE_MINUS_ZERO
| #define REAL_VALUE_MINUS_ZERO | ( | x | ) | real_isnegzero (&(x)) |
Determine whether a floating-point value X is minus zero.
Referenced by fold_real_zero_addition_p(), initializer_zerop(), and tree_expr_maybe_real_minus_zero_p().
◆ REAL_VALUE_NEGATIVE
| #define REAL_VALUE_NEGATIVE | ( | x | ) | real_isneg (&(x)) |
Determine whether a floating-point value X is negative.
Referenced by canonicalize_condition(), dump_generic_node(), expand_pow_as_sqrts(), find_comparison_args(), fold_abs_const(), fold_binary_loc(), negate_expr_p(), print_real_cst(), representable_as_half_series_p(), simplify_context::simplify_binary_operation_1(), simplify_const_binary_operation(), simplify_const_unary_operation(), and tree_single_nonnegative_warnv_p().
◆ REAL_VALUE_TO_TARGET_DECIMAL128
| #define REAL_VALUE_TO_TARGET_DECIMAL128 | ( | IN, | |
| OUT ) real_to_target (OUT, &(IN), decimal_float_mode_for_size (128).require ()) |
Real values to IEEE 754 decimal floats.
IN is a REAL_VALUE_TYPE. OUT is an array of longs.
◆ REAL_VALUE_TO_TARGET_DECIMAL32
IN is a REAL_VALUE_TYPE. OUT is a long.
◆ REAL_VALUE_TO_TARGET_DECIMAL64
| #define REAL_VALUE_TO_TARGET_DECIMAL64 | ( | IN, | |
| OUT ) real_to_target (OUT, &(IN), decimal_float_mode_for_size (64).require ()) |
◆ REAL_VALUE_TO_TARGET_DOUBLE
| #define REAL_VALUE_TO_TARGET_DOUBLE | ( | IN, | |
| OUT ) real_to_target (OUT, &(IN), float_mode_for_size (64).require ()) |
Referenced by split_double().
◆ REAL_VALUE_TO_TARGET_LONG_DOUBLE
IN is a REAL_VALUE_TYPE. OUT is an array of longs.
◆ REAL_VALUE_TO_TARGET_SINGLE
| #define REAL_VALUE_TO_TARGET_SINGLE | ( | IN, | |
| OUT ) ((OUT) = real_to_target (NULL, &(IN), float_mode_for_size (32).require ())) |
IN is a REAL_VALUE_TYPE. OUT is a long.
◆ REAL_VALUE_TYPE
| #define REAL_VALUE_TYPE struct real_value |
Various headers condition prototypes on #ifdef REAL_VALUE_TYPE, so it needs to be a macro. We do need to continue to have a structure tag so that other headers can forward declare it.
Referenced by acceptable_pow_call(), build_complex_inf(), build_ge(), build_gt(), build_le(), build_lt(), build_real(), build_real_from_wide(), build_sinatan_real(), canonicalize_condition(), check_pow(), check_real_for_fixed_mode(), compress_float_constant(), const_binop(), dconst_e_ptr(), dconst_pi_ptr(), dconst_sqrt2_ptr(), decimal_do_compare(), decimal_from_decnumber(), decimal_integer_string(), decimal_real_arithmetic(), decimal_real_to_integer(), decimal_real_to_integer(), decode_ibm_extended(), decrement_power(), div_significands(), do_add(), do_divide(), do_mpc_arg2(), do_mpc_ckconv(), do_mpc_ckconv(), do_mpfr_ckconv(), do_mpfr_ckconv(), do_mpfr_lgamma_r(), do_mpfr_remquo(), do_multiply(), dump_generic_node(), encode_ibm_extended(), encode_ieee_quad(), exact_inverse(), exact_real_inverse(), exact_real_truncate(), expand_fix(), expand_float(), expand_pow_as_sqrts(), find_comparison_args(), fixed_convert_from_real(), fixed_from_string(), fixed_to_decimal(), float_widen_lhs_range(), fold_builtin_fpclassify(), fold_builtin_frexp(), fold_builtin_interclass_mathfn(), fold_builtin_modf(), fold_const_builtin_load_exponent(), fold_const_builtin_nan(), fold_const_call_1(), fold_const_call_1(), fold_const_call_1(), fold_const_pow(), fold_convert_const_int_from_real(), fold_convert_const_real_from_fixed(), fold_convert_const_real_from_real(), cfn_sqrt::fold_range(), cfn_sincos::fold_range(), operator_abs::fold_range(), operator_negate::fold_range(), cfn_constant_float_p::fold_range(), fold_relational_const(), frange_arithmetic(), frange_drop_inf(), frange_drop_infs(), frange_drop_ninf(), frange_mpfr_arg1(), frange_nextafter(), frange_val_is_max(), frange_val_is_min(), gen_conditions_for_pow_cst_base(), range_query::get_tree_range(), gimple_expand_builtin_pow(), hash_tree(), init_emit_once(), frange::internal_singleton_p(), native_decode_rtx(), native_interpret_real(), omp_reduction_init_op(), cfn_sqrt::op1_range(), cfn_sincos::op1_range(), foperator_div::op1_range(), operator_mult::op1_range(), operator_equal::op1_range(), operator_not_equal::op1_range(), foperator_div::op2_range(), pack_ts_real_cst_value_fields(), print_real_cst(), real_ceil(), real_convert_from_fixed(), real_digit(), real_floor(), real_from_string2(), real_isinteger(), real_isinteger(), real_max_representable(), real_min_representable(), real_nan(), real_nextafter(), real_powi(), real_to_decimal_for_mode(), real_to_target(), real_value_abs(), real_value_from_int_cst(), real_value_negate(), real_value_truncate(), relational_result(), representable_as_half_series_p(), round_for_format(), operator_mult::rv_fold(), foperator_div::rv_fold(), operator_plus::rv_fold(), operator_minus::rv_fold(), frange::set(), simplify_context::simplify_binary_operation_1(), simplify_const_binary_operation(), simplify_const_relational_operation(), simplify_const_unary_operation(), streamer_read_value_range(), strip_float_extensions(), ten_to_mptwo(), ten_to_ptwo(), times_pten(), tree_call_nonnegative_warnv_p(), ubsan_instrument_float_cast(), unpack_ts_real_cst_value_fields(), vect_build_all_ones_mask(), and vect_build_zero_merge_argument().
◆ REAL_VALUE_TYPE_SIZE
| #define REAL_VALUE_TYPE_SIZE (SIGNIFICAND_BITS + 32) |
We store a REAL_VALUE_TYPE into an rtx, and we do this by putting it in consecutive "w" slots. Moreover, we've got to compute the number of "w" slots at preprocessor time, which means we can't use sizeof. Guess.
◆ REAL_VALUE_UNSIGNED_FIX
| #define REAL_VALUE_UNSIGNED_FIX | ( | r | ) | real_to_integer (&(r)) |
??? Not quite right.
◆ REAL_WIDTH
| #define REAL_WIDTH |
◆ SET_REAL_EXP
| #define SET_REAL_EXP | ( | REAL, | |
| EXP ) ((REAL)->uexp = ((unsigned int)(EXP) & (unsigned int)((1 << EXP_BITS) - 1))) |
Referenced by decode_arm_bfloat_half(), decode_ieee_double(), decode_ieee_extended(), decode_ieee_half(), decode_ieee_quad(), decode_ieee_single(), decode_vax_d(), decode_vax_f(), decode_vax_g(), do_add(), do_divide(), do_multiply(), float_widen_lhs_range(), fold_builtin_frexp(), fold_const_significand(), gimple_expand_builtin_pow(), init_emit_once(), normalize(), real_2expN(), real_from_integer(), real_from_string(), real_ldexp(), real_maxval(), real_nextafter(), real_to_decimal_for_mode(), round_for_format(), rtd_divmod(), and ubsan_instrument_float_cast().
◆ SIG_MSB
| #define SIG_MSB ((unsigned long)1 << (HOST_BITS_PER_LONG - 1)) |
Referenced by decode_arm_bfloat_half(), decode_ieee_double(), decode_ieee_half(), decode_ieee_quad(), decode_ieee_single(), decode_vax_d(), decode_vax_f(), decode_vax_g(), div_significands(), do_add(), exact_real_inverse(), real_2expN(), real_isdenormal(), real_nextafter(), round_for_format(), and rtd_divmod().
◆ SIGNIFICAND_BITS
| #define SIGNIFICAND_BITS (128 + HOST_BITS_PER_LONG) |
Referenced by dconst_e_ptr(), dconst_pi_ptr(), dconst_sqrt2_ptr(), decode_ieee_quad(), div_significands(), do_add(), do_fix_trunc(), encode_ieee_quad(), is_even(), is_halfway_below(), real_from_integer(), real_from_string(), real_maxval(), real_nan(), real_nextafter(), real_roundeven(), real_to_decimal_for_mode(), real_to_hexadecimal(), and round_for_format().
◆ SIGSZ
| #define SIGSZ (SIGNIFICAND_BITS / HOST_BITS_PER_LONG) |
Referenced by inchash::hash::add_real_value(), add_significands(), bp_pack_real_value(), bp_unpack_real_value(), cmp_significand_0(), cmp_significands(), decode_arm_bfloat_half(), decode_ieee_double(), decode_ieee_extended(), decode_ieee_half(), decode_ieee_quad(), decode_ieee_single(), decode_vax_d(), decode_vax_f(), decode_vax_g(), div_significands(), do_add(), do_multiply(), encode_arm_bfloat_half(), encode_ieee_double(), encode_ieee_extended(), encode_ieee_half(), encode_ieee_single(), encode_vax_d(), encode_vax_f(), encode_vax_g(), exact_real_inverse(), lshift_significand(), lshift_significand_1(), neg_significand(), normalize(), real_2expN(), real_from_integer(), real_hash(), real_identical(), real_isdenormal(), real_maxval(), real_nan(), real_nextafter(), real_to_hexadecimal(), real_to_integer(), real_to_integer(), round_for_format(), rshift_significand(), rtd_divmod(), sticky_rshift_significand(), and sub_significands().
Enumeration Type Documentation
◆ real_value_class
Definitions of floating-point access for GNU compiler. Copyright (C) 1989-2024 Free Software Foundation, Inc. This file is part of GCC. GCC is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3, or (at your option) any later version. GCC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with GCC; see the file COPYING3. If not see <http://www.gnu.org/licenses/>.
An expanded form of the represented number.
Enumerate the special cases of numbers that we encounter.
| Enumerator | |
|---|---|
| rvc_zero | |
| rvc_normal | |
| rvc_inf | |
| rvc_nan | |
Function Documentation
◆ build_real()
|
extern |
In tree.cc: wrap up a REAL_VALUE_TYPE in a tree node.
Return a new REAL_CST node whose type is TYPE and value is D.
References dconst0, dconst1, dconst2, dconsthalf, dconstm1, DECIMAL_FLOAT_MODE_P, decimal_real_from_string(), gcc_unreachable, ggc_alloc(), make_node(), REAL_MODE_FORMAT, REAL_VALUE_TYPE, rvc_normal, rvc_zero, TREE_OVERFLOW, TREE_REAL_CST_PTR, TREE_TYPE, type(), and TYPE_MODE.
Referenced by scev_dfs::add_to_evolution(), scev_dfs::add_to_evolution_1(), build_complex_inf(), build_minus_one_cst(), build_one_cst(), build_real_from_int_cst(), build_real_from_wide(), build_real_truncate(), build_zero_cst(), chrec_fold_multiply_poly_poly(), chrec_fold_plus_1(), chrec_fold_plus_poly_poly(), const_binop(), decrement_power(), do_mpc_ckconv(), do_mpfr_ckconv(), exact_inverse(), expand_builtin_cexpi(), expand_builtin_signbit(), expand_omp_for_init_vars(), expand_pow_as_sqrts(), fold_abs_const(), fold_builtin_fpclassify(), fold_builtin_frexp(), fold_builtin_inf(), fold_builtin_interclass_mathfn(), fold_builtin_modf(), fold_const_builtin_nan(), fold_const_call_1(), fold_const_call_1(), fold_const_call_1(), fold_convert_const_real_from_fixed(), fold_convert_const_real_from_real(), fold_negate_const(), get_component_ssa_name(), gimple_expand_builtin_pow(), frange::lbound(), make_tree(), native_interpret_real(), neutral_op_for_reduction(), omp_reduction_init_op(), powi_as_mults(), frange::singleton_p(), frange::ubound(), ubsan_instrument_float_cast(), vect_build_all_ones_mask(), and vect_build_zero_merge_argument().
◆ build_real_truncate()
|
extern |
Likewise, but first truncate the value to the type.
Like build_real, but first truncate D to the type.
References build_real(), real_value_truncate(), and TYPE_MODE.
Referenced by strip_float_extensions().
◆ build_sinatan_real()
|
extern |
Fills r with the largest value such that 1 + r*r won't overflow. This is used in both sin (atan (x)) and cos (atan(x)) optimizations.
References dconst1, ggc_alloc(), mpfr_from_real(), NULL, r, real_from_mpfr(), real_maxval(), REAL_MODE_FORMAT, REAL_VALUE_TYPE, and TYPE_MODE.
◆ const_double_from_real_value()
|
extern |
Return a CONST_DOUBLE with value R and mode M.
Return a CONST_DOUBLE rtx for a floating-point value specified by VALUE in mode MODE.
References ggc_alloc(), lookup_const_double(), PUT_MODE(), rtx_alloc(), rtx_def::u::rv, and rtx_def::u.
Referenced by avoid_constant_pool_reference(), compress_float_constant(), const_vector_from_tree(), expand_expr_real_1(), expand_fix(), expand_float(), fold_rtx(), init_emit_once(), native_decode_rtx(), relational_result(), simplify_context::simplify_binary_operation_1(), simplify_const_binary_operation(), and simplify_const_unary_operation().
◆ dconst_e_ptr()
|
extern |
Function to return the real value special constant 'e'.
Returns the special REAL_VALUE_TYPE corresponding to 'e'.
References ggc_alloc(), NULL_TREE, real_from_mpfr(), REAL_VALUE_TYPE, rvc_zero, and SIGNIFICAND_BITS.
◆ dconst_ninth_ptr()
|
extern |
◆ dconst_pi_ptr()
|
extern |
Function to return the real value special constant 'pi'.
Returns the special REAL_VALUE_TYPE corresponding to 'pi'.
References ggc_alloc(), NULL_TREE, real_from_mpfr(), REAL_VALUE_TYPE, rvc_zero, and SIGNIFICAND_BITS.
◆ dconst_quarter_ptr()
|
extern |
◆ dconst_sixth_ptr()
|
extern |
◆ dconst_sqrt2_ptr()
|
extern |
Returns the special REAL_VALUE_TYPE corresponding to sqrt(2).
References ggc_alloc(), NULL_TREE, real_from_mpfr(), REAL_VALUE_TYPE, rvc_zero, and SIGNIFICAND_BITS.
◆ dconst_third_ptr()
|
extern |
Returns a cached REAL_VALUE_TYPE corresponding to 1/n, for various n.
◆ exact_real_inverse()
|
extern |
Replace R by 1/R in the given format, if the result is exact.
Try to change R into its exact multiplicative inverse in format FMT. Return true if successful.
References do_divide(), ggc_alloc(), i, r, real_convert(), real_digit(), REAL_VALUE_TYPE, rvc_normal, SIG_MSB, and SIGSZ.
Referenced by exact_inverse().
◆ exact_real_truncate()
|
extern |
Return true if truncating to NEW is exact.
Return true if truncating to FMT is exact.
References a, ggc_alloc(), real_convert(), REAL_EXP, real_identical(), and REAL_VALUE_TYPE.
Referenced by compress_float_constant(), fold_convert_const_real_from_real(), simplify_const_unary_operation(), and strip_float_extensions().
◆ get_max_float()
Write into BUF the maximum representable finite floating-point number, (1 - b**-p) * b**emax for a given FP format FMT as a hex float string. BUF must be large enough to contain the result.
Write into BUF the maximum representable finite floating-point number, (1 - b**-p) * b**emax for a given FP format FMT as a hex float string. LEN is the size of BUF, and the buffer must be large enough to contain the resulting string. If NORM_MAX, instead write the maximum representable finite normalized floating-point number, defined to be such that all choices of digits for that exponent are representable in the format (this only makes a difference for IBM long double).
References gcc_assert, ggc_alloc(), i, and real_format::p.
Referenced by fold_builtin_interclass_mathfn(), and real_max_representable().
◆ HONOR_INFINITIES() [1/3]
References GET_MODE, and HONOR_INFINITIES().
◆ HONOR_INFINITIES() [2/3]
|
extern |
References element_mode(), and HONOR_INFINITIES().
◆ HONOR_INFINITIES() [3/3]
|
extern |
As for HONOR_NANS, but true if the mode can represent infinity and the treatment of infinite values is important.
References ggc_alloc(), and MODE_HAS_INFINITIES.
Referenced by frange_val_max(), frange_val_min(), HONOR_INFINITIES(), HONOR_INFINITIES(), omp_reduction_init_op(), frange::set(), tree_expr_finite_p(), tree_expr_infinite_p(), and tree_expr_maybe_infinite_p().
◆ HONOR_NANS() [1/3]
References GET_MODE, and HONOR_NANS().
◆ HONOR_NANS() [2/3]
|
extern |
References element_mode(), and HONOR_NANS().
◆ HONOR_NANS() [3/3]
|
extern |
Declare functions in real.cc.
True if the given mode has a NaN representation and the treatment of NaN operands is important. Certain optimizations, such as folding x * 0 into 0, are not correct for NaN operands, and are normally disabled for modes with NaNs. The user can ask for them to be done anyway using the -funsafe-math-optimizations switch.
True if mode M has a NaN representation and the treatment of NaN operands is important.
References ggc_alloc(), and MODE_HAS_NANS.
Referenced by ipa_predicate::add_clause(), bitwise_inverted_equal_p(), build_gt(), build_lt(), combine_comparisons(), cond_stmts_equal_p(), convert_mode_scalar(), do_compare_rtx_and_jump(), eliminate_using_constants(), emit_store_flag(), emit_store_flag_force(), expand_builtin_issignaling(), expand_complex_multiplication(), fold_binary_loc(), fold_cond_expr_with_comparison(), fold_ternary_loc(), fold_truth_not_expr(), gen_one_condition(), frange_storage::get_frange(), gimple_bitwise_inverted_equal_p(), gimple_equal_p(), gimple_expand_builtin_pow(), gimple_simplify_phiopt(), HONOR_NANS(), HONOR_NANS(), HONOR_SNANS(), ifcombine_ifandif(), frange::internal_singleton_p(), inverse_conditions_p(), may_trap_p_1(), merge_truthop_with_opposite_arm(), minmax_from_comparison(), minmax_replacement(), noce_try_minmax(), noce_try_move(), frange::normalize_kind(), optimize_spaceship(), parloops_is_simple_reduction(), parse_predicate(), process_bb(), fold_using_range::relation_fold_and_or(), reversed_comparison_code_parts(), frange::set(), set_cond_stmt_execution_predicate(), frange::set_nan(), frange::set_varying(), avail_exprs_stack::simplify_binary_operation(), simplify_context::simplify_binary_operation_1(), simplify_const_binary_operation(), simplify_const_relational_operation(), simplify_if_then_else(), simplify_context::simplify_ternary_operation(), spaceship_replacement(), split_comparison(), tree_expr_finite_p(), tree_expr_maybe_nan_p(), tree_expr_nan_p(), ubsan_instrument_float_cast(), frange::update_nan(), valid_lattice_transition(), vect_build_slp_tree_1(), vectorizable_condition(), and frange::verify_range().
◆ HONOR_SIGN_DEPENDENT_ROUNDING() [1/3]
References GET_MODE, and HONOR_SIGN_DEPENDENT_ROUNDING().
◆ HONOR_SIGN_DEPENDENT_ROUNDING() [2/3]
|
extern |
References element_mode(), and HONOR_SIGN_DEPENDENT_ROUNDING().
◆ HONOR_SIGN_DEPENDENT_ROUNDING() [3/3]
|
extern |
Like HONOR_NANS, but true if given mode supports sign-dependent rounding, and the rounding mode is important.
References ggc_alloc(), and MODE_HAS_SIGN_DEPENDENT_ROUNDING.
Referenced by fold_convert_const(), fold_convert_const_real_from_real(), fold_negate_expr_1(), fold_real_zero_addition_p(), HONOR_SIGN_DEPENDENT_ROUNDING(), HONOR_SIGN_DEPENDENT_ROUNDING(), negate_expr_p(), simplify_context::simplify_binary_operation_1(), simplify_const_unary_operation(), simplify_context::simplify_unary_operation_1(), vectorizable_reduction(), vectorize_fold_left_reduction(), and visit_nary_op().
◆ HONOR_SIGNED_ZEROS() [1/3]
References GET_MODE, and HONOR_SIGNED_ZEROS().
◆ HONOR_SIGNED_ZEROS() [2/3]
|
extern |
References element_mode(), and HONOR_SIGNED_ZEROS().
◆ HONOR_SIGNED_ZEROS() [3/3]
|
extern |
Like HONOR_NANS, but true if the given mode distinguishes between positive and negative zero, and the sign of zero is important.
References ggc_alloc(), and MODE_HAS_SIGNED_ZEROS.
Referenced by loop_cand::analyze_induction_var(), associate_equivalences_with_edges(), frange::contains_p(), eliminate_using_constants(), expand_abs_nojump(), expand_builtin_signbit(), expand_unop(), frange::flush_denormals_to_zero(), fold_binary_loc(), fold_cond_expr_with_comparison(), fold_negate_expr_1(), fold_real_zero_addition_p(), fold_ternary_loc(), frange_add_zeros(), gimple_expand_builtin_pow(), operand_compare::hash_operand(), HONOR_SIGNED_ZEROS(), HONOR_SIGNED_ZEROS(), implicit_set_cond_p(), frange::intersect(), minmax_from_comparison(), minmax_replacement(), negate_expr_p(), neutral_op_for_reduction(), noce_try_abs(), noce_try_minmax(), noce_try_move(), operand_compare::operand_equal_p(), reassociate_bb(), record_edge_info(), record_equality(), frange::set(), frange::set_zero(), simplify_context::simplify_binary_operation_1(), simplify_if_then_else(), simplify_context::simplify_ternary_operation(), simplify_context::simplify_unary_operation_1(), tree_call_nonnegative_warnv_p(), tree_expr_maybe_real_minus_zero_p(), try_special_add_to_ops(), frange::union_(), value_replacement(), and vectorize_fold_left_reduction().
◆ HONOR_SNANS() [1/3]
References GET_MODE, and HONOR_SNANS().
◆ HONOR_SNANS() [2/3]
|
extern |
References element_mode(), and HONOR_SNANS().
◆ HONOR_SNANS() [3/3]
|
extern |
Like HONOR_NANs, but true if we honor signaling NaNs (or sNaNs).
References ggc_alloc(), and HONOR_NANS().
Referenced by loop_cand::analyze_induction_var(), const_binop(), const_unop(), convert_expand_mult_copysign(), do_compare_rtx_and_jump(), eliminate_using_constants(), emit_store_flag(), emit_store_flag_force(), fold_binary_loc(), fold_convert_const_real_from_real(), fold_real_zero_addition_p(), gimple_expand_builtin_pow(), HONOR_SNANS(), HONOR_SNANS(), may_trap_p_1(), reassociate_bb(), simplify_context::simplify_binary_operation_1(), simplify_const_binary_operation(), simplify_const_relational_operation(), simplify_const_unary_operation(), tree_expr_maybe_signaling_nan_p(), tree_expr_signaling_nan_p(), and try_special_add_to_ops().
◆ real_2expN()
|
extern |
Fills R with 2**N.
References decimal_real_convert(), ggc_alloc(), MAX_EXP, r, rvc_inf, rvc_normal, SET_REAL_EXP, SIG_MSB, and SIGSZ.
Referenced by check_real_for_fixed_mode(), expand_fix(), expand_float(), fixed_convert_from_real(), fixed_from_string(), fixed_to_decimal(), and real_convert_from_fixed().
◆ real_arithmetic()
|
extern |
Binary or unary arithmetic on tree_code.
Perform the binary or unary operation described by CODE. For a unary operation, leave OP1 NULL. This function returns true if the result may be inexact due to loss of precision.
References decimal_real_arithmetic(), do_add(), do_compare(), do_divide(), do_fix_trunc(), do_multiply(), gcc_unreachable, ggc_alloc(), r, and rvc_nan.
Referenced by check_real_for_fixed_mode(), const_binop(), expand_pow_as_sqrts(), fixed_convert_from_real(), fixed_from_string(), fixed_to_decimal(), float_widen_lhs_range(), fold_builtin_modf(), cfn_sincos::fold_range(), frange_arithmetic(), gimple_expand_builtin_pow(), omp_reduction_init_op(), real_convert_from_fixed(), real_value_abs(), real_value_negate(), representable_as_half_series_p(), simplify_context::simplify_binary_operation_1(), simplify_const_binary_operation(), simplify_const_unary_operation(), and ubsan_instrument_float_cast().
◆ real_can_shorten_arithmetic()
| bool real_can_shorten_arithmetic | ( | machine_mode | imode, |
| machine_mode | tmode ) |
Return true if arithmetic on values in IMODE that were promoted from values in TMODE is equivalent to direct arithmetic on values in TMODE.
References ggc_alloc(), MODE_COMPOSITE_P, and REAL_MODE_FORMAT.
◆ real_ceil()
|
extern |
Round X to the smallest integer not less then argument, i.e. round up, placing the result in R in format FMT.
References dconst1, do_add(), do_fix_trunc(), ggc_alloc(), r, real_convert(), real_identical(), and REAL_VALUE_TYPE.
Referenced by expand_pow_as_sqrts(), fold_const_call_ss(), and fold_const_call_ss().
◆ real_compare()
|
extern |
Compare reals by tree_code.
References do_compare(), gcc_unreachable, ggc_alloc(), real_equal(), real_less(), and rvc_nan.
Referenced by check_real_for_fixed_mode(), frange::contains_p(), contains_zero_p(), decimal_real_arithmetic(), float_binary_op_range_finish(), fold_const_call_ss(), fold_const_call_sss(), operator_abs::fold_range(), operator_le::fold_range(), operator_gt::fold_range(), operator_ge::fold_range(), fold_relational_const(), frange::set(), and ubsan_instrument_float_cast().
◆ real_convert()
|
extern |
Extend or truncate to a new format.
References a, decimal_real_convert(), ggc_alloc(), normalize(), r, round_for_format(), rvc_nan, and rvc_normal.
Referenced by const_binop(), do_mpc_ckconv(), do_mpc_ckconv(), do_mpfr_ckconv(), do_mpfr_ckconv(), exact_real_inverse(), exact_real_truncate(), fold_const_nextafter(), fold_convert_const_real_from_real(), frange_arithmetic(), frange_mpfr_arg1(), frange_nextafter(), gimple_expand_builtin_pow(), frange::internal_singleton_p(), real_ceil(), real_convert_from_fixed(), real_floor(), real_from_integer(), real_from_string2(), real_from_string3(), real_nextafter(), real_powi(), real_round(), real_roundeven(), real_to_decimal_for_mode(), real_trunc(), real_value_truncate(), simplify_context::simplify_binary_operation_1(), simplify_const_binary_operation(), simplify_const_unary_operation(), and ubsan_instrument_float_cast().
◆ real_copysign()
|
extern |
Set the sign of R to the sign of X.
References r.
Referenced by fold_const_call_sss(), and simplify_const_binary_operation().
◆ real_equal()
|
extern |
Return whether OP0 == OP1.
References do_compare().
Referenced by associate_equivalences_with_edges(), check_pow(), const_binop(), estimate_num_insns(), expand_mult(), fold_const_builtin_load_exponent(), fold_const_pow(), frange_arithmetic(), gen_conditions_for_pow_cst_base(), gimple_expand_builtin_pow(), implicit_set_cond_p(), optimize_recip_sqrt(), real_compare(), real_maybe_zerop(), real_minus_onep(), real_onep(), real_zerop(), record_equality(), representable_as_half_series_p(), operator_mult::rv_fold(), simplify_context::simplify_binary_operation_1(), simplify_const_binary_operation(), simplify_const_relational_operation(), and vect_recog_pow_pattern().
◆ real_exponent()
|
extern |
??? These were added for Paranoia support.
Return floor log2(R).
Return floor log2(R).
References gcc_unreachable, r, REAL_EXP, rvc_inf, rvc_nan, rvc_normal, and rvc_zero.
◆ real_floor()
|
extern |
Round X to the largest integer not greater in value, i.e. round down, placing the result in R in format FMT.
References dconstm1, do_add(), do_fix_trunc(), ggc_alloc(), r, real_convert(), real_identical(), and REAL_VALUE_TYPE.
Referenced by expand_pow_as_sqrts(), fold_const_call_ss(), and fold_const_call_ss().
◆ real_from_integer()
|
extern |
Initialize R from the wide_int VAL_IN. Round it to format FMT if FMT is nonnull.
References wi::clz(), decimal_from_integer(), generic_wide_int< storage >::elt(), wide_int_storage::from(), gcc_assert, get_zero(), ggc_alloc(), HOST_BITS_PER_LONG, HOST_BITS_PER_WIDE_INT, i, wi::lrshift(), wi::neg_p(), normalize(), r, real_convert(), rvc_normal, SET_REAL_EXP, SIGNIFICAND_BITS, and SIGSZ.
Referenced by acceptable_pow_call(), build_real_from_wide(), check_pow(), decrement_power(), expand_pow_as_sqrts(), fixed_to_decimal(), fold_const_logb(), fold_const_pow(), gen_conditions_for_pow_cst_base(), gimple_expand_builtin_pow(), init_emit_once(), real_convert_from_fixed(), real_digit(), real_isinteger(), real_value_from_int_cst(), simplify_const_unary_operation(), ten_to_ptwo(), and tree_call_nonnegative_warnv_p().
◆ real_from_string()
|
extern |
Initialize R from a decimal or hexadecimal string. Return -1 if the value underflows, +1 if overflows, and 0 otherwise.
Initialize R from a decimal or hexadecimal string. The string is assumed to have been syntax checked already. Return -1 if the value underflows, +1 if overflows, and 0 otherwise.
References cmp_significand_0(), exp(), gcc_assert, get_canonical_qnan(), get_canonical_snan(), get_inf(), get_zero(), ggc_alloc(), HOST_BITS_PER_LONG, MAX_EXP, normalize(), NULL, NULL_TREE, r, real_from_mpfr(), rvc_normal, SET_REAL_EXP, SIGNIFICAND_BITS, and startswith().
Referenced by check_real_for_fixed_mode(), decimal_real_to_integer(), decimal_real_to_integer(), fixed_from_string(), fold_builtin_fpclassify(), fold_builtin_interclass_mathfn(), real_from_mpfr(), real_from_string2(), real_from_string3(), real_max_representable(), and real_to_decimal_for_mode().
◆ real_from_string2()
|
extern |
Legacy. Similar, but return the result directly.
References ggc_alloc(), r, real_convert(), real_from_string(), and REAL_VALUE_TYPE.
◆ real_from_string3()
|
extern |
Wrapper to allow different internal representation for decimal floats.
Initialize R from string S and desired format FMT.
References decimal_real_from_string(), ggc_alloc(), r, real_convert(), and real_from_string().
Referenced by decimal_to_binary().
◆ real_from_target()
|
extern |
Read R from the given target format. Read the words of the result in target word order in BUF. There are always 32 bits in each long, no matter the size of the host long.
References ggc_alloc(), and r.
Referenced by native_decode_rtx(), native_interpret_real(), simplify_const_binary_operation(), simplify_const_unary_operation(), vect_build_all_ones_mask(), and vect_build_zero_merge_argument().
◆ real_hash()
|
extern |
Return a hash value for the given real value.
??? The "unsigned int" return value is intended to be hashval_t, but I didn't want to pull hashtab.h into real.h.
References gcc_unreachable, ggc_alloc(), HOST_BITS_PER_LONG, i, r, REAL_EXP, rvc_inf, rvc_nan, rvc_normal, rvc_zero, and SIGSZ.
Referenced by const_hash_1(), const_rtx_hash_1(), cselib_hash_rtx(), const_double_hasher::hash(), operand_compare::hash_operand(), and hash_rtx().
◆ real_identical()
|
extern |
Test relationships between reals.
Compare two floating-point objects for bitwise identity.
References a, b, gcc_unreachable, i, REAL_EXP, rvc_inf, rvc_nan, rvc_normal, rvc_zero, and SIGSZ.
Referenced by acceptable_pow_call(), compare_constant(), const_binop(), do_mpc_ckconv(), do_mpc_ckconv(), do_mpfr_ckconv(), do_mpfr_ckconv(), const_double_hasher::equal(), ipa_icf::sem_variable::equals(), exact_real_truncate(), expand_complex_multiplication(), expand_pow_as_sqrts(), fold_const_pow(), frange_arithmetic(), frange_mpfr_arg1(), frange_val_is_max(), frange_val_is_min(), gimple_expand_builtin_pow(), frange::internal_singleton_p(), frange::known_isinf(), operand_compare::operand_equal_p(), frange::operator==(), real_ceil(), real_floor(), real_isinteger(), real_isinteger(), real_to_decimal_for_mode(), simple_cst_equal(), simplify_const_binary_operation(), some_nonzerop(), and tree_call_nonnegative_warnv_p().
◆ real_inf()
|
extern |
Fills R with Inf with SIGN.
Referenced by init_emit_once(), and foperator_div::rv_fold().
◆ real_isdenormal()
|
inline |
Determine whether floating-point value R is a denormal. This function is only valid for normalized values.
References r, REAL_EXP, REAL_MODE_FORMAT, and rvc_normal.
◆ real_isfinite()
|
extern |
Determine whether a floating-point value X is finite.
References r, rvc_inf, and rvc_nan.
Referenced by do_mpc_arg1(), do_mpc_arg2(), do_mpc_arg2(), do_mpc_ckconv(), do_mpc_ckconv(), do_mpfr_arg1(), do_mpfr_arg2(), do_mpfr_arg2(), do_mpfr_arg3(), do_mpfr_ckconv(), do_mpfr_ckconv(), do_mpfr_lgamma_r(), do_mpfr_remquo(), do_mpfr_sincos(), float_widen_lhs_range(), fold_const_call_ss(), fold_const_conversion(), cfn_sincos::fold_range(), frange_mpfr_arg1(), cfn_sqrt::op1_range(), and tree_expr_finite_p().
◆ real_isinf() [1/2]
|
extern |
Determine whether a floating-point value X is infinite.
Referenced by build_gt(), build_lt(), float_binary_op_range_finish(), float_widen_lhs_range(), fold_const_builtin_load_exponent(), fold_const_call_cc(), fold_const_call_ss(), frange_arithmetic(), frange::internal_singleton_p(), frange::known_isfinite(), frange::known_isinf(), frange::maybe_isinf(), foperator_div::op1_range(), operator_mult::op1_range(), foperator_div::op2_range(), vrange_printer::print_real_value(), real_isinf(), operator_mult::rv_fold(), foperator_div::rv_fold(), operator_plus::rv_fold(), operator_minus::rv_fold(), singleton_inf_p(), tree_expr_infinite_p(), tree_expr_maybe_infinite_p(), and ubsan_instrument_float_cast().
◆ real_isinf() [2/2]
|
extern |
Determine whether a floating-point value X is infinite with SIGN.
References r, and real_isinf().
◆ real_isinteger() [1/2]
|
extern |
Check whether the real constant value given is an integer.
Check whether the real constant value given is an integer. Returns false for signaling NaN.
References ggc_alloc(), real_identical(), real_trunc(), and REAL_VALUE_TYPE.
Referenced by do_mpfr_lgamma_r(), integer_valued_real_single_p(), and optimize_pow_to_exp().
◆ real_isinteger() [2/2]
|
extern |
Check whether C is an integer that fits in a HOST_WIDE_INT, storing it in *INT_OUT if so.
References ggc_alloc(), real_from_integer(), real_identical(), real_to_integer(), REAL_VALUE_TYPE, and SIGNED.
◆ real_isnan()
|
extern |
Determine whether a floating-point value X is a NaN.
Referenced by frange::contains_p(), fold_const_call_ss(), fold_relational_const(), range_query::get_tree_range(), vrange_printer::print_real_value(), real_issignaling_nan(), operator_mult::rv_fold(), foperator_div::rv_fold(), operator_plus::rv_fold(), operator_minus::rv_fold(), frange::set(), tree_expr_maybe_nan_p(), tree_expr_nan_p(), and frange::verify_range().
◆ real_isneg()
|
extern |
Determine whether a floating-point value X is negative.
References r.
Referenced by attempt_builtin_copysign(), frange::combine_zeros(), const_with_all_bytes_same(), do_mpfr_lgamma_r(), expand_copysign(), frange::flush_denormals_to_zero(), fold_const_call_ss(), cfn_sincos::fold_range(), cfn_constant_float_p::fold_range(), frange_arithmetic(), range_query::get_tree_range(), operator_mult::rv_fold(), signbit_known_p(), and singleton_inf_p().
◆ real_isnegzero()
|
extern |
Determine whether a floating-point value X is minus zero.
Referenced by find_range().
◆ real_issignaling_nan()
|
extern |
Determine whether a floating-point value X is a signaling NaN.
References r, and real_isnan().
Referenced by fold_const_call_ss(), tree_expr_maybe_signaling_nan_p(), and tree_expr_signaling_nan_p().
◆ real_iszero() [1/2]
|
extern |
Determine whether a floating-point value X is plus or minus zero.
Referenced by frange::combine_zeros(), frange::contains_p(), find_range(), operator_abs::fold_range(), operator_not_equal::fold_range(), operator_equal::fold_range(), frange_add_zeros(), frange_arithmetic(), frange_nextafter(), real_iszero(), frange::set(), frange::verify_range(), frange::zero_p(), and zero_p().
◆ real_iszero() [2/2]
|
extern |
Determine whether a floating-point value X is zero with SIGN.
References r, and real_iszero().
◆ real_ldexp()
|
extern |
R = A * 2**EXP.
R = OP0 * 2**EXP.
References exp(), gcc_unreachable, get_inf(), get_zero(), MAX_EXP, r, REAL_EXP, rvc_inf, rvc_nan, rvc_normal, rvc_zero, and SET_REAL_EXP.
Referenced by fold_const_builtin_load_exponent().
◆ real_less()
|
extern |
Return whether OP0 < OP1.
References do_compare().
Referenced by check_pow(), find_range(), fold_convert_const_int_from_real(), cfn_sqrt::fold_range(), cfn_sincos::fold_range(), operator_lt::fold_range(), frange_arithmetic(), frange_mpfr_arg1(), gen_conditions_for_pow_cst_base(), frange::intersect(), cfn_sqrt::op1_range(), cfn_sincos::op1_range(), real_compare(), frange::set(), simplify_const_relational_operation(), simplify_const_unary_operation(), frange::union_(), and frange::verify_range().
◆ real_maxval()
|
extern |
Fills R with the largest finite value representable in mode MODE. If SIGN is nonzero, R is set to the most negative finite value.
References clear_significand_below(), clear_significand_bit(), decimal_real_maxval(), gcc_assert, ggc_alloc(), r, REAL_MODE_FORMAT, rvc_normal, SET_REAL_EXP, SIGNIFICAND_BITS, and SIGSZ.
Referenced by build_sinatan_real(), and omp_reduction_init_op().
◆ real_nan()
|
extern |
Fills R with a NaN whose significand is described by STR. If QUIET, we force a QNaN, else we force an SNaN. The string, if not empty, is parsed as a number and placed in the significand. Return true if the string was successfully parsed.
References add_significands(), gcc_unreachable, get_canonical_qnan(), get_canonical_snan(), get_zero(), ggc_alloc(), lshift_significand(), lshift_significand_1(), r, REAL_VALUE_TYPE, rvc_nan, SIGNIFICAND_BITS, and SIGSZ.
Referenced by fold_const_builtin_nan(), and real_from_mpfr().
◆ real_nextafter()
|
extern |
Calculate nextafter (X, Y) in format FMT.
Calculate nextafter (X, Y) or nexttoward (X, Y). Return true if underflow or overflow needs to be raised.
References add_significands(), clear_significand_below(), clear_significand_bit(), do_compare(), gcc_assert, get_canonical_qnan(), get_inf(), get_zero(), ggc_alloc(), i, normalize(), r, real_convert(), REAL_EXP, REAL_VALUE_TYPE, rvc_inf, rvc_normal, rvc_zero, SET_REAL_EXP, set_significand_bit(), SIG_MSB, SIGNIFICAND_BITS, SIGSZ, sub_significands(), and y.
Referenced by fold_const_nextafter(), frange_arithmetic(), and frange_nextafter().
◆ real_powi()
|
extern |
Calculate R as X raised to the integer exponent N in format FMT.
Calculate X raised to the integer exponent N in format FMT and store the result in R. Return true if the result may be inexact due to loss of precision. The algorithm is the classic "left-to-right binary method" described in section 4.6.3 of Donald Knuth's "Seminumerical Algorithms", "The Art of Computer Programming", Volume 2.
References dconst1, do_divide(), do_multiply(), ggc_alloc(), HOST_BITS_PER_WIDE_INT, HOST_WIDE_INT_1U, i, r, real_convert(), and REAL_VALUE_TYPE.
Referenced by fold_const_call_sss(), and fold_const_pow().
◆ real_round()
|
extern |
Round X to the nearest integer, but round halfway cases away from zero.
References dconsthalf, do_add(), do_fix_trunc(), ggc_alloc(), r, and real_convert().
Referenced by fold_const_call_ss(), fold_const_call_ss(), gimple_expand_builtin_pow(), and real_roundeven().
◆ real_roundeven()
|
extern |
Round X to nearest integer, rounding halfway cases towards even.
References clear_significand_below(), dconsthalf, dconstm1, do_add(), ggc_alloc(), is_even(), is_halfway_below(), r, real_convert(), REAL_EXP, real_round(), and SIGNIFICAND_BITS.
Referenced by fold_const_call_ss().
◆ real_to_decimal()
|
extern |
Render R as a decimal floating point constant.
Likewise, except always uses round-to-nearest.
References ggc_alloc(), and real_to_decimal_for_mode().
Referenced by decimal_from_binary(), decimal_to_binary(), dump_generic_node(), dump_real(), expand_pow_as_sqrts(), fixed_to_decimal(), print_real_cst(), rtx_writer::print_rtx(), and print_value().
◆ real_to_decimal_for_mode()
|
extern |
Render R as a decimal floating point constant, rounded so as to be parsed back to the same value when interpreted in mode MODE.
References cmp_significand_0(), cmp_significands(), decimal_real_to_decimal(), do_compare(), do_divide(), do_fix_trunc(), do_multiply(), floor_log2(), gcc_assert, gcc_unreachable, ggc_alloc(), last, M_LOG10_2, NULL, real_format::p, r, real_convert(), real_digit(), REAL_EXP, real_from_string(), real_identical(), REAL_MODE_FORMAT, REAL_VALUE_TYPE, round_up, rtd_divmod(), rvc_inf, rvc_nan, rvc_normal, rvc_zero, SET_REAL_EXP, SIGNIFICAND_BITS, ten_to_mptwo(), and ten_to_ptwo().
Referenced by vrange_printer::print_real_value(), and real_to_decimal().
◆ real_to_hexadecimal()
|
extern |
Render R as a hexadecimal floating point constant.
Render R as a hexadecimal floating point constant. Emit DIGITS significant digits in the result, bounded by BUF_SIZE. If DIGITS is 0, choose the maximum for the representation. If CROP_TRAILING_ZEROS, strip trailing zeros.
References exp(), gcc_assert, gcc_unreachable, ggc_alloc(), HOST_BITS_PER_LONG, i, real_format::p, r, REAL_EXP, rvc_inf, rvc_nan, rvc_normal, rvc_zero, SIGNIFICAND_BITS, and SIGSZ.
Referenced by debug(), mpfr_from_real(), vrange_printer::print_real_value(), and rtx_writer::print_rtx().
◆ real_to_integer() [1/2]
|
extern |
Render R as an integer.
References decimal_real_to_integer(), gcc_assert, gcc_unreachable, ggc_alloc(), HOST_BITS_PER_LONG, HOST_BITS_PER_WIDE_INT, HOST_WIDE_INT_1U, i, r, REAL_EXP, rvc_inf, rvc_nan, rvc_normal, rvc_zero, and SIGSZ.
Referenced by acceptable_pow_call(), decimal_real_to_integer(), decimal_real_to_integer(), decrement_power(), expand_pow_as_sqrts(), expr_expected_value_1(), fixed_convert_from_real(), fixed_from_string(), fold_const_conversion(), fold_const_pow(), fold_convert_const(), fold_convert_const_int_from_real(), get_upper_bound_based_on_builtin_expr_with_prob(), gimple_expand_builtin_pow(), real_isinteger(), simplify_const_unary_operation(), and tree_call_nonnegative_warnv_p().
◆ real_to_integer() [2/2]
|
extern |
real related routines.
Likewise, but producing a wide-int of PRECISION. If the value cannot be represented in precision, *FAIL is set to TRUE.
References decimal_real_to_integer(), exp(), wide_int_storage::from(), wide_int_storage::from_array(), gcc_assert, gcc_unreachable, ggc_alloc(), HOST_BITS_PER_LONG, HOST_BITS_PER_WIDE_INT, i, wi::lrshift(), r, REAL_EXP, rvc_inf, rvc_nan, rvc_normal, rvc_zero, wi::set_bit_in_zero(), SIGSZ, UNLIKELY, UNSIGNED, WIDE_INT_MAX_INL_ELTS, and wi::zero().
◆ real_to_target()
|
extern |
Write R to the given target format. Place the words of the result in target word order in BUF. There are always 32 bits in each long, no matter the size of the host long. Legacy: return word 0 for implementing REAL_VALUE_TO_TARGET_SINGLE.
References ggc_alloc(), r, REAL_VALUE_TYPE, and round_for_format().
Referenced by assemble_real(), insert_float(), native_encode_real(), native_encode_rtx(), simplify_const_binary_operation(), and simplify_const_unary_operation().
◆ real_trunc()
|
extern |
Standard round to integer value functions.
Round X to the nearest integer not larger in absolute value, i.e. towards zero, placing the result in R in format FMT.
References do_fix_trunc(), ggc_alloc(), r, and real_convert().
Referenced by fold_builtin_modf(), fold_const_call_ss(), fold_convert_const_int_from_real(), and real_isinteger().
◆ real_value_abs()
|
extern |
References ggc_alloc(), NULL, r, real_arithmetic(), and REAL_VALUE_TYPE.
Referenced by expand_pow_as_sqrts(), operator_abs::fold_range(), and simplify_const_unary_operation().
◆ real_value_from_int_cst()
| REAL_VALUE_TYPE real_value_from_int_cst | ( | const_tree | type, |
| const_tree | i ) |
Function to return a real value (not a tree node) from a given integer constant.
Return a new REAL_CST node whose type is TYPE and whose value is the integer value of the INTEGER_CST node I.
References ggc_alloc(), i, real_from_integer(), REAL_VALUE_TYPE, wi::to_wide(), TREE_TYPE, TYPE_MODE, and TYPE_SIGN.
Referenced by build_real_from_int_cst(), and fold_convert_const_int_from_real().
◆ real_value_negate()
|
extern |
References ggc_alloc(), NULL, r, real_arithmetic(), and REAL_VALUE_TYPE.
Referenced by check_real_for_fixed_mode(), fold_abs_const(), fold_const_call_ssss(), fold_negate_const(), operator_negate::fold_range(), operator_abs::op1_range(), real_from_mpfr(), real_min_representable(), and simplify_const_unary_operation().
◆ real_value_truncate()
|
extern |
Legacy. Likewise, except return the struct directly.
References a, ggc_alloc(), r, real_convert(), and REAL_VALUE_TYPE.
Referenced by build_real_truncate(), fold_const_builtin_load_exponent(), gimple_expand_builtin_pow(), and simplify_const_unary_operation().
◆ significand_size()
|
extern |
Return the number of bits of the largest binary value that the significand of FMT will hold.
??? Legacy. Should get access to real_format directly.
References ggc_alloc(), and NULL.
Referenced by format_helper::can_represent_integral_type_p(), exact_int_to_float_conversion_p(), and expand_float().
Variable Documentation
◆ arm_bfloat_half_format
|
extern |
ARM Bfloat half-precision format. This format resembles a truncated (16-bit) version of the 32-bit IEEE 754 single-precision floating-point format.
Referenced by build_common_tree_nodes(), convert_mode_scalar(), expand_fix(), and gen_trunc_conv_libfunc().
◆ arm_half_format
|
extern |
ARM's alternative half-precision format, similar to IEEE but with no reserved exponent value for NaNs and infinities; rather, it just extends the range of exponents by one.
◆ dconst0
|
extern |
**** End of software floating point emulator interface macros ****
Constant real values 0, 1, 2, -1 and 0.5.
Referenced by scev_dfs::add_to_evolution_1(), adjust_equivalence_range(), associate_equivalences_with_edges(), build_complex_inf(), build_real(), build_zero_cst(), const_binop(), contains_zero_p(), expand_builtin_cexpi(), expand_builtin_signbit(), expand_pow_as_sqrts(), float_binary_op_range_finish(), frange::flush_denormals_to_zero(), fold_builtin_fpclassify(), fold_builtin_interclass_mathfn(), fold_builtin_modf(), fold_const_call_cc(), fold_const_call_ss(), fold_const_call_sss(), fold_const_pow(), cfn_sqrt::fold_range(), operator_abs::fold_range(), get_component_ssa_name(), implicit_set_cond_p(), init_emit_once(), cfn_sqrt::op1_range(), operator_abs::op1_range(), cfn_signbit::op1_range(), real_maybe_zerop(), real_zerop(), record_equality(), representable_as_half_series_p(), operator_mult::rv_fold(), frange::set_nonnegative(), frange::set_zero(), simplify_context::simplify_binary_operation_1(), simplify_const_binary_operation(), some_nonzerop(), zero_range(), and zero_to_inf_range().
◆ dconst1
|
extern |
Referenced by build_one_cst(), build_real(), build_sinatan_real(), check_pow(), decimal_to_decnumber(), expand_complex_multiplication(), expand_pow_as_sqrts(), float_widen_lhs_range(), fold_const_call_ss(), cfn_sincos::fold_range(), gen_conditions_for_pow_cst_base(), gimple_expand_builtin_pow(), init_emit_once(), cfn_sincos::op1_range(), optimize_recip_sqrt(), powi_as_mults(), real_ceil(), real_onep(), real_powi(), simplify_context::simplify_binary_operation_1(), and ubsan_instrument_float_cast().
◆ dconst2
|
extern |
Referenced by build_real(), chrec_fold_multiply_poly_poly(), decimal_to_decnumber(), estimate_num_insns(), expand_mult(), expand_omp_for_init_vars(), float_widen_lhs_range(), gimple_expand_builtin_pow(), init_emit_once(), simplify_context::simplify_binary_operation_1(), and vect_recog_pow_pattern().
◆ dconsthalf
|
extern |
◆ dconstinf
|
extern |
Referenced by build_complex_inf(), float_widen_lhs_range(), fold_builtin_fpclassify(), fold_builtin_inf(), fold_const_call_cc(), cfn_sqrt::fold_range(), cfn_sincos::fold_range(), frange_mpfr_arg1(), frange_val_max(), inf_range(), init_emit_once(), omp_reduction_init_op(), cfn_sqrt::op1_range(), cfn_sincos::op1_range(), real_from_mpfr(), operator_mult::rv_fold(), range_operator::rv_fold(), foperator_div::rv_fold(), operator_plus::rv_fold(), operator_minus::rv_fold(), and zero_to_inf_range().
◆ dconstm0
|
extern |
◆ dconstm1
|
extern |
Referenced by scev_dfs::add_to_evolution(), build_minus_one_cst(), build_real(), chrec_fold_plus_1(), chrec_fold_plus_poly_poly(), decimal_to_decnumber(), float_widen_lhs_range(), fold_const_call_ss(), cfn_sincos::fold_range(), init_emit_once(), cfn_sincos::op1_range(), real_floor(), real_minus_onep(), real_roundeven(), simplify_context::simplify_binary_operation_1(), and ubsan_instrument_float_cast().
◆ dconstninf
|
extern |
Referenced by float_widen_lhs_range(), cfn_sqrt::fold_range(), cfn_sincos::fold_range(), frange_mpfr_arg1(), frange_val_min(), inf_range(), init_emit_once(), cfn_sqrt::op1_range(), cfn_sincos::op1_range(), operator_mult::rv_fold(), range_operator::rv_fold(), foperator_div::rv_fold(), operator_plus::rv_fold(), operator_minus::rv_fold(), and zero_to_inf_range().
◆ decimal_double_format
|
extern |
Double precision decimal floating point (IEEE 754).
Referenced by decimal_round_for_format().
◆ decimal_quad_format
|
extern |
Quad precision decimal floating point (IEEE 754).
Referenced by decimal_round_for_format().
◆ decimal_single_format
|
extern |
Single precision decimal floating point (IEEE 754).
Referenced by decimal_round_for_format().
◆ ibm_extended_format
|
extern |
◆ ieee_double_format
|
extern |
Referenced by check_target_format(), decode_ibm_extended(), encode_ibm_extended(), and glibc_linux_libm_function_max_error().
◆ ieee_extended_intel_128_format
|
extern |
Referenced by check_target_format(), and glibc_linux_libm_function_max_error().
◆ ieee_extended_intel_96_format
|
extern |
Referenced by check_target_format(), and glibc_linux_libm_function_max_error().
◆ ieee_extended_intel_96_round_53_format
|
extern |
The following caters to i386 systems that set the rounding precision to 53 bits instead of 64, e.g. FreeBSD.
Referenced by check_target_format().
◆ ieee_extended_motorola_format
|
extern |
Referenced by check_target_format(), and glibc_linux_libm_function_max_error().
◆ ieee_half_format
|
extern |
Half-precision format, as specified in IEEE 754R.
Referenced by convert_mode_scalar(), and gen_trunc_conv_libfunc().
◆ ieee_quad_format
|
extern |
Referenced by check_target_format(), and glibc_linux_libm_function_max_error().
◆ ieee_single_format
|
extern |
Target formats defined in real.cc.
Referenced by check_target_format(), convert_mode_scalar(), expand_fix(), and glibc_linux_libm_function_max_error().
◆ mips_double_format
|
extern |
Referenced by check_target_format(), decode_ibm_extended(), encode_ibm_extended(), and glibc_linux_libm_function_max_error().
◆ mips_extended_format
|
extern |
◆ mips_quad_format
|
extern |
Referenced by check_target_format(), and glibc_linux_libm_function_max_error().
◆ mips_single_format
|
extern |
Referenced by check_target_format(), and glibc_linux_libm_function_max_error().
◆ motorola_double_format
|
extern |
Referenced by check_target_format(), and glibc_linux_libm_function_max_error().
◆ motorola_single_format
|
extern |
Referenced by check_target_format(), and glibc_linux_libm_function_max_error().
◆ real_format_for_mode
|
extern |
The target format used for each floating point mode. Float modes are followed by decimal float modes, with entries for float modes indexed by (MODE - first float mode), and entries for decimal float modes indexed by (MODE - first decimal float mode) + the number of float modes.
◆ real_internal_format
|
extern |
◆ spu_single_format
|
extern |
SPU Single Precision (Extended-Range Mode) format is the same as IEEE
single precision with the following differences:
- Infinities are not supported. Instead MAX_FLOAT or MIN_FLOAT
are generated.
- NaNs are not supported.
- The range of non-zero numbers in binary is
(001)[1.]000...000 to (255)[1.]111...111.
- Denormals can be represented, but are treated as +0.0 when
used as an operand and are never generated as a result.
- -0.0 can be represented, but a zero result is always +0.0.
- the only supported rounding mode is trunction (towards zero).
◆ test_real_width
|
extern |
Verify the guess.
◆ vax_d_format
|
extern |
◆ vax_f_format
|
extern |
◆ vax_g_format
|
extern |
