-
- /* Simplify if (...) x = a; else x = b; by converting it
- to x = b; if (...) x = a;
- if B is sufficiently simple, the test doesn't involve X,
- and nothing in the test modifies B or X.
-
- If we have small register classes, we also can't do this if X
- is a hard register.
-
- If the "x = b;" insn has any REG_NOTES, we don't do this because
- of the possibility that we are running after CSE and there is a
- REG_EQUAL note that is only valid if the branch has already been
- taken. If we move the insn with the REG_EQUAL note, we may
- fold the comparison to always be false in a later CSE pass.
- (We could also delete the REG_NOTES when moving the insn, but it
- seems simpler to not move it.) An exception is that we can move
- the insn if the only note is a REG_EQUAL or REG_EQUIV whose
- value is the same as "b".
-
- INSN is the branch over the `else' part.
-
- We set:
-
- TEMP to the jump insn preceding "x = a;"
- TEMP1 to X
- TEMP2 to the insn that sets "x = b;"
- TEMP3 to the insn that sets "x = a;"
- TEMP4 to the set of "x = b"; */
-
- if (this_is_simplejump
- && (temp3 = prev_active_insn (insn)) != 0
- && GET_CODE (temp3) == INSN
- && (temp4 = single_set (temp3)) != 0
- && GET_CODE (temp1 = SET_DEST (temp4)) == REG
- && (! SMALL_REGISTER_CLASSES
- || REGNO (temp1) >= FIRST_PSEUDO_REGISTER)
- && (temp2 = next_active_insn (insn)) != 0
- && GET_CODE (temp2) == INSN
- && (temp4 = single_set (temp2)) != 0
- && rtx_equal_p (SET_DEST (temp4), temp1)
- && ! side_effects_p (SET_SRC (temp4))
- && ! may_trap_p (SET_SRC (temp4))
- && (REG_NOTES (temp2) == 0
- || ((REG_NOTE_KIND (REG_NOTES (temp2)) == REG_EQUAL
- || REG_NOTE_KIND (REG_NOTES (temp2)) == REG_EQUIV)
- && XEXP (REG_NOTES (temp2), 1) == 0
- && rtx_equal_p (XEXP (REG_NOTES (temp2), 0),
- SET_SRC (temp4))))
- && (temp = prev_active_insn (temp3)) != 0
- && condjump_p (temp) && ! simplejump_p (temp)
- /* TEMP must skip over the "x = a;" insn */
- && prev_real_insn (JUMP_LABEL (temp)) == insn
- && no_labels_between_p (insn, JUMP_LABEL (temp))
- /* There must be no other entries to the "x = b;" insn. */
- && no_labels_between_p (JUMP_LABEL (temp), temp2)
- /* INSN must either branch to the insn after TEMP2 or the insn
- after TEMP2 must branch to the same place as INSN. */
- && (reallabelprev == temp2
- || ((temp5 = next_active_insn (temp2)) != 0
- && simplejump_p (temp5)
- && JUMP_LABEL (temp5) == JUMP_LABEL (insn))))
- {
- /* The test expression, X, may be a complicated test with
- multiple branches. See if we can find all the uses of
- the label that TEMP branches to without hitting a CALL_INSN
- or a jump to somewhere else. */
- rtx target = JUMP_LABEL (temp);
- int nuses = LABEL_NUSES (target);
- rtx p;
-#ifdef HAVE_cc0
- rtx q;
-#endif
-
- /* Set P to the first jump insn that goes around "x = a;". */
- for (p = temp; nuses && p; p = prev_nonnote_insn (p))
- {
- if (GET_CODE (p) == JUMP_INSN)
- {
- if (condjump_p (p) && ! simplejump_p (p)
- && JUMP_LABEL (p) == target)
- {
- nuses--;
- if (nuses == 0)
- break;
- }
- else
- break;
- }
- else if (GET_CODE (p) == CALL_INSN)
- break;
- }
-
-#ifdef HAVE_cc0
- /* We cannot insert anything between a set of cc and its use
- so if P uses cc0, we must back up to the previous insn. */
- q = prev_nonnote_insn (p);
- if (q && GET_RTX_CLASS (GET_CODE (q)) == 'i'
- && sets_cc0_p (PATTERN (q)))
- p = q;
-#endif
-
- if (p)
- p = PREV_INSN (p);
-
- /* If we found all the uses and there was no data conflict, we
- can move the assignment unless we can branch into the middle
- from somewhere. */
- if (nuses == 0 && p
- && no_labels_between_p (p, insn)
- && ! reg_referenced_between_p (temp1, p, NEXT_INSN (temp3))
- && ! reg_set_between_p (temp1, p, temp3)
- && (GET_CODE (SET_SRC (temp4)) == CONST_INT
- || ! modified_between_p (SET_SRC (temp4), p, temp2))
- /* Verify that registers used by the jump are not clobbered
- by the instruction being moved. */
- && ! regs_set_between_p (PATTERN (temp),
- PREV_INSN (temp2),
- NEXT_INSN (temp2)))
- {
- emit_insn_after_with_line_notes (PATTERN (temp2), p, temp2);
- delete_insn (temp2);
-
- /* Set NEXT to an insn that we know won't go away. */
- next = next_active_insn (insn);
-
- /* Delete the jump around the set. Note that we must do
- this before we redirect the test jumps so that it won't
- delete the code immediately following the assignment
- we moved (which might be a jump). */
-
- delete_insn (insn);
-
- /* We either have two consecutive labels or a jump to
- a jump, so adjust all the JUMP_INSNs to branch to where
- INSN branches to. */
- for (p = NEXT_INSN (p); p != next; p = NEXT_INSN (p))
- if (GET_CODE (p) == JUMP_INSN)
- redirect_jump (p, target);
-
- changed = 1;
- next = NEXT_INSN (insn);
- continue;
- }
- }
-
- /* Simplify if (...) { x = a; goto l; } x = b; by converting it
- to x = a; if (...) goto l; x = b;
- if A is sufficiently simple, the test doesn't involve X,
- and nothing in the test modifies A or X.
-
- If we have small register classes, we also can't do this if X
- is a hard register.
-
- If the "x = a;" insn has any REG_NOTES, we don't do this because
- of the possibility that we are running after CSE and there is a
- REG_EQUAL note that is only valid if the branch has already been
- taken. If we move the insn with the REG_EQUAL note, we may
- fold the comparison to always be false in a later CSE pass.
- (We could also delete the REG_NOTES when moving the insn, but it
- seems simpler to not move it.) An exception is that we can move
- the insn if the only note is a REG_EQUAL or REG_EQUIV whose
- value is the same as "a".
-
- INSN is the goto.
-
- We set:
-
- TEMP to the jump insn preceding "x = a;"
- TEMP1 to X
- TEMP2 to the insn that sets "x = b;"
- TEMP3 to the insn that sets "x = a;"
- TEMP4 to the set of "x = a"; */
-
- if (this_is_simplejump
- && (temp2 = next_active_insn (insn)) != 0
- && GET_CODE (temp2) == INSN
- && (temp4 = single_set (temp2)) != 0
- && GET_CODE (temp1 = SET_DEST (temp4)) == REG
- && (! SMALL_REGISTER_CLASSES
- || REGNO (temp1) >= FIRST_PSEUDO_REGISTER)
- && (temp3 = prev_active_insn (insn)) != 0
- && GET_CODE (temp3) == INSN
- && (temp4 = single_set (temp3)) != 0
- && rtx_equal_p (SET_DEST (temp4), temp1)
- && ! side_effects_p (SET_SRC (temp4))
- && ! may_trap_p (SET_SRC (temp4))
- && (REG_NOTES (temp3) == 0
- || ((REG_NOTE_KIND (REG_NOTES (temp3)) == REG_EQUAL
- || REG_NOTE_KIND (REG_NOTES (temp3)) == REG_EQUIV)
- && XEXP (REG_NOTES (temp3), 1) == 0
- && rtx_equal_p (XEXP (REG_NOTES (temp3), 0),
- SET_SRC (temp4))))
- && (temp = prev_active_insn (temp3)) != 0
- && condjump_p (temp) && ! simplejump_p (temp)
- /* TEMP must skip over the "x = a;" insn */
- && prev_real_insn (JUMP_LABEL (temp)) == insn
- && no_labels_between_p (temp, insn))
- {
- rtx prev_label = JUMP_LABEL (temp);
- rtx insert_after = prev_nonnote_insn (temp);
-
-#ifdef HAVE_cc0
- /* We cannot insert anything between a set of cc and its use. */
- if (insert_after && GET_RTX_CLASS (GET_CODE (insert_after)) == 'i'
- && sets_cc0_p (PATTERN (insert_after)))
- insert_after = prev_nonnote_insn (insert_after);
-#endif
- ++LABEL_NUSES (prev_label);
-
- if (insert_after
- && no_labels_between_p (insert_after, temp)
- && ! reg_referenced_between_p (temp1, insert_after, temp3)
- && ! reg_referenced_between_p (temp1, temp3,
- NEXT_INSN (temp2))
- && ! reg_set_between_p (temp1, insert_after, temp)
- && ! modified_between_p (SET_SRC (temp4), insert_after, temp)
- /* Verify that registers used by the jump are not clobbered
- by the instruction being moved. */
- && ! regs_set_between_p (PATTERN (temp),
- PREV_INSN (temp3),
- NEXT_INSN (temp3))
- && invert_jump (temp, JUMP_LABEL (insn)))
- {
- emit_insn_after_with_line_notes (PATTERN (temp3),
- insert_after, temp3);
- delete_insn (temp3);
- delete_insn (insn);
- /* Set NEXT to an insn that we know won't go away. */
- next = temp2;
- changed = 1;
- }
- if (prev_label && --LABEL_NUSES (prev_label) == 0)
- delete_insn (prev_label);
- if (changed)
- continue;
- }
-
-#if !defined(HAVE_cc0) && !defined(HAVE_conditional_arithmetic)
-
- /* If we have if (...) x = exp; and branches are expensive,
- EXP is a single insn, does not have any side effects, cannot
- trap, and is not too costly, convert this to
- t = exp; if (...) x = t;
-
- Don't do this when we have CC0 because it is unlikely to help
- and we'd need to worry about where to place the new insn and
- the potential for conflicts. We also can't do this when we have
- notes on the insn for the same reason as above.
-
- If we have conditional arithmetic, this will make this
- harder to optimize later and isn't needed, so don't do it
- in that case either.
-
- We set:
-
- TEMP to the "x = exp;" insn.
- TEMP1 to the single set in the "x = exp;" insn.
- TEMP2 to "x". */
-
- if (! reload_completed
- && this_is_condjump && ! this_is_simplejump
- && BRANCH_COST >= 3
- && (temp = next_nonnote_insn (insn)) != 0
- && GET_CODE (temp) == INSN
- && REG_NOTES (temp) == 0
- && (reallabelprev == temp
- || ((temp2 = next_active_insn (temp)) != 0
- && simplejump_p (temp2)
- && JUMP_LABEL (temp2) == JUMP_LABEL (insn)))
- && (temp1 = single_set (temp)) != 0
- && (temp2 = SET_DEST (temp1), GET_CODE (temp2) == REG)
- && (! SMALL_REGISTER_CLASSES
- || REGNO (temp2) >= FIRST_PSEUDO_REGISTER)
- && GET_CODE (SET_SRC (temp1)) != REG
- && GET_CODE (SET_SRC (temp1)) != SUBREG
- && GET_CODE (SET_SRC (temp1)) != CONST_INT
- && ! side_effects_p (SET_SRC (temp1))
- && ! may_trap_p (SET_SRC (temp1))
- && rtx_cost (SET_SRC (temp1), SET) < 10)
- {
- rtx new = gen_reg_rtx (GET_MODE (temp2));
-
- if ((temp3 = find_insert_position (insn, temp))
- && validate_change (temp, &SET_DEST (temp1), new, 0))
- {
- next = emit_insn_after (gen_move_insn (temp2, new), insn);
- emit_insn_after_with_line_notes (PATTERN (temp),
- PREV_INSN (temp3), temp);
- delete_insn (temp);
- reallabelprev = prev_active_insn (JUMP_LABEL (insn));
-
- if (after_regscan)
- {
- reg_scan_update (temp3, NEXT_INSN (next), old_max_reg);
- old_max_reg = max_reg_num ();
- }
- }
- }
-
- /* Similarly, if it takes two insns to compute EXP but they
- have the same destination. Here TEMP3 will be the second
- insn and TEMP4 the SET from that insn. */
-
- if (! reload_completed
- && this_is_condjump && ! this_is_simplejump
- && BRANCH_COST >= 4
- && (temp = next_nonnote_insn (insn)) != 0
- && GET_CODE (temp) == INSN
- && REG_NOTES (temp) == 0
- && (temp3 = next_nonnote_insn (temp)) != 0
- && GET_CODE (temp3) == INSN
- && REG_NOTES (temp3) == 0
- && (reallabelprev == temp3
- || ((temp2 = next_active_insn (temp3)) != 0
- && simplejump_p (temp2)
- && JUMP_LABEL (temp2) == JUMP_LABEL (insn)))
- && (temp1 = single_set (temp)) != 0
- && (temp2 = SET_DEST (temp1), GET_CODE (temp2) == REG)
- && GET_MODE_CLASS (GET_MODE (temp2)) == MODE_INT
- && (! SMALL_REGISTER_CLASSES
- || REGNO (temp2) >= FIRST_PSEUDO_REGISTER)
- && ! side_effects_p (SET_SRC (temp1))
- && ! may_trap_p (SET_SRC (temp1))
- && rtx_cost (SET_SRC (temp1), SET) < 10
- && (temp4 = single_set (temp3)) != 0
- && rtx_equal_p (SET_DEST (temp4), temp2)
- && ! side_effects_p (SET_SRC (temp4))
- && ! may_trap_p (SET_SRC (temp4))
- && rtx_cost (SET_SRC (temp4), SET) < 10)
- {
- rtx new = gen_reg_rtx (GET_MODE (temp2));
-
- if ((temp5 = find_insert_position (insn, temp))
- && (temp6 = find_insert_position (insn, temp3))
- && validate_change (temp, &SET_DEST (temp1), new, 0))
- {
- /* Use the earliest of temp5 and temp6. */
- if (temp5 != insn)
- temp6 = temp5;
- next = emit_insn_after (gen_move_insn (temp2, new), insn);
- emit_insn_after_with_line_notes (PATTERN (temp),
- PREV_INSN (temp6), temp);
- emit_insn_after_with_line_notes
- (replace_rtx (PATTERN (temp3), temp2, new),
- PREV_INSN (temp6), temp3);
- delete_insn (temp);
- delete_insn (temp3);
- reallabelprev = prev_active_insn (JUMP_LABEL (insn));
-
- if (after_regscan)
- {
- reg_scan_update (temp6, NEXT_INSN (next), old_max_reg);
- old_max_reg = max_reg_num ();
- }
- }
- }
-
- /* Finally, handle the case where two insns are used to
- compute EXP but a temporary register is used. Here we must
- ensure that the temporary register is not used anywhere else. */
-
- if (! reload_completed
- && after_regscan
- && this_is_condjump && ! this_is_simplejump
- && BRANCH_COST >= 4
- && (temp = next_nonnote_insn (insn)) != 0
- && GET_CODE (temp) == INSN
- && REG_NOTES (temp) == 0
- && (temp3 = next_nonnote_insn (temp)) != 0
- && GET_CODE (temp3) == INSN
- && REG_NOTES (temp3) == 0
- && (reallabelprev == temp3
- || ((temp2 = next_active_insn (temp3)) != 0
- && simplejump_p (temp2)
- && JUMP_LABEL (temp2) == JUMP_LABEL (insn)))
- && (temp1 = single_set (temp)) != 0
- && (temp5 = SET_DEST (temp1),
- (GET_CODE (temp5) == REG
- || (GET_CODE (temp5) == SUBREG
- && (temp5 = SUBREG_REG (temp5),
- GET_CODE (temp5) == REG))))
- && REGNO (temp5) >= FIRST_PSEUDO_REGISTER
- && REGNO_FIRST_UID (REGNO (temp5)) == INSN_UID (temp)
- && REGNO_LAST_UID (REGNO (temp5)) == INSN_UID (temp3)
- && ! side_effects_p (SET_SRC (temp1))
- && ! may_trap_p (SET_SRC (temp1))
- && rtx_cost (SET_SRC (temp1), SET) < 10
- && (temp4 = single_set (temp3)) != 0
- && (temp2 = SET_DEST (temp4), GET_CODE (temp2) == REG)
- && GET_MODE_CLASS (GET_MODE (temp2)) == MODE_INT
- && (! SMALL_REGISTER_CLASSES
- || REGNO (temp2) >= FIRST_PSEUDO_REGISTER)
- && rtx_equal_p (SET_DEST (temp4), temp2)
- && ! side_effects_p (SET_SRC (temp4))
- && ! may_trap_p (SET_SRC (temp4))
- && rtx_cost (SET_SRC (temp4), SET) < 10)
- {
- rtx new = gen_reg_rtx (GET_MODE (temp2));
-
- if ((temp5 = find_insert_position (insn, temp))
- && (temp6 = find_insert_position (insn, temp3))
- && validate_change (temp3, &SET_DEST (temp4), new, 0))
- {
- /* Use the earliest of temp5 and temp6. */
- if (temp5 != insn)
- temp6 = temp5;
- next = emit_insn_after (gen_move_insn (temp2, new), insn);
- emit_insn_after_with_line_notes (PATTERN (temp),
- PREV_INSN (temp6), temp);
- emit_insn_after_with_line_notes (PATTERN (temp3),
- PREV_INSN (temp6), temp3);
- delete_insn (temp);
- delete_insn (temp3);
- reallabelprev = prev_active_insn (JUMP_LABEL (insn));
-
- if (after_regscan)
- {
- reg_scan_update (temp6, NEXT_INSN (next), old_max_reg);
- old_max_reg = max_reg_num ();
- }
- }
- }
-#endif /* HAVE_cc0 */
-
-#ifdef HAVE_conditional_arithmetic
- /* ??? This is disabled in genconfig, as this simple-minded
- transformation can incredibly lengthen register lifetimes.
-
- Consider this example from cexp.c's yyparse:
-
- 234 (set (pc)
- (if_then_else (ne (reg:DI 149) (const_int 0 [0x0]))
- (label_ref 248) (pc)))
- 237 (set (reg/i:DI 0 $0) (const_int 1 [0x1]))
- 239 (set (pc) (label_ref 2382))
- 248 (code_label ("yybackup"))
-
- This will be transformed to:
-
- 237 (set (reg/i:DI 0 $0)
- (if_then_else:DI (eq (reg:DI 149) (const_int 0 [0x0]))
- (const_int 1 [0x1]) (reg/i:DI 0 $0)))
- 239 (set (pc)
- (if_then_else (eq (reg:DI 149) (const_int 0 [0x0]))
- (label_ref 2382) (pc)))
-
- which, from this narrow viewpoint looks fine. Except that
- between this and 3 other ocurrences of the same pattern, $0
- is now live for basically the entire function, and we'll
- get an abort in caller_save.
-
- Any replacement for this code should recall that a set of
- a register that is not live need not, and indeed should not,
- be conditionalized. Either that, or delay the transformation
- until after register allocation. */
-
- /* See if this is a conditional jump around a small number of
- instructions that we can conditionalize. Don't do this before
- the initial CSE pass or after reload.
-
- We reject any insns that have side effects or may trap.
- Strictly speaking, this is not needed since the machine may
- support conditionalizing these too, but we won't deal with that
- now. Specifically, this means that we can't conditionalize a
- CALL_INSN, which some machines, such as the ARC, can do, but
- this is a very minor optimization. */
- if (this_is_condjump && ! this_is_simplejump
- && cse_not_expected && ! reload_completed
- && BRANCH_COST > 2
- && can_reverse_comparison_p (XEXP (SET_SRC (PATTERN (insn)), 0),
- insn))
- {
- rtx ourcond = XEXP (SET_SRC (PATTERN (insn)), 0);
- int num_insns = 0;
- char *storage = (char *) oballoc (0);
- int last_insn = 0, failed = 0;
- rtx changed_jump = 0;
-
- ourcond = gen_rtx (reverse_condition (GET_CODE (ourcond)),
- VOIDmode, XEXP (ourcond, 0),
- XEXP (ourcond, 1));
-
- /* Scan forward BRANCH_COST real insns looking for the JUMP_LABEL
- of this insn. We see if we think we can conditionalize the
- insns we pass. For now, we only deal with insns that have
- one SET. We stop after an insn that modifies anything in
- OURCOND, if we have too many insns, or if we have an insn
- with a side effect or that may trip. Note that we will
- be modifying any unconditional jumps we encounter to be
- conditional; this will have the effect of also doing this
- optimization on the "else" the next time around. */
- for (temp1 = NEXT_INSN (insn);
- num_insns <= BRANCH_COST && ! failed && temp1 != 0
- && GET_CODE (temp1) != CODE_LABEL;
- temp1 = NEXT_INSN (temp1))
- {
- /* Ignore everything but an active insn. */
- if (GET_RTX_CLASS (GET_CODE (temp1)) != 'i'
- || GET_CODE (PATTERN (temp1)) == USE
- || GET_CODE (PATTERN (temp1)) == CLOBBER)
- continue;
-
- /* If this was an unconditional jump, record it since we'll
- need to remove the BARRIER if we succeed. We can only
- have one such jump since there must be a label after
- the BARRIER and it's either ours, in which case it's the
- only one or some other, in which case we'd fail.
- Likewise if it's a CALL_INSN followed by a BARRIER. */
-
- if (simplejump_p (temp1)
- || (GET_CODE (temp1) == CALL_INSN
- && NEXT_INSN (temp1) != 0
- && GET_CODE (NEXT_INSN (temp1)) == BARRIER))
- {
- if (changed_jump == 0)
- changed_jump = temp1;
- else
- changed_jump
- = gen_rtx_INSN_LIST (VOIDmode, temp1, changed_jump);
- }
-
- /* See if we are allowed another insn and if this insn
- if one we think we may be able to handle. */
- if (++num_insns > BRANCH_COST
- || last_insn
- || (((temp2 = single_set (temp1)) == 0
- || side_effects_p (SET_SRC (temp2))
- || may_trap_p (SET_SRC (temp2)))
- && GET_CODE (temp1) != CALL_INSN))
- failed = 1;
- else if (temp2 != 0)
- validate_change (temp1, &SET_SRC (temp2),
- gen_rtx_IF_THEN_ELSE
- (GET_MODE (SET_DEST (temp2)),
- copy_rtx (ourcond),
- SET_SRC (temp2), SET_DEST (temp2)),
- 1);
- else
- {
- /* This is a CALL_INSN that doesn't have a SET. */
- rtx *call_loc = &PATTERN (temp1);
-
- if (GET_CODE (*call_loc) == PARALLEL)
- call_loc = &XVECEXP (*call_loc, 0, 0);
-
- validate_change (temp1, call_loc,
- gen_rtx_IF_THEN_ELSE
- (VOIDmode, copy_rtx (ourcond),
- *call_loc, const0_rtx),
- 1);
- }
-
-
- if (modified_in_p (ourcond, temp1))
- last_insn = 1;
- }
-
- /* If we've reached our jump label, haven't failed, and all
- the changes above are valid, we can delete this jump
- insn. Also remove a BARRIER after any jump that used
- to be unconditional and remove any REG_EQUAL or REG_EQUIV
- that might have previously been present on insns we
- made conditional. */
- if (temp1 == JUMP_LABEL (insn) && ! failed
- && apply_change_group ())
- {
- for (temp1 = NEXT_INSN (insn); temp1 != JUMP_LABEL (insn);
- temp1 = NEXT_INSN (temp1))
- if (GET_RTX_CLASS (GET_CODE (temp1)) == 'i')
- for (temp2 = REG_NOTES (temp1); temp2 != 0;
- temp2 = XEXP (temp2, 1))
- if (REG_NOTE_KIND (temp2) == REG_EQUAL
- || REG_NOTE_KIND (temp2) == REG_EQUIV)
- remove_note (temp1, temp2);
-
- if (changed_jump != 0)
- {
- while (GET_CODE (changed_jump) == INSN_LIST)
- {
- delete_barrier (NEXT_INSN (XEXP (changed_jump, 0)));
- changed_jump = XEXP (changed_jump, 1);
- }
-
- delete_barrier (NEXT_INSN (changed_jump));
- }
-
- delete_insn (insn);
- changed = 1;
- continue;
- }
- else
- {
- cancel_changes (0);
- obfree (storage);
- }
- }
-#endif
- /* If branches are expensive, convert
- if (foo) bar++; to bar += (foo != 0);
- and similarly for "bar--;"
-
- INSN is the conditional branch around the arithmetic. We set:
-
- TEMP is the arithmetic insn.
- TEMP1 is the SET doing the arithmetic.
- TEMP2 is the operand being incremented or decremented.
- TEMP3 to the condition being tested.
- TEMP4 to the earliest insn used to find the condition. */
-
- if ((BRANCH_COST >= 2
-#ifdef HAVE_incscc
- || HAVE_incscc
-#endif
-#ifdef HAVE_decscc
- || HAVE_decscc
-#endif
- )
- && ! reload_completed
- && this_is_condjump && ! this_is_simplejump
- && (temp = next_nonnote_insn (insn)) != 0
- && (temp1 = single_set (temp)) != 0
- && (temp2 = SET_DEST (temp1),
- GET_MODE_CLASS (GET_MODE (temp2)) == MODE_INT)
- && GET_CODE (SET_SRC (temp1)) == PLUS
- && (XEXP (SET_SRC (temp1), 1) == const1_rtx
- || XEXP (SET_SRC (temp1), 1) == constm1_rtx)
- && rtx_equal_p (temp2, XEXP (SET_SRC (temp1), 0))
- && ! side_effects_p (temp2)
- && ! may_trap_p (temp2)
- /* INSN must either branch to the insn after TEMP or the insn
- after TEMP must branch to the same place as INSN. */
- && (reallabelprev == temp
- || ((temp3 = next_active_insn (temp)) != 0
- && simplejump_p (temp3)
- && JUMP_LABEL (temp3) == JUMP_LABEL (insn)))
- && (temp3 = get_condition (insn, &temp4)) != 0
- /* We must be comparing objects whose modes imply the size.
- We could handle BLKmode if (1) emit_store_flag could
- and (2) we could find the size reliably. */
- && GET_MODE (XEXP (temp3, 0)) != BLKmode
- && can_reverse_comparison_p (temp3, insn))
- {
- rtx temp6, target = 0, seq, init_insn = 0, init = temp2;
- enum rtx_code code = reverse_condition (GET_CODE (temp3));
-
- start_sequence ();
-
- /* It must be the case that TEMP2 is not modified in the range
- [TEMP4, INSN). The one exception we make is if the insn
- before INSN sets TEMP2 to something which is also unchanged
- in that range. In that case, we can move the initialization
- into our sequence. */
-
- if ((temp5 = prev_active_insn (insn)) != 0
- && no_labels_between_p (temp5, insn)
- && GET_CODE (temp5) == INSN
- && (temp6 = single_set (temp5)) != 0
- && rtx_equal_p (temp2, SET_DEST (temp6))
- && (CONSTANT_P (SET_SRC (temp6))
- || GET_CODE (SET_SRC (temp6)) == REG
- || GET_CODE (SET_SRC (temp6)) == SUBREG))
- {
- emit_insn (PATTERN (temp5));
- init_insn = temp5;
- init = SET_SRC (temp6);
- }
-
- if (CONSTANT_P (init)
- || ! reg_set_between_p (init, PREV_INSN (temp4), insn))
- target = emit_store_flag (gen_reg_rtx (GET_MODE (temp2)), code,
- XEXP (temp3, 0), XEXP (temp3, 1),
- VOIDmode,
- (code == LTU || code == LEU
- || code == GTU || code == GEU), 1);
-
- /* If we can do the store-flag, do the addition or
- subtraction. */
-
- if (target)
- target = expand_binop (GET_MODE (temp2),
- (XEXP (SET_SRC (temp1), 1) == const1_rtx
- ? add_optab : sub_optab),
- temp2, target, temp2, 0, OPTAB_WIDEN);
-
- if (target != 0)
- {
- /* Put the result back in temp2 in case it isn't already.
- Then replace the jump, possible a CC0-setting insn in
- front of the jump, and TEMP, with the sequence we have
- made. */
-
- if (target != temp2)
- emit_move_insn (temp2, target);
-
- seq = get_insns ();
- end_sequence ();
-
- emit_insns_before (seq, temp4);
- delete_insn (temp);
-
- if (init_insn)
- delete_insn (init_insn);
-
- next = NEXT_INSN (insn);
-#ifdef HAVE_cc0
- delete_insn (prev_nonnote_insn (insn));
-#endif
- delete_insn (insn);
-
- if (after_regscan)
- {
- reg_scan_update (seq, NEXT_INSN (next), old_max_reg);
- old_max_reg = max_reg_num ();
- }
-
- changed = 1;
- continue;
- }
- else
- end_sequence ();
- }
-
- /* Try to use a conditional move (if the target has them), or a
- store-flag insn. If the target has conditional arithmetic as
- well as conditional move, the above code will have done something.
- Note that we prefer the above code since it is more general: the
- code below can make changes that require work to undo.
-
- The general case here is:
-
- 1) x = a; if (...) x = b; and
- 2) if (...) x = b;
-
- If the jump would be faster, the machine should not have defined
- the movcc or scc insns!. These cases are often made by the
- previous optimization.
-
- The second case is treated as x = x; if (...) x = b;.
-
- INSN here is the jump around the store. We set:
-
- TEMP to the "x op= b;" insn.
- TEMP1 to X.
- TEMP2 to B.
- TEMP3 to A (X in the second case).
- TEMP4 to the condition being tested.
- TEMP5 to the earliest insn used to find the condition.
- TEMP6 to the SET of TEMP. */
-
- if (/* We can't do this after reload has completed. */
- ! reload_completed
-#ifdef HAVE_conditional_arithmetic
- /* Defer this until after CSE so the above code gets the
- first crack at it. */
- && cse_not_expected
-#endif
- && this_is_condjump && ! this_is_simplejump
- /* Set TEMP to the "x = b;" insn. */
- && (temp = next_nonnote_insn (insn)) != 0
- && GET_CODE (temp) == INSN
- && (temp6 = single_set (temp)) != NULL_RTX
- && GET_CODE (temp1 = SET_DEST (temp6)) == REG
- && (! SMALL_REGISTER_CLASSES
- || REGNO (temp1) >= FIRST_PSEUDO_REGISTER)
- && ! side_effects_p (temp2 = SET_SRC (temp6))
- && ! may_trap_p (temp2)
- /* Allow either form, but prefer the former if both apply.
- There is no point in using the old value of TEMP1 if
- it is a register, since cse will alias them. It can
- lose if the old value were a hard register since CSE
- won't replace hard registers. Avoid using TEMP3 if
- small register classes and it is a hard register. */
- && (((temp3 = reg_set_last (temp1, insn)) != 0
- && ! (SMALL_REGISTER_CLASSES && GET_CODE (temp3) == REG
- && REGNO (temp3) < FIRST_PSEUDO_REGISTER))
- /* Make the latter case look like x = x; if (...) x = b; */
- || (temp3 = temp1, 1))
- /* INSN must either branch to the insn after TEMP or the insn
- after TEMP must branch to the same place as INSN. */
- && (reallabelprev == temp
- || ((temp4 = next_active_insn (temp)) != 0
- && simplejump_p (temp4)
- && JUMP_LABEL (temp4) == JUMP_LABEL (insn)))
- && (temp4 = get_condition (insn, &temp5)) != 0
- /* We must be comparing objects whose modes imply the size.
- We could handle BLKmode if (1) emit_store_flag could
- and (2) we could find the size reliably. */
- && GET_MODE (XEXP (temp4, 0)) != BLKmode
- /* Even if branches are cheap, the store_flag optimization
- can win when the operation to be performed can be
- expressed directly. */
-#ifdef HAVE_cc0
- /* If the previous insn sets CC0 and something else, we can't
- do this since we are going to delete that insn. */
-
- && ! ((temp6 = prev_nonnote_insn (insn)) != 0
- && GET_CODE (temp6) == INSN
- && (sets_cc0_p (PATTERN (temp6)) == -1
- || (sets_cc0_p (PATTERN (temp6)) == 1
- && FIND_REG_INC_NOTE (temp6, NULL_RTX))))
-#endif
- )
- {
-#ifdef HAVE_conditional_move
- /* First try a conditional move. */
- {
- enum rtx_code code = GET_CODE (temp4);
- rtx var = temp1;
- rtx cond0, cond1, aval, bval;
- rtx target, new_insn;
-
- /* Copy the compared variables into cond0 and cond1, so that
- any side effects performed in or after the old comparison,
- will not affect our compare which will come later. */
- /* ??? Is it possible to just use the comparison in the jump
- insn? After all, we're going to delete it. We'd have
- to modify emit_conditional_move to take a comparison rtx
- instead or write a new function. */
- cond0 = gen_reg_rtx (GET_MODE (XEXP (temp4, 0)));
- /* We want the target to be able to simplify comparisons with
- zero (and maybe other constants as well), so don't create
- pseudos for them. There's no need to either. */
- if (GET_CODE (XEXP (temp4, 1)) == CONST_INT
- || GET_CODE (XEXP (temp4, 1)) == CONST_DOUBLE)
- cond1 = XEXP (temp4, 1);
- else
- cond1 = gen_reg_rtx (GET_MODE (XEXP (temp4, 1)));
-
- /* Careful about copying these values -- an IOR or what may
- need to do other things, like clobber flags. */
- /* ??? Assume for the moment that AVAL is ok. */
- aval = temp3;
-
- start_sequence ();
-
- /* We're dealing with a single_set insn with no side effects
- on SET_SRC. We do need to be reasonably certain that if
- we need to force BVAL into a register that we won't
- clobber the flags -- general_operand should suffice. */
- if (general_operand (temp2, GET_MODE (var)))
- bval = temp2;
- else
- {
- bval = gen_reg_rtx (GET_MODE (var));
- new_insn = copy_rtx (temp);
- temp6 = single_set (new_insn);
- SET_DEST (temp6) = bval;
- emit_insn (PATTERN (new_insn));
- }
-
- target = emit_conditional_move (var, code,
- cond0, cond1, VOIDmode,
- aval, bval, GET_MODE (var),
- (code == LTU || code == GEU
- || code == LEU || code == GTU));
-
- if (target)
- {
- rtx seq1, seq2, last;
- int copy_ok;
-
- /* Save the conditional move sequence but don't emit it
- yet. On some machines, like the alpha, it is possible
- that temp5 == insn, so next generate the sequence that
- saves the compared values and then emit both
- sequences ensuring seq1 occurs before seq2. */
- seq2 = get_insns ();
- end_sequence ();
-
- /* "Now that we can't fail..." Famous last words.
- Generate the copy insns that preserve the compared
- values. */
- start_sequence ();
- emit_move_insn (cond0, XEXP (temp4, 0));
- if (cond1 != XEXP (temp4, 1))
- emit_move_insn (cond1, XEXP (temp4, 1));
- seq1 = get_insns ();
- end_sequence ();
-
- /* Validate the sequence -- this may be some weird
- bit-extract-and-test instruction for which there
- exists no complimentary bit-extract insn. */
- copy_ok = 1;
- for (last = seq1; last ; last = NEXT_INSN (last))
- if (recog_memoized (last) < 0)
- {
- copy_ok = 0;
- break;
- }
-
- if (copy_ok)
- {
- emit_insns_before (seq1, temp5);
-
- /* Insert conditional move after insn, to be sure
- that the jump and a possible compare won't be
- separated. */
- last = emit_insns_after (seq2, insn);
-
- /* ??? We can also delete the insn that sets X to A.
- Flow will do it too though. */
- delete_insn (temp);
- next = NEXT_INSN (insn);
- delete_jump (insn);
-
- if (after_regscan)
- {
- reg_scan_update (seq1, NEXT_INSN (last),
- old_max_reg);
- old_max_reg = max_reg_num ();
- }
-
- changed = 1;
- continue;
- }
- }
- else
- end_sequence ();
- }
-#endif
-
- /* That didn't work, try a store-flag insn.
-
- We further divide the cases into:
-
- 1) x = a; if (...) x = b; and either A or B is zero,
- 2) if (...) x = 0; and jumps are expensive,
- 3) x = a; if (...) x = b; and A and B are constants where all
- the set bits in A are also set in B and jumps are expensive,
- 4) x = a; if (...) x = b; and A and B non-zero, and jumps are
- more expensive, and
- 5) if (...) x = b; if jumps are even more expensive. */
-
- if (GET_MODE_CLASS (GET_MODE (temp1)) == MODE_INT
- /* We will be passing this as operand into expand_and. No
- good if it's not valid as an operand. */
- && general_operand (temp2, GET_MODE (temp2))
- && ((GET_CODE (temp3) == CONST_INT)
- /* Make the latter case look like
- x = x; if (...) x = 0; */
- || (temp3 = temp1,
- ((BRANCH_COST >= 2
- && temp2 == const0_rtx)
- || BRANCH_COST >= 3)))
- /* If B is zero, OK; if A is zero, can only do (1) if we
- can reverse the condition. See if (3) applies possibly
- by reversing the condition. Prefer reversing to (4) when
- branches are very expensive. */
- && (((BRANCH_COST >= 2
- || STORE_FLAG_VALUE == -1
- || (STORE_FLAG_VALUE == 1
- /* Check that the mask is a power of two,
- so that it can probably be generated
- with a shift. */
- && GET_CODE (temp3) == CONST_INT
- && exact_log2 (INTVAL (temp3)) >= 0))
- && (reversep = 0, temp2 == const0_rtx))
- || ((BRANCH_COST >= 2
- || STORE_FLAG_VALUE == -1
- || (STORE_FLAG_VALUE == 1
- && GET_CODE (temp2) == CONST_INT
- && exact_log2 (INTVAL (temp2)) >= 0))
- && temp3 == const0_rtx
- && (reversep = can_reverse_comparison_p (temp4, insn)))
- || (BRANCH_COST >= 2
- && GET_CODE (temp2) == CONST_INT
- && GET_CODE (temp3) == CONST_INT
- && ((INTVAL (temp2) & INTVAL (temp3)) == INTVAL (temp2)
- || ((INTVAL (temp2) & INTVAL (temp3)) == INTVAL (temp3)
- && (reversep = can_reverse_comparison_p (temp4,
- insn)))))
- || BRANCH_COST >= 3)
- )
- {
- enum rtx_code code = GET_CODE (temp4);
- rtx uval, cval, var = temp1;
- int normalizep;
- rtx target;
-
- /* If necessary, reverse the condition. */
- if (reversep)
- code = reverse_condition (code), uval = temp2, cval = temp3;
- else
- uval = temp3, cval = temp2;
-
- /* If CVAL is non-zero, normalize to -1. Otherwise, if UVAL
- is the constant 1, it is best to just compute the result
- directly. If UVAL is constant and STORE_FLAG_VALUE
- includes all of its bits, it is best to compute the flag
- value unnormalized and `and' it with UVAL. Otherwise,
- normalize to -1 and `and' with UVAL. */
- normalizep = (cval != const0_rtx ? -1
- : (uval == const1_rtx ? 1
- : (GET_CODE (uval) == CONST_INT
- && (INTVAL (uval) & ~STORE_FLAG_VALUE) == 0)
- ? 0 : -1));
-
- /* We will be putting the store-flag insn immediately in
- front of the comparison that was originally being done,
- so we know all the variables in TEMP4 will be valid.
- However, this might be in front of the assignment of
- A to VAR. If it is, it would clobber the store-flag
- we will be emitting.
-
- Therefore, emit into a temporary which will be copied to
- VAR immediately after TEMP. */
-
- start_sequence ();
- target = emit_store_flag (gen_reg_rtx (GET_MODE (var)), code,
- XEXP (temp4, 0), XEXP (temp4, 1),
- VOIDmode,
- (code == LTU || code == LEU
- || code == GEU || code == GTU),
- normalizep);
- if (target)
- {
- rtx seq;
- rtx before = insn;
-
- seq = get_insns ();
- end_sequence ();
-
- /* Put the store-flag insns in front of the first insn
- used to compute the condition to ensure that we
- use the same values of them as the current
- comparison. However, the remainder of the insns we
- generate will be placed directly in front of the
- jump insn, in case any of the pseudos we use
- are modified earlier. */
-
- emit_insns_before (seq, temp5);
-
- start_sequence ();
-
- /* Both CVAL and UVAL are non-zero. */
- if (cval != const0_rtx && uval != const0_rtx)
- {
- rtx tem1, tem2;
-
- tem1 = expand_and (uval, target, NULL_RTX);
- if (GET_CODE (cval) == CONST_INT
- && GET_CODE (uval) == CONST_INT
- && (INTVAL (cval) & INTVAL (uval)) == INTVAL (cval))
- tem2 = cval;
- else
- {
- tem2 = expand_unop (GET_MODE (var), one_cmpl_optab,
- target, NULL_RTX, 0);
- tem2 = expand_and (cval, tem2,
- (GET_CODE (tem2) == REG
- ? tem2 : 0));
- }
-
- /* If we usually make new pseudos, do so here. This
- turns out to help machines that have conditional
- move insns. */
- /* ??? Conditional moves have already been handled.
- This may be obsolete. */
-
- if (flag_expensive_optimizations)
- target = 0;
-
- target = expand_binop (GET_MODE (var), ior_optab,
- tem1, tem2, target,
- 1, OPTAB_WIDEN);
- }
- else if (normalizep != 1)
- {
- /* We know that either CVAL or UVAL is zero. If
- UVAL is zero, negate TARGET and `and' with CVAL.
- Otherwise, `and' with UVAL. */
- if (uval == const0_rtx)
- {
- target = expand_unop (GET_MODE (var), one_cmpl_optab,
- target, NULL_RTX, 0);
- uval = cval;
- }
-
- target = expand_and (uval, target,
- (GET_CODE (target) == REG
- && ! preserve_subexpressions_p ()
- ? target : NULL_RTX));
- }
-
- emit_move_insn (var, target);
- seq = get_insns ();
- end_sequence ();
-#ifdef HAVE_cc0
- /* If INSN uses CC0, we must not separate it from the
- insn that sets cc0. */
- if (reg_mentioned_p (cc0_rtx, PATTERN (before)))
- before = prev_nonnote_insn (before);
-#endif
- emit_insns_before (seq, before);
-
- delete_insn (temp);
- next = NEXT_INSN (insn);
- delete_jump (insn);
-
- if (after_regscan)
- {
- reg_scan_update (seq, NEXT_INSN (next), old_max_reg);
- old_max_reg = max_reg_num ();
- }
-
- changed = 1;
- continue;
- }
- else
- end_sequence ();
- }
- }
-
-
- /* Simplify if (...) x = 1; else {...} if (x) ...
- We recognize this case scanning backwards as well.
-
- TEMP is the assignment to x;
- TEMP1 is the label at the head of the second if. */
- /* ?? This should call get_condition to find the values being
- compared, instead of looking for a COMPARE insn when HAVE_cc0
- is not defined. This would allow it to work on the m88k. */
- /* ?? This optimization is only safe before cse is run if HAVE_cc0
- is not defined and the condition is tested by a separate compare
- insn. This is because the code below assumes that the result
- of the compare dies in the following branch.
-
- Not only that, but there might be other insns between the
- compare and branch whose results are live. Those insns need
- to be executed.
-
- A way to fix this is to move the insns at JUMP_LABEL (insn)
- to before INSN. If we are running before flow, they will
- be deleted if they aren't needed. But this doesn't work
- well after flow.
-
- This is really a special-case of jump threading, anyway. The
- right thing to do is to replace this and jump threading with
- much simpler code in cse.
-
- This code has been turned off in the non-cc0 case in the
- meantime. */
-
-#ifdef HAVE_cc0
- else if (this_is_simplejump
- /* Safe to skip USE and CLOBBER insns here
- since they will not be deleted. */
- && (temp = prev_active_insn (insn))
- && no_labels_between_p (temp, insn)
- && GET_CODE (temp) == INSN
- && GET_CODE (PATTERN (temp)) == SET
- && GET_CODE (SET_DEST (PATTERN (temp))) == REG
- && CONSTANT_P (SET_SRC (PATTERN (temp)))
- && (temp1 = next_active_insn (JUMP_LABEL (insn)))
- /* If we find that the next value tested is `x'
- (TEMP1 is the insn where this happens), win. */
- && GET_CODE (temp1) == INSN
- && GET_CODE (PATTERN (temp1)) == SET
-#ifdef HAVE_cc0
- /* Does temp1 `tst' the value of x? */
- && SET_SRC (PATTERN (temp1)) == SET_DEST (PATTERN (temp))
- && SET_DEST (PATTERN (temp1)) == cc0_rtx
- && (temp1 = next_nonnote_insn (temp1))
-#else
- /* Does temp1 compare the value of x against zero? */
- && GET_CODE (SET_SRC (PATTERN (temp1))) == COMPARE
- && XEXP (SET_SRC (PATTERN (temp1)), 1) == const0_rtx
- && (XEXP (SET_SRC (PATTERN (temp1)), 0)
- == SET_DEST (PATTERN (temp)))
- && GET_CODE (SET_DEST (PATTERN (temp1))) == REG
- && (temp1 = find_next_ref (SET_DEST (PATTERN (temp1)), temp1))
-#endif
- && condjump_p (temp1))
- {
- /* Get the if_then_else from the condjump. */
- rtx choice = SET_SRC (PATTERN (temp1));
- if (GET_CODE (choice) == IF_THEN_ELSE)
- {
- enum rtx_code code = GET_CODE (XEXP (choice, 0));
- rtx val = SET_SRC (PATTERN (temp));
- rtx cond
- = simplify_relational_operation (code, GET_MODE (SET_DEST (PATTERN (temp))),
- val, const0_rtx);
- rtx ultimate;
-
- if (cond == const_true_rtx)
- ultimate = XEXP (choice, 1);
- else if (cond == const0_rtx)
- ultimate = XEXP (choice, 2);
- else
- ultimate = 0;
-
- if (ultimate == pc_rtx)
- ultimate = get_label_after (temp1);
- else if (ultimate && GET_CODE (ultimate) != RETURN)
- ultimate = XEXP (ultimate, 0);
-
- if (ultimate && JUMP_LABEL(insn) != ultimate)
- changed |= redirect_jump (insn, ultimate);
- }
- }
-#endif
-
-#if 0
- /* @@ This needs a bit of work before it will be right.
-
- Any type of comparison can be accepted for the first and
- second compare. When rewriting the first jump, we must
- compute the what conditions can reach label3, and use the
- appropriate code. We can not simply reverse/swap the code
- of the first jump. In some cases, the second jump must be
- rewritten also.
-
- For example,
- < == converts to > ==
- < != converts to == >
- etc.
-
- If the code is written to only accept an '==' test for the second
- compare, then all that needs to be done is to swap the condition
- of the first branch.
-
- It is questionable whether we want this optimization anyways,
- since if the user wrote code like this because he/she knew that
- the jump to label1 is taken most of the time, then rewriting
- this gives slower code. */
- /* @@ This should call get_condition to find the values being
- compared, instead of looking for a COMPARE insn when HAVE_cc0
- is not defined. This would allow it to work on the m88k. */
- /* @@ This optimization is only safe before cse is run if HAVE_cc0
- is not defined and the condition is tested by a separate compare
- insn. This is because the code below assumes that the result
- of the compare dies in the following branch. */
-
- /* Simplify test a ~= b
- condjump label1;
- test a == b
- condjump label2;
- jump label3;
- label1:
-
- rewriting as
- test a ~~= b
- condjump label3
- test a == b
- condjump label2
- label1:
-
- where ~= is an inequality, e.g. >, and ~~= is the swapped
- inequality, e.g. <.
-
- We recognize this case scanning backwards.
-
- TEMP is the conditional jump to `label2';
- TEMP1 is the test for `a == b';
- TEMP2 is the conditional jump to `label1';
- TEMP3 is the test for `a ~= b'. */
- else if (this_is_simplejump
- && (temp = prev_active_insn (insn))
- && no_labels_between_p (temp, insn)
- && condjump_p (temp)
- && (temp1 = prev_active_insn (temp))
- && no_labels_between_p (temp1, temp)
- && GET_CODE (temp1) == INSN
- && GET_CODE (PATTERN (temp1)) == SET
-#ifdef HAVE_cc0
- && sets_cc0_p (PATTERN (temp1)) == 1
-#else
- && GET_CODE (SET_SRC (PATTERN (temp1))) == COMPARE
- && GET_CODE (SET_DEST (PATTERN (temp1))) == REG
- && (temp == find_next_ref (SET_DEST (PATTERN (temp1)), temp1))
-#endif
- && (temp2 = prev_active_insn (temp1))
- && no_labels_between_p (temp2, temp1)
- && condjump_p (temp2)
- && JUMP_LABEL (temp2) == next_nonnote_insn (NEXT_INSN (insn))
- && (temp3 = prev_active_insn (temp2))
- && no_labels_between_p (temp3, temp2)
- && GET_CODE (PATTERN (temp3)) == SET
- && rtx_equal_p (SET_DEST (PATTERN (temp3)),
- SET_DEST (PATTERN (temp1)))
- && rtx_equal_p (SET_SRC (PATTERN (temp1)),
- SET_SRC (PATTERN (temp3)))
- && ! inequality_comparisons_p (PATTERN (temp))
- && inequality_comparisons_p (PATTERN (temp2)))
- {
- rtx fallthrough_label = JUMP_LABEL (temp2);
-
- ++LABEL_NUSES (fallthrough_label);
- if (swap_jump (temp2, JUMP_LABEL (insn)))
- {
- delete_insn (insn);
- changed = 1;
- }
-
- if (--LABEL_NUSES (fallthrough_label) == 0)
- delete_insn (fallthrough_label);
- }
-#endif
- /* Simplify if (...) {... x = 1;} if (x) ...
-
- We recognize this case backwards.
-
- TEMP is the test of `x';
- TEMP1 is the assignment to `x' at the end of the
- previous statement. */
- /* @@ This should call get_condition to find the values being
- compared, instead of looking for a COMPARE insn when HAVE_cc0
- is not defined. This would allow it to work on the m88k. */
- /* @@ This optimization is only safe before cse is run if HAVE_cc0
- is not defined and the condition is tested by a separate compare
- insn. This is because the code below assumes that the result
- of the compare dies in the following branch. */
-
- /* ??? This has to be turned off. The problem is that the
- unconditional jump might indirectly end up branching to the
- label between TEMP1 and TEMP. We can't detect this, in general,
- since it may become a jump to there after further optimizations.
- If that jump is done, it will be deleted, so we will retry
- this optimization in the next pass, thus an infinite loop.
-
- The present code prevents this by putting the jump after the
- label, but this is not logically correct. */
-#if 0
- else if (this_is_condjump
- /* Safe to skip USE and CLOBBER insns here
- since they will not be deleted. */
- && (temp = prev_active_insn (insn))
- && no_labels_between_p (temp, insn)
- && GET_CODE (temp) == INSN
- && GET_CODE (PATTERN (temp)) == SET
-#ifdef HAVE_cc0
- && sets_cc0_p (PATTERN (temp)) == 1
- && GET_CODE (SET_SRC (PATTERN (temp))) == REG
-#else
- /* Temp must be a compare insn, we can not accept a register
- to register move here, since it may not be simply a
- tst insn. */
- && GET_CODE (SET_SRC (PATTERN (temp))) == COMPARE
- && XEXP (SET_SRC (PATTERN (temp)), 1) == const0_rtx
- && GET_CODE (XEXP (SET_SRC (PATTERN (temp)), 0)) == REG
- && GET_CODE (SET_DEST (PATTERN (temp))) == REG
- && insn == find_next_ref (SET_DEST (PATTERN (temp)), temp)
-#endif
- /* May skip USE or CLOBBER insns here
- for checking for opportunity, since we
- take care of them later. */
- && (temp1 = prev_active_insn (temp))
- && GET_CODE (temp1) == INSN
- && GET_CODE (PATTERN (temp1)) == SET
-#ifdef HAVE_cc0
- && SET_SRC (PATTERN (temp)) == SET_DEST (PATTERN (temp1))
-#else
- && (XEXP (SET_SRC (PATTERN (temp)), 0)
- == SET_DEST (PATTERN (temp1)))
-#endif
- && CONSTANT_P (SET_SRC (PATTERN (temp1)))
- /* If this isn't true, cse will do the job. */
- && ! no_labels_between_p (temp1, temp))
- {
- /* Get the if_then_else from the condjump. */
- rtx choice = SET_SRC (PATTERN (insn));
- if (GET_CODE (choice) == IF_THEN_ELSE
- && (GET_CODE (XEXP (choice, 0)) == EQ
- || GET_CODE (XEXP (choice, 0)) == NE))
- {
- int want_nonzero = (GET_CODE (XEXP (choice, 0)) == NE);
- rtx last_insn;
- rtx ultimate;
- rtx p;
-
- /* Get the place that condjump will jump to
- if it is reached from here. */
- if ((SET_SRC (PATTERN (temp1)) != const0_rtx)
- == want_nonzero)
- ultimate = XEXP (choice, 1);
- else
- ultimate = XEXP (choice, 2);
- /* Get it as a CODE_LABEL. */
- if (ultimate == pc_rtx)
- ultimate = get_label_after (insn);
- else
- /* Get the label out of the LABEL_REF. */
- ultimate = XEXP (ultimate, 0);
-
- /* Insert the jump immediately before TEMP, specifically
- after the label that is between TEMP1 and TEMP. */
- last_insn = PREV_INSN (temp);
-
- /* If we would be branching to the next insn, the jump
- would immediately be deleted and the re-inserted in
- a subsequent pass over the code. So don't do anything
- in that case. */
- if (next_active_insn (last_insn)
- != next_active_insn (ultimate))
- {
- emit_barrier_after (last_insn);
- p = emit_jump_insn_after (gen_jump (ultimate),
- last_insn);
- JUMP_LABEL (p) = ultimate;
- ++LABEL_NUSES (ultimate);
- if (INSN_UID (ultimate) < max_jump_chain
- && INSN_CODE (p) < max_jump_chain)
- {
- jump_chain[INSN_UID (p)]
- = jump_chain[INSN_UID (ultimate)];
- jump_chain[INSN_UID (ultimate)] = p;
- }
- changed = 1;
- continue;
- }
- }
- }
-#endif