[3/4] Dissect expand
Michael Matz
matz@suse.de
Tue Aug 25 13:28:00 GMT 2009
Hi,
this time the goal is to get rid of 'exp' for the simple binary
comparisons. It's only one innocent call to jumpifnot() in
expand_expr_real_1, but it requires splitting out some parts of do_jump()
into a separate helper, using that for a new jumpifnot_1(), and rewriting
everything of the split out part to not use TREE_OPERAND (exp, ...) but to
take the exploded arguments/code directly.
I've also exported the do_jump_1() helper because I'll make use of it in
cfgexpand.c.
Regstrapped together with [2/4] on x86_64-linux, all langs + Ada, no
regression. Okay for trunk?
Patch [4/4] isn't ready yet, so I seek approval for 1 to 3 already now
to see the wood behind the trees again :)
Ciao,
Michael.
--
* expr.h (jumpifnot_1, jumpif_1, do_jump_1): Declare.
* dojump.c (do_jump_by_parts_greater): Take two operands instead of
full expression.
(do_jump_by_parts_equality, do_compare_and_jump): Ditto.
(jumpifnot_1, jumpif_1): New wrappers for do_jump_1.
(do_jump): Split out code for simple binary comparisons into ...
(do_jump_1): ... this, taking the individual operands and code.
Change callers to helper function above accordingly.
* expr.c (expand_expr_real_1): Use jumpifnot_1 for simple binary
comparisons.
Index: gcc/dojump.c
===================================================================
--- gcc.orig/dojump.c 2009-07-01 12:56:16.000000000 +0200
+++ gcc/dojump.c 2009-08-24 10:15:42.000000000 +0200
@@ -37,9 +37,9 @@ along with GCC; see the file COPYING3.
#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
@@ -101,6 +101,12 @@ jumpifnot (tree exp, rtx label)
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
@@ -109,6 +115,12 @@ jumpif (tree exp, rtx label)
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;
@@ -149,6 +161,165 @@ prefer_and_bit_test (enum machine_mode m
<= 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,
@@ -266,118 +437,29 @@ do_jump (tree exp, rtx if_false_label, r
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);
- break;
-
case ORDERED_EXPR:
- do_compare_and_jump (exp, ORDERED, ORDERED,
- if_false_label, if_true_label);
- break;
-
case UNORDERED_EXPR:
- do_compare_and_jump (exp, UNORDERED, UNORDERED,
- if_false_label, if_true_label);
- break;
-
case UNLT_EXPR:
- do_compare_and_jump (exp, UNLT, UNLT, if_false_label, if_true_label);
- break;
-
case UNLE_EXPR:
- do_compare_and_jump (exp, UNLE, UNLE, if_false_label, if_true_label);
- break;
-
case UNGT_EXPR:
- do_compare_and_jump (exp, UNGT, UNGT, if_false_label, if_true_label);
- break;
-
case UNGE_EXPR:
- do_compare_and_jump (exp, UNGE, UNGE, if_false_label, if_true_label);
- break;
-
case UNEQ_EXPR:
- do_compare_and_jump (exp, UNEQ, UNEQ, if_false_label, if_true_label);
- break;
-
case LTGT_EXPR:
- do_compare_and_jump (exp, LTGT, LTGT, if_false_label, if_true_label);
+ 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 BIT_AND_EXPR:
@@ -466,20 +548,6 @@ do_jump (tree exp, rtx if_false_label, r
|| 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.
@@ -489,20 +557,6 @@ do_jump (tree exp, rtx if_false_label, r
|| 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:
@@ -588,13 +642,13 @@ do_jump_by_parts_greater_rtx (enum machi
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);
@@ -693,11 +747,12 @@ do_jump_by_parts_equality_rtx (enum mach
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);
}
@@ -994,7 +1049,7 @@ do_compare_rtx_and_jump (rtx op0, rtx op
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)
{
@@ -1005,25 +1060,24 @@ do_compare_and_jump (tree exp, enum rtx_
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);
@@ -1036,11 +1090,11 @@ do_compare_and_jump (tree exp, enum rtx_
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);
@@ -1056,7 +1110,7 @@ do_compare_and_jump (tree exp, enum rtx_
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);
}
Index: gcc/expr.c
===================================================================
--- gcc.orig/expr.c 2009-08-24 09:00:40.000000000 +0200
+++ gcc/expr.c 2009-08-24 10:16:33.000000000 +0200
@@ -9169,8 +9169,7 @@ expand_expr_real_1 (tree exp, rtx target
emit_move_insn (target, const0_rtx);
op1 = gen_label_rtx ();
- /* BLA */
- jumpifnot (exp, op1);
+ jumpifnot_1 (code, treeop0, treeop1, op1);
if (target)
emit_move_insn (target, const1_rtx);
Index: gcc/expr.h
===================================================================
--- gcc.orig/expr.h 2009-08-24 08:40:16.000000000 +0200
+++ gcc/expr.h 2009-08-24 10:03:11.000000000 +0200
@@ -579,13 +579,16 @@ extern tree string_constant (tree, tree
/* Generate code to evaluate EXP and jump to LABEL if the value is zero. */
extern void jumpifnot (tree, rtx);
+extern void jumpifnot_1 (enum tree_code, tree, tree, rtx);
/* Generate code to evaluate EXP and jump to LABEL if the value is nonzero. */
extern void jumpif (tree, rtx);
+extern void jumpif_1 (enum tree_code, tree, tree, rtx);
/* 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. */
extern void do_jump (tree, rtx, rtx);
+extern void do_jump_1 (enum tree_code, tree, tree, rtx, rtx);
extern void do_compare_rtx_and_jump (rtx, rtx, enum rtx_code, int,
enum machine_mode, rtx, rtx, rtx);
More information about the Gcc-patches
mailing list