Re: [3/4] Dissect expand

[Richard Guenther <richard dot guenther at gmail dot com>]

On Tue, Aug 25, 2009 at 2:28 PM, Michael Matz<matz@suse.de> wrote:
> 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 :)

Ok with the stray /* BLA */ comments removed.

Thanks,
Richard.

>
> 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);
>