the Free Software Foundation, 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
-
/* This is the jump-optimization pass of the compiler.
It is run two or three times: once before cse, sometimes once after cse,
and once after reload (before final).
static int max_jump_chain;
-/* Set nonzero by jump_optimize if control can fall through
- to the end of the function. */
-int can_reach_end;
-
/* Indicates whether death notes are significant in cross jump analysis.
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
static void mark_all_labels PARAMS ((rtx, int));
static rtx delete_unreferenced_labels PARAMS ((rtx));
static void delete_noop_moves PARAMS ((rtx));
-static int calculate_can_reach_end PARAMS ((rtx, int));
static int duplicate_loop_exit_test PARAMS ((rtx));
static void find_cross_jump PARAMS ((rtx, rtx, int, rtx *, rtx *));
static void do_cross_jump PARAMS ((rtx, rtx, rtx));
}
/* Alternate entry into the jump optimizer. Do only trivial optimizations. */
+
void
jump_optimize_minimal (f)
rtx f;
&& 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. */
+ might arrange to use that reg for real. */
&& REGNO_LAST_NOTE_UID (REGNO (SET_DEST (set))) == INSN_UID (insn)
&& ! side_effects_p (SET_SRC (set))
&& ! find_reg_note (insn, REG_RETVAL, 0)
&& dispatch != 0
&& GET_CODE (dispatch) == JUMP_INSN
&& JUMP_LABEL (dispatch) != 0
- /* Don't mess with a casesi insn.
+ /* Don't mess with a casesi insn.
XXX according to the comment before computed_jump_p(),
all casesi insns should be a parallel of the jump
and a USE of a LABEL_REF. */
for (temp2 = insn; temp2 != temp; temp2 = NEXT_INSN (temp2))
if (GET_CODE (temp2) == NOTE && NOTE_LINE_NUMBER (temp2) > 0)
break;
-
+
if (temp2 == temp)
{
delete_jump (insn);
&& GET_CODE (PATTERN (temp)) == TRAP_IF
&& (this_is_any_uncondjump
|| (this_is_any_condjump
- && temp2 = get_condition (insn, &temp4))))
+ && (temp2 = get_condition (insn, &temp4)))))
{
rtx tc = TRAP_CONDITION (PATTERN (temp));
if (tc == const_true_rtx
- || (! this_is_uncondjump && rtx_equal_p (temp2, tc)))
+ || (! this_is_any_uncondjump && rtx_equal_p (temp2, tc)))
{
rtx new;
/* Replace an unconditional jump to a trap with a trap. */
- if (this_is_uncondjump)
+ if (this_is_any_uncondjump)
{
emit_barrier_after (emit_insn_before (gen_trap (), insn));
delete_jump (insn);
/* TARGET is nonzero if it is ok to cross jump
to code before TARGET. If so, see if matches. */
if (x != 0)
- find_cross_jump (insn, x,
- (optimize_size ? 1 : BRANCH_COST) + 1,
+ find_cross_jump (insn, x, 2,
&newjpos, &newlpos);
if (newjpos != 0)
/* TARGET is nonzero if it is ok to cross jump
to code before TARGET. If so, see if matches. */
- find_cross_jump (insn, JUMP_LABEL (insn),
- optimize_size ? 1 : BRANCH_COST,
+ find_cross_jump (insn, JUMP_LABEL (insn), 1,
&newjpos, &newlpos);
/* If cannot cross jump to code before the label,
&& JUMP_LABEL (target) == JUMP_LABEL (insn)
/* Ignore TARGET if it's deleted. */
&& ! INSN_DELETED_P (target))
- find_cross_jump (insn, target,
- (optimize_size ? 1 : BRANCH_COST) + 1,
+ find_cross_jump (insn, target, 2,
&newjpos, &newlpos);
if (newjpos != 0)
if (target != insn
&& ! INSN_DELETED_P (target)
&& GET_CODE (PATTERN (target)) == RETURN)
- find_cross_jump (insn, target,
- (optimize_size ? 1 : BRANCH_COST) + 1,
+ find_cross_jump (insn, target, 2,
&newjpos, &newlpos);
if (newjpos != 0)
}
}
- /* CAN_REACH_END is persistent for each function. Once set it should
- not be cleared. This is especially true for the case where we
- delete the NOTE_FUNCTION_END note. CAN_REACH_END is cleared by
- the front-end before compiling each function. */
- if (! minimal && calculate_can_reach_end (last_insn, optimize != 0))
- can_reach_end = 1;
-
end:
/* Clean up. */
free (jump_chain);
return largest_uid;
}
-/* Delete insns following barriers, up to next label.
+/* Delete insns following barriers, up to next label.
Also delete no-op jumps created by gcse. */
rtx insn;
for (insn = f; insn; insn = NEXT_INSN (insn))
- if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
+ if (INSN_P (insn))
{
if (GET_CODE (insn) == CALL_INSN
&& GET_CODE (PATTERN (insn)) == CALL_PLACEHOLDER)
mark_all_labels (XEXP (PATTERN (insn), 2), cross_jump);
continue;
}
-
+
mark_jump_label (PATTERN (insn), insn, cross_jump, 0);
if (! INSN_DELETED_P (insn) && GET_CODE (insn) == JUMP_INSN)
{
rtx final = NULL_RTX;
rtx insn;
- for (insn = f; insn; )
+ for (insn = f; insn;)
{
if (GET_CODE (insn) == CODE_LABEL
- && LABEL_NUSES (insn) == 0
- && LABEL_ALTERNATE_NAME (insn) == NULL)
+ && LABEL_NUSES (insn) == 0
+ && LABEL_ALTERNATE_NAME (insn) == NULL)
insn = delete_insn (insn);
else
{
{
rtx insn, next;
- for (insn = f; insn; )
+ for (insn = f; insn;)
{
next = NEXT_INSN (insn);
|| dreg != sreg)
break;
}
-
+
if (i < 0)
delete_insn (insn);
}
}
}
-/* See if there is still a NOTE_INSN_FUNCTION_END in this function.
- If so indicate that this function can drop off the end by returning
- 1, else return 0.
-
- CHECK_DELETED indicates whether we must check if the note being
- searched for has the deleted flag set.
-
- DELETE_FINAL_NOTE indicates whether we should delete the note
- if we find it. */
-
-static int
-calculate_can_reach_end (last, delete_final_note)
- rtx last;
- int delete_final_note;
-{
- rtx insn = last;
- int n_labels = 1;
-
- while (insn != NULL_RTX)
- {
- int ok = 0;
-
- /* One label can follow the end-note: the return label. */
- if (GET_CODE (insn) == CODE_LABEL && n_labels-- > 0)
- ok = 1;
- /* Ordinary insns can follow it if returning a structure. */
- else if (GET_CODE (insn) == INSN)
- ok = 1;
- /* If machine uses explicit RETURN insns, no epilogue,
- then one of them follows the note. */
- else if (GET_CODE (insn) == JUMP_INSN
- && GET_CODE (PATTERN (insn)) == RETURN)
- ok = 1;
- /* A barrier can follow the return insn. */
- else if (GET_CODE (insn) == BARRIER)
- ok = 1;
- /* Other kinds of notes can follow also. */
- else if (GET_CODE (insn) == NOTE
- && NOTE_LINE_NUMBER (insn) != NOTE_INSN_FUNCTION_END)
- ok = 1;
-
- if (ok != 1)
- break;
-
- insn = PREV_INSN (insn);
- }
-
- /* See if we backed up to the appropriate type of note. */
- if (insn != NULL_RTX
- && GET_CODE (insn) == NOTE
- && NOTE_LINE_NUMBER (insn) == NOTE_INSN_FUNCTION_END)
- {
- if (delete_final_note)
- delete_insn (insn);
- return 1;
- }
-
- return 0;
-}
-
/* LOOP_START is a NOTE_INSN_LOOP_BEG note that is followed by an unconditional
jump. Assume that this unconditional jump is to the exit test code. If
the code is sufficiently simple, make a copy of it before INSN,
NOTE_SOURCE_FILE (copy) = NOTE_SOURCE_FILE (insn);
}
break;
-
+
case INSN:
copy = emit_insn_before (copy_insn (PATTERN (insn)), loop_start);
if (reg_map)
replace_regs (PATTERN (copy), reg_map, max_reg, 1);
-
+
mark_jump_label (PATTERN (copy), copy, 0, 0);
-
+
/* Copy all REG_NOTES except REG_LABEL since mark_jump_label will
make them. */
for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
if (reg_map && REG_NOTES (copy))
replace_regs (REG_NOTES (copy), reg_map, max_reg, 1);
break;
-
+
case JUMP_INSN:
- copy = emit_jump_insn_before (copy_insn (PATTERN (insn)), loop_start);
+ copy = emit_jump_insn_before (copy_insn (PATTERN (insn)),
+ loop_start);
if (reg_map)
replace_regs (PATTERN (copy), reg_map, max_reg, 1);
mark_jump_label (PATTERN (copy), copy, 0, 0);
if (reg_map)
replace_regs (REG_NOTES (copy), reg_map, max_reg, 1);
}
-
+
/* If this is a simple jump, add it to the jump chain. */
-
+
if (INSN_UID (copy) < max_jump_chain && JUMP_LABEL (copy)
&& simplejump_p (copy))
{
jump_chain[INSN_UID (JUMP_LABEL (copy))] = copy;
}
break;
-
+
default:
abort ();
}
emit_note_before (NOTE_INSN_LOOP_VTOP, exitcode);
delete_insn (next_nonnote_insn (loop_start));
-
+
/* Clean up. */
if (reg_map)
free (reg_map);
p1 = PATTERN (i1);
p2 = PATTERN (i2);
-
+
/* If this is a CALL_INSN, compare register usage information.
If we don't check this on stack register machines, the two
CALL_INSNs might be merged leaving reg-stack.c with mismatching
arg0 = XEXP (comparison, 0);
/* Make sure ARG0 is one of the actual objects being compared. If we
- can't do this, we can't be sure the comparison can be reversed.
+ can't do this, we can't be sure the comparison can be reversed.
Handle cc0 and a MODE_CC register. */
if ((GET_CODE (arg0) == REG && GET_MODE_CLASS (GET_MODE (arg0)) == MODE_CC)
if (! insn)
return 0;
-
+
for (prev = prev_nonnote_insn (insn);
prev != 0 && GET_CODE (prev) != CODE_LABEL;
prev = prev_nonnote_insn (prev))
WATCH OUT! reverse_condition is not safe to use on a jump that might
be acting on the results of an IEEE floating point comparison, because
- of the special treatment of non-signaling nans in comparisons.
+ of the special treatment of non-signaling nans in comparisons.
Use can_reverse_comparison_p to be sure. */
enum rtx_code
if (code2 == NE)
return 1;
break;
-
+
default:
break;
}
}
/* Return nonzero if INSN is a (possibly) conditional jump
- and nothing more.
-
+ and nothing more.
+
Use this function is deprecated, since we need to support combined
branch and compare insns. Use any_condjump_p instead whenever possible. */
x = SET_SRC (x);
if (GET_CODE (x) == LABEL_REF)
return 1;
- else return (GET_CODE (x) == IF_THEN_ELSE
- && ((GET_CODE (XEXP (x, 2)) == PC
- && (GET_CODE (XEXP (x, 1)) == LABEL_REF
- || GET_CODE (XEXP (x, 1)) == RETURN))
- || (GET_CODE (XEXP (x, 1)) == PC
- && (GET_CODE (XEXP (x, 2)) == LABEL_REF
- || GET_CODE (XEXP (x, 2)) == RETURN))));
+ else
+ return (GET_CODE (x) == IF_THEN_ELSE
+ && ((GET_CODE (XEXP (x, 2)) == PC
+ && (GET_CODE (XEXP (x, 1)) == LABEL_REF
+ || GET_CODE (XEXP (x, 1)) == RETURN))
+ || (GET_CODE (XEXP (x, 1)) == PC
+ && (GET_CODE (XEXP (x, 2)) == LABEL_REF
+ || GET_CODE (XEXP (x, 2)) == RETURN))));
return 0;
}
/* Return nonzero if INSN is a (possibly) conditional jump inside a
PARALLEL.
-
+
Use this function is deprecated, since we need to support combined
branch and compare insns. Use any_condjump_p instead whenever possible. */
/* Return true when insn is a conditional jump. This function works for
instructions containing PC sets in PARALLELs. The instruction may have
various other effects so before removing the jump you must verify
- safe_to_remove_jump_p.
+ onlyjump_p.
Note that unlike condjump_p it returns false for unconditional jumps. */
b = GET_CODE (XEXP (SET_SRC (x), 2));
return ((b == PC && (a == LABEL_REF || a == RETURN))
- || (a == PC && (b == LABEL_REF || b == RETURN)));
+ || (a == PC && (b == LABEL_REF || b == RETURN)));
}
/* Return the label of a conditional jump. */
case SYMBOL_REF:
if (!in_mem)
- return;
+ return;
/* If this is a constant-pool reference, see if it is a label. */
if (CONSTANT_POOL_ADDRESS_P (x))
- mark_jump_label (get_pool_constant (x), insn, cross_jump, in_mem);
+ mark_jump_label (get_pool_constant (x), insn, cross_jump, in_mem);
break;
case LABEL_REF:
/* Ignore remaining references to unreachable labels that
have been deleted. */
- if (GET_CODE (label) == NOTE
+ if (GET_CODE (label) == NOTE
&& NOTE_LINE_NUMBER (label) == NOTE_INSN_DELETED_LABEL)
break;
|| 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)))
+ || (flag_test_coverage
+ && NOTE_LINE_NUMBER (next) > 0)))
break;
}
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, in_mem);
+ mark_jump_label (XVECEXP (x, eltnum, i), NULL_RTX,
+ cross_jump, in_mem);
}
return;
-
+
default:
break;
}
{
int dest_regno = REGNO (SET_DEST (pat));
int dest_endregno
- = dest_regno + (dest_regno < FIRST_PSEUDO_REGISTER
+ = (dest_regno
+ + (dest_regno < FIRST_PSEUDO_REGISTER
? HARD_REGNO_NREGS (dest_regno,
- GET_MODE (SET_DEST (pat))) : 1);
+ GET_MODE (SET_DEST (pat))) : 1));
int regno = REGNO (reg);
- int endregno = regno + (regno < FIRST_PSEUDO_REGISTER
- ? HARD_REGNO_NREGS (regno, GET_MODE (reg)) : 1);
+ int endregno
+ = (regno
+ + (regno < FIRST_PSEUDO_REGISTER
+ ? HARD_REGNO_NREGS (regno, GET_MODE (reg)) : 1));
if (dest_regno >= regno
&& dest_endregno <= endregno)
int i;
REG_NOTES (our_prev)
- = gen_rtx_EXPR_LIST (REG_UNUSED, reg, REG_NOTES (our_prev));
+ = gen_rtx_EXPR_LIST (REG_UNUSED, reg,
+ REG_NOTES (our_prev));
for (i = dest_regno; i < dest_endregno; i++)
if (! find_regno_note (our_prev, REG_UNUSED, i))
set = single_set (insn);
if (set && GET_CODE (SET_DEST (set)) == REG)
{
- int dest_regno = REGNO (SET_DEST (set));
- int dest_endregno
- = dest_regno + (dest_regno < FIRST_PSEUDO_REGISTER
- ? HARD_REGNO_NREGS (dest_regno,
- GET_MODE (SET_DEST (set))) : 1);
- int i;
-
- for (i = dest_regno; i < dest_endregno; i++)
- {
- if (! refers_to_regno_p (i, i + 1, SET_SRC (set), NULL_PTR)
- || find_regno_note (insn, REG_DEAD, i))
- continue;
-
- note = gen_rtx_EXPR_LIST (REG_DEAD, (i < FIRST_PSEUDO_REGISTER
- ? gen_rtx_REG (reg_raw_mode[i], i)
- : SET_DEST (set)), NULL_RTX);
- delete_prior_computation (note, insn);
- }
+ int dest_regno = REGNO (SET_DEST (set));
+ int dest_endregno
+ = dest_regno + (dest_regno < FIRST_PSEUDO_REGISTER
+ ? HARD_REGNO_NREGS (dest_regno,
+ GET_MODE (SET_DEST (set))) : 1);
+ int i;
+
+ for (i = dest_regno; i < dest_endregno; i++)
+ {
+ if (! refers_to_regno_p (i, i + 1, SET_SRC (set), NULL_PTR)
+ || find_regno_note (insn, REG_DEAD, i))
+ continue;
+
+ note = gen_rtx_EXPR_LIST (REG_DEAD,
+ (i < FIRST_PSEUDO_REGISTER
+ ? gen_rtx_REG (reg_raw_mode[i], i)
+ : SET_DEST (set)), NULL_RTX);
+ delete_prior_computation (note, insn);
+ }
}
for (note = REG_NOTES (insn); note; note = next)
rtx a_line_note = NULL;
int two_avoided_lines = 0;
int contains_insn = 0;
-
+
if (! warn_notreached)
return;
/* Scan forwards, looking at LINE_NUMBER notes, until
we hit a LABEL or we run out of insns. */
-
+
for (insn = avoided_insn; insn != NULL; insn = NEXT_INSN (insn))
{
- if (GET_CODE (insn) == CODE_LABEL)
- break;
- else if (GET_CODE (insn) == NOTE /* A line number note? */
- && NOTE_LINE_NUMBER (insn) >= 0)
+ if (GET_CODE (insn) == CODE_LABEL)
+ break;
+ else if (GET_CODE (insn) == NOTE /* A line number note? */
+ && NOTE_LINE_NUMBER (insn) >= 0)
{
if (a_line_note == NULL)
a_line_note = insn;
two_avoided_lines |= (NOTE_LINE_NUMBER (a_line_note)
!= NOTE_LINE_NUMBER (insn));
}
- else if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
- contains_insn = 1;
+ else if (INSN_P (insn))
+ contains_insn = 1;
}
if (two_avoided_lines && contains_insn)
warning_with_file_and_line (NOTE_SOURCE_FILE (a_line_note),
if (nlabel)
n = gen_rtx_LABEL_REF (VOIDmode, nlabel);
else
- n = gen_rtx_RETURN (VOIDmode);
+ n = gen_rtx_RETURN (VOIDmode);
validate_change (insn, loc, n, 1);
return;
/* If we're eliding the jump over exception cleanups at the end of a
function, move the function end note so that -Wreturn-type works. */
- if (olabel && NEXT_INSN (olabel)
+ if (olabel && nlabel
+ && NEXT_INSN (olabel)
&& GET_CODE (NEXT_INSN (olabel)) == NOTE
&& NOTE_LINE_NUMBER (NEXT_INSN (olabel)) == NOTE_INSN_FUNCTION_END)
emit_note_after (NOTE_INSN_FUNCTION_END, nlabel);
return 1;
}
-/* Invert the jump condition of rtx X contained in jump insn, INSN.
+/* Invert the jump condition of rtx X contained in jump insn, INSN.
Accrue the modifications into the change group. */
static void
rtx x = pc_set (insn);
if (!x)
- abort();
+ abort ();
x = SET_SRC (x);
code = GET_CODE (x);
1);
return;
}
-
+
tem = XEXP (x, 1);
validate_change (insn, &XEXP (x, 1), XEXP (x, 2), 1);
validate_change (insn, &XEXP (x, 2), tem, 1);
abort ();
}
-/* Invert the jump condition of conditional jump insn, INSN.
+/* Invert the jump condition of conditional jump insn, INSN.
Return 1 if we can do so, 0 if we cannot find a way to do so that
matches a pattern. */
/* Handle return insns. */
else if (jump_chain && GET_CODE (PATTERN (jump)) == RETURN)
index = 0;
- else return;
+ else
+ return;
if (jump_chain[index] == jump)
jump_chain[index] = jump_chain[INSN_UID (jump)];
register int i;
register RTX_CODE code = GET_CODE (x);
register const char *fmt;
-
+
if (x == y)
return 1;
return reg_x >= 0 && reg_x == reg_y && word_x == word_y;
}
- /* Now we have disposed of all the cases
+ /* Now we have disposed of all the cases
in which different rtx codes can match. */
if (code != GET_CODE (y))
return 0;
In general, if the first test fails, the program can branch
directly to `foo' and skip the second try which is doomed to fail.
We run this after loop optimization and before flow analysis. */
-
+
/* When comparing the insn patterns, we track the fact that different
pseudo-register numbers may have been used in each computation.
The following array stores an equivalence -- same_regs[I] == J means
static int modified_mem;
-/* Called via note_stores on each insn between the target of the first
+/* Called via note_stores on each insn between the target of the first
branch and the second branch. It marks any changed registers. */
static void
}
/* F is the first insn in the chain of insns. */
-
+
void
thread_jumps (f, max_reg, flag_before_loop)
rtx f;
will either always succeed or always fail depending on the relative
senses of the two branches. So adjust the first branch accordingly
in this case. */
-
+
rtx label, b1, b2, t1, t2;
enum rtx_code code1, code2;
rtx b1op0, b1op1, b2op0, b2op1;
all_reset = (int *) xmalloc (max_reg * sizeof (int));
for (i = 0; i < max_reg; i++)
all_reset[i] = -1;
-
+
while (changed)
{
changed = 0;
{
rtx set;
rtx set2;
+
/* Get to a candidate branch insn. */
if (GET_CODE (b1) != JUMP_INSN
|| ! any_condjump_p (b1) || JUMP_LABEL (b1) == 0)
continue;
- bzero (modified_regs, max_reg * sizeof (char));
+ memset (modified_regs, 0, max_reg * sizeof (char));
modified_mem = 0;
bcopy ((char *) all_reset, (char *) same_regs,
&& 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,
+ reverse_condition (code2)))))
{
t1 = prev_nonnote_insn (b1);
t2 = prev_nonnote_insn (b2);
-
+
while (t1 != 0 && t2 != 0)
{
if (t2 == label)
break;
if (comparison_dominates_p (code1, code2))
- new_label = JUMP_LABEL (b2);
+ new_label = JUMP_LABEL (b2);
else
new_label = get_label_after (b2);
}
break;
}
-
+
/* If either of these is not a normal insn (it might be
a JUMP_INSN, CALL_INSN, or CODE_LABEL) we fail. (NOTEs
have already been skipped above.) Similarly, fail
|| ! rtx_equal_for_thread_p (PATTERN (t1),
PATTERN (t2), t2))
break;
-
+
t1 = prev_nonnote_insn (t1);
t2 = prev_nonnote_insn (t2);
}
/* This is like RTX_EQUAL_P except that it knows about our handling of
possibly equivalent registers and knows to consider volatile and
modified objects as not equal.
-
+
YINSN is the insn containing Y. */
int
num_same_regs++;
/* 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
+ 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))
return 0;
if (GET_CODE (SET_DEST (x)) == REG
&& GET_CODE (SET_DEST (y)) == REG)
{
- if (same_regs[REGNO (SET_DEST (x))] == (int) REGNO (SET_DEST (y)))
+ if (same_regs[REGNO (SET_DEST (x))] == (int) REGNO (SET_DEST (y)))
{
same_regs[REGNO (SET_DEST (x))] = -1;
num_same_regs--;
return 0;
}
else
- if (rtx_equal_for_thread_p (SET_DEST (x), SET_DEST (y), yinsn) == 0)
- return 0;
+ {
+ if (rtx_equal_for_thread_p (SET_DEST (x), SET_DEST (y), yinsn) == 0)
+ return 0;
+ }
return rtx_equal_for_thread_p (SET_SRC (x), SET_SRC (y), yinsn);
case SYMBOL_REF:
return XSTR (x, 0) == XSTR (y, 0);
-
+
default:
break;
}
/* And the corresponding elements must match. */
for (j = 0; j < XVECLEN (x, i); j++)
if (rtx_equal_for_thread_p (XVECEXP (x, i, j),
- XVECEXP (y, i, j), yinsn) == 0)
+ XVECEXP (y, i, j), yinsn) == 0)
return 0;
break;
projects / gcc.git / blobdiff