git
/
gcc
mirror of git://gcc.gnu.org/git/gcc.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

cfgexpand.c (expand_debug_locations): Encapsulate test for CONST_DOUBLE in macro. 

2012-08-02  Kenneth Zadeck <zadeck@naturalbridge.com>

	* cfgexpand.c (expand_debug_locations):  Encapsulate test for
	CONST_DOUBLE in macro.
	* combine.c (try_combine, gen_lowpart_for_combine): Ditto.
	* cprop.c (implicit_set_cond_p): Ditto.
	* cselib.c (rtx_equal_for_cselib_1): Ditto.
	* expmed.c (expand_mult): Ditto.
	* expr.c (convert_modes): Ditto.
	* ira-costs.c (record_reg_classes): Ditto.
	* ira-lives.c (single_reg_class): Ditto.
	* optabs.c (expand_copysign_absneg, expand_copysign): Ditto.
	* print-rtl.c (print_rtx): Ditto.
	* recog.c (simplify_while_replacing, const_double_operand)
	(asm_operand_ok, constrain_operands): Ditto.
	* reg-stack.c (subst_stack_regs_pat): Ditto.
	* reload.c (find_reloads, find_equiv_reg): Ditto.
	* rtlanal.c (replace_rtx): Remove test.
	* rtlanal.c (constant_pool_constant_p, split_double): Encapsulate test for
	CONST_DOUBLE in macro.
	* simplify-rtx.c (mode_signbit_p, avoid_constant_pool_reference)
	(simplify_unary_operation_1, simplify_const_unary_operation)
	(simplify_binary_operation_1, simplify_const_binary_operation)
	(simplify_relational_operation_1)
	(simplify_const_relational_operations)
	(implify_subreg): Ditto.
	* varasm.c (output_constant_pool_2): Ditto.
	* rtl.h (CONST_DOUBLE_AS_INT_P, CONST_DOUBLE_AS_FLOAT_P): New
	macros.
	* rtl.def (CONST_DOUBLE):  Updated comments.

From-SVN: r190105
This commit is contained in:
Kenneth Zadeck 2012-08-02 22:39:57 +00:00 committed by Kenneth Zadeck
parent 36be1dee1d
commit 481755378d
20 changed files with 136 additions and 136 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

31
gcc/ChangeLog
View File

@ -1,3 +1,34 @@
2012-08-02 Kenneth Zadeck <zadeck@naturalbridge.com>
* cfgexpand.c (expand_debug_locations): Encapsulate test for
CONST_DOUBLE in macro.
* combine.c (try_combine, gen_lowpart_for_combine): Ditto.
* cprop.c (implicit_set_cond_p): Ditto.
* cselib.c (rtx_equal_for_cselib_1): Ditto.
* expmed.c (expand_mult): Ditto.
* expr.c (convert_modes): Ditto.
* ira-costs.c (record_reg_classes): Ditto.
* ira-lives.c (single_reg_class): Ditto.
* optabs.c (expand_copysign_absneg, expand_copysign): Ditto.
* print-rtl.c (print_rtx): Ditto.
* recog.c (simplify_while_replacing, const_double_operand)
(asm_operand_ok, constrain_operands): Ditto.
* reg-stack.c (subst_stack_regs_pat): Ditto.
* reload.c (find_reloads, find_equiv_reg): Ditto.
* rtlanal.c (replace_rtx): Remove test.
* rtlanal.c (constant_pool_constant_p, split_double): Encapsulate test for
CONST_DOUBLE in macro.
* simplify-rtx.c (mode_signbit_p, avoid_constant_pool_reference)
(simplify_unary_operation_1, simplify_const_unary_operation)
(simplify_binary_operation_1, simplify_const_binary_operation)
(simplify_relational_operation_1)
(simplify_const_relational_operations)
(implify_subreg): Ditto.
* varasm.c (output_constant_pool_2): Ditto.
* rtl.h (CONST_DOUBLE_AS_INT_P, CONST_DOUBLE_AS_FLOAT_P): New
macros.
* rtl.def (CONST_DOUBLE): Updated comments.
2012-08-02 Richard Sandiford <rdsandiford@googlemail.com> 2012-08-02 Richard Sandiford <rdsandiford@googlemail.com>
PR target/51931 PR target/51931

2
gcc/cfgexpand.c
View File

@ -3627,7 +3627,7 @@ expand_debug_locations (void)
|| (GET_MODE (val) == VOIDmode || (GET_MODE (val) == VOIDmode
&& (CONST_INT_P (val) && (CONST_INT_P (val)
|| GET_CODE (val) == CONST_FIXED || GET_CODE (val) == CONST_FIXED
|| GET_CODE (val) == CONST_DOUBLE || CONST_DOUBLE_AS_INT_P (val)
|| GET_CODE (val) == LABEL_REF))); || GET_CODE (val) == LABEL_REF)));
} }

14
gcc/combine.c
View File

