To maintain symmetry after the previous removal of
CONST_DOUBLE_FROM_REAL_VALUE, this patch also gets rid of
REAL_VALUE_FROM_CONST_DOUBLE. All the macro did was copy the
contents of CONST_DOUBLE_REAL_VALUE into a temporary real_value
structure. In many cases there was no need for this temporary
and we could simply use the CONST_DOUBLE_REAL_VALUE directly.
For that reason this patch is less automatic than the others.
Bootstrapped & regression-tested on x86_64-linux-gnu. Also tested by
building one target per CPU directory and checking that there were
no new warnings and no changes in testsuite output at -O2. OK to install?
Thanks,
Richard
gcc/
* real.h (REAL_VALUE_FROM_CONST_DOUBLE): Delete.
* config/aarch64/aarch64.c (aarch64_float_const_zero_rtx_p)
(aarch64_print_operand, aarch64_float_const_representable_p)
(aarch64_output_simd_mov_immediate): Use CONST_DOUBLE_REAL_VALUE
instead of REAL_VALUE_FROM_CONST_DOUBLE.
* config/arc/arc.c (arc_print_operand): Likewise.
* config/arm/arm.c (arm_const_double_rtx, vfp3_const_double_index)
(neon_valid_immediate, arm_print_operand, arm_emit_fp16_const)
(vfp3_const_double_for_fract_bits, vfp3_const_double_for_bits):
Likewise.
* config/arm/arm.md (*arm32_movhf, consttable_4, consttable_8)
(consttable_16): Likewise.
* config/arm/vfp.md (*movhf_vfp_neon, *movhf_vfp): Likewise.
* config/avr/avr.c (avr_print_operand): Likewise.
* config/bfin/bfin.md: Likewise (in a define_split).
* config/c6x/c6x.md: Likewise (in a define_split).
* config/cr16/cr16.c (cr16_const_double_ok): Likewise.
(cr16_print_operand): Likewise.
* config/cris/cris.c (cris_print_operand): Likewise.
* config/epiphany/epiphany.c (epiphany_print_operand): Likewise.
* config/fr30/fr30.c (fr30_print_operand): Likewise.
(fr30_const_double_is_zero): Likewise.
* config/frv/frv.c (frv_print_operand, output_move_single): Likewise.
* config/frv/frv.md: Likewise (in a define_split).
* config/frv/predicates.md (int_2word_operand): Likewise.
* config/h8300/h8300.c (h8300_print_operand): Likewise.
* config/i386/i386.c (standard_80387_constant_p): Likewise.
(ix86_print_operand, ix86_split_to_parts): Likewise.
* config/i386/i386.md: Likewise (in a define_split).
* config/ia64/ia64.c (ia64_split_tmode, ia64_print_operand): Likewise.
* config/iq2000/iq2000.md (movsf_lo_sum, movsf_high): Likewise.
* config/m32r/m32r.c (easy_df_const, m32r_print_operand): Likewise.
* config/m68k/m68k.c (handle_move_double, standard_68881_constant_p)
(print_operand): Likewise.
* config/m68k/m68k.md (movsf_cf_hard, movdf_cf_hard): Likewise.
* config/mep/mep.md: Likewise (in define_split).
* config/microblaze/microblaze.c (microblaze_const_double_ok)
(print_operand): Likewise.
* config/mips/mips.md (consttable_float): Likewise.
* config/mmix/mmix.c (mmix_intval): Likewise.
* config/mn10300/mn10300.c (mn10300_print_operand): Likewise.
* config/nvptx/nvptx.c (nvptx_print_operand): Likewise.
* config/pa/pa.c (pa_singlemove_string): Likewise.
* config/pdp11/pdp11.c (pdp11_expand_operands): Likewise.
(pdp11_asm_print_operand, legitimate_const_double_p): Likewise.
* config/rs6000/rs6000.c (num_insns_constant, rs6000_emit_cmove)
(output_toc): Likewise.
* config/rs6000/rs6000.md: Likewise (in define_splits).
* config/rx/rx.c (rx_print_operand): Likewise.
* config/s390/s390.c (s390_output_pool_entry): Likewise.
* config/sh/sh.c (fp_zero_operand, fp_one_operand): Likewise.
* config/sh/sh.md (consttable_sf, consttable_df): Likewise
(and also in define_splits).
* config/sparc/sparc.c (fp_sethi_p, fp_mov_p): Likewise.
(fp_high_losum_p): Likewise.
* config/sparc/sparc.md (*movsf_insn, *movsf_lo_sum): Likewise.
(*movsf_high): Likewise.
* config/spu/spu.c (const_double_to_hwint): Likewise.
* config/v850/v850.c (const_double_split): Likewise.
* config/vax/vax.c (vax_float_literal): Likewise.
* config/visium/visium.c (visium_expand_copysign): Likewise.
* config/visium/visium.md: Likewise (in define_split).
* config/xtensa/predicates.md (const_float_1_operand): Likewise.
* config/xtensa/xtensa.c (print_operand): Likewise.
(xtensa_output_literal): Likewise.
* cprop.c (implicit_set_cond_p): Likewise.
* dwarf2out.c (insert_float): Likewise.
* expmed.c (expand_mult, make_tree): Likewise.
* expr.c (compress_float_constant): Likewise.
* rtlanal.c (split_double): Likewise.
* simplify-rtx.c (avoid_constant_pool_reference): Likewise.
(simplify_const_unary_operation, simplify_binary_operation_1)
(simplify_const_binary_operation): Likewise.
(simplify_const_relational_operation): Likewise.
* varasm.c (output_constant_pool_2): Likewise.
diff --git a/gcc/config/aarch64/aarch64.c b/gcc/config/aarch64/aarch64.c
index a1057c9..c9fe368 100644
--- a/gcc/config/aarch64/aarch64.c
+++ b/gcc/config/aarch64/aarch64.c
@@ -3763,15 +3763,12 @@ aarch64_legitimate_address_p (machine_mode mode, rtx x,
bool
aarch64_float_const_zero_rtx_p (rtx x)
{
- REAL_VALUE_TYPE r;
-
if (GET_MODE (x) == VOIDmode)
return false;
- REAL_VALUE_FROM_CONST_DOUBLE (r, x);
- if (REAL_VALUE_MINUS_ZERO (r))
+ if (REAL_VALUE_MINUS_ZERO (*CONST_DOUBLE_REAL_VALUE (x)))
return !HONOR_SIGNED_ZEROS (GET_MODE (x));
- return real_equal (&r, &dconst0);
+ return real_equal (CONST_DOUBLE_REAL_VALUE (x), &dconst0);
}
/* Return the fixed registers used for condition codes. */
@@ -4401,9 +4398,8 @@ aarch64_print_operand (FILE *f, rtx x, char code)
{
#define buf_size 20
char float_buf[buf_size] = {'\0'};
- REAL_VALUE_TYPE r;
- REAL_VALUE_FROM_CONST_DOUBLE (r, x);
- real_to_decimal_for_mode (float_buf, &r,
+ real_to_decimal_for_mode (float_buf,
+ CONST_DOUBLE_REAL_VALUE (x),
buf_size, buf_size,
1, GET_MODE (x));
asm_fprintf (asm_out_file, "%s", float_buf);
@@ -11309,7 +11305,7 @@ aarch64_float_const_representable_p (rtx x)
if (GET_MODE (x) == VOIDmode || GET_MODE (x) == HFmode)
return false;
- REAL_VALUE_FROM_CONST_DOUBLE (r, x);
+ r = *CONST_DOUBLE_REAL_VALUE (x);
/* We cannot represent infinities, NaNs or +/-zero. We won't
know if we have +zero until we analyse the mantissa, but we
@@ -11401,10 +11397,10 @@ aarch64_output_simd_mov_immediate (rtx const_vector,
else
{
#define buf_size 20
- REAL_VALUE_TYPE r;
- REAL_VALUE_FROM_CONST_DOUBLE (r, info.value);
char float_buf[buf_size] = {'\0'};
- real_to_decimal_for_mode (float_buf, &r, buf_size, buf_size, 1, mode);
+ real_to_decimal_for_mode (float_buf,
+ CONST_DOUBLE_REAL_VALUE (info.value),
+ buf_size, buf_size, 1, mode);
#undef buf_size
if (lane_count == 1)
diff --git a/gcc/config/arc/arc.c b/gcc/config/arc/arc.c
index a6a1921..1f4bfed 100644
--- a/gcc/config/arc/arc.c
+++ b/gcc/config/arc/arc.c
@@ -3178,11 +3178,9 @@ arc_print_operand (FILE *file, rtx x, int code)
/* We handle SFmode constants here as output_addr_const doesn't. */
if (GET_MODE (x) == SFmode)
{
- REAL_VALUE_TYPE d;
long l;
- REAL_VALUE_FROM_CONST_DOUBLE (d, x);
- REAL_VALUE_TO_TARGET_SINGLE (d, l);
+ REAL_VALUE_TO_TARGET_SINGLE (*CONST_DOUBLE_REAL_VALUE (x), l);
fprintf (file, "0x%08lx", l);
break;
}
diff --git a/gcc/config/arm/arm.c b/gcc/config/arm/arm.c
index 184ce50..87e55e9 100644
--- a/gcc/config/arm/arm.c
+++ b/gcc/config/arm/arm.c
@@ -12098,16 +12098,16 @@ init_fp_table (void)
int
arm_const_double_rtx (rtx x)
{
- REAL_VALUE_TYPE r;
+ const REAL_VALUE_TYPE *r;
if (!fp_consts_inited)
init_fp_table ();
- REAL_VALUE_FROM_CONST_DOUBLE (r, x);
- if (REAL_VALUE_MINUS_ZERO (r))
+ r = CONST_DOUBLE_REAL_VALUE (x);
+ if (REAL_VALUE_MINUS_ZERO (*r))
return 0;
- if (real_equal (&r, &value_fp0))
+ if (real_equal (r, &value_fp0))
return 1;
return 0;
@@ -12144,7 +12144,7 @@ vfp3_const_double_index (rtx x)
if (!TARGET_VFP3 || !CONST_DOUBLE_P (x))
return -1;
- REAL_VALUE_FROM_CONST_DOUBLE (r, x);
+ r = *CONST_DOUBLE_REAL_VALUE (x);
/* We can't represent these things, so detect them first. */
if (REAL_VALUE_ISINF (r) || REAL_VALUE_ISNAN (r) || REAL_VALUE_MINUS_ZERO
(r))
@@ -12305,21 +12305,17 @@ neon_valid_immediate (rtx op, machine_mode mode, int
inverse,
if (GET_MODE_CLASS (mode) == MODE_VECTOR_FLOAT)
{
rtx el0 = CONST_VECTOR_ELT (op, 0);
- REAL_VALUE_TYPE r0;
+ const REAL_VALUE_TYPE *r0;
if (!vfp3_const_double_rtx (el0) && el0 != CONST0_RTX (GET_MODE (el0)))
return -1;
- REAL_VALUE_FROM_CONST_DOUBLE (r0, el0);
+ r0 = CONST_DOUBLE_REAL_VALUE (el0);
for (i = 1; i < n_elts; i++)
{
rtx elt = CONST_VECTOR_ELT (op, i);
- REAL_VALUE_TYPE re;
-
- REAL_VALUE_FROM_CONST_DOUBLE (re, elt);
-
- if (!real_equal (&r0, &re))
+ if (!real_equal (r0, CONST_DOUBLE_REAL_VALUE (elt)))
return -1;
}
@@ -21843,8 +21839,7 @@ arm_print_operand (FILE *stream, rtx x, int code)
case 'N':
{
REAL_VALUE_TYPE r;
- REAL_VALUE_FROM_CONST_DOUBLE (r, x);
- r = real_value_negate (&r);
+ r = real_value_negate (CONST_DOUBLE_REAL_VALUE (x));
fprintf (stream, "%s", fp_const_from_val (&r));
}
return;
@@ -22638,13 +22633,9 @@ arm_assemble_integer (rtx x, unsigned int size, int
aligned_p)
for (i = 0; i < units; i++)
{
rtx elt = CONST_VECTOR_ELT (x, i);
- REAL_VALUE_TYPE rval;
-
- REAL_VALUE_FROM_CONST_DOUBLE (rval, elt);
-
assemble_real
- (rval, GET_MODE_INNER (mode),
- i == 0 ? BIGGEST_ALIGNMENT : size * BITS_PER_UNIT);
+ (*CONST_DOUBLE_REAL_VALUE (elt), GET_MODE_INNER (mode),
+ i == 0 ? BIGGEST_ALIGNMENT : size * BITS_PER_UNIT);
}
return true;
@@ -26251,11 +26242,9 @@ arm_emit_vector_const (FILE *file, rtx x)
void
arm_emit_fp16_const (rtx c)
{
- REAL_VALUE_TYPE r;
long bits;
- REAL_VALUE_FROM_CONST_DOUBLE (r, c);
- bits = real_to_target (NULL, &r, HFmode);
+ bits = real_to_target (NULL, CONST_DOUBLE_REAL_VALUE (c), HFmode);
if (WORDS_BIG_ENDIAN)
assemble_zeros (2);
assemble_integer (GEN_INT (bits), 2, BITS_PER_WORD, 1);
@@ -27729,7 +27718,7 @@ vfp3_const_double_for_fract_bits (rtx operand)
if (!CONST_DOUBLE_P (operand))
return 0;
- REAL_VALUE_FROM_CONST_DOUBLE (r0, operand);
+ r0 = *CONST_DOUBLE_REAL_VALUE (operand);
if (exact_real_inverse (DFmode, &r0)
&& !REAL_VALUE_NEGATIVE (r0))
{
@@ -27747,15 +27736,15 @@ vfp3_const_double_for_fract_bits (rtx operand)
int
vfp3_const_double_for_bits (rtx operand)
{
- REAL_VALUE_TYPE r0;
+ const REAL_VALUE_TYPE *r0;
if (!CONST_DOUBLE_P (operand))
return 0;
- REAL_VALUE_FROM_CONST_DOUBLE (r0, operand);
- if (exact_real_truncate (DFmode, &r0))
+ r0 = CONST_DOUBLE_REAL_VALUE (operand);
+ if (exact_real_truncate (DFmode, r0))
{
- HOST_WIDE_INT value = real_to_integer (&r0);
+ HOST_WIDE_INT value = real_to_integer (r0);
value = value & 0xffffffff;
if ((value != 0) && ( (value & (value - 1)) == 0))
return int_log2 (value);
diff --git a/gcc/config/arm/arm.md b/gcc/config/arm/arm.md
index ad5b02e..b4c555b 100644
--- a/gcc/config/arm/arm.md
+++ b/gcc/config/arm/arm.md
@@ -6634,12 +6634,11 @@
return \"mov%?\\t%0, %1\\t%@ __fp16\";
case 3: /* ARM register from constant */
{
- REAL_VALUE_TYPE r;
long bits;
rtx ops[4];
- REAL_VALUE_FROM_CONST_DOUBLE (r, operands[1]);
- bits = real_to_target (NULL, &r, HFmode);
+ bits = real_to_target (NULL, CONST_DOUBLE_REAL_VALUE (operands[1]),
+ HFmode);
ops[0] = operands[0];
ops[1] = GEN_INT (bits);
ops[2] = GEN_INT (bits & 0xff00);
@@ -10854,12 +10853,9 @@
switch (GET_MODE_CLASS (GET_MODE (x)))
{
case MODE_FLOAT:
- {
- REAL_VALUE_TYPE r;
- REAL_VALUE_FROM_CONST_DOUBLE (r, x);
- assemble_real (r, GET_MODE (x), BITS_PER_WORD);
- break;
- }
+ assemble_real (*CONST_DOUBLE_REAL_VALUE (x), GET_MODE (x),
+ BITS_PER_WORD);
+ break;
default:
/* XXX: Sometimes gcc does something really dumb and ends up with
a HIGH in a constant pool entry, usually because it's trying to
@@ -10886,13 +10882,10 @@
making_const_table = TRUE;
switch (GET_MODE_CLASS (GET_MODE (operands[0])))
{
- case MODE_FLOAT:
- {
- REAL_VALUE_TYPE r;
- REAL_VALUE_FROM_CONST_DOUBLE (r, operands[0]);
- assemble_real (r, GET_MODE (operands[0]), BITS_PER_WORD);
- break;
- }
+ case MODE_FLOAT:
+ assemble_real (*CONST_DOUBLE_REAL_VALUE (operands[0]),
+ GET_MODE (operands[0]), BITS_PER_WORD);
+ break;
default:
assemble_integer (operands[0], 8, BITS_PER_WORD, 1);
break;
@@ -10911,13 +10904,10 @@
making_const_table = TRUE;
switch (GET_MODE_CLASS (GET_MODE (operands[0])))
{
- case MODE_FLOAT:
- {
- REAL_VALUE_TYPE r;
- REAL_VALUE_FROM_CONST_DOUBLE (r, operands[0]);
- assemble_real (r, GET_MODE (operands[0]), BITS_PER_WORD);
- break;
- }
+ case MODE_FLOAT:
+ assemble_real (*CONST_DOUBLE_REAL_VALUE (operands[0]),
+ GET_MODE (operands[0]), BITS_PER_WORD);
+ break;
default:
assemble_integer (operands[0], 16, BITS_PER_WORD, 1);
break;
diff --git a/gcc/config/arm/vfp.md b/gcc/config/arm/vfp.md
index 081aab2..baeac62 100644
--- a/gcc/config/arm/vfp.md
+++ b/gcc/config/arm/vfp.md
@@ -238,12 +238,11 @@
return \"vmov\\t%0, %1\";
case 8: /* ARM register from constant */
{
- REAL_VALUE_TYPE r;
long bits;
rtx ops[4];
- REAL_VALUE_FROM_CONST_DOUBLE (r, operands[1]);
- bits = real_to_target (NULL, &r, HFmode);
+ bits = real_to_target (NULL, CONST_DOUBLE_REAL_VALUE (operands[1]),
+ HFmode);
ops[0] = operands[0];
ops[1] = GEN_INT (bits);
ops[2] = GEN_INT (bits & 0xff00);
@@ -289,12 +288,11 @@
return \"vmov\\t%0, %1\";
case 6: /* ARM register from constant */
{
- REAL_VALUE_TYPE r;
long bits;
rtx ops[4];
- REAL_VALUE_FROM_CONST_DOUBLE (r, operands[1]);
- bits = real_to_target (NULL, &r, HFmode);
+ bits = real_to_target (NULL, CONST_DOUBLE_REAL_VALUE (operands[1]),
+ HFmode);
ops[0] = operands[0];
ops[1] = GEN_INT (bits);
ops[2] = GEN_INT (bits & 0xff00);
diff --git a/gcc/config/avr/avr.c b/gcc/config/avr/avr.c
index 9f5bc88..4963488 100644
--- a/gcc/config/avr/avr.c
+++ b/gcc/config/avr/avr.c
@@ -2431,11 +2431,9 @@ avr_print_operand (FILE *file, rtx x, int code)
else if (GET_CODE (x) == CONST_DOUBLE)
{
long val;
- REAL_VALUE_TYPE rv;
if (GET_MODE (x) != SFmode)
fatal_insn ("internal compiler error. Unknown mode:", x);
- REAL_VALUE_FROM_CONST_DOUBLE (rv, x);
- REAL_VALUE_TO_TARGET_SINGLE (rv, val);
+ REAL_VALUE_TO_TARGET_SINGLE (*CONST_DOUBLE_REAL_VALUE (x), val);
fprintf (file, "0x%lx", val);
}
else if (GET_CODE (x) == CONST_STRING)
diff --git a/gcc/config/bfin/bfin.md b/gcc/config/bfin/bfin.md
index 1d45535..18152ee 100644
--- a/gcc/config/bfin/bfin.md
+++ b/gcc/config/bfin/bfin.md
@@ -848,12 +848,10 @@
(set (match_dup 2) (lo_sum:SI (match_dup 2) (match_dup 3)))]
{
long values;
- REAL_VALUE_TYPE value;
gcc_assert (GET_CODE (operands[1]) == CONST_DOUBLE);
- REAL_VALUE_FROM_CONST_DOUBLE (value, operands[1]);
- REAL_VALUE_TO_TARGET_SINGLE (value, values);
+ REAL_VALUE_TO_TARGET_SINGLE (*CONST_DOUBLE_REAL_VALUE (operands[1]), values);
operands[2] = gen_rtx_REG (SImode, true_regnum (operands[0]));
operands[3] = GEN_INT (trunc_int_for_mode (values, SImode));
diff --git a/gcc/config/c6x/c6x.md b/gcc/config/c6x/c6x.md
index 692d83f..fa89587 100644
--- a/gcc/config/c6x/c6x.md
+++ b/gcc/config/c6x/c6x.md
@@ -549,12 +549,10 @@
(ashift:SI (match_dup 4) (const_int 16))))]
{
long values;
- REAL_VALUE_TYPE value;
gcc_assert (GET_CODE (operands[1]) == CONST_DOUBLE);
- REAL_VALUE_FROM_CONST_DOUBLE (value, operands[1]);
- REAL_VALUE_TO_TARGET_SINGLE (value, values);
+ REAL_VALUE_TO_TARGET_SINGLE (*CONST_DOUBLE_REAL_VALUE (operands[1]), values);
operands[2] = gen_rtx_REG (SImode, true_regnum (operands[0]));
operands[3] = GEN_INT (trunc_int_for_mode (values, HImode));
diff --git a/gcc/config/cr16/cr16.c b/gcc/config/cr16/cr16.c
index 7b3b6ef..accb605 100644
--- a/gcc/config/cr16/cr16.c
+++ b/gcc/config/cr16/cr16.c
@@ -1386,10 +1386,8 @@ cr16_const_double_ok (rtx op)
{
if (GET_MODE (op) == SFmode)
{
- REAL_VALUE_TYPE r;
long l;
- REAL_VALUE_FROM_CONST_DOUBLE (r, op);
- REAL_VALUE_TO_TARGET_SINGLE (r, l);
+ REAL_VALUE_TO_TARGET_SINGLE (*CONST_DOUBLE_REAL_VALUE (op), l);
return UNSIGNED_INT_FITS_N_BITS (l, 4) ? 1 : 0;
}
@@ -1521,11 +1519,9 @@ cr16_print_operand (FILE * file, rtx x, int code)
case CONST_DOUBLE:
{
- REAL_VALUE_TYPE r;
long l;
- REAL_VALUE_FROM_CONST_DOUBLE (r, x);
- REAL_VALUE_TO_TARGET_SINGLE (r, l);
+ REAL_VALUE_TO_TARGET_SINGLE (*CONST_DOUBLE_REAL_VALUE (x), l);
fprintf (file, "$0x%lx", l);
return;
diff --git a/gcc/config/cris/cris.c b/gcc/config/cris/cris.c
index 70f3442..e4ab65f 100644
--- a/gcc/config/cris/cris.c
+++ b/gcc/config/cris/cris.c
@@ -1154,14 +1154,11 @@ cris_print_operand (FILE *file, rtx x, int code)
else
{
/* Only single precision is allowed as plain operands the
- moment. FIXME: REAL_VALUE_FROM_CONST_DOUBLE isn't
- documented. */
- REAL_VALUE_TYPE r;
+ moment. */
long l;
/* FIXME: Perhaps check overflow of the "single". */
- REAL_VALUE_FROM_CONST_DOUBLE (r, operand);
- REAL_VALUE_TO_TARGET_SINGLE (r, l);
+ REAL_VALUE_TO_TARGET_SINGLE (*CONST_DOUBLE_REAL_VALUE (operand), l);
fprintf (file, "0x%lx", l);
}
diff --git a/gcc/config/epiphany/epiphany.c b/gcc/config/epiphany/epiphany.c
index 593c9a1..a87c98f 100644
--- a/gcc/config/epiphany/epiphany.c
+++ b/gcc/config/epiphany/epiphany.c
@@ -1362,11 +1362,9 @@ epiphany_print_operand (FILE *file, rtx x, int code)
/* We handle SFmode constants here as output_addr_const doesn't. */
if (GET_MODE (x) == SFmode)
{
- REAL_VALUE_TYPE d;
long l;
- REAL_VALUE_FROM_CONST_DOUBLE (d, x);
- REAL_VALUE_TO_TARGET_SINGLE (d, l);
+ REAL_VALUE_TO_TARGET_SINGLE (*CONST_DOUBLE_REAL_VALUE (x), l);
fprintf (file, "%s0x%08lx", IMMEDIATE_PREFIX, l);
break;
}
diff --git a/gcc/config/fr30/fr30.c b/gcc/config/fr30/fr30.c
index 0cac6ce..6afd5d4 100644
--- a/gcc/config/fr30/fr30.c
+++ b/gcc/config/fr30/fr30.c
@@ -699,11 +699,9 @@ fr30_print_operand (FILE *file, rtx x, int code)
/* We handle SFmode constants here as output_addr_const doesn't. */
if (GET_MODE (x) == SFmode)
{
- REAL_VALUE_TYPE d;
long l;
- REAL_VALUE_FROM_CONST_DOUBLE (d, x);
- REAL_VALUE_TO_TARGET_SINGLE (d, l);
+ REAL_VALUE_TO_TARGET_SINGLE (*CONST_DOUBLE_REAL_VALUE (x), l);
fprintf (file, "0x%08lx", l);
break;
}
@@ -888,14 +886,10 @@ fr30_check_multiple_regs (rtx *operands, int
num_operands, int descending)
int
fr30_const_double_is_zero (rtx operand)
{
- REAL_VALUE_TYPE d;
-
if (operand == NULL || GET_CODE (operand) != CONST_DOUBLE)
return 0;
- REAL_VALUE_FROM_CONST_DOUBLE (d, operand);
-
- return real_equal (&d, &dconst0);
+ return real_equal (CONST_DOUBLE_REAL_VALUE (operand), &dconst0);
}
/*}}}*/
diff --git a/gcc/config/frv/frv.c b/gcc/config/frv/frv.c
index 15de223..9e355b2 100644
--- a/gcc/config/frv/frv.c
+++ b/gcc/config/frv/frv.c
@@ -2767,11 +2767,9 @@ frv_print_operand (FILE * file, rtx x, int code)
{
if (GET_MODE (x) == SFmode)
{
- REAL_VALUE_TYPE rv;
long l;
- REAL_VALUE_FROM_CONST_DOUBLE (rv, x);
- REAL_VALUE_TO_TARGET_SINGLE (rv, l);
+ REAL_VALUE_TO_TARGET_SINGLE (*CONST_DOUBLE_REAL_VALUE (x), l);
value = l;
}
@@ -4290,11 +4288,10 @@ output_move_single (rtx operands[], rtx insn)
else if (mode == SFmode)
{
- REAL_VALUE_TYPE rv;
long l;
- REAL_VALUE_FROM_CONST_DOUBLE (rv, src);
- REAL_VALUE_TO_TARGET_SINGLE (rv, l);
+ REAL_VALUE_TO_TARGET_SINGLE
+ (*CONST_DOUBLE_REAL_VALUE (src), l);
value = l;
}
diff --git a/gcc/config/frv/frv.md b/gcc/config/frv/frv.md
index 96f78b1..0604b23 100644
--- a/gcc/config/frv/frv.md
+++ b/gcc/config/frv/frv.md
@@ -1870,11 +1870,9 @@
{
rtx op0 = operands[0];
rtx op1 = operands[1];
- REAL_VALUE_TYPE rv;
long l[2];
- REAL_VALUE_FROM_CONST_DOUBLE (rv, op1);
- REAL_VALUE_TO_TARGET_DOUBLE (rv, l);
+ REAL_VALUE_TO_TARGET_DOUBLE (*CONST_DOUBLE_REAL_VALUE (op1), l);
operands[2] = gen_highpart (SImode, op0);
operands[3] = gen_lowpart (SImode, op0);
diff --git a/gcc/config/frv/predicates.md b/gcc/config/frv/predicates.md
index 3c27d72..ad834a5 100644
--- a/gcc/config/frv/predicates.md
+++ b/gcc/config/frv/predicates.md
@@ -504,7 +504,6 @@
(match_code "const_int,const_double,symbol_ref,label_ref,const")
{
HOST_WIDE_INT value;
- REAL_VALUE_TYPE rv;
long l;
switch (GET_CODE (op))
@@ -540,8 +539,7 @@
case CONST_DOUBLE:
if (GET_MODE (op) == SFmode)
{
- REAL_VALUE_FROM_CONST_DOUBLE (rv, op);
- REAL_VALUE_TO_TARGET_SINGLE (rv, l);
+ REAL_VALUE_TO_TARGET_SINGLE (*CONST_DOUBLE_REAL_VALUE (op), l);
value = l;
return ! IN_RANGE (value, -32768, 32767);
}
diff --git a/gcc/config/h8300/h8300.c b/gcc/config/h8300/h8300.c
index 63a7adb..1eef7bf 100644
--- a/gcc/config/h8300/h8300.c
+++ b/gcc/config/h8300/h8300.c
@@ -1596,9 +1596,7 @@ h8300_print_operand (FILE *file, rtx x, int code)
case CONST_DOUBLE:
{
long val;
- REAL_VALUE_TYPE rv;
- REAL_VALUE_FROM_CONST_DOUBLE (rv, x);
- REAL_VALUE_TO_TARGET_SINGLE (rv, val);
+ REAL_VALUE_TO_TARGET_SINGLE (*CONST_DOUBLE_REAL_VALUE (x), val);
fprintf (file, "#%ld", ((val >> 16) & 0xffff));
break;
}
@@ -1626,9 +1624,7 @@ h8300_print_operand (FILE *file, rtx x, int code)
case CONST_DOUBLE:
{
long val;
- REAL_VALUE_TYPE rv;
- REAL_VALUE_FROM_CONST_DOUBLE (rv, x);
- REAL_VALUE_TO_TARGET_SINGLE (rv, val);
+ REAL_VALUE_TO_TARGET_SINGLE (*CONST_DOUBLE_REAL_VALUE (x), val);
fprintf (file, "#%ld", (val & 0xffff));
break;
}
@@ -1785,9 +1781,7 @@ h8300_print_operand (FILE *file, rtx x, int code)
case CONST_DOUBLE:
{
long val;
- REAL_VALUE_TYPE rv;
- REAL_VALUE_FROM_CONST_DOUBLE (rv, x);
- REAL_VALUE_TO_TARGET_SINGLE (rv, val);
+ REAL_VALUE_TO_TARGET_SINGLE (*CONST_DOUBLE_REAL_VALUE (x), val);
fprintf (file, "#%ld", val);
break;
}
diff --git a/gcc/config/i386/i386.c b/gcc/config/i386/i386.c
index ff52779..d59b59b 100644
--- a/gcc/config/i386/i386.c
+++ b/gcc/config/i386/i386.c
@@ -10480,7 +10480,7 @@ standard_80387_constant_p (rtx x)
{
machine_mode mode = GET_MODE (x);
- REAL_VALUE_TYPE r;
+ const REAL_VALUE_TYPE *r;
if (!(CONST_DOUBLE_P (x) && X87_FLOAT_MODE_P (mode)))
return -1;
@@ -10490,7 +10490,7 @@ standard_80387_constant_p (rtx x)
if (x == CONST1_RTX (mode))
return 2;
- REAL_VALUE_FROM_CONST_DOUBLE (r, x);
+ r = CONST_DOUBLE_REAL_VALUE (x);
/* For XFmode constants, try to find a special 80387 instruction when
optimizing for size or on those CPUs that benefit from them. */
@@ -10503,15 +10503,15 @@ standard_80387_constant_p (rtx x)
init_ext_80387_constants ();
for (i = 0; i < 5; i++)
- if (real_identical (&r, &ext_80387_constants_table[i]))
+ if (real_identical (r, &ext_80387_constants_table[i]))
return i + 3;
}
/* Load of the constant -0.0 or -1.0 will be split as
fldz;fchs or fld1;fchs sequence. */
- if (real_isnegzero (&r))
+ if (real_isnegzero (r))
return 8;
- if (real_identical (&r, &dconstm1))
+ if (real_identical (r, &dconstm1))
return 9;
return 0;
@@ -17023,11 +17023,9 @@ ix86_print_operand (FILE *file, rtx x, int code)
else if (CONST_DOUBLE_P (x) && GET_MODE (x) == SFmode)
{
- REAL_VALUE_TYPE r;
long l;
- REAL_VALUE_FROM_CONST_DOUBLE (r, x);
- REAL_VALUE_TO_TARGET_SINGLE (r, l);
+ REAL_VALUE_TO_TARGET_SINGLE (*CONST_DOUBLE_REAL_VALUE (x), l);
if (ASSEMBLER_DIALECT == ASM_ATT)
putc ('$', file);
@@ -17041,11 +17039,9 @@ ix86_print_operand (FILE *file, rtx x, int code)
else if (CONST_DOUBLE_P (x) && GET_MODE (x) == DFmode)
{
- REAL_VALUE_TYPE r;
long l[2];
- REAL_VALUE_FROM_CONST_DOUBLE (r, x);
- REAL_VALUE_TO_TARGET_DOUBLE (r, l);
+ REAL_VALUE_TO_TARGET_DOUBLE (*CONST_DOUBLE_REAL_VALUE (x), l);
if (ASSEMBLER_DIALECT == ASM_ATT)
putc ('$', file);
@@ -23749,25 +23745,25 @@ ix86_split_to_parts (rtx operand, rtx *parts,
machine_mode mode)
}
else if (CONST_DOUBLE_P (operand))
{
- REAL_VALUE_TYPE r;
+ const REAL_VALUE_TYPE *r;
long l[4];
- REAL_VALUE_FROM_CONST_DOUBLE (r, operand);
+ r = CONST_DOUBLE_REAL_VALUE (operand);
switch (mode)
{
case TFmode:
- real_to_target (l, &r, mode);
+ real_to_target (l, r, mode);
parts[3] = gen_int_mode (l[3], SImode);
parts[2] = gen_int_mode (l[2], SImode);
break;
case XFmode:
/* We can't use REAL_VALUE_TO_TARGET_LONG_DOUBLE since
long double may not be 80-bit. */
- real_to_target (l, &r, mode);
+ real_to_target (l, r, mode);
parts[2] = gen_int_mode (l[2], SImode);
break;
case DFmode:
- REAL_VALUE_TO_TARGET_DOUBLE (r, l);
+ REAL_VALUE_TO_TARGET_DOUBLE (*r, l);
break;
default:
gcc_unreachable ();
@@ -23800,11 +23796,9 @@ ix86_split_to_parts (rtx operand, rtx *parts,
machine_mode mode)
}
else if (CONST_DOUBLE_P (operand))
{
- REAL_VALUE_TYPE r;
long l[4];
- REAL_VALUE_FROM_CONST_DOUBLE (r, operand);
- real_to_target (l, &r, mode);
+ real_to_target (l, CONST_DOUBLE_REAL_VALUE (operand), mode);
/* real_to_target puts 32-bit pieces in each long. */
parts[0] =
diff --git a/gcc/config/i386/i386.md b/gcc/config/i386/i386.md
index 8c2ed60..5fcebb5 100644
--- a/gcc/config/i386/i386.md
+++ b/gcc/config/i386/i386.md
@@ -3577,10 +3577,7 @@
(set (match_dup 0)
(neg:X87MODEF (match_dup 0)))]
{
- REAL_VALUE_TYPE r;
-
- REAL_VALUE_FROM_CONST_DOUBLE (r, operands[1]);
- if (real_isnegzero (&r))
+ if (real_isnegzero (CONST_DOUBLE_REAL_VALUE (operands[1])))
operands[1] = CONST0_RTX (<MODE>mode);
else
operands[1] = CONST1_RTX (<MODE>mode);
diff --git a/gcc/config/ia64/ia64.c b/gcc/config/ia64/ia64.c
index 99c965a..b495ac1 100644
--- a/gcc/config/ia64/ia64.c
+++ b/gcc/config/ia64/ia64.c
@@ -1415,12 +1415,10 @@ ia64_split_tmode (rtx out[2], rtx in, bool reversed,
bool dead)
/* split_double does not understand how to split a TFmode
quantity into a pair of DImode constants. */
{
- REAL_VALUE_TYPE r;
unsigned HOST_WIDE_INT p[2];
long l[4]; /* TFmode is 128 bits */
- REAL_VALUE_FROM_CONST_DOUBLE (r, in);
- real_to_target (l, &r, TFmode);
+ real_to_target (l, CONST_DOUBLE_REAL_VALUE (in), TFmode);
if (FLOAT_WORDS_BIG_ENDIAN)
{
@@ -5362,9 +5360,7 @@ ia64_print_operand (FILE * file, rtx x, int code)
case 'G':
{
long val[4];
- REAL_VALUE_TYPE rv;
- REAL_VALUE_FROM_CONST_DOUBLE (rv, x);
- real_to_target (val, &rv, GET_MODE (x));
+ real_to_target (val, CONST_DOUBLE_REAL_VALUE (x), GET_MODE (x));
if (GET_MODE (x) == SFmode)
fprintf (file, "0x%08lx", val[0] & 0xffffffff);
else if (GET_MODE (x) == DFmode)
diff --git a/gcc/config/iq2000/iq2000.md b/gcc/config/iq2000/iq2000.md
index bba6760..a030661 100644
--- a/gcc/config/iq2000/iq2000.md
+++ b/gcc/config/iq2000/iq2000.md
@@ -849,11 +849,9 @@
""
"*
{
- REAL_VALUE_TYPE r;
long i;
- REAL_VALUE_FROM_CONST_DOUBLE (r, operands[2]);
- REAL_VALUE_TO_TARGET_SINGLE (r, i);
+ REAL_VALUE_TO_TARGET_SINGLE (*CONST_DOUBLE_REAL_VALUE (operands[2]), i);
operands[2] = GEN_INT (i);
return \"addiu\\t%0,%1,%%lo(%2) # low\";
}"
@@ -866,11 +864,9 @@
""
"*
{
- REAL_VALUE_TYPE r;
long i;
- REAL_VALUE_FROM_CONST_DOUBLE (r, operands[1]);
- REAL_VALUE_TO_TARGET_SINGLE (r, i);
+ REAL_VALUE_TO_TARGET_SINGLE (*CONST_DOUBLE_REAL_VALUE (operands[1]), i);
operands[1] = GEN_INT (i);
return \"lui\\t%0,%%hi(%1) # high\";
}"
diff --git a/gcc/config/m32r/m32r.c b/gcc/config/m32r/m32r.c
index 341f24a..80fceb5 100644
--- a/gcc/config/m32r/m32r.c
+++ b/gcc/config/m32r/m32r.c
@@ -650,11 +650,9 @@ easy_di_const (rtx op)
int
easy_df_const (rtx op)
{
- REAL_VALUE_TYPE r;
long l[2];
- REAL_VALUE_FROM_CONST_DOUBLE (r, op);
- REAL_VALUE_TO_TARGET_DOUBLE (r, l);
+ REAL_VALUE_TO_TARGET_DOUBLE (*CONST_DOUBLE_REAL_VALUE (op), l);
if (l[0] == 0 && l[1] == 0)
return 1;
if ((l[0] & 0xffff) == 0 && l[1] == 0)
@@ -2280,11 +2278,9 @@ m32r_print_operand (FILE * file, rtx x, int code)
/* We handle SFmode constants here as output_addr_const doesn't. */
if (GET_MODE (x) == SFmode)
{
- REAL_VALUE_TYPE d;
long l;
- REAL_VALUE_FROM_CONST_DOUBLE (d, x);
- REAL_VALUE_TO_TARGET_SINGLE (d, l);
+ REAL_VALUE_TO_TARGET_SINGLE (*CONST_DOUBLE_REAL_VALUE (x), l);
fprintf (file, "0x%08lx", l);
break;
}
diff --git a/gcc/config/m68k/m68k.c b/gcc/config/m68k/m68k.c
index 74de983..bfc19f3 100644
--- a/gcc/config/m68k/m68k.c
+++ b/gcc/config/m68k/m68k.c
@@ -3295,11 +3295,10 @@ handle_move_double (rtx operands[2],
{
if (GET_CODE (operands[1]) == CONST_DOUBLE)
{
- REAL_VALUE_TYPE r;
long l[3];
- REAL_VALUE_FROM_CONST_DOUBLE (r, operands[1]);
- REAL_VALUE_TO_TARGET_LONG_DOUBLE (r, l);
+ REAL_VALUE_TO_TARGET_LONG_DOUBLE
+ (*CONST_DOUBLE_REAL_VALUE (operands[1]), l);
operands[1] = GEN_INT (l[0]);
middlehalf[1] = GEN_INT (l[1]);
latehalf[1] = GEN_INT (l[2]);
@@ -4323,7 +4322,7 @@ init_68881_table (void)
int
standard_68881_constant_p (rtx x)
{
- REAL_VALUE_TYPE r;
+ const REAL_VALUE_TYPE *r;
int i;
/* fmovecr must be emulated on the 68040 and 68060, so it shouldn't be
@@ -4334,19 +4333,19 @@ standard_68881_constant_p (rtx x)
if (! inited_68881_table)
init_68881_table ();
- REAL_VALUE_FROM_CONST_DOUBLE (r, x);
+ r = CONST_DOUBLE_REAL_VALUE (x);
/* Use real_identical instead of real_equal so that -0.0 is rejected. */
for (i = 0; i < 6; i++)
{
- if (real_identical (&r, &values_68881[i]))
+ if (real_identical (r, &values_68881[i]))
return (codes_68881[i]);
}
if (GET_MODE (x) == SFmode)
return 0;
- if (real_equal (&r, &values_68881[6]))
+ if (real_equal (r, &values_68881[6]))
return (codes_68881[6]);
/* larger powers of ten in the constants ram are not used
@@ -4360,17 +4359,18 @@ standard_68881_constant_p (rtx x)
int
floating_exact_log2 (rtx x)
{
- REAL_VALUE_TYPE r, r1;
+ const REAL_VALUE_TYPE *r;
+ REAL_VALUE_TYPE r1;
int exp;
- REAL_VALUE_FROM_CONST_DOUBLE (r, x);
+ r = CONST_DOUBLE_REAL_VALUE (x);
- if (real_less (&r, &dconst1))
+ if (real_less (r, &dconst1))
return 0;
- exp = real_exponent (&r);
+ exp = real_exponent (r);
real_2expN (&r1, exp, DFmode);
- if (real_equal (&r1, &r))
+ if (real_equal (&r1, r))
return exp;
return 0;
@@ -4480,27 +4480,21 @@ print_operand (FILE *file, rtx op, int letter)
}
else if (GET_CODE (op) == CONST_DOUBLE && GET_MODE (op) == SFmode)
{
- REAL_VALUE_TYPE r;
long l;
- REAL_VALUE_FROM_CONST_DOUBLE (r, op);
- REAL_VALUE_TO_TARGET_SINGLE (r, l);
+ REAL_VALUE_TO_TARGET_SINGLE (*CONST_DOUBLE_REAL_VALUE (op), l);
asm_fprintf (file, "%I0x%lx", l & 0xFFFFFFFF);
}
else if (GET_CODE (op) == CONST_DOUBLE && GET_MODE (op) == XFmode)
{
- REAL_VALUE_TYPE r;
long l[3];
- REAL_VALUE_FROM_CONST_DOUBLE (r, op);
- REAL_VALUE_TO_TARGET_LONG_DOUBLE (r, l);
+ REAL_VALUE_TO_TARGET_LONG_DOUBLE (*CONST_DOUBLE_REAL_VALUE (op), l);
asm_fprintf (file, "%I0x%lx%08lx%08lx", l[0] & 0xFFFFFFFF,
l[1] & 0xFFFFFFFF, l[2] & 0xFFFFFFFF);
}
else if (GET_CODE (op) == CONST_DOUBLE && GET_MODE (op) == DFmode)
{
- REAL_VALUE_TYPE r;
long l[2];
- REAL_VALUE_FROM_CONST_DOUBLE (r, op);
- REAL_VALUE_TO_TARGET_DOUBLE (r, l);
+ REAL_VALUE_TO_TARGET_DOUBLE (*CONST_DOUBLE_REAL_VALUE (op), l);
asm_fprintf (file, "%I0x%lx%08lx", l[0] & 0xFFFFFFFF, l[1] & 0xFFFFFFFF);
}
else
diff --git a/gcc/config/m68k/m68k.md b/gcc/config/m68k/m68k.md
index 463c827..1eaf58f 100644
--- a/gcc/config/m68k/m68k.md
+++ b/gcc/config/m68k/m68k.md
@@ -1218,10 +1218,8 @@
{
if (which_alternative == 4 || which_alternative == 5) {
rtx xoperands[2];
- REAL_VALUE_TYPE r;
long l;
- REAL_VALUE_FROM_CONST_DOUBLE (r, operands[1]);
- REAL_VALUE_TO_TARGET_SINGLE (r, l);
+ REAL_VALUE_TO_TARGET_SINGLE (*CONST_DOUBLE_REAL_VALUE (operands[1]), l);
xoperands[0] = operands[0];
xoperands[1] = GEN_INT (l);
if (which_alternative == 5) {
@@ -1360,7 +1358,6 @@
"TARGET_COLDFIRE_FPU"
{
rtx xoperands[3];
- REAL_VALUE_TYPE r;
long l[2];
switch (which_alternative)
@@ -1376,8 +1373,7 @@
case 4: case 5: case 6:
return output_move_double (operands);
case 7:
- REAL_VALUE_FROM_CONST_DOUBLE (r, operands[1]);
- REAL_VALUE_TO_TARGET_DOUBLE (r, l);
+ REAL_VALUE_TO_TARGET_DOUBLE (*CONST_DOUBLE_REAL_VALUE (operands[1]), l);
xoperands[0] = operands[0];
xoperands[1] = GEN_INT (l[0]);
xoperands[2] = GEN_INT (l[1]);
diff --git a/gcc/config/mep/mep.md b/gcc/config/mep/mep.md
index 39d1d63..bcaab56 100644
--- a/gcc/config/mep/mep.md
+++ b/gcc/config/mep/mep.md
@@ -760,13 +760,11 @@
[(const_int 0)]
"
{
- REAL_VALUE_TYPE rv;
HOST_WIDE_INT value;
HOST_WIDE_INT lo, hi;
rtx out;
- REAL_VALUE_FROM_CONST_DOUBLE (rv, operands[1]);
- REAL_VALUE_TO_TARGET_SINGLE (rv, value);
+ REAL_VALUE_TO_TARGET_SINGLE (*CONST_DOUBLE_REAL_VALUE (operands[1]), value);
lo = value & 0xffff;
hi = trunc_int_for_mode (value & 0xffff0000, SImode);
diff --git a/gcc/config/microblaze/microblaze.c
b/gcc/config/microblaze/microblaze.c
index 9efa739..43c01d1 100644
--- a/gcc/config/microblaze/microblaze.c
+++ b/gcc/config/microblaze/microblaze.c
@@ -270,7 +270,7 @@ microblaze_const_double_ok (rtx op, machine_mode mode)
if (op == CONST0_RTX (mode))
return 1;
- REAL_VALUE_FROM_CONST_DOUBLE (d, op);
+ d = *CONST_DOUBLE_REAL_VALUE (op);
if (REAL_VALUE_ISNAN (d))
return FALSE;
@@ -2354,11 +2354,7 @@ print_operand (FILE * file, rtx op, int letter)
if (code == CONST_DOUBLE)
{
if (GET_MODE (op) == DFmode)
- {
- REAL_VALUE_TYPE value;
- REAL_VALUE_FROM_CONST_DOUBLE (value, op);
- REAL_VALUE_TO_TARGET_DOUBLE (value, val);
- }
+ REAL_VALUE_TO_TARGET_DOUBLE (*CONST_DOUBLE_REAL_VALUE (op), val);
else
{
val[0] = CONST_DOUBLE_HIGH (op);
@@ -2380,9 +2376,8 @@ print_operand (FILE * file, rtx op, int letter)
if (letter == 'F')
{
unsigned long value_long;
- REAL_VALUE_TYPE value;
- REAL_VALUE_FROM_CONST_DOUBLE (value, op);
- REAL_VALUE_TO_TARGET_SINGLE (value, value_long);
+ REAL_VALUE_TO_TARGET_SINGLE (*CONST_DOUBLE_REAL_VALUE (op),
+ value_long);
fprintf (file, HOST_WIDE_INT_PRINT_HEX, value_long);
}
else
diff --git a/gcc/config/mips/mips.md b/gcc/config/mips/mips.md
index 3ad41c6..d24dcfe 100644
--- a/gcc/config/mips/mips.md
+++ b/gcc/config/mips/mips.md
@@ -7304,11 +7304,9 @@
UNSPEC_CONSTTABLE_FLOAT)]
"TARGET_MIPS16"
{
- REAL_VALUE_TYPE d;
-
gcc_assert (GET_CODE (operands[0]) == CONST_DOUBLE);
- REAL_VALUE_FROM_CONST_DOUBLE (d, operands[0]);
- assemble_real (d, GET_MODE (operands[0]),
+ assemble_real (*CONST_DOUBLE_REAL_VALUE (operands[0]),
+ GET_MODE (operands[0]),
GET_MODE_BITSIZE (GET_MODE (operands[0])));
return "";
}
diff --git a/gcc/config/mmix/mmix.c b/gcc/config/mmix/mmix.c
index 16e734c..a341e3a 100644
--- a/gcc/config/mmix/mmix.c
+++ b/gcc/config/mmix/mmix.c
@@ -2710,16 +2710,11 @@ mmix_intval (const_rtx x)
if (GET_CODE (x) == CONST_DOUBLE)
{
- REAL_VALUE_TYPE value;
-
- /* FIXME: This macro is not in the manual but should be. */
- REAL_VALUE_FROM_CONST_DOUBLE (value, x);
-
if (GET_MODE (x) == DFmode)
{
long bits[2];
- REAL_VALUE_TO_TARGET_DOUBLE (value, bits);
+ REAL_VALUE_TO_TARGET_DOUBLE (*CONST_DOUBLE_REAL_VALUE (x), bits);
/* The double cast is necessary to avoid getting the long
sign-extended to unsigned long long(!) when they're of
@@ -2732,7 +2727,7 @@ mmix_intval (const_rtx x)
else if (GET_MODE (x) == SFmode)
{
long bits;
- REAL_VALUE_TO_TARGET_SINGLE (value, bits);
+ REAL_VALUE_TO_TARGET_SINGLE (*CONST_DOUBLE_REAL_VALUE (x), bits);
return (unsigned long) bits;
}
diff --git a/gcc/config/mn10300/mn10300.c b/gcc/config/mn10300/mn10300.c
index fd527ab..31bf103 100644
--- a/gcc/config/mn10300/mn10300.c
+++ b/gcc/config/mn10300/mn10300.c
@@ -285,18 +285,17 @@ mn10300_print_operand (FILE *file, rtx x, int code)
case CONST_DOUBLE:
{
long val[2];
- REAL_VALUE_TYPE rv;
switch (GET_MODE (x))
{
case DFmode:
- REAL_VALUE_FROM_CONST_DOUBLE (rv, x);
- REAL_VALUE_TO_TARGET_DOUBLE (rv, val);
+ REAL_VALUE_TO_TARGET_DOUBLE
+ (*CONST_DOUBLE_REAL_VALUE (x), val);
fprintf (file, "0x%lx", val[0]);
break;;
case SFmode:
- REAL_VALUE_FROM_CONST_DOUBLE (rv, x);
- REAL_VALUE_TO_TARGET_SINGLE (rv, val[0]);
+ REAL_VALUE_TO_TARGET_SINGLE
+ (*CONST_DOUBLE_REAL_VALUE (x), val[0]);
fprintf (file, "0x%lx", val[0]);
break;;
case VOIDmode:
@@ -345,13 +344,12 @@ mn10300_print_operand (FILE *file, rtx x, int code)
case CONST_DOUBLE:
{
long val[2];
- REAL_VALUE_TYPE rv;
switch (GET_MODE (x))
{
case DFmode:
- REAL_VALUE_FROM_CONST_DOUBLE (rv, x);
- REAL_VALUE_TO_TARGET_DOUBLE (rv, val);
+ REAL_VALUE_TO_TARGET_DOUBLE
+ (*CONST_DOUBLE_REAL_VALUE (x), val);
fprintf (file, "0x%lx", val[1]);
break;;
case SFmode:
@@ -436,10 +434,8 @@ mn10300_print_operand (FILE *file, rtx x, int code)
case CONST_DOUBLE:
{
unsigned long val;
- REAL_VALUE_TYPE rv;
- REAL_VALUE_FROM_CONST_DOUBLE (rv, x);
- REAL_VALUE_TO_TARGET_SINGLE (rv, val);
+ REAL_VALUE_TO_TARGET_SINGLE (*CONST_DOUBLE_REAL_VALUE (x), val);
fprintf (file, "0x%lx", val);
break;
}
diff --git a/gcc/config/nvptx/nvptx.c b/gcc/config/nvptx/nvptx.c
index a7fdd92..e9177dc 100644
--- a/gcc/config/nvptx/nvptx.c
+++ b/gcc/config/nvptx/nvptx.c
@@ -1857,9 +1857,7 @@ nvptx_print_operand (FILE *file, rtx x, int code)
case CONST_DOUBLE:
long vals[2];
- REAL_VALUE_TYPE real;
- REAL_VALUE_FROM_CONST_DOUBLE (real, x);
- real_to_target (vals, &real, GET_MODE (x));
+ real_to_target (vals, CONST_DOUBLE_REAL_VALUE (x), GET_MODE (x));
vals[0] &= 0xffffffff;
vals[1] &= 0xffffffff;
if (GET_MODE (x) == SFmode)
diff --git a/gcc/config/pa/pa.c b/gcc/config/pa/pa.c
index 0dc0931..b995d10 100644
--- a/gcc/config/pa/pa.c
+++ b/gcc/config/pa/pa.c
@@ -2346,14 +2346,12 @@ pa_singlemove_string (rtx *operands)
if (GET_CODE (operands[1]) == CONST_DOUBLE)
{
long i;
- REAL_VALUE_TYPE d;
gcc_assert (GET_MODE (operands[1]) == SFmode);
/* Translate the CONST_DOUBLE to a CONST_INT with the same target
bit pattern. */
- REAL_VALUE_FROM_CONST_DOUBLE (d, operands[1]);
- REAL_VALUE_TO_TARGET_SINGLE (d, i);
+ REAL_VALUE_TO_TARGET_SINGLE (*CONST_DOUBLE_REAL_VALUE (operands[1]), i);
operands[1] = GEN_INT (i);
/* Fall through to CONST_INT case. */
diff --git a/gcc/config/pdp11/pdp11.c b/gcc/config/pdp11/pdp11.c
index 8eb37c6..7f0f06f 100644
--- a/gcc/config/pdp11/pdp11.c
+++ b/gcc/config/pdp11/pdp11.c
@@ -488,7 +488,6 @@ pdp11_expand_operands (rtx *operands, rtx exops[][2], int
opcount,
pdp11_partorder useorder;
bool sameoff = false;
enum { REGOP, OFFSOP, MEMOP, PUSHOP, POPOP, CNSTOP, RNDOP } optype;
- REAL_VALUE_TYPE r;
long sval[2];
words = GET_MODE_BITSIZE (GET_MODE (operands[0])) / 16;
@@ -602,10 +601,8 @@ pdp11_expand_operands (rtx *operands, rtx exops[][2], int
opcount,
}
if (GET_CODE (operands[op]) == CONST_DOUBLE)
- {
- REAL_VALUE_FROM_CONST_DOUBLE (r, operands[op]);
- REAL_VALUE_TO_TARGET_DOUBLE (r, sval);
- }
+ REAL_VALUE_TO_TARGET_DOUBLE
+ (*CONST_DOUBLE_REAL_VALUE (operands[op]), sval);
for (i = 0; i < words; i++)
{
@@ -729,7 +726,6 @@ pdp11_asm_output_var (FILE *file, const char *name, int
size,
static void
pdp11_asm_print_operand (FILE *file, rtx x, int code)
{
- REAL_VALUE_TYPE r;
long sval[2];
if (code == '#')
@@ -747,8 +743,7 @@ pdp11_asm_print_operand (FILE *file, rtx x, int code)
output_address (XEXP (x, 0));
else if (GET_CODE (x) == CONST_DOUBLE && GET_MODE (x) != SImode)
{
- REAL_VALUE_FROM_CONST_DOUBLE (r, x);
- REAL_VALUE_TO_TARGET_DOUBLE (r, sval);
+ REAL_VALUE_TO_TARGET_DOUBLE (*CONST_DOUBLE_REAL_VALUE (x), sval);
fprintf (file, "$%#lo", sval[0] >> 16);
}
else
@@ -1366,10 +1361,8 @@ output_block_move(rtx *operands)
int
legitimate_const_double_p (rtx address)
{
- REAL_VALUE_TYPE r;
long sval[2];
- REAL_VALUE_FROM_CONST_DOUBLE (r, address);
- REAL_VALUE_TO_TARGET_DOUBLE (r, sval);
+ REAL_VALUE_TO_TARGET_DOUBLE (*CONST_DOUBLE_REAL_VALUE (address), sval);
if ((sval[0] & 0xffff) == 0 && sval[1] == 0)
return 1;
return 0;
diff --git a/gcc/config/rs6000/rs6000.c b/gcc/config/rs6000/rs6000.c
index 3b4820b..c00d730 100644
--- a/gcc/config/rs6000/rs6000.c
+++ b/gcc/config/rs6000/rs6000.c
@@ -5325,24 +5325,20 @@ num_insns_constant (rtx op, machine_mode mode)
if (mode == SFmode || mode == SDmode)
{
long l;
- REAL_VALUE_TYPE rv;
- REAL_VALUE_FROM_CONST_DOUBLE (rv, op);
if (DECIMAL_FLOAT_MODE_P (mode))
- REAL_VALUE_TO_TARGET_DECIMAL32 (rv, l);
+ REAL_VALUE_TO_TARGET_DECIMAL32
+ (*CONST_DOUBLE_REAL_VALUE (op), l);
else
- REAL_VALUE_TO_TARGET_SINGLE (rv, l);
+ REAL_VALUE_TO_TARGET_SINGLE (*CONST_DOUBLE_REAL_VALUE (op), l);
return num_insns_constant_wide ((HOST_WIDE_INT) l);
}
long l[2];
- REAL_VALUE_TYPE rv;
-
- REAL_VALUE_FROM_CONST_DOUBLE (rv, op);
if (DECIMAL_FLOAT_MODE_P (mode))
- REAL_VALUE_TO_TARGET_DECIMAL64 (rv, l);
+ REAL_VALUE_TO_TARGET_DECIMAL64 (*CONST_DOUBLE_REAL_VALUE (op), l);
else
- REAL_VALUE_TO_TARGET_DOUBLE (rv, l);
+ REAL_VALUE_TO_TARGET_DOUBLE (*CONST_DOUBLE_REAL_VALUE (op), l);
high = l[WORDS_BIG_ENDIAN == 0];
low = l[WORDS_BIG_ENDIAN != 0];
@@ -20731,7 +20727,6 @@ rs6000_emit_cmove (rtx dest, rtx op, rtx true_cond, rtx
false_cond)
enum rtx_code code = GET_CODE (op);
rtx op0 = XEXP (op, 0);
rtx op1 = XEXP (op, 1);
- REAL_VALUE_TYPE c1;
machine_mode compare_mode = GET_MODE (op0);
machine_mode result_mode = GET_MODE (dest);
rtx temp;
@@ -20792,9 +20787,6 @@ rs6000_emit_cmove (rtx dest, rtx op, rtx true_cond, rtx
false_cond)
if (code == UNEQ && HONOR_NANS (compare_mode))
return 0;
- if (GET_CODE (op1) == CONST_DOUBLE)
- REAL_VALUE_FROM_CONST_DOUBLE (c1, op1);
-
/* We're going to try to implement comparisons by performing
a subtract, then comparing against zero. Unfortunately,
Inf - Inf is NaN which is not zero, and so if we don't
@@ -20802,7 +20794,8 @@ rs6000_emit_cmove (rtx dest, rtx op, rtx true_cond, rtx
false_cond)
would treat EQ different to UNORDERED, we can't do it. */
if (HONOR_INFINITIES (compare_mode)
&& code != GT && code != UNGE
- && (GET_CODE (op1) != CONST_DOUBLE || real_isinf (&c1))
+ && (GET_CODE (op1) != CONST_DOUBLE
+ || real_isinf (CONST_DOUBLE_REAL_VALUE (op1)))
/* Constructs of the form (a OP b ? a : b) are safe. */
&& ((! rtx_equal_p (op0, false_cond) && ! rtx_equal_p (op1, false_cond))
|| (! rtx_equal_p (op0, true_cond)
@@ -27103,14 +27096,12 @@ output_toc (FILE *file, rtx x, int labelno,
machine_mode mode)
(GET_MODE (x) == TFmode || GET_MODE (x) == TDmode
|| GET_MODE (x) == IFmode || GET_MODE (x) == KFmode))
{
- REAL_VALUE_TYPE rv;
long k[4];
- REAL_VALUE_FROM_CONST_DOUBLE (rv, x);
if (DECIMAL_FLOAT_MODE_P (GET_MODE (x)))
- REAL_VALUE_TO_TARGET_DECIMAL128 (rv, k);
+ REAL_VALUE_TO_TARGET_DECIMAL128 (*CONST_DOUBLE_REAL_VALUE (x), k);
else
- REAL_VALUE_TO_TARGET_LONG_DOUBLE (rv, k);
+ REAL_VALUE_TO_TARGET_LONG_DOUBLE (*CONST_DOUBLE_REAL_VALUE (x), k);
if (TARGET_64BIT)
{
@@ -27144,15 +27135,12 @@ output_toc (FILE *file, rtx x, int labelno,
machine_mode mode)
else if (GET_CODE (x) == CONST_DOUBLE &&
(GET_MODE (x) == DFmode || GET_MODE (x) == DDmode))
{
- REAL_VALUE_TYPE rv;
long k[2];
- REAL_VALUE_FROM_CONST_DOUBLE (rv, x);
-
if (DECIMAL_FLOAT_MODE_P (GET_MODE (x)))
- REAL_VALUE_TO_TARGET_DECIMAL64 (rv, k);
+ REAL_VALUE_TO_TARGET_DECIMAL64 (*CONST_DOUBLE_REAL_VALUE (x), k);
else
- REAL_VALUE_TO_TARGET_DOUBLE (rv, k);
+ REAL_VALUE_TO_TARGET_DOUBLE (*CONST_DOUBLE_REAL_VALUE (x), k);
if (TARGET_64BIT)
{
@@ -27181,14 +27169,12 @@ output_toc (FILE *file, rtx x, int labelno,
machine_mode mode)
else if (GET_CODE (x) == CONST_DOUBLE &&
(GET_MODE (x) == SFmode || GET_MODE (x) == SDmode))
{
- REAL_VALUE_TYPE rv;
long l;
- REAL_VALUE_FROM_CONST_DOUBLE (rv, x);
if (DECIMAL_FLOAT_MODE_P (GET_MODE (x)))
- REAL_VALUE_TO_TARGET_DECIMAL32 (rv, l);
+ REAL_VALUE_TO_TARGET_DECIMAL32 (*CONST_DOUBLE_REAL_VALUE (x), l);
else
- REAL_VALUE_TO_TARGET_SINGLE (rv, l);
+ REAL_VALUE_TO_TARGET_SINGLE (*CONST_DOUBLE_REAL_VALUE (x), l);
if (TARGET_64BIT)
{
diff --git a/gcc/config/rs6000/rs6000.md b/gcc/config/rs6000/rs6000.md
index df9d48e..cf40f10 100644
--- a/gcc/config/rs6000/rs6000.md
+++ b/gcc/config/rs6000/rs6000.md
@@ -6172,10 +6172,8 @@
"
{
long l;
- REAL_VALUE_TYPE rv;
- REAL_VALUE_FROM_CONST_DOUBLE (rv, operands[1]);
- <real_value_to_target> (rv, l);
+ <real_value_to_target> (*CONST_DOUBLE_REAL_VALUE (operands[1]), l);
if (! TARGET_POWERPC64)
operands[2] = operand_subword (operands[0], 0, 0, <MODE>mode);
@@ -6274,10 +6272,8 @@
{
int endian = (WORDS_BIG_ENDIAN == 0);
long l[2];
- REAL_VALUE_TYPE rv;
- REAL_VALUE_FROM_CONST_DOUBLE (rv, operands[1]);
- <real_value_to_target> (rv, l);
+ <real_value_to_target> (*CONST_DOUBLE_REAL_VALUE (operands[1]), l);
operands[2] = operand_subword (operands[0], endian, 0, <MODE>mode);
operands[3] = operand_subword (operands[0], 1 - endian, 0, <MODE>mode);
@@ -6298,11 +6294,9 @@
{
int endian = (WORDS_BIG_ENDIAN == 0);
long l[2];
- REAL_VALUE_TYPE rv;
HOST_WIDE_INT val;
- REAL_VALUE_FROM_CONST_DOUBLE (rv, operands[1]);
- <real_value_to_target> (rv, l);
+ <real_value_to_target> (*CONST_DOUBLE_REAL_VALUE (operands[1]), l);
operands[2] = gen_lowpart (DImode, operands[0]);
/* HIGHPART is lower memory address when WORDS_BIG_ENDIAN. */
diff --git a/gcc/config/rx/rx.c b/gcc/config/rx/rx.c
index 6d911d2..cee8c99 100644
--- a/gcc/config/rx/rx.c
+++ b/gcc/config/rx/rx.c
@@ -886,10 +886,8 @@ rx_print_operand (FILE * file, rtx op, int letter)
case CONST_DOUBLE:
{
unsigned long val;
- REAL_VALUE_TYPE rv;
- REAL_VALUE_FROM_CONST_DOUBLE (rv, op);
- REAL_VALUE_TO_TARGET_SINGLE (rv, val);
+ REAL_VALUE_TO_TARGET_SINGLE (*CONST_DOUBLE_REAL_VALUE (op), val);
if (print_hash)
fprintf (file, "#");
fprintf (file, TARGET_AS100_SYNTAX ? "0%lxH" : "0x%lx", val);
diff --git a/gcc/config/s390/s390.c b/gcc/config/s390/s390.c
index ad3132f..5ab6ce7 100644
--- a/gcc/config/s390/s390.c
+++ b/gcc/config/s390/s390.c
@@ -8719,16 +8719,13 @@ s390_chunkify_cancel (struct constant_pool *pool_list)
void
s390_output_pool_entry (rtx exp, machine_mode mode, unsigned int align)
{
- REAL_VALUE_TYPE r;
-
switch (GET_MODE_CLASS (mode))
{
case MODE_FLOAT:
case MODE_DECIMAL_FLOAT:
gcc_assert (GET_CODE (exp) == CONST_DOUBLE);
- REAL_VALUE_FROM_CONST_DOUBLE (r, exp);
- assemble_real (r, mode, align);
+ assemble_real (*CONST_DOUBLE_REAL_VALUE (exp), mode, align);
break;
case MODE_INT:
diff --git a/gcc/config/sh/sh.c b/gcc/config/sh/sh.c
index a0d2e16..92e9f9f 100644
--- a/gcc/config/sh/sh.c
+++ b/gcc/config/sh/sh.c
@@ -10000,26 +10000,23 @@ system_reg_operand (rtx op, machine_mode mode
ATTRIBUTE_UNUSED)
bool
fp_zero_operand (rtx op)
{
- REAL_VALUE_TYPE r;
+ const REAL_VALUE_TYPE *r;
if (GET_MODE (op) != SFmode)
return false;
- REAL_VALUE_FROM_CONST_DOUBLE (r, op);
- return real_equal (&r, &dconst0) && ! REAL_VALUE_MINUS_ZERO (r);
+ r = CONST_DOUBLE_REAL_VALUE (op);
+ return real_equal (r, &dconst0) && ! REAL_VALUE_MINUS_ZERO (*r);
}
/* Returns true if OP is a floating point value with value 1.0. */
bool
fp_one_operand (rtx op)
{
- REAL_VALUE_TYPE r;
-
if (GET_MODE (op) != SFmode)
return false;
- REAL_VALUE_FROM_CONST_DOUBLE (r, op);
- return real_equal (&r, &dconst1);
+ return real_equal (CONST_DOUBLE_REAL_VALUE (op), &dconst1);
}
/* Return the TLS type for TLS symbols. */
diff --git a/gcc/config/sh/sh.md b/gcc/config/sh/sh.md
index 3b56afb..e8d3e51 100644
--- a/gcc/config/sh/sh.md
+++ b/gcc/config/sh/sh.md
@@ -8011,10 +8011,8 @@ label:
{
int endian = WORDS_BIG_ENDIAN ? 1 : 0;
long values[2];
- REAL_VALUE_TYPE value;
- REAL_VALUE_FROM_CONST_DOUBLE (value, operands[1]);
- REAL_VALUE_TO_TARGET_DOUBLE (value, values);
+ REAL_VALUE_TO_TARGET_DOUBLE (*CONST_DOUBLE_REAL_VALUE (operands[1]), values);
if (HOST_BITS_PER_WIDE_INT >= 64)
operands[2] = immed_double_const ((unsigned long) values[endian]
@@ -8718,10 +8716,8 @@ label:
[(set (match_dup 3) (match_dup 2))]
{
long values;
- REAL_VALUE_TYPE value;
- REAL_VALUE_FROM_CONST_DOUBLE (value, operands[1]);
- REAL_VALUE_TO_TARGET_SINGLE (value, values);
+ REAL_VALUE_TO_TARGET_SINGLE (*CONST_DOUBLE_REAL_VALUE (operands[1]), values);
operands[2] = GEN_INT (values);
operands[3] = gen_rtx_REG (DImode, true_regnum (operands[0]));
@@ -12454,11 +12450,8 @@ label:
""
{
if (operands[1] != const0_rtx)
- {
- REAL_VALUE_TYPE d;
- REAL_VALUE_FROM_CONST_DOUBLE (d, operands[0]);
- assemble_real (d, SFmode, GET_MODE_ALIGNMENT (SFmode));
- }
+ assemble_real (*CONST_DOUBLE_REAL_VALUE (operands[0]),
+ SFmode, GET_MODE_ALIGNMENT (SFmode));
return "";
}
[(set_attr "length" "4")
@@ -12472,11 +12465,8 @@ label:
""
{
if (operands[1] != const0_rtx)
- {
- REAL_VALUE_TYPE d;
- REAL_VALUE_FROM_CONST_DOUBLE (d, operands[0]);
- assemble_real (d, DFmode, GET_MODE_ALIGNMENT (DFmode));
- }
+ assemble_real (*CONST_DOUBLE_REAL_VALUE (operands[0]),
+ DFmode, GET_MODE_ALIGNMENT (DFmode));
return "";
}
[(set_attr "length" "8")
diff --git a/gcc/config/sparc/sparc.c b/gcc/config/sparc/sparc.c
index a7fe546..a0adf22 100644
--- a/gcc/config/sparc/sparc.c
+++ b/gcc/config/sparc/sparc.c
@@ -1650,11 +1650,9 @@ fp_sethi_p (rtx op)
{
if (GET_CODE (op) == CONST_DOUBLE)
{
- REAL_VALUE_TYPE r;
long i;
- REAL_VALUE_FROM_CONST_DOUBLE (r, op);
- REAL_VALUE_TO_TARGET_SINGLE (r, i);
+ REAL_VALUE_TO_TARGET_SINGLE (*CONST_DOUBLE_REAL_VALUE (op), i);
return !SPARC_SIMM13_P (i) && SPARC_SETHI_P (i);
}
@@ -1670,11 +1668,9 @@ fp_mov_p (rtx op)
{
if (GET_CODE (op) == CONST_DOUBLE)
{
- REAL_VALUE_TYPE r;
long i;
- REAL_VALUE_FROM_CONST_DOUBLE (r, op);
- REAL_VALUE_TO_TARGET_SINGLE (r, i);
+ REAL_VALUE_TO_TARGET_SINGLE (*CONST_DOUBLE_REAL_VALUE (op), i);
return SPARC_SIMM13_P (i);
}
@@ -1693,11 +1689,9 @@ fp_high_losum_p (rtx op)
be moved using a single insn will do. */
if (GET_CODE (op) == CONST_DOUBLE)
{
- REAL_VALUE_TYPE r;
long i;
- REAL_VALUE_FROM_CONST_DOUBLE (r, op);
- REAL_VALUE_TO_TARGET_SINGLE (r, i);
+ REAL_VALUE_TO_TARGET_SINGLE (*CONST_DOUBLE_REAL_VALUE (op), i);
return !SPARC_SIMM13_P (i) && !SPARC_SETHI_P (i);
}
diff --git a/gcc/config/sparc/sparc.md b/gcc/config/sparc/sparc.md
index e01db51..de65cc6 100644
--- a/gcc/config/sparc/sparc.md
+++ b/gcc/config/sparc/sparc.md
@@ -2218,11 +2218,9 @@
|| which_alternative == 4
|| which_alternative == 5))
{
- REAL_VALUE_TYPE r;
long i;
- REAL_VALUE_FROM_CONST_DOUBLE (r, operands[1]);
- REAL_VALUE_TO_TARGET_SINGLE (r, i);
+ REAL_VALUE_TO_TARGET_SINGLE (*CONST_DOUBLE_REAL_VALUE (operands[1]), i);
operands[1] = GEN_INT (i);
}
@@ -2265,11 +2263,9 @@
(match_operand:SF 2 "fp_const_high_losum_operand" "S")))]
""
{
- REAL_VALUE_TYPE r;
long i;
- REAL_VALUE_FROM_CONST_DOUBLE (r, operands[2]);
- REAL_VALUE_TO_TARGET_SINGLE (r, i);
+ REAL_VALUE_TO_TARGET_SINGLE (*CONST_DOUBLE_REAL_VALUE (operands[2]), i);
operands[2] = GEN_INT (i);
return "or\t%1, %%lo(%a2), %0";
})
@@ -2279,11 +2275,9 @@
(high:SF (match_operand:SF 1 "fp_const_high_losum_operand" "S")))]
""
{
- REAL_VALUE_TYPE r;
long i;
- REAL_VALUE_FROM_CONST_DOUBLE (r, operands[1]);
- REAL_VALUE_TO_TARGET_SINGLE (r, i);
+ REAL_VALUE_TO_TARGET_SINGLE (*CONST_DOUBLE_REAL_VALUE (operands[1]), i);
operands[1] = GEN_INT (i);
return "sethi\t%%hi(%1), %0";
})
diff --git a/gcc/config/spu/spu.c b/gcc/config/spu/spu.c
index 62faff6..0ec9209 100644
--- a/gcc/config/spu/spu.c
+++ b/gcc/config/spu/spu.c
@@ -997,17 +997,12 @@ HOST_WIDE_INT
const_double_to_hwint (rtx x)
{
HOST_WIDE_INT val;
- REAL_VALUE_TYPE rv;
if (GET_MODE (x) == SFmode)
- {
- REAL_VALUE_FROM_CONST_DOUBLE (rv, x);
- REAL_VALUE_TO_TARGET_SINGLE (rv, val);
- }
+ REAL_VALUE_TO_TARGET_SINGLE (*CONST_DOUBLE_REAL_VALUE (x), val);
else if (GET_MODE (x) == DFmode)
{
long l[2];
- REAL_VALUE_FROM_CONST_DOUBLE (rv, x);
- REAL_VALUE_TO_TARGET_DOUBLE (rv, l);
+ REAL_VALUE_TO_TARGET_DOUBLE (*CONST_DOUBLE_REAL_VALUE (x), l);
val = l[0];
val = (val << 32) | (l[1] & 0xffffffff);
}
diff --git a/gcc/config/v850/v850.c b/gcc/config/v850/v850.c
index a03f5e2..839e42f 100644
--- a/gcc/config/v850/v850.c
+++ b/gcc/config/v850/v850.c
@@ -277,20 +277,17 @@ const_double_split (rtx x, HOST_WIDE_INT * p_high,
HOST_WIDE_INT * p_low)
if (GET_CODE (x) == CONST_DOUBLE)
{
long t[2];
- REAL_VALUE_TYPE rv;
switch (GET_MODE (x))
{
case DFmode:
- REAL_VALUE_FROM_CONST_DOUBLE (rv, x);
- REAL_VALUE_TO_TARGET_DOUBLE (rv, t);
+ REAL_VALUE_TO_TARGET_DOUBLE (*CONST_DOUBLE_REAL_VALUE (x), t);
*p_high = t[1]; /* since v850 is little endian */
*p_low = t[0]; /* high is second word */
return;
case SFmode:
- REAL_VALUE_FROM_CONST_DOUBLE (rv, x);
- REAL_VALUE_TO_TARGET_SINGLE (rv, *p_high);
+ REAL_VALUE_TO_TARGET_SINGLE (*CONST_DOUBLE_REAL_VALUE (x), *p_high);
*p_low = 0;
return;
diff --git a/gcc/config/vax/vax.c b/gcc/config/vax/vax.c
index 2ad0e0ad..5ab6ab1 100644
--- a/gcc/config/vax/vax.c
+++ b/gcc/config/vax/vax.c
@@ -640,7 +640,8 @@ static bool
vax_float_literal (rtx c)
{
machine_mode mode;
- REAL_VALUE_TYPE r, s;
+ const REAL_VALUE_TYPE *r;
+ REAL_VALUE_TYPE s;
int i;
if (GET_CODE (c) != CONST_DOUBLE)
@@ -653,7 +654,7 @@ vax_float_literal (rtx c)
|| c == const_tiny_rtx[(int) mode][2])
return true;
- REAL_VALUE_FROM_CONST_DOUBLE (r, c);
+ r = CONST_DOUBLE_REAL_VALUE (c);
for (i = 0; i < 7; i++)
{
@@ -661,11 +662,11 @@ vax_float_literal (rtx c)
bool ok;
real_from_integer (&s, mode, x, SIGNED);
- if (real_equal (&r, &s))
+ if (real_equal (r, &s))
return true;
ok = exact_real_inverse (mode, &s);
gcc_assert (ok);
- if (real_equal (&r, &s))
+ if (real_equal (r, &s))
return true;
}
return false;
diff --git a/gcc/config/visium/visium.c b/gcc/config/visium/visium.c
index 41b7964..d399a63 100644
--- a/gcc/config/visium/visium.c
+++ b/gcc/config/visium/visium.c
@@ -2039,9 +2039,7 @@ visium_expand_copysign (rtx *operands, enum machine_mode
mode)
if (op0 != CONST0_RTX (mode))
{
long l;
- REAL_VALUE_TYPE rv;
- REAL_VALUE_FROM_CONST_DOUBLE (rv, op0);
- REAL_VALUE_TO_TARGET_SINGLE (rv, l);
+ REAL_VALUE_TO_TARGET_SINGLE (*CONST_DOUBLE_REAL_VALUE (op0), l);
op0 = force_reg (SImode, GEN_INT (trunc_int_for_mode (l, SImode)));
}
}
diff --git a/gcc/config/visium/visium.md b/gcc/config/visium/visium.md
index 370b6a4..dab265d 100644
--- a/gcc/config/visium/visium.md
+++ b/gcc/config/visium/visium.md
@@ -687,10 +687,8 @@
[(set (match_dup 2) (match_dup 3))]
{
long l;
- REAL_VALUE_TYPE rv;
- REAL_VALUE_FROM_CONST_DOUBLE (rv, operands[1]);
- REAL_VALUE_TO_TARGET_SINGLE (rv, l);
+ REAL_VALUE_TO_TARGET_SINGLE (*CONST_DOUBLE_REAL_VALUE (operands[1]), l);
operands[2] = operand_subword (operands[0], 0, 0, SFmode);
operands[3] = GEN_INT (trunc_int_for_mode (l, SImode));
diff --git a/gcc/config/xtensa/predicates.md b/gcc/config/xtensa/predicates.md
index e297b82..00f2370 100644
--- a/gcc/config/xtensa/predicates.md
+++ b/gcc/config/xtensa/predicates.md
@@ -150,9 +150,7 @@
(define_predicate "const_float_1_operand"
(match_code "const_double")
{
- REAL_VALUE_TYPE d;
- REAL_VALUE_FROM_CONST_DOUBLE (d, op);
- return real_equal (&d, &dconst1);
+ return real_equal (CONST_DOUBLE_REAL_VALUE (op), &dconst1);
})
(define_predicate "fpmem_offset_operand"
diff --git a/gcc/config/xtensa/xtensa.c b/gcc/config/xtensa/xtensa.c
index 1e1ac6b..1d58311 100644
--- a/gcc/config/xtensa/xtensa.c
+++ b/gcc/config/xtensa/xtensa.c
@@ -2397,12 +2397,10 @@ print_operand (FILE *file, rtx x, int letter)
}
else if (GET_CODE (x) == CONST_DOUBLE)
{
- REAL_VALUE_TYPE r;
- REAL_VALUE_FROM_CONST_DOUBLE (r, x);
if (GET_MODE (x) == SFmode)
{
long l;
- REAL_VALUE_TO_TARGET_SINGLE (r, l);
+ REAL_VALUE_TO_TARGET_SINGLE (*CONST_DOUBLE_REAL_VALUE (x), l);
fprintf (file, "0x%08lx@%c", l, letter == 't' ? 'h' : 'l');
}
else
@@ -2436,10 +2434,8 @@ print_operand (FILE *file, rtx x, int letter)
if (GET_CODE (x) == CONST_DOUBLE &&
GET_MODE (x) == SFmode)
{
- REAL_VALUE_TYPE r;
long l;
- REAL_VALUE_FROM_CONST_DOUBLE (r, x);
- REAL_VALUE_TO_TARGET_SINGLE (r, l);
+ REAL_VALUE_TO_TARGET_SINGLE (*CONST_DOUBLE_REAL_VALUE (x), l);
fprintf (file, "0x%08lx", l);
break;
}
@@ -2555,7 +2551,6 @@ void
xtensa_output_literal (FILE *file, rtx x, machine_mode mode, int labelno)
{
long value_long[2];
- REAL_VALUE_TYPE r;
int size;
rtx first, second;
@@ -2566,18 +2561,19 @@ xtensa_output_literal (FILE *file, rtx x, machine_mode
mode, int labelno)
case MODE_FLOAT:
gcc_assert (GET_CODE (x) == CONST_DOUBLE);
- REAL_VALUE_FROM_CONST_DOUBLE (r, x);
switch (mode)
{
case SFmode:
- REAL_VALUE_TO_TARGET_SINGLE (r, value_long[0]);
+ REAL_VALUE_TO_TARGET_SINGLE (*CONST_DOUBLE_REAL_VALUE (x),
+ value_long[0]);
if (HOST_BITS_PER_LONG > 32)
value_long[0] &= 0xffffffff;
fprintf (file, "0x%08lx\n", value_long[0]);
break;
case DFmode:
- REAL_VALUE_TO_TARGET_DOUBLE (r, value_long);
+ REAL_VALUE_TO_TARGET_DOUBLE (*CONST_DOUBLE_REAL_VALUE (x),
+ value_long);
if (HOST_BITS_PER_LONG > 32)
{
value_long[0] &= 0xffffffff;
diff --git a/gcc/cprop.c b/gcc/cprop.c
index aa23a07..4cb8586 100644
--- a/gcc/cprop.c
+++ b/gcc/cprop.c
@@ -1351,13 +1351,9 @@ implicit_set_cond_p (const_rtx cond)
the optimization can't be performed. */
/* ??? The complex and vector checks are not implemented yet. We just
always return zero for them. */
- if (CONST_DOUBLE_AS_FLOAT_P (cst))
- {
- REAL_VALUE_TYPE d;
- REAL_VALUE_FROM_CONST_DOUBLE (d, cst);
- if (real_equal (&d, &dconst0))
- return 0;
- }
+ if (CONST_DOUBLE_AS_FLOAT_P (cst)
+ && real_equal (CONST_DOUBLE_REAL_VALUE (cst), &dconst0))
+ return 0;
else
return 0;
}
diff --git a/gcc/dwarf2out.c b/gcc/dwarf2out.c
index 66c1c4c..e438718 100644
--- a/gcc/dwarf2out.c
+++ b/gcc/dwarf2out.c
@@ -15574,12 +15574,10 @@ insert_wide_int (const wide_int &val, unsigned char
*dest, int elt_size)
static void
insert_float (const_rtx rtl, unsigned char *array)
{
- REAL_VALUE_TYPE rv;
long val[4];
int i;
- REAL_VALUE_FROM_CONST_DOUBLE (rv, rtl);
- real_to_target (val, &rv, GET_MODE (rtl));
+ real_to_target (val, CONST_DOUBLE_REAL_VALUE (rtl), GET_MODE (rtl));
/* real_to_target puts 32-bit pieces in each long. Pack them. */
for (i = 0; i < GET_MODE_SIZE (GET_MODE (rtl)) / 4; i++)
diff --git a/gcc/expmed.c b/gcc/expmed.c
index 07578e7..93cf508 100644
--- a/gcc/expmed.c
+++ b/gcc/expmed.c
@@ -3234,17 +3234,12 @@ expand_mult (machine_mode mode, rtx op0, rtx op1, rtx
target,
skip_synth:
/* Expand x*2.0 as x+x. */
- if (CONST_DOUBLE_AS_FLOAT_P (scalar_op1))
+ if (CONST_DOUBLE_AS_FLOAT_P (scalar_op1)
+ && real_equal (CONST_DOUBLE_REAL_VALUE (scalar_op1), &dconst2))
{
- REAL_VALUE_TYPE d;
- REAL_VALUE_FROM_CONST_DOUBLE (d, scalar_op1);
-
- if (real_equal (&d, &dconst2))
- {
- op0 = force_reg (GET_MODE (op0), op0);
- return expand_binop (mode, add_optab, op0, op0,
- target, unsignedp, OPTAB_LIB_WIDEN);
- }
+ op0 = force_reg (GET_MODE (op0), op0);
+ return expand_binop (mode, add_optab, op0, op0,
+ target, unsignedp, OPTAB_LIB_WIDEN);
}
/* This used to use umul_optab if unsigned, but for non-widening multiply
@@ -4997,12 +4992,7 @@ make_tree (tree type, rtx x)
wide_int::from_array (&CONST_DOUBLE_LOW (x), 2,
HOST_BITS_PER_WIDE_INT *
2));
else
- {
- REAL_VALUE_TYPE d;
-
- REAL_VALUE_FROM_CONST_DOUBLE (d, x);
- t = build_real (type, d);
- }
+ t = build_real (type, *CONST_DOUBLE_REAL_VALUE (x));
return t;
diff --git a/gcc/expr.c b/gcc/expr.c
index 6bb24c0..6498a63 100644
--- a/gcc/expr.c
+++ b/gcc/expr.c
@@ -3626,11 +3626,11 @@ compress_float_constant (rtx x, rtx y)
machine_mode dstmode = GET_MODE (x);
machine_mode orig_srcmode = GET_MODE (y);
machine_mode srcmode;
- REAL_VALUE_TYPE r;
+ const REAL_VALUE_TYPE *r;
int oldcost, newcost;
bool speed = optimize_insn_for_speed_p ();
- REAL_VALUE_FROM_CONST_DOUBLE (r, y);
+ r = CONST_DOUBLE_REAL_VALUE (y);
if (targetm.legitimate_constant_p (dstmode, y))
oldcost = set_src_cost (y, orig_srcmode, speed);
@@ -3651,10 +3651,10 @@ compress_float_constant (rtx x, rtx y)
continue;
/* Skip if the narrowed value isn't exact. */
- if (! exact_real_truncate (srcmode, &r))
+ if (! exact_real_truncate (srcmode, r))
continue;
- trunc_y = const_double_from_real_value (r, srcmode);
+ trunc_y = const_double_from_real_value (*r, srcmode);
if (targetm.legitimate_constant_p (srcmode, trunc_y))
{
diff --git a/gcc/real.h b/gcc/real.h
index 24fb18d..1497279 100644
--- a/gcc/real.h
+++ b/gcc/real.h
@@ -426,10 +426,6 @@ extern const REAL_VALUE_TYPE * dconst_sqrt2_ptr (void);
from a given integer constant. */
REAL_VALUE_TYPE real_value_from_int_cst (const_tree, const_tree);
-/* Given a CONST_DOUBLE in FROM, store into TO the value it represents. */
-#define REAL_VALUE_FROM_CONST_DOUBLE(to, from) \
- ((to) = *CONST_DOUBLE_REAL_VALUE (from))
-
/* Return a CONST_DOUBLE with value R and mode M. */
extern rtx const_double_from_real_value (REAL_VALUE_TYPE, machine_mode);
diff --git a/gcc/rtlanal.c b/gcc/rtlanal.c
index 815fc49..23b2c45 100644
--- a/gcc/rtlanal.c
+++ b/gcc/rtlanal.c
@@ -5785,15 +5785,13 @@ split_double (rtx value, rtx *first, rtx *second)
}
else
{
- REAL_VALUE_TYPE r;
long l[2];
- REAL_VALUE_FROM_CONST_DOUBLE (r, value);
/* Note, this converts the REAL_VALUE_TYPE to the target's
format, splits up the floating point double and outputs
exactly 32 bits of it into each of l[0] and l[1] --
not necessarily BITS_PER_WORD bits. */
- REAL_VALUE_TO_TARGET_DOUBLE (r, l);
+ REAL_VALUE_TO_TARGET_DOUBLE (*CONST_DOUBLE_REAL_VALUE (value), l);
/* If 32 bits is an entire word for the target, but not for the host,
then sign-extend on the host so that the number will look the same
diff --git a/gcc/simplify-rtx.c b/gcc/simplify-rtx.c
index 84a4bad..1f91afc 100644
--- a/gcc/simplify-rtx.c
+++ b/gcc/simplify-rtx.c
@@ -224,12 +224,8 @@ avoid_constant_pool_reference (rtx x)
tmp = XEXP (x, 0);
c = avoid_constant_pool_reference (tmp);
if (c != tmp && CONST_DOUBLE_AS_FLOAT_P (c))
- {
- REAL_VALUE_TYPE d;
-
- REAL_VALUE_FROM_CONST_DOUBLE (d, c);
- return const_double_from_real_value (d, GET_MODE (x));
- }
+ return const_double_from_real_value (*CONST_DOUBLE_REAL_VALUE (c),
+ GET_MODE (x));
return x;
default:
@@ -1793,9 +1789,7 @@ simplify_const_unary_operation (enum rtx_code code,
machine_mode mode,
&& SCALAR_FLOAT_MODE_P (mode)
&& SCALAR_FLOAT_MODE_P (GET_MODE (op)))
{
- REAL_VALUE_TYPE d;
- REAL_VALUE_FROM_CONST_DOUBLE (d, op);
-
+ REAL_VALUE_TYPE d = *CONST_DOUBLE_REAL_VALUE (op);
switch (code)
{
case SQRT:
@@ -1846,8 +1840,8 @@ simplify_const_unary_operation (enum rtx_code code,
machine_mode mode,
/* This was formerly used only for non-IEEE float.
egg...@twinsun.com says it is safe for IEEE also. */
- REAL_VALUE_TYPE x, t;
- REAL_VALUE_FROM_CONST_DOUBLE (x, op);
+ REAL_VALUE_TYPE t;
+ const REAL_VALUE_TYPE *x = CONST_DOUBLE_REAL_VALUE (op);
wide_int wmax, wmin;
/* This is part of the abi to real_to_integer, but we check
things before making this call. */
@@ -1856,37 +1850,36 @@ simplify_const_unary_operation (enum rtx_code code,
machine_mode mode,
switch (code)
{
case FIX:
- if (REAL_VALUE_ISNAN (x))
+ if (REAL_VALUE_ISNAN (*x))
return const0_rtx;
/* Test against the signed upper bound. */
wmax = wi::max_value (width, SIGNED);
real_from_integer (&t, VOIDmode, wmax, SIGNED);
- if (real_less (&t, &x))
+ if (real_less (&t, x))
return immed_wide_int_const (wmax, mode);
/* Test against the signed lower bound. */
wmin = wi::min_value (width, SIGNED);
real_from_integer (&t, VOIDmode, wmin, SIGNED);
- if (real_less (&x, &t))
+ if (real_less (x, &t))
return immed_wide_int_const (wmin, mode);
- return immed_wide_int_const (real_to_integer (&x, &fail, width),
mode);
- break;
+ return immed_wide_int_const (real_to_integer (x, &fail, width),
+ mode);
case UNSIGNED_FIX:
- if (REAL_VALUE_ISNAN (x) || REAL_VALUE_NEGATIVE (x))
+ if (REAL_VALUE_ISNAN (*x) || REAL_VALUE_NEGATIVE (*x))
return const0_rtx;
/* Test against the unsigned upper bound. */
wmax = wi::max_value (width, UNSIGNED);
real_from_integer (&t, VOIDmode, wmax, UNSIGNED);
- if (real_less (&t, &x))
+ if (real_less (&t, x))
return immed_wide_int_const (wmax, mode);
- return immed_wide_int_const (real_to_integer (&x, &fail, width),
+ return immed_wide_int_const (real_to_integer (x, &fail, width),
mode);
- break;
default:
gcc_unreachable ();
@@ -2469,14 +2462,13 @@ simplify_binary_operation_1 (enum rtx_code code,
machine_mode mode,
&& !DECIMAL_FLOAT_MODE_P (GET_MODE (trueop1))
&& GET_MODE (op0) == mode)
{
- REAL_VALUE_TYPE d;
- REAL_VALUE_FROM_CONST_DOUBLE (d, trueop1);
+ const REAL_VALUE_TYPE *d1 = CONST_DOUBLE_REAL_VALUE (trueop1);
- if (real_equal (&d, &dconst2))
+ if (real_equal (d1, &dconst2))
return simplify_gen_binary (PLUS, mode, op0, copy_rtx (op0));
if (!HONOR_SNANS (mode)
- && real_equal (&d, &dconstm1))
+ && real_equal (d1, &dconstm1))
return simplify_gen_unary (NEG, mode, op0, mode);
}
@@ -3098,20 +3090,20 @@ simplify_binary_operation_1 (enum rtx_code code,
machine_mode mode,
if (CONST_DOUBLE_AS_FLOAT_P (trueop1)
&& trueop1 != CONST0_RTX (mode))
{
- REAL_VALUE_TYPE d;
- REAL_VALUE_FROM_CONST_DOUBLE (d, trueop1);
+ const REAL_VALUE_TYPE *d1 = CONST_DOUBLE_REAL_VALUE (trueop1);
/* x/-1.0 is -x. */
- if (real_equal (&d, &dconstm1)
+ if (real_equal (d1, &dconstm1)
&& !HONOR_SNANS (mode))
return simplify_gen_unary (NEG, mode, op0, mode);
/* Change FP division by a constant into multiplication.
Only do this with -freciprocal-math. */
if (flag_reciprocal_math
- && !real_equal (&d, &dconst0))
+ && !real_equal (d1, &dconst0))
{
- real_arithmetic (&d, RDIV_EXPR, &dconst1, &d);
+ REAL_VALUE_TYPE d;
+ real_arithmetic (&d, RDIV_EXPR, &dconst1, d1);
tem = const_double_from_real_value (d, mode);
return simplify_gen_binary (MULT, mode, op0, tem);
}
@@ -3862,10 +3854,8 @@ simplify_const_binary_operation (enum rtx_code code,
machine_mode mode,
REAL_VALUE_TYPE f0, f1, value, result;
bool inexact;
- REAL_VALUE_FROM_CONST_DOUBLE (f0, op0);
- REAL_VALUE_FROM_CONST_DOUBLE (f1, op1);
- real_convert (&f0, mode, &f0);
- real_convert (&f1, mode, &f1);
+ real_convert (&f0, mode, CONST_DOUBLE_REAL_VALUE (op0));
+ real_convert (&f1, mode, CONST_DOUBLE_REAL_VALUE (op1));
if (HONOR_SNANS (mode)
&& (REAL_VALUE_ISNAN (f0) || REAL_VALUE_ISNAN (f1)))
@@ -4912,13 +4902,11 @@ simplify_const_relational_operation (enum rtx_code code,
&& CONST_DOUBLE_AS_FLOAT_P (trueop1)
&& SCALAR_FLOAT_MODE_P (GET_MODE (trueop0)))
{
- REAL_VALUE_TYPE d0, d1;
-
- REAL_VALUE_FROM_CONST_DOUBLE (d0, trueop0);
- REAL_VALUE_FROM_CONST_DOUBLE (d1, trueop1);
+ const REAL_VALUE_TYPE *d0 = CONST_DOUBLE_REAL_VALUE (trueop0);
+ const REAL_VALUE_TYPE *d1 = CONST_DOUBLE_REAL_VALUE (trueop1);
/* Comparisons are unordered iff at least one of the values is NaN. */
- if (REAL_VALUE_ISNAN (d0) || REAL_VALUE_ISNAN (d1))
+ if (REAL_VALUE_ISNAN (*d0) || REAL_VALUE_ISNAN (*d1))
switch (code)
{
case UNEQ:
@@ -4942,8 +4930,8 @@ simplify_const_relational_operation (enum rtx_code code,
}
return comparison_result (code,
- (real_equal (&d0, &d1) ? CMP_EQ :
- real_less (&d0, &d1) ? CMP_LT : CMP_GT));
+ (real_equal (d0, d1) ? CMP_EQ :
+ real_less (d0, d1) ? CMP_LT : CMP_GT));
}
/* Otherwise, see if the operands are both integers. */
diff --git a/gcc/varasm.c b/gcc/varasm.c
index a5bb2b5..48c3662 100644
--- a/gcc/varasm.c
+++ b/gcc/varasm.c
@@ -3841,11 +3841,8 @@ output_constant_pool_2 (machine_mode mode, rtx x,
unsigned int align)
case MODE_FLOAT:
case MODE_DECIMAL_FLOAT:
{
- REAL_VALUE_TYPE r;
-
gcc_assert (CONST_DOUBLE_AS_FLOAT_P (x));
- REAL_VALUE_FROM_CONST_DOUBLE (r, x);
- assemble_real (r, mode, align);
+ assemble_real (*CONST_DOUBLE_REAL_VALUE (x), mode, align);
break;
}
