diff options
Diffstat (limited to 'contrib/gcc/jump.c')
| -rw-r--r-- | contrib/gcc/jump.c | 693 |
1 files changed, 562 insertions, 131 deletions
diff --git a/contrib/gcc/jump.c b/contrib/gcc/jump.c index 88a6c3a..ff4680c 100644 --- a/contrib/gcc/jump.c +++ b/contrib/gcc/jump.c @@ -1,5 +1,5 @@ /* Optimize jump instructions, for GNU compiler. - Copyright (C) 1987, 88, 89, 91-94, 1995 Free Software Foundation, Inc. + Copyright (C) 1987, 88, 89, 91-97, 1998 Free Software Foundation, Inc. This file is part of GNU CC. @@ -52,14 +52,19 @@ Boston, MA 02111-1307, USA. */ from other passes as well. */ #include "config.h" +#include "system.h" #include "rtl.h" #include "flags.h" #include "hard-reg-set.h" #include "regs.h" #include "insn-config.h" #include "insn-flags.h" +#include "insn-attr.h" +#include "recog.h" #include "expr.h" #include "real.h" +#include "except.h" +#include "toplev.h" /* ??? Eventually must record somehow the labels used by jumps from nested functions. */ @@ -100,7 +105,7 @@ int can_reach_end; Normally they are not significant, because of A and B jump to C, and R dies in A, it must die in B. But this might not be true after stack register conversion, and we must compare death notes in that - case. */ + case. */ static int cross_jump_death_matters = 0; @@ -113,7 +118,11 @@ static void mark_jump_label PROTO((rtx, rtx, int)); static void delete_computation PROTO((rtx)); static void delete_from_jump_chain PROTO((rtx)); static int delete_labelref_insn PROTO((rtx, rtx, int)); +static void mark_modified_reg PROTO((rtx, rtx)); static void redirect_tablejump PROTO((rtx, rtx)); +#ifndef HAVE_cc0 +static rtx find_insert_position PROTO((rtx, rtx)); +#endif /* Delete no-op jumps and optimize jumps to jumps and jumps around jumps. @@ -143,6 +152,7 @@ jump_optimize (f, cross_jump, noop_moves, after_regscan) { register rtx insn, next, note; int changed; + int old_max_reg; int first = 1; int max_uid = 0; rtx last_insn; @@ -173,6 +183,12 @@ jump_optimize (f, cross_jump, noop_moves, after_regscan) max_uid++; + /* If we are performing cross jump optimizations, then initialize + tables mapping UIDs to EH regions to avoid incorrect movement + of insns from one EH region to another. */ + if (flag_exceptions && cross_jump) + init_insn_eh_region (f, max_uid); + /* Delete insns following barriers, up to next label. */ for (insn = f; insn;) @@ -208,11 +224,10 @@ jump_optimize (f, cross_jump, noop_moves, after_regscan) also make a chain of all returns. */ for (insn = f; insn; insn = NEXT_INSN (insn)) - if (GET_RTX_CLASS (GET_CODE (insn)) == 'i' - && ! INSN_DELETED_P (insn)) + if (GET_RTX_CLASS (GET_CODE (insn)) == 'i') { mark_jump_label (PATTERN (insn), insn, cross_jump); - if (GET_CODE (insn) == JUMP_INSN) + if (! INSN_DELETED_P (insn) && GET_CODE (insn) == JUMP_INSN) { if (JUMP_LABEL (insn) != 0 && simplejump_p (insn)) { @@ -234,6 +249,16 @@ jump_optimize (f, cross_jump, noop_moves, after_regscan) for (insn = forced_labels; insn; insn = XEXP (insn, 1)) LABEL_NUSES (XEXP (insn, 0))++; + check_exception_handler_labels (); + + /* Keep track of labels used for marking handlers for exception + regions; they cannot usually be deleted. */ + + for (insn = exception_handler_labels; insn; insn = XEXP (insn, 1)) + LABEL_NUSES (XEXP (insn, 0))++; + + exception_optimize (); + /* Delete all labels already not referenced. Also find the last insn. */ @@ -283,6 +308,9 @@ jump_optimize (f, cross_jump, noop_moves, after_regscan) /* Zero the "deleted" flag of all the "deleted" insns. */ for (insn = f; insn; insn = NEXT_INSN (insn)) INSN_DELETED_P (insn) = 0; + + /* Show that the jump chain is not valid. */ + jump_chain = 0; return; } @@ -381,9 +409,14 @@ jump_optimize (f, cross_jump, noop_moves, after_regscan) if (GET_CODE (p) != INSN) break; pbody = PATTERN (p); - if (GET_CODE (pbody) == SET) + if (GET_CODE (pbody) != SET) break; dest = SET_DEST (pbody); + /* Allow a no-op move between the adjust and the push. */ + if (GET_CODE (dest) == REG + && GET_CODE (SET_SRC (pbody)) == REG + && REGNO (dest) == REGNO (SET_SRC (pbody))) + continue; if (! (GET_CODE (dest) == MEM && GET_CODE (XEXP (dest, 0)) == POST_INC && XEXP (XEXP (dest, 0), 0) == stack_pointer_rtx)) @@ -438,28 +471,40 @@ jump_optimize (f, cross_jump, noop_moves, after_regscan) sreg, NULL_PTR, dreg, GET_MODE (SET_SRC (body))); -#ifdef PRESERVE_DEATH_INFO_REGNO_P - /* Deleting insn could lose a death-note for SREG or DREG - so don't do it if final needs accurate death-notes. */ - if (! PRESERVE_DEATH_INFO_REGNO_P (sreg) - && ! PRESERVE_DEATH_INFO_REGNO_P (dreg)) -#endif + if (tem != 0 + && GET_MODE (tem) == GET_MODE (SET_DEST (body))) { /* DREG may have been the target of a REG_DEAD note in the insn which makes INSN redundant. If so, reorg would still think it is dead. So search for such a note and delete it if we find it. */ - for (trial = prev_nonnote_insn (insn); - trial && GET_CODE (trial) != CODE_LABEL; - trial = prev_nonnote_insn (trial)) - if (find_regno_note (trial, REG_DEAD, dreg)) - { - remove_death (dreg, trial); - break; - } - - if (tem != 0 - && GET_MODE (tem) == GET_MODE (SET_DEST (body))) + if (! find_regno_note (insn, REG_UNUSED, dreg)) + for (trial = prev_nonnote_insn (insn); + trial && GET_CODE (trial) != CODE_LABEL; + trial = prev_nonnote_insn (trial)) + if (find_regno_note (trial, REG_DEAD, dreg)) + { + remove_death (dreg, trial); + break; + } +#ifdef PRESERVE_DEATH_INFO_REGNO_P + /* Deleting insn could lose a death-note for SREG + so don't do it if final needs accurate + death-notes. */ + if (PRESERVE_DEATH_INFO_REGNO_P (sreg) + && (trial = find_regno_note (insn, REG_DEAD, sreg))) + { + /* Change this into a USE so that we won't emit + code for it, but still can keep the note. */ + PATTERN (insn) + = gen_rtx_USE (VOIDmode, XEXP (trial, 0)); + INSN_CODE (insn) = -1; + /* Remove all reg notes but the REG_DEAD one. */ + REG_NOTES (insn) = trial; + XEXP (trial, 1) = NULL_RTX; + } + else +#endif delete_insn (insn); } } @@ -499,7 +544,7 @@ jump_optimize (f, cross_jump, noop_moves, after_regscan) else if (GET_CODE (body) == PARALLEL) { /* If each part is a set between two identical registers or - a USE or CLOBBER, delete the insn. */ + a USE or CLOBBER, delete the insn. */ int i, sreg, dreg; rtx tem; @@ -547,11 +592,11 @@ jump_optimize (f, cross_jump, noop_moves, after_regscan) if (set && GET_CODE (SET_DEST (set)) == REG && REGNO (SET_DEST (set)) >= FIRST_PSEUDO_REGISTER - && regno_first_uid[REGNO (SET_DEST (set))] == INSN_UID (insn) + && REGNO_FIRST_UID (REGNO (SET_DEST (set))) == INSN_UID (insn) /* We use regno_last_note_uid so as not to delete the setting of a reg that's used in notes. A subsequent optimization might arrange to use that reg for real. */ - && regno_last_note_uid[REGNO (SET_DEST (set))] == INSN_UID (insn) + && REGNO_LAST_NOTE_UID (REGNO (SET_DEST (set))) == INSN_UID (insn) && ! side_effects_p (SET_SRC (set)) && ! find_reg_note (insn, REG_RETVAL, 0)) delete_insn (insn); @@ -559,6 +604,7 @@ jump_optimize (f, cross_jump, noop_moves, after_regscan) /* Now iterate optimizing jumps until nothing changes over one pass. */ changed = 1; + old_max_reg = max_reg_num (); while (changed) { changed = 0; @@ -568,8 +614,9 @@ jump_optimize (f, cross_jump, noop_moves, after_regscan) rtx reallabelprev; rtx temp, temp1, temp2, temp3, temp4, temp5, temp6; rtx nlabel; - int this_is_simplejump, this_is_condjump, reversep; + int this_is_simplejump, this_is_condjump, reversep = 0; int this_is_condjump_in_parallel; + #if 0 /* If NOT the first iteration, if this is the last jump pass (just before final), do the special peephole optimizations. @@ -682,7 +729,15 @@ jump_optimize (f, cross_jump, noop_moves, after_regscan) && (temp1 = prev_nonnote_insn (JUMP_LABEL (insn))) != 0 && (GET_CODE (temp1) == BARRIER || (GET_CODE (temp1) == INSN - && rtx_equal_p (PATTERN (temp), PATTERN (temp1))))) + && rtx_equal_p (PATTERN (temp), PATTERN (temp1)))) + /* Don't do this optimization if we have a loop containing only + the USE instruction, and the loop start label has a usage + count of 1. This is because we will redo this optimization + everytime through the outer loop, and jump opt will never + exit. */ + && ! ((temp2 = prev_nonnote_insn (temp)) != 0 + && temp2 == JUMP_LABEL (insn) + && LABEL_NUSES (temp2) == 1)) { if (GET_CODE (temp1) == BARRIER) { @@ -729,16 +784,14 @@ jump_optimize (f, cross_jump, noop_moves, after_regscan) && GET_CODE (temp3) == INSN && (temp4 = single_set (temp3)) != 0 && GET_CODE (temp1 = SET_DEST (temp4)) == REG -#ifdef SMALL_REGISTER_CLASSES - && REGNO (temp1) >= FIRST_PSEUDO_REGISTER -#endif + && (! 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) - && (GET_CODE (SET_SRC (temp4)) == REG - || GET_CODE (SET_SRC (temp4)) == SUBREG - || CONSTANT_P (SET_SRC (temp4))) + && ! 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) @@ -765,7 +818,10 @@ jump_optimize (f, cross_jump, noop_moves, after_regscan) or a jump to somewhere else. */ rtx target = JUMP_LABEL (temp); int nuses = LABEL_NUSES (target); - rtx p, q; + 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)) @@ -806,7 +862,7 @@ jump_optimize (f, cross_jump, noop_moves, after_regscan) && ! reg_referenced_between_p (temp1, p, NEXT_INSN (temp3)) && ! reg_set_between_p (temp1, p, temp3) && (GET_CODE (SET_SRC (temp4)) == CONST_INT - || ! reg_set_between_p (SET_SRC (temp4), p, temp2))) + || ! modified_between_p (SET_SRC (temp4), p, temp2))) { emit_insn_after_with_line_notes (PATTERN (temp2), p, temp2); delete_insn (temp2); @@ -833,6 +889,93 @@ jump_optimize (f, cross_jump, noop_moves, after_regscan) } } + /* 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) + && 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; + } + #ifndef HAVE_cc0 /* If we have if (...) x = exp; and branches are expensive, EXP is a single insn, does not have any side effects, cannot @@ -847,7 +990,7 @@ jump_optimize (f, cross_jump, noop_moves, after_regscan) We set: TEMP to the "x = exp;" insn. - TEMP1 to the single set in the "x = exp; insn. + TEMP1 to the single set in the "x = exp;" insn. TEMP2 to "x". */ if (! reload_completed @@ -862,10 +1005,8 @@ jump_optimize (f, cross_jump, noop_moves, after_regscan) && 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 -#ifdef SMALL_REGISTER_CLASSES - && REGNO (temp2) >= FIRST_PSEUDO_REGISTER -#endif + && (! 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 @@ -875,13 +1016,20 @@ jump_optimize (f, cross_jump, noop_moves, after_regscan) { rtx new = gen_reg_rtx (GET_MODE (temp2)); - if (validate_change (temp, &SET_DEST (temp1), new, 0)) + 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 (insn), 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 (); + } } } @@ -905,9 +1053,8 @@ jump_optimize (f, cross_jump, noop_moves, after_regscan) && (temp1 = single_set (temp)) != 0 && (temp2 = SET_DEST (temp1), GET_CODE (temp2) == REG) && GET_MODE_CLASS (GET_MODE (temp2)) == MODE_INT -#ifdef SMALL_REGISTER_CLASSES - && REGNO (temp2) >= FIRST_PSEUDO_REGISTER -#endif + && (! 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 @@ -919,23 +1066,34 @@ jump_optimize (f, cross_jump, noop_moves, after_regscan) { rtx new = gen_reg_rtx (GET_MODE (temp2)); - if (validate_change (temp, &SET_DEST (temp1), new, 0)) + 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 (insn), temp); + PREV_INSN (temp6), temp); emit_insn_after_with_line_notes (replace_rtx (PATTERN (temp3), temp2, new), - PREV_INSN (insn), 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 (); + } } } /* 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. */ + ensure that the temporary register is not used anywhere else. */ if (! reload_completed && after_regscan @@ -958,17 +1116,16 @@ jump_optimize (f, cross_jump, noop_moves, after_regscan) && (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) + && 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 -#ifdef SMALL_REGISTER_CLASSES - && REGNO (temp2) >= FIRST_PSEUDO_REGISTER -#endif + && (! 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)) @@ -976,16 +1133,27 @@ jump_optimize (f, cross_jump, noop_moves, after_regscan) { rtx new = gen_reg_rtx (GET_MODE (temp2)); - if (validate_change (temp3, &SET_DEST (temp4), new, 0)) + 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 (insn), temp); + PREV_INSN (temp6), temp); emit_insn_after_with_line_notes (PATTERN (temp3), - PREV_INSN (insn), 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 */ @@ -1019,19 +1187,19 @@ jump_optimize (f, cross_jump, noop_moves, after_regscan) && GET_CODE (temp) == INSN && GET_CODE (PATTERN (temp)) == SET && GET_CODE (temp1 = SET_DEST (PATTERN (temp))) == REG -#ifdef SMALL_REGISTER_CLASSES - && REGNO (temp1) >= FIRST_PSEUDO_REGISTER -#endif - && (GET_CODE (temp2 = SET_SRC (PATTERN (temp))) == REG - || GET_CODE (temp2) == SUBREG - /* ??? How about floating point constants? */ - || GET_CODE (temp2) == CONST_INT) + && (! SMALL_REGISTER_CLASSES + || REGNO (temp1) >= FIRST_PSEUDO_REGISTER) + && ! side_effects_p (temp2 = SET_SRC (PATTERN (temp))) + && ! 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. */ - && (((temp3 = reg_set_last (temp1, insn)) != 0) + 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 @@ -1045,13 +1213,9 @@ jump_optimize (f, cross_jump, noop_moves, after_regscan) We could handle BLKmode if (1) emit_store_flag could and (2) we could find the size reliably. */ && GET_MODE (XEXP (temp4, 0)) != BLKmode - /* No point in doing any of this if branches are cheap or we - don't have conditional moves. */ - && (BRANCH_COST >= 2 -#ifdef HAVE_conditional_move - || 1 -#endif - ) + /* 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. */ @@ -1101,7 +1265,7 @@ jump_optimize (f, cross_jump, noop_moves, after_regscan) if (target) { - rtx seq1,seq2; + rtx seq1,seq2,last; /* Save the conditional move sequence but don't emit it yet. On some machines, like the alpha, it is possible @@ -1121,13 +1285,22 @@ jump_optimize (f, cross_jump, noop_moves, after_regscan) end_sequence (); emit_insns_before (seq1, temp5); - emit_insns_before (seq2, insn); + /* 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; } @@ -1160,8 +1333,21 @@ jump_optimize (f, cross_jump, noop_moves, after_regscan) can reverse the condition. See if (3) applies possibly by reversing the condition. Prefer reversing to (4) when branches are very expensive. */ - && ((reversep = 0, temp2 == const0_rtx) - || (temp3 == const0_rtx + && (((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 @@ -1297,6 +1483,13 @@ jump_optimize (f, cross_jump, noop_moves, after_regscan) 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; } @@ -1362,6 +1555,7 @@ jump_optimize (f, cross_jump, noop_moves, after_regscan) 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)) @@ -1415,6 +1609,13 @@ jump_optimize (f, cross_jump, noop_moves, after_regscan) 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; } @@ -1505,7 +1706,7 @@ jump_optimize (f, cross_jump, noop_moves, after_regscan) else if (ultimate && GET_CODE (ultimate) != RETURN) ultimate = XEXP (ultimate, 0); - if (ultimate) + if (ultimate && JUMP_LABEL(insn) != ultimate) changed |= redirect_jump (insn, ultimate); } } @@ -1730,10 +1931,96 @@ jump_optimize (f, cross_jump, noop_moves, after_regscan) && (next_active_insn (JUMP_LABEL (insn)) == next_active_insn (JUMP_LABEL (temp)))) { - delete_jump (insn); - changed = 1; - continue; + rtx tem = temp; + + /* ??? Optional. Disables some optimizations, but makes + gcov output more accurate with -O. */ + if (flag_test_coverage && !reload_completed) + for (tem = insn; tem != temp; tem = NEXT_INSN (tem)) + if (GET_CODE (tem) == NOTE && NOTE_LINE_NUMBER (tem) > 0) + break; + + if (tem == temp) + { + delete_jump (insn); + changed = 1; + continue; + } } +#ifdef HAVE_trap + /* Detect a conditional jump jumping over an unconditional trap. */ + else if (HAVE_trap + && this_is_condjump && ! this_is_simplejump + && reallabelprev != 0 + && GET_CODE (reallabelprev) == INSN + && GET_CODE (PATTERN (reallabelprev)) == TRAP_IF + && TRAP_CONDITION (PATTERN (reallabelprev)) == const_true_rtx + && prev_active_insn (reallabelprev) == insn + && no_labels_between_p (insn, reallabelprev) + && (temp2 = get_condition (insn, &temp4)) + && can_reverse_comparison_p (temp2, insn)) + { + rtx new = gen_cond_trap (reverse_condition (GET_CODE (temp2)), + XEXP (temp2, 0), XEXP (temp2, 1), + TRAP_CODE (PATTERN (reallabelprev))); + + if (new) + { + emit_insn_before (new, temp4); + delete_insn (reallabelprev); + delete_jump (insn); + changed = 1; + continue; + } + } + /* Detect a jump jumping to an unconditional trap. */ + else if (HAVE_trap && this_is_condjump + && (temp = next_active_insn (JUMP_LABEL (insn))) + && GET_CODE (temp) == INSN + && GET_CODE (PATTERN (temp)) == TRAP_IF + && (this_is_simplejump + || (temp2 = get_condition (insn, &temp4)))) + { + rtx tc = TRAP_CONDITION (PATTERN (temp)); + + if (tc == const_true_rtx + || (! this_is_simplejump && rtx_equal_p (temp2, tc))) + { + rtx new; + /* Replace an unconditional jump to a trap with a trap. */ + if (this_is_simplejump) + { + emit_barrier_after (emit_insn_before (gen_trap (), insn)); + delete_jump (insn); + changed = 1; + continue; + } + new = gen_cond_trap (GET_CODE (temp2), XEXP (temp2, 0), + XEXP (temp2, 1), + TRAP_CODE (PATTERN (temp))); + if (new) + { + emit_insn_before (new, temp4); + delete_jump (insn); + changed = 1; + continue; + } + } + /* If the trap condition and jump condition are mutually + exclusive, redirect the jump to the following insn. */ + else if (GET_RTX_CLASS (GET_CODE (tc)) == '<' + && ! this_is_simplejump + && swap_condition (GET_CODE (temp2)) == GET_CODE (tc) + && rtx_equal_p (XEXP (tc, 0), XEXP (temp2, 0)) + && rtx_equal_p (XEXP (tc, 1), XEXP (temp2, 1)) + && redirect_jump (insn, get_label_after (temp))) + { + changed = 1; + continue; + } + } +#endif + /* Detect a conditional jump jumping over an unconditional jump. */ else if ((this_is_condjump || this_is_condjump_in_parallel) @@ -1916,7 +2203,7 @@ jump_optimize (f, cross_jump, noop_moves, after_regscan) /* Now that the jump has been tensioned, try cross jumping: check for identical code - before the jump and before its target label. */ + before the jump and before its target label. */ /* First, cross jumping of conditional jumps: */ @@ -1947,11 +2234,11 @@ jump_optimize (f, cross_jump, noop_moves, after_regscan) /* Make the old conditional jump into an unconditional one. */ SET_SRC (PATTERN (insn)) - = gen_rtx (LABEL_REF, VOIDmode, JUMP_LABEL (insn)); + = gen_rtx_LABEL_REF (VOIDmode, JUMP_LABEL (insn)); INSN_CODE (insn) = -1; emit_barrier_after (insn); /* Add to jump_chain unless this is a new label - whose UID is too large. */ + whose UID is too large. */ if (INSN_UID (JUMP_LABEL (insn)) < max_jump_chain) { jump_chain[INSN_UID (insn)] @@ -2147,6 +2434,11 @@ duplicate_loop_exit_test (loop_start) is a NOTE_INSN_LOOP_BEG because this means we have a nested loop is a NOTE_INSN_BLOCK_{BEG,END} because duplicating these notes are not valid + + + We also do not do this if we find an insn with ASM_OPERANDS. While + this restriction should not be necessary, copying an insn with + ASM_OPERANDS can confuse asm_noperands in some cases. Also, don't do this if the exit code is more than 20 insns. */ @@ -2172,18 +2464,29 @@ duplicate_loop_exit_test (loop_start) This can be avoided by checking here for NOTE_INSN_LOOP_CONT. */ if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_BEG - || NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_BEG - || NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_END || NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_CONT) return 0; + + if (optimize < 2 + && (NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_BEG + || NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_END)) + /* If we were to duplicate this code, we would not move + the BLOCK notes, and so debugging the moved code would + be difficult. Thus, we only move the code with -O2 or + higher. */ + return 0; + break; case JUMP_INSN: case INSN: if (++num_insns > 20 || find_reg_note (insn, REG_RETVAL, NULL_RTX) - || find_reg_note (insn, REG_LIBCALL, NULL_RTX)) + || find_reg_note (insn, REG_LIBCALL, NULL_RTX) + || asm_noperands (PATTERN (insn)) > 0) return 0; break; + default: + break; } } @@ -2202,10 +2505,10 @@ duplicate_loop_exit_test (loop_start) || (GET_CODE (reg) == SUBREG && (reg = SUBREG_REG (reg), GET_CODE (reg) == REG))) && REGNO (reg) >= FIRST_PSEUDO_REGISTER - && regno_first_uid[REGNO (reg)] == INSN_UID (insn)) + && REGNO_FIRST_UID (REGNO (reg)) == INSN_UID (insn)) { for (p = NEXT_INSN (insn); p != lastexit; p = NEXT_INSN (p)) - if (regno_last_uid[REGNO (reg)] == INSN_UID (p)) + if (REGNO_LAST_UID (REGNO (reg)) == INSN_UID (p)) break; if (p != lastexit) @@ -2252,8 +2555,9 @@ duplicate_loop_exit_test (loop_start) for (link = REG_NOTES (insn); link; link = XEXP (link, 1)) if (REG_NOTE_KIND (link) != REG_LABEL) REG_NOTES (copy) - = copy_rtx (gen_rtx (EXPR_LIST, REG_NOTE_KIND (link), - XEXP (link, 0), REG_NOTES (copy))); + = copy_rtx (gen_rtx_EXPR_LIST (REG_NOTE_KIND (link), + XEXP (link, 0), + REG_NOTES (copy))); if (reg_map && REG_NOTES (copy)) replace_regs (REG_NOTES (copy), reg_map, max_reg, 1); break; @@ -2379,7 +2683,6 @@ find_cross_jump (e1, e2, minimum, f1, f2) rtx last1 = 0, last2 = 0; rtx afterlast1 = 0, afterlast2 = 0; - rtx prev1; *f1 = 0; *f2 = 0; @@ -2412,6 +2715,13 @@ find_cross_jump (e1, e2, minimum, f1, f2) if (i2 == 0 || GET_CODE (i1) != GET_CODE (i2)) break; + /* Avoid moving insns across EH regions. + + ??? This is only necessary if i1 or i2 can throw an exception. */ + if (flag_exceptions + && !in_same_eh_region (i1, i2)) + break; + p1 = PATTERN (i1); p2 = PATTERN (i2); @@ -2433,13 +2743,13 @@ find_cross_jump (e1, e2, minimum, f1, f2) #ifdef STACK_REGS /* If cross_jump_death_matters is not 0, the insn's mode indicates whether or not the insn contains any stack-like - regs. */ + regs. */ if (!lose && cross_jump_death_matters && GET_MODE (i1) == QImode) { /* If register stack conversion has already been done, then death notes must also be compared before it is certain that - the two instruction streams match. */ + the two instruction streams match. */ rtx note; HARD_REG_SET i1_regset, i2_regset; @@ -2466,7 +2776,19 @@ find_cross_jump (e1, e2, minimum, f1, f2) } #endif - if (lose || GET_CODE (p1) != GET_CODE (p2) + /* Don't allow old-style asm or volatile extended asms to be accepted + for cross jumping purposes. It is conceptually correct to allow + them, since cross-jumping preserves the dynamic instruction order + even though it is changing the static instruction order. However, + if an asm is being used to emit an assembler pseudo-op, such as + the MIPS `.set reorder' pseudo-op, then the static instruction order + matters and it must be preserved. */ + if (GET_CODE (p1) == ASM_INPUT || GET_CODE (p2) == ASM_INPUT + || (GET_CODE (p1) == ASM_OPERANDS && MEM_VOLATILE_P (p1)) + || (GET_CODE (p2) == ASM_OPERANDS && MEM_VOLATILE_P (p2))) + lose = 1; + + if (lose || GET_CODE (p1) != GET_CODE (p2) || ! rtx_renumbered_equal_p (p1, p2)) { /* The following code helps take care of G++ cleanups. */ @@ -2922,6 +3244,9 @@ comparison_dominates_p (code1, code2) if (code2 == GEU || code2 == NE) return 1; break; + + default: + break; } return 0; @@ -3054,7 +3379,8 @@ follow_jumps (label) (depth < 10 && (insn = next_active_insn (value)) != 0 && GET_CODE (insn) == JUMP_INSN - && (JUMP_LABEL (insn) != 0 || GET_CODE (PATTERN (insn)) == RETURN) + && ((JUMP_LABEL (insn) != 0 && simplejump_p (insn)) + || GET_CODE (PATTERN (insn)) == RETURN) && (next = NEXT_INSN (insn)) && GET_CODE (next) == BARRIER); depth++) @@ -3067,7 +3393,10 @@ follow_jumps (label) if (!reload_completed) for (tem = value; tem != insn; tem = NEXT_INSN (tem)) if (GET_CODE (tem) == NOTE - && NOTE_LINE_NUMBER (tem) == NOTE_INSN_LOOP_BEG) + && (NOTE_LINE_NUMBER (tem) == NOTE_INSN_LOOP_BEG + /* ??? Optional. Disables some optimizations, but makes + gcov output more accurate with -O. */ + || (flag_test_coverage && NOTE_LINE_NUMBER (tem) > 0))) return value; /* If we have found a cycle, make the insn jump to itself. */ @@ -3188,12 +3517,16 @@ mark_jump_label (x, insn, cross_jump) break; else if (! cross_jump && (NOTE_LINE_NUMBER (next) == NOTE_INSN_LOOP_BEG - || NOTE_LINE_NUMBER (next) == NOTE_INSN_FUNCTION_END)) + || NOTE_LINE_NUMBER (next) == NOTE_INSN_FUNCTION_END + /* ??? Optional. Disables some optimizations, but + makes gcov output more accurate with -O. */ + || (flag_test_coverage && NOTE_LINE_NUMBER (next) > 0))) break; } XEXP (x, 0) = label; - ++LABEL_NUSES (label); + if (! insn || ! INSN_DELETED_P (insn)) + ++LABEL_NUSES (label); if (insn) { @@ -3210,17 +3543,21 @@ mark_jump_label (x, insn, cross_jump) is one. */ else if (! find_reg_note (insn, REG_LABEL, label)) { - rtx next = next_real_insn (label); - /* Don't record labels that refer to dispatch tables. - This is not necessary, since the tablejump - references the same label. - And if we did record them, flow.c would make worse code. */ - if (next == 0 - || ! (GET_CODE (next) == JUMP_INSN - && (GET_CODE (PATTERN (next)) == ADDR_VEC - || GET_CODE (PATTERN (next)) == ADDR_DIFF_VEC))) - REG_NOTES (insn) = gen_rtx (EXPR_LIST, REG_LABEL, label, - REG_NOTES (insn)); + /* This code used to ignore labels which refered to dispatch + tables to avoid flow.c generating worse code. + + However, in the presense of global optimizations like + gcse which call find_basic_blocks without calling + life_analysis, not recording such labels will lead + to compiler aborts because of inconsistencies in the + flow graph. So we go ahead and record the label. + + It may also be the case that the optimization argument + is no longer valid because of the more accurate cfg + we build in find_basic_blocks -- it no longer pessimizes + code when it finds a REG_LABEL note. */ + REG_NOTES (insn) = gen_rtx_EXPR_LIST (REG_LABEL, label, + REG_NOTES (insn)); } } return; @@ -3230,13 +3567,17 @@ mark_jump_label (x, insn, cross_jump) ADDR_DIFF_VEC. Don't set the JUMP_LABEL of a vector. */ case ADDR_VEC: case ADDR_DIFF_VEC: - { - int eltnum = code == ADDR_DIFF_VEC ? 1 : 0; + if (! INSN_DELETED_P (insn)) + { + int eltnum = code == ADDR_DIFF_VEC ? 1 : 0; - for (i = 0; i < XVECLEN (x, eltnum); i++) - mark_jump_label (XVECEXP (x, eltnum, i), NULL_RTX, cross_jump); - return; - } + for (i = 0; i < XVECLEN (x, eltnum); i++) + mark_jump_label (XVECEXP (x, eltnum, i), NULL_RTX, cross_jump); + } + return; + + default: + break; } fmt = GET_RTX_FORMAT (code); @@ -3304,12 +3645,23 @@ delete_computation (insn) delete_computation (prev); else /* Otherwise, show that cc0 won't be used. */ - REG_NOTES (prev) = gen_rtx (EXPR_LIST, REG_UNUSED, - cc0_rtx, REG_NOTES (prev)); + REG_NOTES (prev) = gen_rtx_EXPR_LIST (REG_UNUSED, + cc0_rtx, REG_NOTES (prev)); } } #endif +#ifdef INSN_SCHEDULING + /* ?!? The schedulers do not keep REG_DEAD notes accurate after + reload has completed. The schedulers need to be fixed. Until + they are, we must not rely on the death notes here. */ + if (reload_completed && flag_schedule_insns_after_reload) + { + delete_insn (insn); + return; + } +#endif + for (note = REG_NOTES (insn); note; note = next) { rtx our_prev; @@ -3603,7 +3955,21 @@ invert_jump (jump, nlabel) return 0; if (redirect_jump (jump, nlabel)) - return 1; + { + if (flag_branch_probabilities) + { + rtx note = find_reg_note (jump, REG_BR_PROB, 0); + + /* An inverted jump means that a probability taken becomes a + probability not taken. Subtract the branch probability from the + probability base to convert it back to a taken probability. + (We don't flip the probability on a branch that's never taken. */ + if (note && XINT (XEXP (note, 0), 0) >= 0) + XINT (XEXP (note, 0), 0) = REG_BR_PROB_BASE - XINT (XEXP (note, 0), 0); + } + + return 1; + } if (! invert_exp (PATTERN (jump), jump)) /* This should just be putting it back the way it was. */ @@ -3640,9 +4006,9 @@ invert_exp (x, insn) if (can_reverse_comparison_p (comp, insn) && validate_change (insn, &XEXP (x, 0), - gen_rtx (reverse_condition (GET_CODE (comp)), - GET_MODE (comp), XEXP (comp, 0), - XEXP (comp, 1)), 0)) + gen_rtx_fmt_ee (reverse_condition (GET_CODE (comp)), + GET_MODE (comp), XEXP (comp, 0), + XEXP (comp, 1)), 0)) return 1; tem = XEXP (x, 1); @@ -3783,22 +4149,22 @@ redirect_exp (loc, olabel, nlabel, insn) if (nlabel) XEXP (x, 0) = nlabel; else - return validate_change (insn, loc, gen_rtx (RETURN, VOIDmode), 0); + return validate_change (insn, loc, gen_rtx_RETURN (VOIDmode), 0); return 1; } } else if (code == RETURN && olabel == 0) { - x = gen_rtx (LABEL_REF, VOIDmode, nlabel); + x = gen_rtx_LABEL_REF (VOIDmode, nlabel); if (loc == &PATTERN (insn)) - x = gen_rtx (SET, VOIDmode, pc_rtx, x); + x = gen_rtx_SET (VOIDmode, pc_rtx, x); return validate_change (insn, loc, x, 0); } if (code == SET && nlabel == 0 && SET_DEST (x) == pc_rtx && GET_CODE (SET_SRC (x)) == LABEL_REF && XEXP (SET_SRC (x), 0) == olabel) - return validate_change (insn, loc, gen_rtx (RETURN, VOIDmode), 0); + return validate_change (insn, loc, gen_rtx_RETURN (VOIDmode), 0); fmt = GET_RTX_FORMAT (code); for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--) @@ -3990,6 +4356,13 @@ rtx_renumbered_equal_p (x, y) case SYMBOL_REF: return XSTR (x, 0) == XSTR (y, 0); + + case CODE_LABEL: + /* If we didn't match EQ equality above, they aren't the same. */ + return 0; + + default: + break; } /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent. */ @@ -4134,7 +4507,7 @@ static int modified_mem; static void mark_modified_reg (dest, x) rtx dest; - rtx x; + rtx x ATTRIBUTE_UNUSED; { int regno, i; @@ -4279,7 +4652,10 @@ 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) - || comparison_dominates_p (code1, reverse_condition (code2)))) + || (comparison_dominates_p (code1, reverse_condition (code2)) + && can_reverse_comparison_p (XEXP (SET_SRC (PATTERN (b1)), + 0), + b1)))) { t1 = prev_nonnote_insn (b1); t2 = prev_nonnote_insn (b2); @@ -4308,6 +4684,7 @@ thread_jumps (f, max_reg, flag_before_loop) rtx prev = PREV_INSN (new_label); if (flag_before_loop + && GET_CODE (prev) == NOTE && NOTE_LINE_NUMBER (prev) == NOTE_INSN_LOOP_BEG) { /* Don't thread to the loop label. If a loop @@ -4366,6 +4743,13 @@ rtx_equal_for_thread_p (x, y, yinsn) if (GET_MODE (x) != GET_MODE (y)) return 0; + /* For floating-point, consider everything unequal. This is a bit + pessimistic, but this pass would only rarely do anything for FP + anyway. */ + if (TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT + && FLOAT_MODE_P (GET_MODE (x)) && ! flag_fast_math) + return 0; + /* For commutative operations, the RTX match if the operand match in any order. Also handle the simple binary and unary cases without a loop. */ if (code == EQ || code == NE || GET_RTX_CLASS (code) == 'c') @@ -4401,7 +4785,7 @@ rtx_equal_for_thread_p (x, y, yinsn) /* If this is the first time we are seeing a register on the `Y' side, see if it is the last use. If not, we can't thread the jump, so mark it as not equivalent. */ - if (regno_last_uid[REGNO (y)] != INSN_UID (yinsn)) + if (REGNO_LAST_UID (REGNO (y)) != INSN_UID (yinsn)) return 0; return 1; @@ -4413,7 +4797,7 @@ rtx_equal_for_thread_p (x, y, yinsn) case MEM: /* If memory modified or either volatile, not equivalent. - Else, check address. */ + Else, check address. */ if (modified_mem || MEM_VOLATILE_P (x) || MEM_VOLATILE_P (y)) return 0; @@ -4450,6 +4834,9 @@ rtx_equal_for_thread_p (x, y, yinsn) case SYMBOL_REF: return XSTR (x, 0) == XSTR (y, 0); + + default: + break; } if (x == y) @@ -4511,3 +4898,47 @@ rtx_equal_for_thread_p (x, y, yinsn) } return 1; } + + +#ifndef HAVE_cc0 +/* Return the insn that NEW can be safely inserted in front of starting at + the jump insn INSN. Return 0 if it is not safe to do this jump + optimization. Note that NEW must contain a single set. */ + +static rtx +find_insert_position (insn, new) + rtx insn; + rtx new; +{ + int i; + rtx prev; + + /* If NEW does not clobber, it is safe to insert NEW before INSN. */ + if (GET_CODE (PATTERN (new)) != PARALLEL) + return insn; + + for (i = XVECLEN (PATTERN (new), 0) - 1; i >= 0; i--) + if (GET_CODE (XVECEXP (PATTERN (new), 0, i)) == CLOBBER + && reg_overlap_mentioned_p (XEXP (XVECEXP (PATTERN (new), 0, i), 0), + insn)) + break; + + if (i < 0) + return insn; + + /* There is a good chance that the previous insn PREV sets the thing + being clobbered (often the CC in a hard reg). If PREV does not + use what NEW sets, we can insert NEW before PREV. */ + + prev = prev_active_insn (insn); + for (i = XVECLEN (PATTERN (new), 0) - 1; i >= 0; i--) + if (GET_CODE (XVECEXP (PATTERN (new), 0, i)) == CLOBBER + && reg_overlap_mentioned_p (XEXP (XVECEXP (PATTERN (new), 0, i), 0), + insn) + && ! modified_in_p (XEXP (XVECEXP (PATTERN (new), 0, i), 0), + prev)) + return 0; + + return reg_mentioned_p (SET_DEST (single_set (new)), prev) ? 0 : prev; +} +#endif /* !HAVE_cc0 */ |