@ -2620,10 +2620,10 @@ try_combine (rtx i3, rtx i2, rtx i1, rtx i0, int *new_direct_jump_p,
if (i1 == 0 if (i1 == 0
&& (temp = single_set (i2)) != 0 && (temp = single_set (i2)) != 0
&& (CONST_INT_P (SET_SRC (temp)) && (CONST_INT_P (SET_SRC (temp))
|| GET_CODE (SET_SRC (temp)) == CONST_DOUBLE) || CONST_DOUBLE_AS_INT_P (SET_SRC (temp)))
&& GET_CODE (PATTERN (i3)) == SET && GET_CODE (PATTERN (i3)) == SET
&& (CONST_INT_P (SET_SRC (PATTERN (i3))) && (CONST_INT_P (SET_SRC (PATTERN (i3)))
|| GET_CODE (SET_SRC (PATTERN (i3))) == CONST_DOUBLE) || CONST_DOUBLE_AS_INT_P (SET_SRC (PATTERN (i3))))
&& reg_subword_p (SET_DEST (PATTERN (i3)), SET_DEST (temp))) && reg_subword_p (SET_DEST (PATTERN (i3)), SET_DEST (temp)))
{ {
rtx dest = SET_DEST (PATTERN (i3)); rtx dest = SET_DEST (PATTERN (i3));
@ -5105,8 +5105,7 @@ subst (rtx x, rtx from, rtx to, int in_dest, int in_cond, int unique_copy)
return new_rtx; return new_rtx;
if (GET_CODE (x) == SUBREG if (GET_CODE (x) == SUBREG
&& (CONST_INT_P (new_rtx) && (CONST_INT_P (new_rtx) || CONST_DOUBLE_AS_INT_P (new_rtx)))
|| GET_CODE (new_rtx) == CONST_DOUBLE))
{ {
enum machine_mode mode = GET_MODE (x); enum machine_mode mode = GET_MODE (x);
@ -7134,8 +7133,7 @@ make_extraction (enum machine_mode mode, rtx inner, HOST_WIDE_INT pos,
if (mode == tmode) if (mode == tmode)
return new_rtx; return new_rtx;
if (CONST_INT_P (new_rtx) if (CONST_INT_P (new_rtx) || CONST_DOUBLE_AS_INT_P (new_rtx))
|| GET_CODE (new_rtx) == CONST_DOUBLE)
return simplify_unary_operation (unsignedp ? ZERO_EXTEND : SIGN_EXTEND, return simplify_unary_operation (unsignedp ? ZERO_EXTEND : SIGN_EXTEND,
mode, new_rtx, tmode); mode, new_rtx, tmode);
@ -10646,9 +10644,7 @@ gen_lowpart_for_combine (enum machine_mode omode, rtx x)
/* We can only support MODE being wider than a word if X is a /* We can only support MODE being wider than a word if X is a
constant integer or has a mode the same size. */ constant integer or has a mode the same size. */
if (GET_MODE_SIZE (omode) > UNITS_PER_WORD if (GET_MODE_SIZE (omode) > UNITS_PER_WORD
&& ! ((imode == VOIDmode && ! ((CONST_INT_P (x) || CONST_DOUBLE_AS_INT_P (x))
&& (CONST_INT_P (x)
|| GET_CODE (x) == CONST_DOUBLE))
|| isize == osize)) || isize == osize))
goto fail; goto fail;

2
gcc/cprop.c
View File

@ -1327,7 +1327,7 @@ implicit_set_cond_p (const_rtx cond)
the optimization can't be performed. */ the optimization can't be performed. */
/* ??? The complex and vector checks are not implemented yet. We just /* ??? The complex and vector checks are not implemented yet. We just
always return zero for them. */ always return zero for them. */
if (GET_CODE (cst) == CONST_DOUBLE) if (CONST_DOUBLE_AS_FLOAT_P (cst))
{ {
REAL_VALUE_TYPE d; REAL_VALUE_TYPE d;
REAL_VALUE_FROM_CONST_DOUBLE (d, cst); REAL_VALUE_FROM_CONST_DOUBLE (d, cst);

5
gcc/cselib.c
View File

@ -1009,8 +1009,9 @@ rtx_equal_for_cselib_1 (rtx x, rtx y, enum machine_mode memmode)
static rtx static rtx
wrap_constant (enum machine_mode mode, rtx x) wrap_constant (enum machine_mode mode, rtx x)
{ {
if (!CONST_INT_P (x) && GET_CODE (x) != CONST_FIXED if (!CONST_INT_P (x)
&& (GET_CODE (x) != CONST_DOUBLE || GET_MODE (x) != VOIDmode)) && GET_CODE (x) != CONST_FIXED
&& !CONST_DOUBLE_AS_INT_P (x))
return x; return x;
gcc_assert (mode != VOIDmode); gcc_assert (mode != VOIDmode);
return gen_rtx_CONST (mode, x); return gen_rtx_CONST (mode, x);

4
gcc/emit-rtl.c
View File

@ -491,7 +491,7 @@ rtx_to_double_int (const_rtx cst)
if (CONST_INT_P (cst)) if (CONST_INT_P (cst))
r = shwi_to_double_int (INTVAL (cst)); r = shwi_to_double_int (INTVAL (cst));
else if (CONST_DOUBLE_P (cst) && GET_MODE (cst) == VOIDmode) else if (CONST_DOUBLE_AS_INT_P (cst))
{ {
r.low = CONST_DOUBLE_LOW (cst); r.low = CONST_DOUBLE_LOW (cst);
r.high = CONST_DOUBLE_HIGH (cst); r.high = CONST_DOUBLE_HIGH (cst);
@ -1244,7 +1244,7 @@ gen_lowpart_common (enum machine_mode mode, rtx x)
} }
else if (GET_CODE (x) == SUBREG || REG_P (x) else if (GET_CODE (x) == SUBREG || REG_P (x)
|| GET_CODE (x) == CONCAT || GET_CODE (x) == CONST_VECTOR || GET_CODE (x) == CONCAT || GET_CODE (x) == CONST_VECTOR
|| GET_CODE (x) == CONST_DOUBLE || CONST_INT_P (x)) || CONST_DOUBLE_P (x) || CONST_INT_P (x))
return simplify_gen_subreg (mode, x, innermode, offset); return simplify_gen_subreg (mode, x, innermode, offset);
/* Otherwise, we can't do this. */ /* Otherwise, we can't do this. */

4
gcc/expmed.c
View File

@ -3217,7 +3217,7 @@ expand_mult (enum machine_mode mode, rtx op0, rtx op1, rtx target,
coeff = INTVAL (scalar_op1); coeff = INTVAL (scalar_op1);
is_neg = coeff < 0; is_neg = coeff < 0;
} }
else if (CONST_DOUBLE_P (scalar_op1)) else if (CONST_DOUBLE_AS_INT_P (scalar_op1))
{ {
/* If we are multiplying in DImode, it may still be a win /* If we are multiplying in DImode, it may still be a win
to try to work with shifts and adds. */ to try to work with shifts and adds. */
@ -3290,7 +3290,7 @@ expand_mult (enum machine_mode mode, rtx op0, rtx op1, rtx target,
skip_synth: skip_synth:
/* Expand x*2.0 as x+x. */ /* Expand x*2.0 as x+x. */
if (GET_CODE (scalar_op1) == CONST_DOUBLE && FLOAT_MODE_P (mode)) if (CONST_DOUBLE_AS_FLOAT_P (scalar_op1))
{ {
REAL_VALUE_TYPE d; REAL_VALUE_TYPE d;
REAL_VALUE_FROM_CONST_DOUBLE (d, scalar_op1); REAL_VALUE_FROM_CONST_DOUBLE (d, scalar_op1);

2
gcc/expr.c
View File

@ -745,7 +745,7 @@ convert_modes (enum machine_mode mode, enum machine_mode oldmode, rtx x, int uns
&& GET_MODE_PRECISION (mode) <= HOST_BITS_PER_WIDE_INT) && GET_MODE_PRECISION (mode) <= HOST_BITS_PER_WIDE_INT)
|| (GET_MODE_CLASS (mode) == MODE_INT || (GET_MODE_CLASS (mode) == MODE_INT
&& GET_MODE_CLASS (oldmode) == MODE_INT && GET_MODE_CLASS (oldmode) == MODE_INT
&& (GET_CODE (x) == CONST_DOUBLE && (CONST_DOUBLE_AS_INT_P (x)
|| (GET_MODE_PRECISION (mode) <= GET_MODE_PRECISION (oldmode) || (GET_MODE_PRECISION (mode) <= GET_MODE_PRECISION (oldmode)
&& ((MEM_P (x) && ! MEM_VOLATILE_P (x) && ((MEM_P (x) && ! MEM_VOLATILE_P (x)
&& direct_load[(int) mode]) && direct_load[(int) mode])

12
gcc/ira-costs.c
View File

@ -652,7 +652,7 @@ record_reg_classes (int n_alts, int n_ops, rtx *ops,
case 'E': case 'E':
case 'F': case 'F':
if (GET_CODE (op) == CONST_DOUBLE if (CONST_DOUBLE_AS_FLOAT_P (op)
|| (GET_CODE (op) == CONST_VECTOR || (GET_CODE (op) == CONST_VECTOR
&& (GET_MODE_CLASS (GET_MODE (op)) && (GET_MODE_CLASS (GET_MODE (op))
== MODE_VECTOR_FLOAT))) == MODE_VECTOR_FLOAT)))
@ -661,15 +661,13 @@ record_reg_classes (int n_alts, int n_ops, rtx *ops,
case 'G': case 'G':
case 'H': case 'H':
if (GET_CODE (op) == CONST_DOUBLE if (CONST_DOUBLE_AS_FLOAT_P (op)
&& CONST_DOUBLE_OK_FOR_CONSTRAINT_P (op, c, p)) && CONST_DOUBLE_OK_FOR_CONSTRAINT_P (op, c, p))
win = 1; win = 1;
break; break;
case 's': case 's':
if (CONST_INT_P (op) if (CONST_INT_P (op) || CONST_DOUBLE_AS_INT_P (op))
|| (GET_CODE (op) == CONST_DOUBLE
&& GET_MODE (op) == VOIDmode))
break; break;
case 'i': case 'i':
@ -679,9 +677,7 @@ record_reg_classes (int n_alts, int n_ops, rtx *ops,
break; break;
case 'n': case 'n':
if (CONST_INT_P (op) if (CONST_INT_P (op) || CONST_DOUBLE_AS_INT_P (op))
|| (GET_CODE (op) == CONST_DOUBLE
&& GET_MODE (op) == VOIDmode))
win = 1; win = 1;
break; break;

21
gcc/ira-lives.c
View File

@ -780,22 +780,21 @@ single_reg_class (const char *constraints, rtx op, rtx equiv_const)
case 'n': case 'n':
if (CONST_INT_P (op) if (CONST_INT_P (op)
|| (GET_CODE (op) == CONST_DOUBLE && GET_MODE (op) == VOIDmode) || CONST_DOUBLE_AS_INT_P (op)
|| (equiv_const != NULL_RTX || (equiv_const != NULL_RTX
&& (CONST_INT_P (equiv_const) && (CONST_INT_P (equiv_const)
|| (GET_CODE (equiv_const) == CONST_DOUBLE || CONST_DOUBLE_AS_INT_P (equiv_const))))
&& GET_MODE (equiv_const) == VOIDmode))))
return NO_REGS; return NO_REGS;
break; break;
case 's': case 's':
if ((CONSTANT_P (op) && !CONST_INT_P (op) if ((CONSTANT_P (op)
&& (GET_CODE (op) != CONST_DOUBLE || GET_MODE (op) != VOIDmode)) && !CONST_INT_P (op)
&& !CONST_DOUBLE_AS_INT_P (op))
|| (equiv_const != NULL_RTX || (equiv_const != NULL_RTX
&& CONSTANT_P (equiv_const) && CONSTANT_P (equiv_const)
&& !CONST_INT_P (equiv_const) && !CONST_INT_P (equiv_const)
&& (GET_CODE (equiv_const) != CONST_DOUBLE && !CONST_DOUBLE_AS_INT_P (equiv_const)))
|| GET_MODE (equiv_const) != VOIDmode)))
return NO_REGS; return NO_REGS;
break; break;
@ -818,11 +817,11 @@ single_reg_class (const char *constraints, rtx op, rtx equiv_const)
case 'E': case 'E':
case 'F': case 'F':
if (GET_CODE (op) == CONST_DOUBLE if (CONST_DOUBLE_AS_FLOAT_P (op)
|| (GET_CODE (op) == CONST_VECTOR || (GET_CODE (op) == CONST_VECTOR
&& GET_MODE_CLASS (GET_MODE (op)) == MODE_VECTOR_FLOAT) && GET_MODE_CLASS (GET_MODE (op)) == MODE_VECTOR_FLOAT)
|| (equiv_const != NULL_RTX || (equiv_const != NULL_RTX
&& (GET_CODE (equiv_const) == CONST_DOUBLE && (CONST_DOUBLE_AS_FLOAT_P (equiv_const)
|| (GET_CODE (equiv_const) == CONST_VECTOR || (GET_CODE (equiv_const) == CONST_VECTOR
&& (GET_MODE_CLASS (GET_MODE (equiv_const)) && (GET_MODE_CLASS (GET_MODE (equiv_const))
== MODE_VECTOR_FLOAT))))) == MODE_VECTOR_FLOAT)))))
@ -831,10 +830,10 @@ single_reg_class (const char *constraints, rtx op, rtx equiv_const)
case 'G': case 'G':
case 'H': case 'H':
if ((GET_CODE (op) == CONST_DOUBLE if ((CONST_DOUBLE_AS_FLOAT_P (op)
&& CONST_DOUBLE_OK_FOR_CONSTRAINT_P (op, c, constraints)) && CONST_DOUBLE_OK_FOR_CONSTRAINT_P (op, c, constraints))
|| (equiv_const != NULL_RTX || (equiv_const != NULL_RTX
&& GET_CODE (equiv_const) == CONST_DOUBLE && CONST_DOUBLE_AS_FLOAT_P (equiv_const)
&& CONST_DOUBLE_OK_FOR_CONSTRAINT_P (equiv_const, && CONST_DOUBLE_OK_FOR_CONSTRAINT_P (equiv_const,
c, constraints))) c, constraints)))
return NO_REGS; return NO_REGS;

6
gcc/optabs.c
View File

@ -3594,7 +3594,7 @@ expand_copysign_absneg (enum machine_mode mode, rtx op0, rtx op1, rtx target,
label = gen_label_rtx (); label = gen_label_rtx ();
emit_cmp_and_jump_insns (sign, const0_rtx, EQ, NULL_RTX, imode, 1, label); emit_cmp_and_jump_insns (sign, const0_rtx, EQ, NULL_RTX, imode, 1, label);
if (GET_CODE (op0) == CONST_DOUBLE) if (CONST_DOUBLE_AS_FLOAT_P (op0))
op0 = simplify_unary_operation (NEG, mode, op0, mode); op0 = simplify_unary_operation (NEG, mode, op0, mode);
else else
op0 = expand_unop (mode, neg_optab, op0, target, 0); op0 = expand_unop (mode, neg_optab, op0, target, 0);
@ -3732,7 +3732,7 @@ expand_copysign (rtx op0, rtx op1, rtx target)
return NULL_RTX; return NULL_RTX;
op0_is_abs = false; op0_is_abs = false;
if (GET_CODE (op0) == CONST_DOUBLE) if (CONST_DOUBLE_AS_FLOAT_P (op0))
{ {
if (real_isneg (CONST_DOUBLE_REAL_VALUE (op0))) if (real_isneg (CONST_DOUBLE_REAL_VALUE (op0)))
op0 = simplify_unary_operation (ABS, mode, op0, mode); op0 = simplify_unary_operation (ABS, mode, op0, mode);
@ -3740,7 +3740,7 @@ expand_copysign (rtx op0, rtx op1, rtx target)
} }
if (fmt->signbit_ro >= 0 if (fmt->signbit_ro >= 0
&& (GET_CODE (op0) == CONST_DOUBLE && (CONST_DOUBLE_AS_FLOAT_P (op0)
|| (optab_handler (neg_optab, mode) != CODE_FOR_nothing || (optab_handler (neg_optab, mode) != CODE_FOR_nothing
&& optab_handler (abs_optab, mode) != CODE_FOR_nothing))) && optab_handler (abs_optab, mode) != CODE_FOR_nothing)))
{ {

2
gcc/print-rtl.c
View File

@ -195,7 +195,7 @@ print_rtx (const_rtx in_rtx)
} }
#ifndef GENERATOR_FILE #ifndef GENERATOR_FILE
if (GET_CODE (in_rtx) == CONST_DOUBLE && FLOAT_MODE_P (GET_MODE (in_rtx))) if (CONST_DOUBLE_AS_FLOAT_P (in_rtx))
i = 5; i = 5;
#endif #endif

30
gcc/recog.c
View File

@ -587,7 +587,7 @@ simplify_while_replacing (rtx *loc, rtx to, rtx object,
break; break;
case MINUS: case MINUS:
if (CONST_INT_P (XEXP (x, 1)) if (CONST_INT_P (XEXP (x, 1))
|| GET_CODE (XEXP (x, 1)) == CONST_DOUBLE) || CONST_DOUBLE_AS_INT_P (XEXP (x, 1)))
validate_change (object, loc, validate_change (object, loc,
simplify_gen_binary simplify_gen_binary
(PLUS, GET_MODE (x), XEXP (x, 0), (PLUS, GET_MODE (x), XEXP (x, 0),
@ -1158,7 +1158,7 @@ const_double_operand (rtx op, enum machine_mode mode)
&& GET_MODE_CLASS (mode) != MODE_PARTIAL_INT) && GET_MODE_CLASS (mode) != MODE_PARTIAL_INT)
return 0; return 0;
return ((GET_CODE (op) == CONST_DOUBLE || CONST_INT_P (op)) return ((CONST_DOUBLE_P (op) || CONST_INT_P (op))
&& (mode == VOIDmode || GET_MODE (op) == mode && (mode == VOIDmode || GET_MODE (op) == mode
|| GET_MODE (op) == VOIDmode)); || GET_MODE (op) == VOIDmode));
} }
@ -1707,27 +1707,25 @@ asm_operand_ok (rtx op, const char *constraint, const char **constraints)
case 'E': case 'E':
case 'F': case 'F':
if (GET_CODE (op) == CONST_DOUBLE if (CONST_DOUBLE_AS_FLOAT_P (op)
|| (GET_CODE (op) == CONST_VECTOR || (GET_CODE (op) == CONST_VECTOR
&& GET_MODE_CLASS (GET_MODE (op)) == MODE_VECTOR_FLOAT)) && GET_MODE_CLASS (GET_MODE (op)) == MODE_VECTOR_FLOAT))
result = 1; result = 1;
break; break;
case 'G': case 'G':
if (GET_CODE (op) == CONST_DOUBLE if (CONST_DOUBLE_AS_FLOAT_P (op)
&& CONST_DOUBLE_OK_FOR_CONSTRAINT_P (op, 'G', constraint)) && CONST_DOUBLE_OK_FOR_CONSTRAINT_P (op, 'G', constraint))
result = 1; result = 1;
break; break;
case 'H': case 'H':
if (GET_CODE (op) == CONST_DOUBLE if (CONST_DOUBLE_AS_FLOAT_P (op)
&& CONST_DOUBLE_OK_FOR_CONSTRAINT_P (op, 'H', constraint)) && CONST_DOUBLE_OK_FOR_CONSTRAINT_P (op, 'H', constraint))
result = 1; result = 1;
break; break;
case 's': case 's':
if (CONST_INT_P (op) if (CONST_INT_P (op) || CONST_DOUBLE_AS_INT_P (op))
|| (GET_CODE (op) == CONST_DOUBLE
&& GET_MODE (op) == VOIDmode))
break; break;
/* Fall through. */ /* Fall through. */
@ -1737,9 +1735,7 @@ asm_operand_ok (rtx op, const char *constraint, const char **constraints)
break; break;
case 'n': case 'n':
if (CONST_INT_P (op) if (CONST_INT_P (op) || CONST_DOUBLE_AS_INT_P (op))
|| (GET_CODE (op) == CONST_DOUBLE
&& GET_MODE (op) == VOIDmode))
result = 1; result = 1;
break; break;
@ -2578,7 +2574,7 @@ constrain_operands (int strict)
case 'E': case 'E':
case 'F': case 'F':
if (GET_CODE (op) == CONST_DOUBLE if (CONST_DOUBLE_AS_FLOAT_P (op)
|| (GET_CODE (op) == CONST_VECTOR || (GET_CODE (op) == CONST_VECTOR
&& GET_MODE_CLASS (GET_MODE (op)) == MODE_VECTOR_FLOAT)) && GET_MODE_CLASS (GET_MODE (op)) == MODE_VECTOR_FLOAT))
win = 1; win = 1;
@ -2586,15 +2582,13 @@ constrain_operands (int strict)
case 'G': case 'G':
case 'H': case 'H':
if (GET_CODE (op) == CONST_DOUBLE if (CONST_DOUBLE_AS_FLOAT_P (op)
&& CONST_DOUBLE_OK_FOR_CONSTRAINT_P (op, c, p)) && CONST_DOUBLE_OK_FOR_CONSTRAINT_P (op, c, p))
win = 1; win = 1;
break; break;
case 's': case 's':
if (CONST_INT_P (op) if (CONST_INT_P (op) || CONST_DOUBLE_AS_INT_P (op))
|| (GET_CODE (op) == CONST_DOUBLE
&& GET_MODE (op) == VOIDmode))
break; break;
case 'i': case 'i':
if (CONSTANT_P (op)) if (CONSTANT_P (op))
@ -2602,9 +2596,7 @@ constrain_operands (int strict)
break; break;
case 'n': case 'n':
if (CONST_INT_P (op) if (CONST_INT_P (op) || CONST_DOUBLE_AS_INT_P (op))
|| (GET_CODE (op) == CONST_DOUBLE
&& GET_MODE (op) == VOIDmode))
win = 1; win = 1;
break; break;

2
gcc/reg-stack.c
View File

@ -1466,7 +1466,7 @@ subst_stack_regs_pat (rtx insn, stack regstack, rtx pat)
if (STACK_REG_P (*src) if (STACK_REG_P (*src)
|| (STACK_REG_P (*dest) || (STACK_REG_P (*dest)
&& (REG_P (*src) || MEM_P (*src) && (REG_P (*src) || MEM_P (*src)
|| GET_CODE (*src) == CONST_DOUBLE))) || CONST_DOUBLE_P (*src))))
{ {
control_flow_insn_deleted |= move_for_stack_reg (insn, regstack, pat); control_flow_insn_deleted |= move_for_stack_reg (insn, regstack, pat);
break; break;

16
gcc/reload.c
View File

@ -3363,7 +3363,7 @@ find_reloads (rtx insn, int replace, int ind_levels, int live_known,
case 'E': case 'E':
case 'F': case 'F':
if (GET_CODE (operand) == CONST_DOUBLE if (CONST_DOUBLE_AS_FLOAT_P (operand)
|| (GET_CODE (operand) == CONST_VECTOR || (GET_CODE (operand) == CONST_VECTOR
&& (GET_MODE_CLASS (GET_MODE (operand)) && (GET_MODE_CLASS (GET_MODE (operand))
== MODE_VECTOR_FLOAT))) == MODE_VECTOR_FLOAT)))
@ -3372,15 +3372,13 @@ find_reloads (rtx insn, int replace, int ind_levels, int live_known,
case 'G': case 'G':
case 'H': case 'H':
if (GET_CODE (operand) == CONST_DOUBLE if (CONST_DOUBLE_AS_FLOAT_P (operand)
&& CONST_DOUBLE_OK_FOR_CONSTRAINT_P (operand, c, p)) && CONST_DOUBLE_OK_FOR_CONSTRAINT_P (operand, c, p))
win = 1; win = 1;
break; break;
case 's': case 's':
if (CONST_INT_P (operand) if (CONST_INT_P (operand) || CONST_DOUBLE_AS_INT_P (operand))
|| (GET_CODE (operand) == CONST_DOUBLE
&& GET_MODE (operand) == VOIDmode))
break; break;
case 'i': case 'i':
if (CONSTANT_P (operand) if (CONSTANT_P (operand)
@ -3389,9 +3387,7 @@ find_reloads (rtx insn, int replace, int ind_levels, int live_known,
break; break;
case 'n': case 'n':
if (CONST_INT_P (operand) if (CONST_INT_P (operand) || CONST_DOUBLE_AS_INT_P (operand))
|| (GET_CODE (operand) == CONST_DOUBLE
&& GET_MODE (operand) == VOIDmode))
win = 1; win = 1;
break; break;
@ -6810,7 +6806,7 @@ find_equiv_reg (rtx goal, rtx insn, enum reg_class rclass, int other,
&& (valueno && (valueno
= true_regnum (valtry = SET_DEST (pat))) >= 0) = true_regnum (valtry = SET_DEST (pat))) >= 0)
|| (REG_P (SET_DEST (pat)) || (REG_P (SET_DEST (pat))
&& GET_CODE (XEXP (tem, 0)) == CONST_DOUBLE && CONST_DOUBLE_AS_FLOAT_P (XEXP (tem, 0))
&& SCALAR_FLOAT_MODE_P (GET_MODE (XEXP (tem, 0))) && SCALAR_FLOAT_MODE_P (GET_MODE (XEXP (tem, 0)))
&& CONST_INT_P (goal) && CONST_INT_P (goal)
&& 0 != (goaltry && 0 != (goaltry
@ -6824,7 +6820,7 @@ find_equiv_reg (rtx goal, rtx insn, enum reg_class rclass, int other,
|| (goal_const && (tem = find_reg_note (p, REG_EQUIV, || (goal_const && (tem = find_reg_note (p, REG_EQUIV,
NULL_RTX)) NULL_RTX))
&& REG_P (SET_DEST (pat)) && REG_P (SET_DEST (pat))
&& GET_CODE (XEXP (tem, 0)) == CONST_DOUBLE && CONST_DOUBLE_AS_FLOAT_P (XEXP (tem, 0))
&& SCALAR_FLOAT_MODE_P (GET_MODE (XEXP (tem, 0))) && SCALAR_FLOAT_MODE_P (GET_MODE (XEXP (tem, 0)))
&& CONST_INT_P (goal) && CONST_INT_P (goal)
&& 0 != (goaltry = operand_subword (XEXP (tem, 0), 1, 0, && 0 != (goaltry = operand_subword (XEXP (tem, 0), 1, 0,

7
gcc/rtl.def
View File

@ -322,9 +322,10 @@ DEF_RTL_EXPR(CONST_INT, "const_int", "w", RTX_CONST_OBJ)
/* fixed-point constant */ /* fixed-point constant */
DEF_RTL_EXPR(CONST_FIXED, "const_fixed", "www", RTX_CONST_OBJ) DEF_RTL_EXPR(CONST_FIXED, "const_fixed", "www", RTX_CONST_OBJ)
/* numeric floating point constant. /* numeric floating point or integer constant. If the mode is
Operands hold the value. They are all 'w' and there may be from 2 to 6; VOIDmode it is an int otherwise it has a floating point mode and a
see real.h. */ floating point value. Operands hold the value. They are all 'w'
and there may be from 2 to 6; see real.h. */
DEF_RTL_EXPR(CONST_DOUBLE, "const_double", CONST_DOUBLE_FORMAT, RTX_CONST_OBJ) DEF_RTL_EXPR(CONST_DOUBLE, "const_double", CONST_DOUBLE_FORMAT, RTX_CONST_OBJ)
/* Describes a vector constant. */ /* Describes a vector constant. */

8
gcc/rtl.h
View File

@ -410,6 +410,14 @@ struct GTY((variable_size)) rtvec_def {
or floating point constant. */ or floating point constant. */
#define CONST_DOUBLE_P(X) (GET_CODE (X) == CONST_DOUBLE) #define CONST_DOUBLE_P(X) (GET_CODE (X) == CONST_DOUBLE)
/* Predicate yielding true iff X is an rtx for a double-int. */
#define CONST_DOUBLE_AS_INT_P(X) \
(GET_CODE (X) == CONST_DOUBLE && GET_MODE (X) == VOIDmode)
/* Predicate yielding true iff X is an rtx for a double-int. */
#define CONST_DOUBLE_AS_FLOAT_P(X) \
(GET_CODE (X) == CONST_DOUBLE && GET_MODE (X) != VOIDmode)
/* Predicate yielding nonzero iff X is a label insn. */ /* Predicate yielding nonzero iff X is a label insn. */
#define LABEL_P(X) (GET_CODE (X) == CODE_LABEL) #define LABEL_P(X) (GET_CODE (X) == CODE_LABEL)

9
gcc/rtlanal.c
View File

@ -2571,11 +2571,6 @@ replace_rtx (rtx x, rtx from, rtx to)
int i, j; int i, j;
const char *fmt; const char *fmt;
/* The following prevents loops occurrence when we change MEM in
CONST_DOUBLE onto the same CONST_DOUBLE. */
if (x != 0 && GET_CODE (x) == CONST_DOUBLE)
return x;
if (x == from) if (x == from)
return to; return to;
@ -5277,7 +5272,7 @@ bool
constant_pool_constant_p (rtx x) constant_pool_constant_p (rtx x)
{ {
x = avoid_constant_pool_reference (x); x = avoid_constant_pool_reference (x);
return GET_CODE (x) == CONST_DOUBLE; return CONST_DOUBLE_P (x);
} }
/* If M is a bitmask that selects a field of low-order bits within an item but /* If M is a bitmask that selects a field of low-order bits within an item but
@ -5391,7 +5386,7 @@ split_double (rtx value, rtx *first, rtx *second)
} }
} }
} }
else if (GET_CODE (value) != CONST_DOUBLE) else if (!CONST_DOUBLE_P (value))
{ {
if (WORDS_BIG_ENDIAN) if (WORDS_BIG_ENDIAN)
{ {

93
gcc/simplify-rtx.c
View File

@ -89,7 +89,7 @@ mode_signbit_p (enum machine_mode mode, const_rtx x)
&& CONST_INT_P (x)) && CONST_INT_P (x))
val = INTVAL (x); val = INTVAL (x);
else if (width <= HOST_BITS_PER_DOUBLE_INT else if (width <= HOST_BITS_PER_DOUBLE_INT
&& GET_CODE (x) == CONST_DOUBLE && CONST_DOUBLE_AS_INT_P (x)
&& CONST_DOUBLE_LOW (x) == 0) && CONST_DOUBLE_LOW (x) == 0)
{ {
val = CONST_DOUBLE_HIGH (x); val = CONST_DOUBLE_HIGH (x);
@ -200,7 +200,7 @@ avoid_constant_pool_reference (rtx x)
/* Handle float extensions of constant pool references. */ /* Handle float extensions of constant pool references. */
tmp = XEXP (x, 0); tmp = XEXP (x, 0);
c = avoid_constant_pool_reference (tmp); c = avoid_constant_pool_reference (tmp);
if (c != tmp && GET_CODE (c) == CONST_DOUBLE) if (c != tmp && CONST_DOUBLE_AS_FLOAT_P (c))
{ {
REAL_VALUE_TYPE d; REAL_VALUE_TYPE d;
@ -730,7 +730,7 @@ simplify_unary_operation_1 (enum rtx_code code, enum machine_mode mode, rtx op)
{ {
/* (neg (plus A C)) is simplified to (minus -C A). */ /* (neg (plus A C)) is simplified to (minus -C A). */
if (CONST_INT_P (XEXP (op, 1)) if (CONST_INT_P (XEXP (op, 1))
|| GET_CODE (XEXP (op, 1)) == CONST_DOUBLE) || CONST_DOUBLE_P (XEXP (op, 1)))
{ {
temp = simplify_unary_operation (NEG, mode, XEXP (op, 1), mode); temp = simplify_unary_operation (NEG, mode, XEXP (op, 1), mode);
if (temp) if (temp)
@ -1275,7 +1275,7 @@ simplify_const_unary_operation (enum rtx_code code, enum machine_mode mode,
gcc_assert (GET_MODE_INNER (mode) == GET_MODE_INNER gcc_assert (GET_MODE_INNER (mode) == GET_MODE_INNER
(GET_MODE (op))); (GET_MODE (op)));
} }
if (CONST_INT_P (op) || GET_CODE (op) == CONST_DOUBLE if (CONST_INT_P (op) || CONST_DOUBLE_P (op)
|| GET_CODE (op) == CONST_VECTOR) || GET_CODE (op) == CONST_VECTOR)
{ {
int elt_size = GET_MODE_SIZE (GET_MODE_INNER (mode)); int elt_size = GET_MODE_SIZE (GET_MODE_INNER (mode));
@ -1328,8 +1328,7 @@ simplify_const_unary_operation (enum rtx_code code, enum machine_mode mode,
check the wrong mode (input vs. output) for a conversion operation, check the wrong mode (input vs. output) for a conversion operation,
such as FIX. At some point, this should be simplified. */ such as FIX. At some point, this should be simplified. */
if (code == FLOAT && GET_MODE (op) == VOIDmode if (code == FLOAT && (CONST_DOUBLE_AS_INT_P (op) || CONST_INT_P (op)))
&& (GET_CODE (op) == CONST_DOUBLE || CONST_INT_P (op)))
{ {
HOST_WIDE_INT hv, lv; HOST_WIDE_INT hv, lv;
REAL_VALUE_TYPE d; REAL_VALUE_TYPE d;
@ -1343,9 +1342,8 @@ simplify_const_unary_operation (enum rtx_code code, enum machine_mode mode,
d = real_value_truncate (mode, d); d = real_value_truncate (mode, d);
return CONST_DOUBLE_FROM_REAL_VALUE (d, mode); return CONST_DOUBLE_FROM_REAL_VALUE (d, mode);
} }
else if (code == UNSIGNED_FLOAT && GET_MODE (op) == VOIDmode else if (code == UNSIGNED_FLOAT
&& (GET_CODE (op) == CONST_DOUBLE && (CONST_DOUBLE_AS_INT_P (op) || CONST_INT_P (op)))
|| CONST_INT_P (op)))
{ {
HOST_WIDE_INT hv, lv; HOST_WIDE_INT hv, lv;
REAL_VALUE_TYPE d; REAL_VALUE_TYPE d;
@ -1516,15 +1514,13 @@ simplify_const_unary_operation (enum rtx_code code, enum machine_mode mode,
/* We can do some operations on integer CONST_DOUBLEs. Also allow /* We can do some operations on integer CONST_DOUBLEs. Also allow
for a DImode operation on a CONST_INT. */ for a DImode operation on a CONST_INT. */
else if (GET_MODE (op) == VOIDmode else if (width <= HOST_BITS_PER_DOUBLE_INT
&& width <= HOST_BITS_PER_DOUBLE_INT && (CONST_DOUBLE_AS_INT_P (op) || CONST_INT_P (op)))
&& (GET_CODE (op) == CONST_DOUBLE
|| CONST_INT_P (op)))
{ {
unsigned HOST_WIDE_INT l1, lv; unsigned HOST_WIDE_INT l1, lv;
HOST_WIDE_INT h1, hv; HOST_WIDE_INT h1, hv;
if (GET_CODE (op) == CONST_DOUBLE) if (CONST_DOUBLE_AS_INT_P (op))
l1 = CONST_DOUBLE_LOW (op), h1 = CONST_DOUBLE_HIGH (op); l1 = CONST_DOUBLE_LOW (op), h1 = CONST_DOUBLE_HIGH (op);
else else
l1 = INTVAL (op), h1 = HWI_SIGN_EXTEND (l1); l1 = INTVAL (op), h1 = HWI_SIGN_EXTEND (l1);
@ -1660,7 +1656,7 @@ simplify_const_unary_operation (enum rtx_code code, enum machine_mode mode,
return immed_double_const (lv, hv, mode); return immed_double_const (lv, hv, mode);
} }
else if (GET_CODE (op) == CONST_DOUBLE else if (CONST_DOUBLE_AS_FLOAT_P (op)
&& SCALAR_FLOAT_MODE_P (mode) && SCALAR_FLOAT_MODE_P (mode)
&& SCALAR_FLOAT_MODE_P (GET_MODE (op))) && SCALAR_FLOAT_MODE_P (GET_MODE (op)))
{ {
@ -1710,7 +1706,7 @@ simplify_const_unary_operation (enum rtx_code code, enum machine_mode mode,
return CONST_DOUBLE_FROM_REAL_VALUE (d, mode); return CONST_DOUBLE_FROM_REAL_VALUE (d, mode);
} }
else if (GET_CODE (op) == CONST_DOUBLE else if (CONST_DOUBLE_AS_FLOAT_P (op)
&& SCALAR_FLOAT_MODE_P (GET_MODE (op)) && SCALAR_FLOAT_MODE_P (GET_MODE (op))
&& GET_MODE_CLASS (mode) == MODE_INT && GET_MODE_CLASS (mode) == MODE_INT
&& width <= HOST_BITS_PER_DOUBLE_INT && width > 0) && width <= HOST_BITS_PER_DOUBLE_INT && width > 0)
@ -2033,11 +2029,10 @@ simplify_binary_operation_1 (enum rtx_code code, enum machine_mode mode,
} }
/* (plus (xor X C1) C2) is (xor X (C1^C2)) if C2 is signbit. */ /* (plus (xor X C1) C2) is (xor X (C1^C2)) if C2 is signbit. */
if ((CONST_INT_P (op1) if ((CONST_INT_P (op1) || CONST_DOUBLE_AS_INT_P (op1))
|| GET_CODE (op1) == CONST_DOUBLE)
&& GET_CODE (op0) == XOR && GET_CODE (op0) == XOR
&& (CONST_INT_P (XEXP (op0, 1)) && (CONST_INT_P (XEXP (op0, 1))
|| GET_CODE (XEXP (op0, 1)) == CONST_DOUBLE) || CONST_DOUBLE_AS_INT_P (XEXP (op0, 1)))
&& mode_signbit_p (mode, op1)) && mode_signbit_p (mode, op1))
return simplify_gen_binary (XOR, mode, XEXP (op0, 0), return simplify_gen_binary (XOR, mode, XEXP (op0, 0),
simplify_gen_binary (XOR, mode, op1, simplify_gen_binary (XOR, mode, op1,
@ -2219,8 +2214,7 @@ simplify_binary_operation_1 (enum rtx_code code, enum machine_mode mode,
/* (-x - c) may be simplified as (-c - x). */ /* (-x - c) may be simplified as (-c - x). */
if (GET_CODE (op0) == NEG if (GET_CODE (op0) == NEG
&& (CONST_INT_P (op1) && (CONST_INT_P (op1) || CONST_DOUBLE_P (op1)))
|| GET_CODE (op1) == CONST_DOUBLE))
{ {
tem = simplify_unary_operation (NEG, mode, op1, mode); tem = simplify_unary_operation (NEG, mode, op1, mode);
if (tem) if (tem)
@ -2370,9 +2364,7 @@ simplify_binary_operation_1 (enum rtx_code code, enum machine_mode mode,
return simplify_gen_binary (ASHIFT, mode, op0, GEN_INT (val)); return simplify_gen_binary (ASHIFT, mode, op0, GEN_INT (val));
/* Likewise for multipliers wider than a word. */ /* Likewise for multipliers wider than a word. */
if (GET_CODE (trueop1) == CONST_DOUBLE if (CONST_DOUBLE_AS_INT_P (trueop1)
&& (GET_MODE (trueop1) == VOIDmode
|| GET_MODE_CLASS (GET_MODE (trueop1)) == MODE_INT)
&& GET_MODE (op0) == mode && GET_MODE (op0) == mode
&& CONST_DOUBLE_LOW (trueop1) == 0 && CONST_DOUBLE_LOW (trueop1) == 0
&& (val = exact_log2 (CONST_DOUBLE_HIGH (trueop1))) >= 0 && (val = exact_log2 (CONST_DOUBLE_HIGH (trueop1))) >= 0
@ -2382,7 +2374,7 @@ simplify_binary_operation_1 (enum rtx_code code, enum machine_mode mode,
GEN_INT (val + HOST_BITS_PER_WIDE_INT)); GEN_INT (val + HOST_BITS_PER_WIDE_INT));
/* x*2 is x+x and x*(-1) is -x */ /* x*2 is x+x and x*(-1) is -x */
if (GET_CODE (trueop1) == CONST_DOUBLE if (CONST_DOUBLE_AS_FLOAT_P (trueop1)
&& SCALAR_FLOAT_MODE_P (GET_MODE (trueop1)) && SCALAR_FLOAT_MODE_P (GET_MODE (trueop1))
&& !DECIMAL_FLOAT_MODE_P (GET_MODE (trueop1)) && !DECIMAL_FLOAT_MODE_P (GET_MODE (trueop1))
&& GET_MODE (op0) == mode) && GET_MODE (op0) == mode)
@ -2577,16 +2569,14 @@ simplify_binary_operation_1 (enum rtx_code code, enum machine_mode mode,
return CONST0_RTX (mode); return CONST0_RTX (mode);
/* Canonicalize XOR of the most significant bit to PLUS. */ /* Canonicalize XOR of the most significant bit to PLUS. */
if ((CONST_INT_P (op1) if ((CONST_INT_P (op1) || CONST_DOUBLE_AS_INT_P (op1))
|| GET_CODE (op1) == CONST_DOUBLE)
&& mode_signbit_p (mode, op1)) && mode_signbit_p (mode, op1))
return simplify_gen_binary (PLUS, mode, op0, op1); return simplify_gen_binary (PLUS, mode, op0, op1);
/* (xor (plus X C1) C2) is (xor X (C1^C2)) if C1 is signbit. */ /* (xor (plus X C1) C2) is (xor X (C1^C2)) if C1 is signbit. */
if ((CONST_INT_P (op1) if ((CONST_INT_P (op1) || CONST_DOUBLE_AS_INT_P (op1))
|| GET_CODE (op1) == CONST_DOUBLE)
&& GET_CODE (op0) == PLUS && GET_CODE (op0) == PLUS
&& (CONST_INT_P (XEXP (op0, 1)) && (CONST_INT_P (XEXP (op0, 1))
|| GET_CODE (XEXP (op0, 1)) == CONST_DOUBLE) || CONST_DOUBLE_AS_INT_P (XEXP (op0, 1)))
&& mode_signbit_p (mode, XEXP (op0, 1))) && mode_signbit_p (mode, XEXP (op0, 1)))
return simplify_gen_binary (XOR, mode, XEXP (op0, 0), return simplify_gen_binary (XOR, mode, XEXP (op0, 0),
simplify_gen_binary (XOR, mode, op1, simplify_gen_binary (XOR, mode, op1,
@ -2929,7 +2919,7 @@ simplify_binary_operation_1 (enum rtx_code code, enum machine_mode mode,
&& !HONOR_SNANS (mode)) && !HONOR_SNANS (mode))
return op0; return op0;
if (GET_CODE (trueop1) == CONST_DOUBLE if (CONST_DOUBLE_AS_FLOAT_P (trueop1)
&& trueop1 != CONST0_RTX (mode)) && trueop1 != CONST0_RTX (mode))
{ {
REAL_VALUE_TYPE d; REAL_VALUE_TYPE d;
@ -3317,11 +3307,9 @@ simplify_binary_operation_1 (enum rtx_code code, enum machine_mode mode,
gcc_assert (GET_MODE_INNER (mode) == op1_mode); gcc_assert (GET_MODE_INNER (mode) == op1_mode);
if ((GET_CODE (trueop0) == CONST_VECTOR if ((GET_CODE (trueop0) == CONST_VECTOR
|| CONST_INT_P (trueop0) || CONST_INT_P (trueop0) || CONST_DOUBLE_P (trueop0))
|| GET_CODE (trueop0) == CONST_DOUBLE)
&& (GET_CODE (trueop1) == CONST_VECTOR && (GET_CODE (trueop1) == CONST_VECTOR
|| CONST_INT_P (trueop1) || CONST_INT_P (trueop1) || CONST_DOUBLE_P (trueop1)))
|| GET_CODE (trueop1) == CONST_DOUBLE))
{ {
int elt_size = GET_MODE_SIZE (GET_MODE_INNER (mode)); int elt_size = GET_MODE_SIZE (GET_MODE_INNER (mode));
unsigned n_elts = (GET_MODE_SIZE (mode) / elt_size); unsigned n_elts = (GET_MODE_SIZE (mode) / elt_size);
@ -3401,10 +3389,10 @@ simplify_const_binary_operation (enum rtx_code code, enum machine_mode mode,
if (VECTOR_MODE_P (mode) if (VECTOR_MODE_P (mode)
&& code == VEC_CONCAT && code == VEC_CONCAT
&& (CONST_INT_P (op0) && (CONST_INT_P (op0)
|| GET_CODE (op0) == CONST_DOUBLE || GET_CODE (op0) == CONST_FIXED
|| GET_CODE (op0) == CONST_FIXED) || CONST_DOUBLE_P (op0))
&& (CONST_INT_P (op1) && (CONST_INT_P (op1)
|| GET_CODE (op1) == CONST_DOUBLE || CONST_DOUBLE_P (op1)
|| GET_CODE (op1) == CONST_FIXED)) || GET_CODE (op1) == CONST_FIXED))
{ {
unsigned n_elts = GET_MODE_NUNITS (mode); unsigned n_elts = GET_MODE_NUNITS (mode);
@ -3439,8 +3427,8 @@ simplify_const_binary_operation (enum rtx_code code, enum machine_mode mode,
} }
if (SCALAR_FLOAT_MODE_P (mode) if (SCALAR_FLOAT_MODE_P (mode)
&& GET_CODE (op0) == CONST_DOUBLE && CONST_DOUBLE_AS_FLOAT_P (op0)
&& GET_CODE (op1) == CONST_DOUBLE && CONST_DOUBLE_AS_FLOAT_P (op1)
&& mode == GET_MODE (op0) && mode == GET_MODE (op1)) && mode == GET_MODE (op0) && mode == GET_MODE (op1))
{ {
if (code == AND if (code == AND
@ -3562,8 +3550,8 @@ simplify_const_binary_operation (enum rtx_code code, enum machine_mode mode,
/* We can fold some multi-word operations. */ /* We can fold some multi-word operations. */
if (GET_MODE_CLASS (mode) == MODE_INT if (GET_MODE_CLASS (mode) == MODE_INT
&& width == HOST_BITS_PER_DOUBLE_INT && width == HOST_BITS_PER_DOUBLE_INT
&& (CONST_DOUBLE_P (op0) || CONST_INT_P (op0)) && (CONST_DOUBLE_AS_INT_P (op0) || CONST_INT_P (op0))
&& (CONST_DOUBLE_P (op1) || CONST_INT_P (op1))) && (CONST_DOUBLE_AS_INT_P (op1) || CONST_INT_P (op1)))
{ {
double_int o0, o1, res, tmp; double_int o0, o1, res, tmp;
@ -4432,10 +4420,9 @@ simplify_relational_operation_1 (enum rtx_code code, enum machine_mode mode,
/* (eq/ne (xor x C1) C2) simplifies to (eq/ne x (C1^C2)). */ /* (eq/ne (xor x C1) C2) simplifies to (eq/ne x (C1^C2)). */
if ((code == EQ || code == NE) if ((code == EQ || code == NE)
&& op0code == XOR && op0code == XOR
&& (CONST_INT_P (op1) && (CONST_INT_P (op1) || CONST_DOUBLE_AS_INT_P (op1))
|| GET_CODE (op1) == CONST_DOUBLE)
&& (CONST_INT_P (XEXP (op0, 1)) && (CONST_INT_P (XEXP (op0, 1))
|| GET_CODE (XEXP (op0, 1)) == CONST_DOUBLE)) || CONST_DOUBLE_AS_INT_P (XEXP (op0, 1))))
return simplify_gen_relational (code, mode, cmp_mode, XEXP (op0, 0), return simplify_gen_relational (code, mode, cmp_mode, XEXP (op0, 0),
simplify_gen_binary (XOR, cmp_mode, simplify_gen_binary (XOR, cmp_mode,
XEXP (op0, 1), op1)); XEXP (op0, 1), op1));
@ -4612,8 +4599,8 @@ simplify_const_relational_operation (enum rtx_code code,
/* If the operands are floating-point constants, see if we can fold /* If the operands are floating-point constants, see if we can fold
the result. */ the result. */
if (GET_CODE (trueop0) == CONST_DOUBLE if (CONST_DOUBLE_AS_FLOAT_P (trueop0)
&& GET_CODE (trueop1) == CONST_DOUBLE && CONST_DOUBLE_AS_FLOAT_P (trueop1)
&& SCALAR_FLOAT_MODE_P (GET_MODE (trueop0))) && SCALAR_FLOAT_MODE_P (GET_MODE (trueop0)))
{ {
REAL_VALUE_TYPE d0, d1; REAL_VALUE_TYPE d0, d1;
@ -4652,17 +4639,15 @@ simplify_const_relational_operation (enum rtx_code code,
/* Otherwise, see if the operands are both integers. */ /* Otherwise, see if the operands are both integers. */
if ((GET_MODE_CLASS (mode) == MODE_INT || mode == VOIDmode) if ((GET_MODE_CLASS (mode) == MODE_INT || mode == VOIDmode)
&& (GET_CODE (trueop0) == CONST_DOUBLE && (CONST_DOUBLE_AS_INT_P (trueop0) || CONST_INT_P (trueop0))
|| CONST_INT_P (trueop0)) && (CONST_DOUBLE_AS_INT_P (trueop1) || CONST_INT_P (trueop1)))
&& (GET_CODE (trueop1) == CONST_DOUBLE
|| CONST_INT_P (trueop1)))
{ {
int width = GET_MODE_PRECISION (mode); int width = GET_MODE_PRECISION (mode);
HOST_WIDE_INT l0s, h0s, l1s, h1s; HOST_WIDE_INT l0s, h0s, l1s, h1s;
unsigned HOST_WIDE_INT l0u, h0u, l1u, h1u; unsigned HOST_WIDE_INT l0u, h0u, l1u, h1u;
/* Get the two words comprising each integer constant. */ /* Get the two words comprising each integer constant. */
if (GET_CODE (trueop0) == CONST_DOUBLE) if (CONST_DOUBLE_AS_INT_P (trueop0))
{ {
l0u = l0s = CONST_DOUBLE_LOW (trueop0); l0u = l0s = CONST_DOUBLE_LOW (trueop0);
h0u = h0s = CONST_DOUBLE_HIGH (trueop0); h0u = h0s = CONST_DOUBLE_HIGH (trueop0);
@ -4673,7 +4658,7 @@ simplify_const_relational_operation (enum rtx_code code,
h0u = h0s = HWI_SIGN_EXTEND (l0s); h0u = h0s = HWI_SIGN_EXTEND (l0s);
} }
if (GET_CODE (trueop1) == CONST_DOUBLE) if (CONST_DOUBLE_AS_INT_P (trueop1))
{ {
l1u = l1s = CONST_DOUBLE_LOW (trueop1); l1u = l1s = CONST_DOUBLE_LOW (trueop1);
h1u = h1s = CONST_DOUBLE_HIGH (trueop1); h1u = h1s = CONST_DOUBLE_HIGH (trueop1);
@ -5455,7 +5440,7 @@ simplify_subreg (enum machine_mode outermode, rtx op,
return op; return op;
if (CONST_INT_P (op) if (CONST_INT_P (op)
|| GET_CODE (op) == CONST_DOUBLE || CONST_DOUBLE_P (op)
|| GET_CODE (op) == CONST_FIXED || GET_CODE (op) == CONST_FIXED
|| GET_CODE (op) == CONST_VECTOR) || GET_CODE (op) == CONST_VECTOR)
return simplify_immed_subreg (outermode, op, innermode, byte); return simplify_immed_subreg (outermode, op, innermode, byte);

2
gcc/varasm.c
View File

@ -3626,7 +3626,7 @@ output_constant_pool_2 (enum machine_mode mode, rtx x, unsigned int align)
{ {
REAL_VALUE_TYPE r; REAL_VALUE_TYPE r;
gcc_assert (GET_CODE (x) == CONST_DOUBLE); gcc_assert (CONST_DOUBLE_AS_FLOAT_P (x));
REAL_VALUE_FROM_CONST_DOUBLE (r, x); REAL_VALUE_FROM_CONST_DOUBLE (r, x);
assemble_real (r, mode, align); assemble_real (r, mode, align);
break; break;