diff options
author | Jan Hubicka <jh@suse.cz> | 2001-01-08 16:16:40 +0100 |
---|---|---|
committer | Jan Hubicka <hubicka@gcc.gnu.org> | 2001-01-08 15:16:40 +0000 |
commit | 261efdefd067fbb10979f662f9fe0a3da986d2b5 (patch) | |
tree | 3ffcebd198ac0745cfb083cc4d096b8c14b9273d /gcc | |
parent | 3febd12318b0cdef645012bbce9cf85e4e4d80ed (diff) | |
download | gcc-261efdefd067fbb10979f662f9fe0a3da986d2b5.zip gcc-261efdefd067fbb10979f662f9fe0a3da986d2b5.tar.gz gcc-261efdefd067fbb10979f662f9fe0a3da986d2b5.tar.bz2 |
jump.c (jump_optimize_1): Use reversed_comparison_code instead of can_reverse_comparison_p.
* jump.c (jump_optimize_1): Use reversed_comparison_code
instead of can_reverse_comparison_p.
(jump_back_p): Likewise.
(invert_exp_1): Likewise.
(thread_jumps): Likewise.
* simplify-rtx.c (simplify_unary_operation): Likewise.
(simplify_ternary_operation): Likewise.
* cse.c (find_comparison_args): Convert to use
can_reverse_comparison_p.
(record_jump_equiv): Likewise.
From-SVN: r38802
Diffstat (limited to 'gcc')
-rw-r--r-- | gcc/ChangeLog | 13 | ||||
-rw-r--r-- | gcc/cse.c | 20 | ||||
-rw-r--r-- | gcc/jump.c | 36 | ||||
-rw-r--r-- | gcc/simplify-rtx.c | 17 |
4 files changed, 58 insertions, 28 deletions
diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 655af22..721b1c7 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,16 @@ +Mon Jan 8 16:14:56 MET 2001 Jan Hubicka <jh@suse.cz> + + * jump.c (jump_optimize_1): Use reversed_comparison_code + instead of can_reverse_comparison_p. + (jump_back_p): Likewise. + (invert_exp_1): Likewise. + (thread_jumps): Likewise. + * simplify-rtx.c (simplify_unary_operation): Likewise. + (simplify_ternary_operation): Likewise. + * cse.c (find_comparison_args): Convert to use + can_reverse_comparison_p. + (record_jump_equiv): Likewise. + 2001-01-08 Richard Earnshaw <rearnsha@arm.com> * arm.h (HARD_REGNO_RENAME_OK): Delete. @@ -3251,15 +3251,16 @@ find_comparison_args (code, parg1, parg2, pmode1, pmode2) /* If we need to reverse the comparison, make sure that that is possible -- we can't necessarily infer the value of GE from LT with floating-point operands. */ - if (reverse_code && ! can_reverse_comparison_p (x, NULL_RTX)) - break; - - arg1 = XEXP (x, 0), arg2 = XEXP (x, 1); - if (GET_RTX_CLASS (GET_CODE (x)) == '<') - code = GET_CODE (x); - if (reverse_code) - code = reverse_condition (code); + { + enum rtx_code reversed = reversed_comparison_code (x, NULL_RTX); + if (reversed == UNKNOWN) + break; + else code = reversed; + } + else if (GET_RTX_CLASS (GET_CODE (x)) == '<') + code = GET_CODE (x); + arg1 = XEXP (x, 0), arg2 = XEXP (x, 1); } /* Return our results. Return the modes from before fold_rtx @@ -4446,8 +4447,7 @@ record_jump_equiv (insn, taken) code = find_comparison_args (code, &op0, &op1, &mode0, &mode1); if (! cond_known_true) { - reversed_nonequality = (code != EQ && code != NE); - code = reverse_condition (code); + code = reversed_comparison_code_parts (code, op0, op1, insn); /* Don't remember if we can't find the inverse. */ if (code == UNKNOWN) @@ -207,6 +207,7 @@ jump_optimize_1 (f, cross_jump, noop_moves, after_regscan, int first = 1; int max_uid = 0; rtx last_insn; + enum rtx_code reversed_code; cross_jump_death_matters = (cross_jump == 2); max_uid = init_label_info (f) + 1; @@ -525,9 +526,10 @@ jump_optimize_1 (f, cross_jump, noop_moves, after_regscan, && prev_active_insn (reallabelprev) == insn && no_labels_between_p (insn, reallabelprev) && (temp2 = get_condition (insn, &temp4)) - && can_reverse_comparison_p (temp2, insn)) + && ((reversed_code = reversed_comparison_code (temp2, insn)) + != UNKNOWN)) { - rtx new = gen_cond_trap (reverse_condition (GET_CODE (temp2)), + rtx new = gen_cond_trap (reversed_code, XEXP (temp2, 0), XEXP (temp2, 1), TRAP_CODE (PATTERN (reallabelprev))); @@ -1682,16 +1684,16 @@ jump_back_p (insn, target) if (XEXP (SET_SRC (set), 1) == pc_rtx) { - if (! can_reverse_comparison_p (cinsn, insn)) + codei = reversed_comparison_code (cinsn, insn); + if (codei == UNKNOWN) return 0; - codei = reverse_condition (codei); } if (XEXP (SET_SRC (tset), 2) == pc_rtx) { - if (! can_reverse_comparison_p (ctarget, target)) + codet = reversed_comparison_code (ctarget, target); + if (codei == UNKNOWN) return 0; - codet = reverse_condition (codet); } return (codei == codet @@ -3319,16 +3321,19 @@ invert_exp_1 (insn) { register rtx comp = XEXP (x, 0); register rtx tem; + enum rtx_code reversed_code; /* We can do this in two ways: The preferable way, which can only be done if this is not an integer comparison, is to reverse the comparison code. Otherwise, swap the THEN-part and ELSE-part of the IF_THEN_ELSE. If we can't do either, fail. */ - if (can_reverse_comparison_p (comp, insn)) + reversed_code = reversed_comparison_code (comp, insn); + + if (reversed_code != UNKNOWN) { validate_change (insn, &XEXP (x, 0), - gen_rtx_fmt_ee (reverse_condition (GET_CODE (comp)), + gen_rtx_fmt_ee (reversed_code, GET_MODE (comp), XEXP (comp, 0), XEXP (comp, 1)), 1); @@ -3849,6 +3854,7 @@ thread_jumps (f, max_reg, flag_before_loop) int changed = 1; int i; int *all_reset; + enum rtx_code reversed_code1, reversed_code2; /* Allocate register tables and quick-reset table. */ modified_regs = (char *) xmalloc (max_reg * sizeof (char)); @@ -3938,14 +3944,20 @@ thread_jumps (f, max_reg, flag_before_loop) b1op0 = XEXP (XEXP (SET_SRC (set), 0), 0); b1op1 = XEXP (XEXP (SET_SRC (set), 0), 1); code1 = GET_CODE (XEXP (SET_SRC (set), 0)); + reversed_code1 = code1; if (XEXP (SET_SRC (set), 1) == pc_rtx) - code1 = reverse_condition (code1); + code1 = reversed_comparison_code (XEXP (SET_SRC (set), 0), b1); + else + reversed_code1 = reversed_comparison_code (XEXP (SET_SRC (set), 0), b1); b2op0 = XEXP (XEXP (SET_SRC (set2), 0), 0); b2op1 = XEXP (XEXP (SET_SRC (set2), 0), 1); code2 = GET_CODE (XEXP (SET_SRC (set2), 0)); + reversed_code2 = code2; if (XEXP (SET_SRC (set2), 1) == pc_rtx) - code2 = reverse_condition (code2); + code2 = reversed_comparison_code (XEXP (SET_SRC (set2), 0), b2); + else + reversed_code2 = reversed_comparison_code (XEXP (SET_SRC (set2), 0), b2); /* If they test the same things and knowing that B1 branches tells us whether or not B2 branches, check if we @@ -3953,9 +3965,7 @@ thread_jumps (f, max_reg, flag_before_loop) if (rtx_equal_for_thread_p (b1op0, b2op0, b2) && rtx_equal_for_thread_p (b1op1, b2op1, b2) && (comparison_dominates_p (code1, code2) - || (can_reverse_comparison_p (XEXP (SET_SRC (set), 0), b1) - && comparison_dominates_p (code1, - reverse_condition (code2))))) + || comparison_dominates_p (code1, reversed_code2))) { t1 = prev_nonnote_insn (b1); diff --git a/gcc/simplify-rtx.c b/gcc/simplify-rtx.c index a3a1bfe..9b0f798 100644 --- a/gcc/simplify-rtx.c +++ b/gcc/simplify-rtx.c @@ -584,6 +584,7 @@ simplify_unary_operation (code, mode, op, op_mode) eggert@twinsun.com says it is safe for IEEE also. */ else { + enum rtx_code reversed; /* There are some simplifications we can do even if the operands aren't constant. */ switch (code) @@ -595,8 +596,9 @@ simplify_unary_operation (code, mode, op, op_mode) /* (not (eq X Y)) == (ne X Y), etc. */ if (mode == BImode && GET_RTX_CLASS (GET_CODE (op)) == '<' - && can_reverse_comparison_p (op, NULL_RTX)) - return gen_rtx_fmt_ee (reverse_condition (GET_CODE (op)), + && ((reversed = reversed_comparison_code (op, NULL_RTX)) + != UNKNOWN)) + return gen_rtx_fmt_ee (reversed, op_mode, XEXP (op, 0), XEXP (op, 1)); break; @@ -2075,9 +2077,14 @@ simplify_ternary_operation (code, mode, op0_mode, op0, op1, op2) if (t == STORE_FLAG_VALUE && f == 0) code = GET_CODE (op0); - else if (t == 0 && f == STORE_FLAG_VALUE - && can_reverse_comparison_p (op0, NULL_RTX)) - code = reverse_condition (GET_CODE (op0)); + else if (t == 0 && f == STORE_FLAG_VALUE) + { + enum rtx_code tmp; + tmp = reversed_comparison_code (op0, NULL_RTX); + if (tmp == UNKNOWN) + break; + code = tmp; + } else break; |