/* Convert tree expression to rtl instructions, for GNU compiler.
Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
- 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
+ 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
Free Software Foundation, Inc.
This file is part of GCC.
#include "basic-block.h"
static bool prefer_and_bit_test (enum machine_mode, int);
-static void do_jump_by_parts_greater (tree, int, rtx, rtx);
-static void do_jump_by_parts_equality (tree, rtx, rtx);
-static void do_compare_and_jump (tree, enum rtx_code, enum rtx_code, rtx,
+static void do_jump_by_parts_greater (tree, tree, int, rtx, rtx);
+static void do_jump_by_parts_equality (tree, tree, rtx, rtx);
+static void do_compare_and_jump (tree, tree, enum rtx_code, enum rtx_code, rtx,
rtx);
/* At the start of a function, record that we have no previously-pushed
do_jump (exp, label, NULL_RTX);
}
+void
+jumpifnot_1 (enum tree_code code, tree op0, tree op1, rtx label)
+{
+ do_jump_1 (code, op0, op1, label, NULL_RTX);
+}
+
/* Generate code to evaluate EXP and jump to LABEL if the value is nonzero. */
void
do_jump (exp, NULL_RTX, label);
}
+void
+jumpif_1 (enum tree_code code, tree op0, tree op1, rtx label)
+{
+ do_jump_1 (code, op0, op1, NULL_RTX, label);
+}
+
/* Used internally by prefer_and_bit_test. */
static GTY(()) rtx and_reg;
}
/* Fill in the integers. */
- XEXP (and_test, 1) = GEN_INT ((unsigned HOST_WIDE_INT) 1 << bitnum);
+ XEXP (and_test, 1)
+ = immed_double_const ((unsigned HOST_WIDE_INT) 1 << bitnum, 0, mode);
XEXP (XEXP (shift_test, 0), 1) = GEN_INT (bitnum);
return (rtx_cost (and_test, IF_THEN_ELSE, optimize_insn_for_speed_p ())
<= rtx_cost (shift_test, IF_THEN_ELSE, optimize_insn_for_speed_p ()));
}
+/* Subroutine of do_jump, dealing with exploded comparisons of the type
+ OP0 CODE OP1 . IF_FALSE_LABEL and IF_TRUE_LABEL like in do_jump. */
+
+void
+do_jump_1 (enum tree_code code, tree op0, tree op1,
+ rtx if_false_label, rtx if_true_label)
+{
+ enum machine_mode mode;
+ rtx drop_through_label = 0;
+
+ switch (code)
+ {
+ case EQ_EXPR:
+ {
+ tree inner_type = TREE_TYPE (op0);
+
+ gcc_assert (GET_MODE_CLASS (TYPE_MODE (inner_type))
+ != MODE_COMPLEX_FLOAT);
+ gcc_assert (GET_MODE_CLASS (TYPE_MODE (inner_type))
+ != MODE_COMPLEX_INT);
+
+ if (integer_zerop (op1))
+ do_jump (op0, if_true_label, if_false_label);
+ else if (GET_MODE_CLASS (TYPE_MODE (inner_type)) == MODE_INT
+ && !can_compare_p (EQ, TYPE_MODE (inner_type), ccp_jump))
+ do_jump_by_parts_equality (op0, op1, if_false_label, if_true_label);
+ else
+ do_compare_and_jump (op0, op1, EQ, EQ, if_false_label, if_true_label);
+ break;
+ }
+
+ case NE_EXPR:
+ {
+ tree inner_type = TREE_TYPE (op0);
+
+ gcc_assert (GET_MODE_CLASS (TYPE_MODE (inner_type))
+ != MODE_COMPLEX_FLOAT);
+ gcc_assert (GET_MODE_CLASS (TYPE_MODE (inner_type))
+ != MODE_COMPLEX_INT);
+
+ if (integer_zerop (op1))
+ do_jump (op0, if_false_label, if_true_label);
+ else if (GET_MODE_CLASS (TYPE_MODE (inner_type)) == MODE_INT
+ && !can_compare_p (NE, TYPE_MODE (inner_type), ccp_jump))
+ do_jump_by_parts_equality (op0, op1, if_true_label, if_false_label);
+ else
+ do_compare_and_jump (op0, op1, NE, NE, if_false_label, if_true_label);
+ break;
+ }
+
+ case LT_EXPR:
+ mode = TYPE_MODE (TREE_TYPE (op0));
+ if (GET_MODE_CLASS (mode) == MODE_INT
+ && ! can_compare_p (LT, mode, ccp_jump))
+ do_jump_by_parts_greater (op0, op1, 1, if_false_label, if_true_label);
+ else
+ do_compare_and_jump (op0, op1, LT, LTU, if_false_label, if_true_label);
+ break;
+
+ case LE_EXPR:
+ mode = TYPE_MODE (TREE_TYPE (op0));
+ if (GET_MODE_CLASS (mode) == MODE_INT
+ && ! can_compare_p (LE, mode, ccp_jump))
+ do_jump_by_parts_greater (op0, op1, 0, if_true_label, if_false_label);
+ else
+ do_compare_and_jump (op0, op1, LE, LEU, if_false_label, if_true_label);
+ break;
+
+ case GT_EXPR:
+ mode = TYPE_MODE (TREE_TYPE (op0));
+ if (GET_MODE_CLASS (mode) == MODE_INT
+ && ! can_compare_p (GT, mode, ccp_jump))
+ do_jump_by_parts_greater (op0, op1, 0, if_false_label, if_true_label);
+ else
+ do_compare_and_jump (op0, op1, GT, GTU, if_false_label, if_true_label);
+ break;
+
+ case GE_EXPR:
+ mode = TYPE_MODE (TREE_TYPE (op0));
+ if (GET_MODE_CLASS (mode) == MODE_INT
+ && ! can_compare_p (GE, mode, ccp_jump))
+ do_jump_by_parts_greater (op0, op1, 1, if_true_label, if_false_label);
+ else
+ do_compare_and_jump (op0, op1, GE, GEU, if_false_label, if_true_label);
+ break;
+
+ case ORDERED_EXPR:
+ do_compare_and_jump (op0, op1, ORDERED, ORDERED,
+ if_false_label, if_true_label);
+ break;
+
+ case UNORDERED_EXPR:
+ do_compare_and_jump (op0, op1, UNORDERED, UNORDERED,
+ if_false_label, if_true_label);
+ break;
+
+ case UNLT_EXPR:
+ do_compare_and_jump (op0, op1, UNLT, UNLT, if_false_label, if_true_label);
+ break;
+
+ case UNLE_EXPR:
+ do_compare_and_jump (op0, op1, UNLE, UNLE, if_false_label, if_true_label);
+ break;
+
+ case UNGT_EXPR:
+ do_compare_and_jump (op0, op1, UNGT, UNGT, if_false_label, if_true_label);
+ break;
+
+ case UNGE_EXPR:
+ do_compare_and_jump (op0, op1, UNGE, UNGE, if_false_label, if_true_label);
+ break;
+
+ case UNEQ_EXPR:
+ do_compare_and_jump (op0, op1, UNEQ, UNEQ, if_false_label, if_true_label);
+ break;
+
+ case LTGT_EXPR:
+ do_compare_and_jump (op0, op1, LTGT, LTGT, if_false_label, if_true_label);
+ break;
+
+ case TRUTH_ANDIF_EXPR:
+ if (if_false_label == NULL_RTX)
+ {
+ drop_through_label = gen_label_rtx ();
+ do_jump (op0, drop_through_label, NULL_RTX);
+ do_jump (op1, NULL_RTX, if_true_label);
+ }
+ else
+ {
+ do_jump (op0, if_false_label, NULL_RTX);
+ do_jump (op1, if_false_label, if_true_label);
+ }
+ break;
+
+ case TRUTH_ORIF_EXPR:
+ if (if_true_label == NULL_RTX)
+ {
+ drop_through_label = gen_label_rtx ();
+ do_jump (op0, NULL_RTX, drop_through_label);
+ do_jump (op1, if_false_label, NULL_RTX);
+ }
+ else
+ {
+ do_jump (op0, NULL_RTX, if_true_label);
+ do_jump (op1, if_false_label, if_true_label);
+ }
+ break;
+
+ default:
+ gcc_unreachable ();
+ }
+
+ if (drop_through_label)
+ {
+ do_pending_stack_adjust ();
+ emit_label (drop_through_label);
+ }
+}
+
/* Generate code to evaluate EXP and jump to IF_FALSE_LABEL if
the result is zero, or IF_TRUE_LABEL if the result is one.
Either of IF_FALSE_LABEL and IF_TRUE_LABEL may be zero,
do_jump (TREE_OPERAND (exp, 0), if_false_label, if_true_label);
break;
- case BIT_AND_EXPR:
- /* fold_single_bit_test() converts (X & (1 << C)) into (X >> C) & 1.
- See if the former is preferred for jump tests and restore it
- if so. */
- if (integer_onep (TREE_OPERAND (exp, 1)))
- {
- tree exp0 = TREE_OPERAND (exp, 0);
- rtx set_label, clr_label;
-
- /* Strip narrowing integral type conversions. */
- while (CONVERT_EXPR_P (exp0)
- && TREE_OPERAND (exp0, 0) != error_mark_node
- && TYPE_PRECISION (TREE_TYPE (exp0))
- <= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (exp0, 0))))
- exp0 = TREE_OPERAND (exp0, 0);
-
- /* "exp0 ^ 1" inverts the sense of the single bit test. */
- if (TREE_CODE (exp0) == BIT_XOR_EXPR
- && integer_onep (TREE_OPERAND (exp0, 1)))
- {
- exp0 = TREE_OPERAND (exp0, 0);
- clr_label = if_true_label;
- set_label = if_false_label;
- }
- else
- {
- clr_label = if_false_label;
- set_label = if_true_label;
- }
-
- if (TREE_CODE (exp0) == RSHIFT_EXPR)
- {
- tree arg = TREE_OPERAND (exp0, 0);
- tree shift = TREE_OPERAND (exp0, 1);
- tree argtype = TREE_TYPE (arg);
- if (TREE_CODE (shift) == INTEGER_CST
- && compare_tree_int (shift, 0) >= 0
- && compare_tree_int (shift, HOST_BITS_PER_WIDE_INT) < 0
- && prefer_and_bit_test (TYPE_MODE (argtype),
- TREE_INT_CST_LOW (shift)))
- {
- HOST_WIDE_INT mask = (HOST_WIDE_INT) 1
- << TREE_INT_CST_LOW (shift);
- do_jump (build2 (BIT_AND_EXPR, argtype, arg,
- build_int_cst_type (argtype, mask)),
- clr_label, set_label);
- break;
- }
- }
- }
-
- /* If we are AND'ing with a small constant, do this comparison in the
- smallest type that fits. If the machine doesn't have comparisons
- that small, it will be converted back to the wider comparison.
- This helps if we are testing the sign bit of a narrower object.
- combine can't do this for us because it can't know whether a
- ZERO_EXTRACT or a compare in a smaller mode exists, but we do. */
-
- if (! SLOW_BYTE_ACCESS
- && TREE_CODE (TREE_OPERAND (exp, 1)) == INTEGER_CST
- && TYPE_PRECISION (TREE_TYPE (exp)) <= HOST_BITS_PER_WIDE_INT
- && (i = tree_floor_log2 (TREE_OPERAND (exp, 1))) >= 0
- && (mode = mode_for_size (i + 1, MODE_INT, 0)) != BLKmode
- && (type = lang_hooks.types.type_for_mode (mode, 1)) != 0
- && TYPE_PRECISION (type) < TYPE_PRECISION (TREE_TYPE (exp))
- && (optab_handler (cmp_optab, TYPE_MODE (type))->insn_code
- != CODE_FOR_nothing))
- {
- do_jump (fold_convert (type, exp), if_false_label, if_true_label);
- break;
- }
- goto normal;
-
case TRUTH_NOT_EXPR:
do_jump (TREE_OPERAND (exp, 0), if_true_label, if_false_label);
break;
if (! SLOW_BYTE_ACCESS
&& type != 0 && bitsize >= 0
&& TYPE_PRECISION (type) < TYPE_PRECISION (TREE_TYPE (exp))
- && (optab_handler (cmp_optab, TYPE_MODE (type))->insn_code
- != CODE_FOR_nothing))
+ && have_insn_for (COMPARE, TYPE_MODE (type)))
{
do_jump (fold_convert (type, exp), if_false_label, if_true_label);
break;
goto normal;
}
- case EQ_EXPR:
- {
- tree inner_type = TREE_TYPE (TREE_OPERAND (exp, 0));
-
- gcc_assert (GET_MODE_CLASS (TYPE_MODE (inner_type))
- != MODE_COMPLEX_FLOAT);
- gcc_assert (GET_MODE_CLASS (TYPE_MODE (inner_type))
- != MODE_COMPLEX_INT);
-
- if (integer_zerop (TREE_OPERAND (exp, 1)))
- do_jump (TREE_OPERAND (exp, 0), if_true_label, if_false_label);
- else if (GET_MODE_CLASS (TYPE_MODE (inner_type)) == MODE_INT
- && !can_compare_p (EQ, TYPE_MODE (inner_type), ccp_jump))
- do_jump_by_parts_equality (exp, if_false_label, if_true_label);
- else
- do_compare_and_jump (exp, EQ, EQ, if_false_label, if_true_label);
- break;
- }
-
case MINUS_EXPR:
/* Nonzero iff operands of minus differ. */
- exp = build2 (NE_EXPR, TREE_TYPE (exp),
- TREE_OPERAND (exp, 0),
- TREE_OPERAND (exp, 1));
+ code = NE_EXPR;
+
/* FALLTHRU */
+ case EQ_EXPR:
case NE_EXPR:
- {
- tree inner_type = TREE_TYPE (TREE_OPERAND (exp, 0));
-
- gcc_assert (GET_MODE_CLASS (TYPE_MODE (inner_type))
- != MODE_COMPLEX_FLOAT);
- gcc_assert (GET_MODE_CLASS (TYPE_MODE (inner_type))
- != MODE_COMPLEX_INT);
-
- if (integer_zerop (TREE_OPERAND (exp, 1)))
- do_jump (TREE_OPERAND (exp, 0), if_false_label, if_true_label);
- else if (GET_MODE_CLASS (TYPE_MODE (inner_type)) == MODE_INT
- && !can_compare_p (NE, TYPE_MODE (inner_type), ccp_jump))
- do_jump_by_parts_equality (exp, if_true_label, if_false_label);
- else
- do_compare_and_jump (exp, NE, NE, if_false_label, if_true_label);
- break;
- }
-
case LT_EXPR:
- mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
- if (GET_MODE_CLASS (mode) == MODE_INT
- && ! can_compare_p (LT, mode, ccp_jump))
- do_jump_by_parts_greater (exp, 1, if_false_label, if_true_label);
- else
- do_compare_and_jump (exp, LT, LTU, if_false_label, if_true_label);
- break;
-
case LE_EXPR:
- mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
- if (GET_MODE_CLASS (mode) == MODE_INT
- && ! can_compare_p (LE, mode, ccp_jump))
- do_jump_by_parts_greater (exp, 0, if_true_label, if_false_label);
- else
- do_compare_and_jump (exp, LE, LEU, if_false_label, if_true_label);
- break;
-
case GT_EXPR:
- mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
- if (GET_MODE_CLASS (mode) == MODE_INT
- && ! can_compare_p (GT, mode, ccp_jump))
- do_jump_by_parts_greater (exp, 0, if_false_label, if_true_label);
- else
- do_compare_and_jump (exp, GT, GTU, if_false_label, if_true_label);
- break;
-
case GE_EXPR:
- mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
- if (GET_MODE_CLASS (mode) == MODE_INT
- && ! can_compare_p (GE, mode, ccp_jump))
- do_jump_by_parts_greater (exp, 1, if_true_label, if_false_label);
- else
- do_compare_and_jump (exp, GE, GEU, if_false_label, if_true_label);
+ case ORDERED_EXPR:
+ case UNORDERED_EXPR:
+ case UNLT_EXPR:
+ case UNLE_EXPR:
+ case UNGT_EXPR:
+ case UNGE_EXPR:
+ case UNEQ_EXPR:
+ case LTGT_EXPR:
+ case TRUTH_ANDIF_EXPR:
+ case TRUTH_ORIF_EXPR:
+ do_jump_1 (code, TREE_OPERAND (exp, 0), TREE_OPERAND (exp, 1),
+ if_false_label, if_true_label);
break;
- case UNORDERED_EXPR:
- case ORDERED_EXPR:
- {
- enum rtx_code cmp, rcmp;
- int do_rev;
+ case BIT_AND_EXPR:
+ /* fold_single_bit_test() converts (X & (1 << C)) into (X >> C) & 1.
+ See if the former is preferred for jump tests and restore it
+ if so. */
+ if (integer_onep (TREE_OPERAND (exp, 1)))
+ {
+ tree exp0 = TREE_OPERAND (exp, 0);
+ rtx set_label, clr_label;
- if (code == UNORDERED_EXPR)
- cmp = UNORDERED, rcmp = ORDERED;
- else
- cmp = ORDERED, rcmp = UNORDERED;
- mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
-
- do_rev = 0;
- if (! can_compare_p (cmp, mode, ccp_jump)
- && (can_compare_p (rcmp, mode, ccp_jump)
- /* If the target doesn't provide either UNORDERED or ORDERED
- comparisons, canonicalize on UNORDERED for the library. */
- || rcmp == UNORDERED))
- do_rev = 1;
-
- if (! do_rev)
- do_compare_and_jump (exp, cmp, cmp, if_false_label, if_true_label);
- else
- do_compare_and_jump (exp, rcmp, rcmp, if_true_label, if_false_label);
- }
- break;
+ /* Strip narrowing integral type conversions. */
+ while (CONVERT_EXPR_P (exp0)
+ && TREE_OPERAND (exp0, 0) != error_mark_node
+ && TYPE_PRECISION (TREE_TYPE (exp0))
+ <= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (exp0, 0))))
+ exp0 = TREE_OPERAND (exp0, 0);
- {
- enum rtx_code rcode1;
- enum tree_code tcode1, tcode2;
-
- case UNLT_EXPR:
- rcode1 = UNLT;
- tcode1 = UNORDERED_EXPR;
- tcode2 = LT_EXPR;
- goto unordered_bcc;
- case UNLE_EXPR:
- rcode1 = UNLE;
- tcode1 = UNORDERED_EXPR;
- tcode2 = LE_EXPR;
- goto unordered_bcc;
- case UNGT_EXPR:
- rcode1 = UNGT;
- tcode1 = UNORDERED_EXPR;
- tcode2 = GT_EXPR;
- goto unordered_bcc;
- case UNGE_EXPR:
- rcode1 = UNGE;
- tcode1 = UNORDERED_EXPR;
- tcode2 = GE_EXPR;
- goto unordered_bcc;
- case UNEQ_EXPR:
- rcode1 = UNEQ;
- tcode1 = UNORDERED_EXPR;
- tcode2 = EQ_EXPR;
- goto unordered_bcc;
- case LTGT_EXPR:
- /* It is ok for LTGT_EXPR to trap when the result is unordered,
- so expand to (a < b) || (a > b). */
- rcode1 = LTGT;
- tcode1 = LT_EXPR;
- tcode2 = GT_EXPR;
- goto unordered_bcc;
-
- unordered_bcc:
- mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
- if (can_compare_p (rcode1, mode, ccp_jump))
- do_compare_and_jump (exp, rcode1, rcode1, if_false_label,
- if_true_label);
- else
- {
- tree op0 = save_expr (TREE_OPERAND (exp, 0));
- tree op1 = save_expr (TREE_OPERAND (exp, 1));
- tree cmp0, cmp1;
-
- /* If the target doesn't support combined unordered
- compares, decompose into two comparisons. */
- if (if_true_label == 0)
- drop_through_label = if_true_label = gen_label_rtx ();
-
- cmp0 = fold_build2 (tcode1, TREE_TYPE (exp), op0, op1);
- cmp1 = fold_build2 (tcode2, TREE_TYPE (exp), op0, op1);
- do_jump (cmp0, 0, if_true_label);
- do_jump (cmp1, if_false_label, if_true_label);
- }
- }
- break;
+ /* "exp0 ^ 1" inverts the sense of the single bit test. */
+ if (TREE_CODE (exp0) == BIT_XOR_EXPR
+ && integer_onep (TREE_OPERAND (exp0, 1)))
+ {
+ exp0 = TREE_OPERAND (exp0, 0);
+ clr_label = if_true_label;
+ set_label = if_false_label;
+ }
+ else
+ {
+ clr_label = if_false_label;
+ set_label = if_true_label;
+ }
+
+ if (TREE_CODE (exp0) == RSHIFT_EXPR)
+ {
+ tree arg = TREE_OPERAND (exp0, 0);
+ tree shift = TREE_OPERAND (exp0, 1);
+ tree argtype = TREE_TYPE (arg);
+ if (TREE_CODE (shift) == INTEGER_CST
+ && compare_tree_int (shift, 0) >= 0
+ && compare_tree_int (shift, HOST_BITS_PER_WIDE_INT) < 0
+ && prefer_and_bit_test (TYPE_MODE (argtype),
+ TREE_INT_CST_LOW (shift)))
+ {
+ unsigned HOST_WIDE_INT mask
+ = (unsigned HOST_WIDE_INT) 1 << TREE_INT_CST_LOW (shift);
+ do_jump (build2 (BIT_AND_EXPR, argtype, arg,
+ build_int_cst_wide_type (argtype, mask, 0)),
+ clr_label, set_label);
+ break;
+ }
+ }
+ }
+
+ /* If we are AND'ing with a small constant, do this comparison in the
+ smallest type that fits. If the machine doesn't have comparisons
+ that small, it will be converted back to the wider comparison.
+ This helps if we are testing the sign bit of a narrower object.
+ combine can't do this for us because it can't know whether a
+ ZERO_EXTRACT or a compare in a smaller mode exists, but we do. */
+
+ if (! SLOW_BYTE_ACCESS
+ && TREE_CODE (TREE_OPERAND (exp, 1)) == INTEGER_CST
+ && TYPE_PRECISION (TREE_TYPE (exp)) <= HOST_BITS_PER_WIDE_INT
+ && (i = tree_floor_log2 (TREE_OPERAND (exp, 1))) >= 0
+ && (mode = mode_for_size (i + 1, MODE_INT, 0)) != BLKmode
+ && (type = lang_hooks.types.type_for_mode (mode, 1)) != 0
+ && TYPE_PRECISION (type) < TYPE_PRECISION (TREE_TYPE (exp))
+ && have_insn_for (COMPARE, TYPE_MODE (type)))
+ {
+ do_jump (fold_convert (type, exp), if_false_label, if_true_label);
+ break;
+ }
+
+ if (TYPE_PRECISION (TREE_TYPE (exp)) > 1
+ || TREE_CODE (TREE_OPERAND (exp, 1)) == INTEGER_CST)
+ goto normal;
+
+ /* Boolean comparisons can be compiled as TRUTH_AND_EXPR. */
case TRUTH_AND_EXPR:
/* High branch cost, expand as the bitwise AND of the conditions.
|| TREE_SIDE_EFFECTS (TREE_OPERAND (exp, 1)))
goto normal;
- case TRUTH_ANDIF_EXPR:
- if (if_false_label == NULL_RTX)
- {
- drop_through_label = gen_label_rtx ();
- do_jump (TREE_OPERAND (exp, 0), drop_through_label, NULL_RTX);
- do_jump (TREE_OPERAND (exp, 1), NULL_RTX, if_true_label);
- }
- else
- {
- do_jump (TREE_OPERAND (exp, 0), if_false_label, NULL_RTX);
- do_jump (TREE_OPERAND (exp, 1), if_false_label, if_true_label);
- }
- break;
-
+ case BIT_IOR_EXPR:
case TRUTH_OR_EXPR:
/* High branch cost, expand as the bitwise OR of the conditions.
Do the same if the RHS has side effects, because we're effectively
|| TREE_SIDE_EFFECTS (TREE_OPERAND (exp, 1)))
goto normal;
- case TRUTH_ORIF_EXPR:
- if (if_true_label == NULL_RTX)
- {
- drop_through_label = gen_label_rtx ();
- do_jump (TREE_OPERAND (exp, 0), NULL_RTX, drop_through_label);
- do_jump (TREE_OPERAND (exp, 1), if_false_label, NULL_RTX);
- }
- else
- {
- do_jump (TREE_OPERAND (exp, 0), NULL_RTX, if_true_label);
- do_jump (TREE_OPERAND (exp, 1), if_false_label, if_true_label);
- }
- break;
-
/* Fall through and generate the normal code. */
default:
normal:
and LT if SWAP is 1. */
static void
-do_jump_by_parts_greater (tree exp, int swap, rtx if_false_label,
- rtx if_true_label)
+do_jump_by_parts_greater (tree treeop0, tree treeop1, int swap,
+ rtx if_false_label, rtx if_true_label)
{
- rtx op0 = expand_normal (TREE_OPERAND (exp, swap));
- rtx op1 = expand_normal (TREE_OPERAND (exp, !swap));
- enum machine_mode mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
- int unsignedp = TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0)));
+ rtx op0 = expand_normal (swap ? treeop1 : treeop0);
+ rtx op1 = expand_normal (swap ? treeop0 : treeop1);
+ enum machine_mode mode = TYPE_MODE (TREE_TYPE (treeop0));
+ int unsignedp = TYPE_UNSIGNED (TREE_TYPE (treeop0));
do_jump_by_parts_greater_rtx (mode, unsignedp, op0, op1, if_false_label,
if_true_label);
be slower, but that's highly unlikely. */
part = gen_reg_rtx (word_mode);
- emit_move_insn (part, operand_subword_force (op0, 0, GET_MODE (op0)));
+ emit_move_insn (part, operand_subword_force (op0, 0, mode));
for (i = 1; i < nwords && part != 0; i++)
part = expand_binop (word_mode, ior_optab, part,
- operand_subword_force (op0, i, GET_MODE (op0)),
+ operand_subword_force (op0, i, mode),
part, 1, OPTAB_WIDEN);
if (part != 0)
drop_through_label = if_false_label = gen_label_rtx ();
for (i = 0; i < nwords; i++)
- do_compare_rtx_and_jump (operand_subword_force (op0, i, GET_MODE (op0)),
+ do_compare_rtx_and_jump (operand_subword_force (op0, i, mode),
const0_rtx, EQ, 1, word_mode, NULL_RTX,
if_false_label, NULL_RTX);
with one insn, test the comparison and jump to the appropriate label. */
static void
-do_jump_by_parts_equality (tree exp, rtx if_false_label, rtx if_true_label)
+do_jump_by_parts_equality (tree treeop0, tree treeop1, rtx if_false_label,
+ rtx if_true_label)
{
- rtx op0 = expand_normal (TREE_OPERAND (exp, 0));
- rtx op1 = expand_normal (TREE_OPERAND (exp, 1));
- enum machine_mode mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
+ rtx op0 = expand_normal (treeop0);
+ rtx op1 = expand_normal (treeop1);
+ enum machine_mode mode = TYPE_MODE (TREE_TYPE (treeop0));
do_jump_by_parts_equality_rtx (mode, op0, op1, if_false_label,
if_true_label);
}
\f
-/* Generate code for a comparison of OP0 and OP1 with rtx code CODE.
- MODE is the machine mode of the comparison, not of the result.
- (including code to compute the values to be compared) and set CC0
- according to the result. The decision as to signed or unsigned
- comparison must be made by the caller.
+/* Split a comparison into two others, the second of which has the other
+ "orderedness". The first is always ORDERED or UNORDERED if MODE
+ does not honor NaNs (which means that it can be skipped in that case;
+ see do_compare_rtx_and_jump).
- We force a stack adjustment unless there are currently
- things pushed on the stack that aren't yet used.
-
- If MODE is BLKmode, SIZE is an RTX giving the size of the objects being
- compared. */
+ The two conditions are written in *CODE1 and *CODE2. Return true if
+ the conditions must be ANDed, false if they must be ORed. */
-rtx
-compare_from_rtx (rtx op0, rtx op1, enum rtx_code code, int unsignedp,
- enum machine_mode mode, rtx size)
+bool
+split_comparison (enum rtx_code code, enum machine_mode mode,
+ enum rtx_code *code1, enum rtx_code *code2)
{
- rtx tem;
-
- /* If one operand is constant, make it the second one. Only do this
- if the other operand is not constant as well. */
-
- if (swap_commutative_operands_p (op0, op1))
- {
- tem = op0;
- op0 = op1;
- op1 = tem;
- code = swap_condition (code);
- }
-
- do_pending_stack_adjust ();
-
- code = unsignedp ? unsigned_condition (code) : code;
- tem = simplify_relational_operation (code, VOIDmode, mode, op0, op1);
- if (tem)
+ switch (code)
{
- if (CONSTANT_P (tem))
- return tem;
-
- if (COMPARISON_P (tem))
+ case LT:
+ *code1 = ORDERED;
+ *code2 = UNLT;
+ return true;
+ case LE:
+ *code1 = ORDERED;
+ *code2 = UNLE;
+ return true;
+ case GT:
+ *code1 = ORDERED;
+ *code2 = UNGT;
+ return true;
+ case GE:
+ *code1 = ORDERED;
+ *code2 = UNGE;
+ return true;
+ case EQ:
+ *code1 = ORDERED;
+ *code2 = UNEQ;
+ return true;
+ case NE:
+ *code1 = UNORDERED;
+ *code2 = LTGT;
+ return false;
+ case UNLT:
+ *code1 = UNORDERED;
+ *code2 = LT;
+ return false;
+ case UNLE:
+ *code1 = UNORDERED;
+ *code2 = LE;
+ return false;
+ case UNGT:
+ *code1 = UNORDERED;
+ *code2 = GT;
+ return false;
+ case UNGE:
+ *code1 = UNORDERED;
+ *code2 = GE;
+ return false;
+ case UNEQ:
+ *code1 = UNORDERED;
+ *code2 = EQ;
+ return false;
+ case LTGT:
+ /* Do not turn a trapping comparison into a non-trapping one. */
+ if (HONOR_SNANS (mode))
+ {
+ *code1 = LT;
+ *code2 = GT;
+ return false;
+ }
+ else
{
- code = GET_CODE (tem);
- op0 = XEXP (tem, 0);
- op1 = XEXP (tem, 1);
- mode = GET_MODE (op0);
- unsignedp = (code == GTU || code == LTU
- || code == GEU || code == LEU);
+ *code1 = ORDERED;
+ *code2 = NE;
+ return true;
}
+ default:
+ gcc_unreachable ();
}
-
- emit_cmp_insn (op0, op1, code, size, mode, unsignedp);
-
-#if HAVE_cc0
- return gen_rtx_fmt_ee (code, VOIDmode, cc0_rtx, const0_rtx);
-#else
- return gen_rtx_fmt_ee (code, VOIDmode, op0, op1);
-#endif
}
+
/* Like do_compare_and_jump but expects the values to compare as two rtx's.
The decision as to signed or unsigned comparison must be made by the caller.
rtx if_true_label)
{
rtx tem;
- int dummy_true_label = 0;
+ rtx dummy_label = NULL_RTX;
/* Reverse the comparison if that is safe and we want to jump if it is
- false. */
- if (! if_true_label && ! FLOAT_MODE_P (mode))
+ false. Also convert to the reverse comparison if the target can
+ implement it. */
+ if ((! if_true_label
+ || ! can_compare_p (code, mode, ccp_jump))
+ && (! FLOAT_MODE_P (mode)
+ || code == ORDERED || code == UNORDERED
+ || (! HONOR_NANS (mode) && (code == LTGT || code == UNEQ))
+ || (! HONOR_SNANS (mode) && (code == EQ || code == NE))))
{
- if_true_label = if_false_label;
- if_false_label = 0;
- code = reverse_condition (code);
+ enum rtx_code rcode;
+ if (FLOAT_MODE_P (mode))
+ rcode = reverse_condition_maybe_unordered (code);
+ else
+ rcode = reverse_condition (code);
+
+ /* Canonicalize to UNORDERED for the libcall. */
+ if (can_compare_p (rcode, mode, ccp_jump)
+ || (code == ORDERED && ! can_compare_p (ORDERED, mode, ccp_jump)))
+ {
+ tem = if_true_label;
+ if_true_label = if_false_label;
+ if_false_label = tem;
+ code = rcode;
+ }
}
/* If one operand is constant, make it the second one. Only do this
unsignedp = (code == GTU || code == LTU || code == GEU || code == LEU);
}
-
if (! if_true_label)
- {
- dummy_true_label = 1;
- if_true_label = gen_label_rtx ();
- }
+ dummy_label = if_true_label = gen_label_rtx ();
if (GET_MODE_CLASS (mode) == MODE_INT
&& ! can_compare_p (code, mode, ccp_jump))
}
}
else
- emit_cmp_and_jump_insns (op0, op1, code, size, mode, unsignedp,
- if_true_label);
+ {
+ if (GET_MODE_CLASS (mode) == MODE_FLOAT
+ && ! can_compare_p (code, mode, ccp_jump)
+ && can_compare_p (swap_condition (code), mode, ccp_jump))
+ {
+ rtx tmp;
+ code = swap_condition (code);
+ tmp = op0;
+ op0 = op1;
+ op1 = tmp;
+ }
+
+ else if (GET_MODE_CLASS (mode) == MODE_FLOAT
+ && ! can_compare_p (code, mode, ccp_jump)
+
+ /* Never split ORDERED and UNORDERED. These must be implemented. */
+ && (code != ORDERED && code != UNORDERED)
+
+ /* Split a floating-point comparison if we can jump on other
+ conditions... */
+ && (have_insn_for (COMPARE, mode)
+
+ /* ... or if there is no libcall for it. */
+ || code_to_optab[code] == NULL))
+ {
+ enum rtx_code first_code;
+ bool and_them = split_comparison (code, mode, &first_code, &code);
+
+ /* If there are no NaNs, the first comparison should always fall
+ through. */
+ if (!HONOR_NANS (mode))
+ gcc_assert (first_code == (and_them ? ORDERED : UNORDERED));
+
+ else
+ {
+ if (and_them)
+ {
+ rtx dest_label;
+ /* If we only jump if true, just bypass the second jump. */
+ if (! if_false_label)
+ {
+ if (! dummy_label)
+ dummy_label = gen_label_rtx ();
+ dest_label = dummy_label;
+ }
+ else
+ dest_label = if_false_label;
+ do_compare_rtx_and_jump (op0, op1, first_code, unsignedp, mode,
+ size, dest_label, NULL_RTX);
+ }
+ else
+ do_compare_rtx_and_jump (op0, op1, first_code, unsignedp, mode,
+ size, NULL_RTX, if_true_label);
+ }
+ }
+
+ emit_cmp_and_jump_insns (op0, op1, code, size, mode, unsignedp,
+ if_true_label);
+ }
if (if_false_label)
emit_jump (if_false_label);
- if (dummy_true_label)
- emit_label (if_true_label);
+ if (dummy_label)
+ emit_label (dummy_label);
}
/* Generate code for a comparison expression EXP (including code to compute
things pushed on the stack that aren't yet used. */
static void
-do_compare_and_jump (tree exp, enum rtx_code signed_code,
+do_compare_and_jump (tree treeop0, tree treeop1, enum rtx_code signed_code,
enum rtx_code unsigned_code, rtx if_false_label,
rtx if_true_label)
{
enum rtx_code code;
/* Don't crash if the comparison was erroneous. */
- op0 = expand_normal (TREE_OPERAND (exp, 0));
- if (TREE_CODE (TREE_OPERAND (exp, 0)) == ERROR_MARK)
+ op0 = expand_normal (treeop0);
+ if (TREE_CODE (treeop0) == ERROR_MARK)
return;
- op1 = expand_normal (TREE_OPERAND (exp, 1));
- if (TREE_CODE (TREE_OPERAND (exp, 1)) == ERROR_MARK)
+ op1 = expand_normal (treeop1);
+ if (TREE_CODE (treeop1) == ERROR_MARK)
return;
- type = TREE_TYPE (TREE_OPERAND (exp, 0));
+ type = TREE_TYPE (treeop0);
mode = TYPE_MODE (type);
- if (TREE_CODE (TREE_OPERAND (exp, 0)) == INTEGER_CST
- && (TREE_CODE (TREE_OPERAND (exp, 1)) != INTEGER_CST
+ if (TREE_CODE (treeop0) == INTEGER_CST
+ && (TREE_CODE (treeop1) != INTEGER_CST
|| (GET_MODE_BITSIZE (mode)
- > GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp,
- 1)))))))
+ > GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (treeop1))))))
{
/* op0 might have been replaced by promoted constant, in which
case the type of second argument should be used. */
- type = TREE_TYPE (TREE_OPERAND (exp, 1));
+ type = TREE_TYPE (treeop1);
mode = TYPE_MODE (type);
}
unsignedp = TYPE_UNSIGNED (type);
If one side isn't, we want a noncanonicalized comparison. See PR
middle-end/17564. */
if (HAVE_canonicalize_funcptr_for_compare
- && TREE_CODE (TREE_TYPE (TREE_OPERAND (exp, 0))) == POINTER_TYPE
- && TREE_CODE (TREE_TYPE (TREE_TYPE (TREE_OPERAND (exp, 0))))
+ && TREE_CODE (TREE_TYPE (treeop0)) == POINTER_TYPE
+ && TREE_CODE (TREE_TYPE (TREE_TYPE (treeop0)))
== FUNCTION_TYPE
- && TREE_CODE (TREE_TYPE (TREE_OPERAND (exp, 1))) == POINTER_TYPE
- && TREE_CODE (TREE_TYPE (TREE_TYPE (TREE_OPERAND (exp, 1))))
+ && TREE_CODE (TREE_TYPE (treeop1)) == POINTER_TYPE
+ && TREE_CODE (TREE_TYPE (TREE_TYPE (treeop1)))
== FUNCTION_TYPE)
{
rtx new_op0 = gen_reg_rtx (mode);
do_compare_rtx_and_jump (op0, op1, code, unsignedp, mode,
((mode == BLKmode)
- ? expr_size (TREE_OPERAND (exp, 0)) : NULL_RTX),
+ ? expr_size (treeop0) : NULL_RTX),
if_false_label, if_true_label);
}