1 /* Optimize jump instructions, for GNU compiler.
2 Copyright (C) 1987, 1988, 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997
3 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
22 /* This is the pathetic reminder of old fame of the jump-optimization pass
23 of the compiler. Now it contains basically set of utility function to
26 Each CODE_LABEL has a count of the times it is used
27 stored in the LABEL_NUSES internal field, and each JUMP_INSN
28 has one label that it refers to stored in the
29 JUMP_LABEL internal field. With this we can detect labels that
30 become unused because of the deletion of all the jumps that
31 formerly used them. The JUMP_LABEL info is sometimes looked
34 The subroutines delete_insn, redirect_jump, and invert_jump are used
35 from other passes as well. */
42 #include "hard-reg-set.h"
44 #include "insn-config.h"
45 #include "insn-attr.h"
55 /* Optimize jump y; x: ... y: jumpif... x?
56 Don't know if it is worth bothering with. */
57 /* Optimize two cases of conditional jump to conditional jump?
58 This can never delete any instruction or make anything dead,
59 or even change what is live at any point.
60 So perhaps let combiner do it. */
62 static int init_label_info PARAMS ((rtx));
63 static void mark_all_labels PARAMS ((rtx));
64 static int duplicate_loop_exit_test PARAMS ((rtx));
65 static void delete_computation PARAMS ((rtx));
66 static void redirect_exp_1 PARAMS ((rtx *, rtx, rtx, rtx));
67 static int redirect_exp PARAMS ((rtx, rtx, rtx));
68 static void invert_exp_1 PARAMS ((rtx));
69 static int invert_exp PARAMS ((rtx));
70 static int returnjump_p_1 PARAMS ((rtx *, void *));
71 static void delete_prior_computation PARAMS ((rtx, rtx));
73 /* Alternate entry into the jump optimizer. This entry point only rebuilds
74 the JUMP_LABEL field in jumping insns and REG_LABEL notes in non-jumping
77 rebuild_jump_labels (f)
83 max_uid = init_label_info (f) + 1;
87 /* Keep track of labels used from static data; we don't track them
88 closely enough to delete them here, so make sure their reference
89 count doesn't drop to zero. */
91 for (insn = forced_labels; insn; insn = XEXP (insn, 1))
92 if (GET_CODE (XEXP (insn, 0)) == CODE_LABEL)
93 LABEL_NUSES (XEXP (insn, 0))++;
95 /* Keep track of labels used for marking handlers for exception
96 regions; they cannot usually be deleted. */
98 for (insn = exception_handler_labels; insn; insn = XEXP (insn, 1))
99 if (GET_CODE (XEXP (insn, 0)) == CODE_LABEL)
100 LABEL_NUSES (XEXP (insn, 0))++;
103 /* Some old code expects exactly one BARRIER as the NEXT_INSN of a
104 non-fallthru insn. This is not generally true, as multiple barriers
105 may have crept in, or the BARRIER may be separated from the last
106 real insn by one or more NOTEs.
108 This simple pass moves barriers and removes duplicates so that the
114 rtx insn, next, prev;
115 for (insn = get_insns (); insn; insn = next)
117 next = NEXT_INSN (insn);
118 if (GET_CODE (insn) == BARRIER)
120 prev = prev_nonnote_insn (insn);
121 if (GET_CODE (prev) == BARRIER)
122 delete_barrier (insn);
123 else if (prev != PREV_INSN (insn))
124 reorder_insns (insn, insn, prev);
130 copy_loop_headers (f)
134 /* Now iterate optimizing jumps until nothing changes over one pass. */
135 for (insn = f; insn; insn = next)
139 next = NEXT_INSN (insn);
141 /* See if this is a NOTE_INSN_LOOP_BEG followed by an unconditional
142 jump. Try to optimize by duplicating the loop exit test if so.
143 This is only safe immediately after regscan, because it uses
144 the values of regno_first_uid and regno_last_uid. */
145 if (GET_CODE (insn) == NOTE
146 && NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_BEG
147 && (temp1 = next_nonnote_insn (insn)) != 0
148 && any_uncondjump_p (temp1) && onlyjump_p (temp1))
150 temp = PREV_INSN (insn);
151 if (duplicate_loop_exit_test (insn))
153 next = NEXT_INSN (temp);
160 purge_line_number_notes (f)
165 /* Delete extraneous line number notes.
166 Note that two consecutive notes for different lines are not really
167 extraneous. There should be some indication where that line belonged,
168 even if it became empty. */
170 for (insn = f; insn; insn = NEXT_INSN (insn))
171 if (GET_CODE (insn) == NOTE)
173 if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_FUNCTION_BEG)
174 /* Any previous line note was for the prologue; gdb wants a new
175 note after the prologue even if it is for the same line. */
176 last_note = NULL_RTX;
177 else if (NOTE_LINE_NUMBER (insn) >= 0)
179 /* Delete this note if it is identical to previous note. */
181 && NOTE_SOURCE_FILE (insn) == NOTE_SOURCE_FILE (last_note)
182 && NOTE_LINE_NUMBER (insn) == NOTE_LINE_NUMBER (last_note))
184 delete_related_insns (insn);
193 /* Initialize LABEL_NUSES and JUMP_LABEL fields. Delete any REG_LABEL
194 notes whose labels don't occur in the insn any more. Returns the
195 largest INSN_UID found. */
203 for (insn = f; insn; insn = NEXT_INSN (insn))
205 if (GET_CODE (insn) == CODE_LABEL)
206 LABEL_NUSES (insn) = (LABEL_PRESERVE_P (insn) != 0);
207 else if (GET_CODE (insn) == JUMP_INSN)
208 JUMP_LABEL (insn) = 0;
209 else if (GET_CODE (insn) == INSN || GET_CODE (insn) == CALL_INSN)
213 for (note = REG_NOTES (insn); note; note = next)
215 next = XEXP (note, 1);
216 if (REG_NOTE_KIND (note) == REG_LABEL
217 && ! reg_mentioned_p (XEXP (note, 0), PATTERN (insn)))
218 remove_note (insn, note);
221 if (INSN_UID (insn) > largest_uid)
222 largest_uid = INSN_UID (insn);
228 /* Mark the label each jump jumps to.
229 Combine consecutive labels, and count uses of labels. */
237 for (insn = f; insn; insn = NEXT_INSN (insn))
240 if (GET_CODE (insn) == CALL_INSN
241 && GET_CODE (PATTERN (insn)) == CALL_PLACEHOLDER)
243 mark_all_labels (XEXP (PATTERN (insn), 0));
244 mark_all_labels (XEXP (PATTERN (insn), 1));
245 mark_all_labels (XEXP (PATTERN (insn), 2));
247 /* Canonicalize the tail recursion label attached to the
248 CALL_PLACEHOLDER insn. */
249 if (XEXP (PATTERN (insn), 3))
251 rtx label_ref = gen_rtx_LABEL_REF (VOIDmode,
252 XEXP (PATTERN (insn), 3));
253 mark_jump_label (label_ref, insn, 0);
254 XEXP (PATTERN (insn), 3) = XEXP (label_ref, 0);
260 mark_jump_label (PATTERN (insn), insn, 0);
261 if (! INSN_DELETED_P (insn) && GET_CODE (insn) == JUMP_INSN)
263 /* When we know the LABEL_REF contained in a REG used in
264 an indirect jump, we'll have a REG_LABEL note so that
265 flow can tell where it's going. */
266 if (JUMP_LABEL (insn) == 0)
268 rtx label_note = find_reg_note (insn, REG_LABEL, NULL_RTX);
271 /* But a LABEL_REF around the REG_LABEL note, so
272 that we can canonicalize it. */
273 rtx label_ref = gen_rtx_LABEL_REF (VOIDmode,
274 XEXP (label_note, 0));
276 mark_jump_label (label_ref, insn, 0);
277 XEXP (label_note, 0) = XEXP (label_ref, 0);
278 JUMP_LABEL (insn) = XEXP (label_note, 0);
285 /* LOOP_START is a NOTE_INSN_LOOP_BEG note that is followed by an unconditional
286 jump. Assume that this unconditional jump is to the exit test code. If
287 the code is sufficiently simple, make a copy of it before INSN,
288 followed by a jump to the exit of the loop. Then delete the unconditional
291 Return 1 if we made the change, else 0.
293 This is only safe immediately after a regscan pass because it uses the
294 values of regno_first_uid and regno_last_uid. */
297 duplicate_loop_exit_test (loop_start)
300 rtx insn, set, reg, p, link;
301 rtx copy = 0, first_copy = 0;
303 rtx exitcode = NEXT_INSN (JUMP_LABEL (next_nonnote_insn (loop_start)));
305 int max_reg = max_reg_num ();
307 rtx loop_pre_header_label;
309 /* Scan the exit code. We do not perform this optimization if any insn:
313 has a REG_RETVAL or REG_LIBCALL note (hard to adjust)
314 is a NOTE_INSN_LOOP_BEG because this means we have a nested loop
315 is a NOTE_INSN_BLOCK_{BEG,END} because duplicating these notes
318 We also do not do this if we find an insn with ASM_OPERANDS. While
319 this restriction should not be necessary, copying an insn with
320 ASM_OPERANDS can confuse asm_noperands in some cases.
322 Also, don't do this if the exit code is more than 20 insns. */
324 for (insn = exitcode;
326 && ! (GET_CODE (insn) == NOTE
327 && NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_END);
328 insn = NEXT_INSN (insn))
330 switch (GET_CODE (insn))
336 /* We could be in front of the wrong NOTE_INSN_LOOP_END if there is
337 a jump immediately after the loop start that branches outside
338 the loop but within an outer loop, near the exit test.
339 If we copied this exit test and created a phony
340 NOTE_INSN_LOOP_VTOP, this could make instructions immediately
341 before the exit test look like these could be safely moved
342 out of the loop even if they actually may be never executed.
343 This can be avoided by checking here for NOTE_INSN_LOOP_CONT. */
345 if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_BEG
346 || NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_CONT)
350 && (NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_BEG
351 || NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_END))
352 /* If we were to duplicate this code, we would not move
353 the BLOCK notes, and so debugging the moved code would
354 be difficult. Thus, we only move the code with -O2 or
361 /* The code below would grossly mishandle REG_WAS_0 notes,
362 so get rid of them here. */
363 while ((p = find_reg_note (insn, REG_WAS_0, NULL_RTX)) != 0)
364 remove_note (insn, p);
366 || find_reg_note (insn, REG_RETVAL, NULL_RTX)
367 || find_reg_note (insn, REG_LIBCALL, NULL_RTX))
375 /* Unless INSN is zero, we can do the optimization. */
381 /* See if any insn sets a register only used in the loop exit code and
382 not a user variable. If so, replace it with a new register. */
383 for (insn = exitcode; insn != lastexit; insn = NEXT_INSN (insn))
384 if (GET_CODE (insn) == INSN
385 && (set = single_set (insn)) != 0
386 && ((reg = SET_DEST (set), GET_CODE (reg) == REG)
387 || (GET_CODE (reg) == SUBREG
388 && (reg = SUBREG_REG (reg), GET_CODE (reg) == REG)))
389 && REGNO (reg) >= FIRST_PSEUDO_REGISTER
390 && REGNO_FIRST_UID (REGNO (reg)) == INSN_UID (insn))
392 for (p = NEXT_INSN (insn); p != lastexit; p = NEXT_INSN (p))
393 if (REGNO_LAST_UID (REGNO (reg)) == INSN_UID (p))
398 /* We can do the replacement. Allocate reg_map if this is the
399 first replacement we found. */
401 reg_map = (rtx *) xcalloc (max_reg, sizeof (rtx));
403 REG_LOOP_TEST_P (reg) = 1;
405 reg_map[REGNO (reg)] = gen_reg_rtx (GET_MODE (reg));
408 loop_pre_header_label = gen_label_rtx ();
410 /* Now copy each insn. */
411 for (insn = exitcode; insn != lastexit; insn = NEXT_INSN (insn))
413 switch (GET_CODE (insn))
416 copy = emit_barrier_before (loop_start);
419 /* Only copy line-number notes. */
420 if (NOTE_LINE_NUMBER (insn) >= 0)
422 copy = emit_note_before (NOTE_LINE_NUMBER (insn), loop_start);
423 NOTE_SOURCE_FILE (copy) = NOTE_SOURCE_FILE (insn);
428 copy = emit_insn_before (copy_insn (PATTERN (insn)), loop_start);
430 replace_regs (PATTERN (copy), reg_map, max_reg, 1);
432 mark_jump_label (PATTERN (copy), copy, 0);
434 /* Copy all REG_NOTES except REG_LABEL since mark_jump_label will
436 for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
437 if (REG_NOTE_KIND (link) != REG_LABEL)
439 if (GET_CODE (link) == EXPR_LIST)
441 = copy_insn_1 (gen_rtx_EXPR_LIST (REG_NOTE_KIND (link),
446 = copy_insn_1 (gen_rtx_INSN_LIST (REG_NOTE_KIND (link),
451 if (reg_map && REG_NOTES (copy))
452 replace_regs (REG_NOTES (copy), reg_map, max_reg, 1);
456 copy = emit_jump_insn_before (copy_insn (PATTERN (insn)),
459 replace_regs (PATTERN (copy), reg_map, max_reg, 1);
460 mark_jump_label (PATTERN (copy), copy, 0);
461 if (REG_NOTES (insn))
463 REG_NOTES (copy) = copy_insn_1 (REG_NOTES (insn));
465 replace_regs (REG_NOTES (copy), reg_map, max_reg, 1);
468 /* Predict conditional jump that do make loop looping as taken.
469 Other jumps are probably exit conditions, so predict
471 if (any_condjump_p (copy))
473 rtx label = JUMP_LABEL (copy);
476 /* The jump_insn after loop_start should be followed
477 by barrier and loopback label. */
478 if (prev_nonnote_insn (label)
479 && (prev_nonnote_insn (prev_nonnote_insn (label))
480 == next_nonnote_insn (loop_start)))
482 predict_insn_def (copy, PRED_LOOP_HEADER, TAKEN);
483 /* To keep pre-header, we need to redirect all loop
484 entrances before the LOOP_BEG note. */
485 redirect_jump (copy, loop_pre_header_label, 0);
488 predict_insn_def (copy, PRED_LOOP_HEADER, NOT_TAKEN);
497 /* Record the first insn we copied. We need it so that we can
498 scan the copied insns for new pseudo registers. */
503 /* Now clean up by emitting a jump to the end label and deleting the jump
504 at the start of the loop. */
505 if (! copy || GET_CODE (copy) != BARRIER)
507 copy = emit_jump_insn_before (gen_jump (get_label_after (insn)),
510 /* Record the first insn we copied. We need it so that we can
511 scan the copied insns for new pseudo registers. This may not
512 be strictly necessary since we should have copied at least one
513 insn above. But I am going to be safe. */
517 mark_jump_label (PATTERN (copy), copy, 0);
518 emit_barrier_before (loop_start);
521 emit_label_before (loop_pre_header_label, loop_start);
523 /* Now scan from the first insn we copied to the last insn we copied
524 (copy) for new pseudo registers. Do this after the code to jump to
525 the end label since that might create a new pseudo too. */
526 reg_scan_update (first_copy, copy, max_reg);
528 /* Mark the exit code as the virtual top of the converted loop. */
529 emit_note_before (NOTE_INSN_LOOP_VTOP, exitcode);
531 delete_related_insns (next_nonnote_insn (loop_start));
540 /* Move all block-beg, block-end, loop-beg, loop-cont, loop-vtop, loop-end,
541 notes between START and END out before START. START and END may be such
542 notes. Returns the values of the new starting and ending insns, which
543 may be different if the original ones were such notes.
544 Return true if there were only such notes and no real instructions. */
547 squeeze_notes (startp, endp)
557 rtx past_end = NEXT_INSN (end);
559 for (insn = start; insn != past_end; insn = next)
561 next = NEXT_INSN (insn);
562 if (GET_CODE (insn) == NOTE
563 && (NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_END
564 || NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_BEG
565 || NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_BEG
566 || NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_END
567 || NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_CONT
568 || NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_VTOP))
574 rtx prev = PREV_INSN (insn);
575 PREV_INSN (insn) = PREV_INSN (start);
576 NEXT_INSN (insn) = start;
577 NEXT_INSN (PREV_INSN (insn)) = insn;
578 PREV_INSN (NEXT_INSN (insn)) = insn;
579 NEXT_INSN (prev) = next;
580 PREV_INSN (next) = prev;
587 /* There were no real instructions. */
588 if (start == past_end)
598 /* Return the label before INSN, or put a new label there. */
601 get_label_before (insn)
606 /* Find an existing label at this point
607 or make a new one if there is none. */
608 label = prev_nonnote_insn (insn);
610 if (label == 0 || GET_CODE (label) != CODE_LABEL)
612 rtx prev = PREV_INSN (insn);
614 label = gen_label_rtx ();
615 emit_label_after (label, prev);
616 LABEL_NUSES (label) = 0;
621 /* Return the label after INSN, or put a new label there. */
624 get_label_after (insn)
629 /* Find an existing label at this point
630 or make a new one if there is none. */
631 label = next_nonnote_insn (insn);
633 if (label == 0 || GET_CODE (label) != CODE_LABEL)
635 label = gen_label_rtx ();
636 emit_label_after (label, insn);
637 LABEL_NUSES (label) = 0;
642 /* Given a comparison (CODE ARG0 ARG1), inside an insn, INSN, return a code
643 of reversed comparison if it is possible to do so. Otherwise return UNKNOWN.
644 UNKNOWN may be returned in case we are having CC_MODE compare and we don't
645 know whether it's source is floating point or integer comparison. Machine
646 description should define REVERSIBLE_CC_MODE and REVERSE_CONDITION macros
647 to help this function avoid overhead in these cases. */
649 reversed_comparison_code_parts (code, arg0, arg1, insn)
650 rtx insn, arg0, arg1;
653 enum machine_mode mode;
655 /* If this is not actually a comparison, we can't reverse it. */
656 if (GET_RTX_CLASS (code) != '<')
659 mode = GET_MODE (arg0);
660 if (mode == VOIDmode)
661 mode = GET_MODE (arg1);
663 /* First see if machine description supply us way to reverse the comparison.
664 Give it priority over everything else to allow machine description to do
666 #ifdef REVERSIBLE_CC_MODE
667 if (GET_MODE_CLASS (mode) == MODE_CC
668 && REVERSIBLE_CC_MODE (mode))
670 #ifdef REVERSE_CONDITION
671 return REVERSE_CONDITION (code, mode);
673 return reverse_condition (code);
677 /* Try a few special cases based on the comparison code. */
686 /* It is always safe to reverse EQ and NE, even for the floating
687 point. Similary the unsigned comparisons are never used for
688 floating point so we can reverse them in the default way. */
689 return reverse_condition (code);
694 /* In case we already see unordered comparison, we can be sure to
695 be dealing with floating point so we don't need any more tests. */
696 return reverse_condition_maybe_unordered (code);
701 /* We don't have safe way to reverse these yet. */
707 if (GET_MODE_CLASS (mode) == MODE_CC
714 /* Try to search for the comparison to determine the real mode.
715 This code is expensive, but with sane machine description it
716 will be never used, since REVERSIBLE_CC_MODE will return true
721 for (prev = prev_nonnote_insn (insn);
722 prev != 0 && GET_CODE (prev) != CODE_LABEL;
723 prev = prev_nonnote_insn (prev))
725 rtx set = set_of (arg0, prev);
726 if (set && GET_CODE (set) == SET
727 && rtx_equal_p (SET_DEST (set), arg0))
729 rtx src = SET_SRC (set);
731 if (GET_CODE (src) == COMPARE)
733 rtx comparison = src;
734 arg0 = XEXP (src, 0);
735 mode = GET_MODE (arg0);
736 if (mode == VOIDmode)
737 mode = GET_MODE (XEXP (comparison, 1));
740 /* We can get past reg-reg moves. This may be useful for model
741 of i387 comparisons that first move flag registers around. */
748 /* If register is clobbered in some ununderstandable way,
755 /* Test for an integer condition, or a floating-point comparison
756 in which NaNs can be ignored. */
757 if (GET_CODE (arg0) == CONST_INT
758 || (GET_MODE (arg0) != VOIDmode
759 && GET_MODE_CLASS (mode) != MODE_CC
760 && !HONOR_NANS (mode)))
761 return reverse_condition (code);
766 /* An wrapper around the previous function to take COMPARISON as rtx
767 expression. This simplifies many callers. */
769 reversed_comparison_code (comparison, insn)
770 rtx comparison, insn;
772 if (GET_RTX_CLASS (GET_CODE (comparison)) != '<')
774 return reversed_comparison_code_parts (GET_CODE (comparison),
775 XEXP (comparison, 0),
776 XEXP (comparison, 1), insn);
779 /* Given an rtx-code for a comparison, return the code for the negated
780 comparison. If no such code exists, return UNKNOWN.
782 WATCH OUT! reverse_condition is not safe to use on a jump that might
783 be acting on the results of an IEEE floating point comparison, because
784 of the special treatment of non-signaling nans in comparisons.
785 Use reversed_comparison_code instead. */
788 reverse_condition (code)
831 /* Similar, but we're allowed to generate unordered comparisons, which
832 makes it safe for IEEE floating-point. Of course, we have to recognize
833 that the target will support them too... */
836 reverse_condition_maybe_unordered (code)
875 /* Similar, but return the code when two operands of a comparison are swapped.
876 This IS safe for IEEE floating-point. */
879 swap_condition (code)
922 /* Given a comparison CODE, return the corresponding unsigned comparison.
923 If CODE is an equality comparison or already an unsigned comparison,
927 unsigned_condition (code)
954 /* Similarly, return the signed version of a comparison. */
957 signed_condition (code)
984 /* Return non-zero if CODE1 is more strict than CODE2, i.e., if the
985 truth of CODE1 implies the truth of CODE2. */
988 comparison_dominates_p (code1, code2)
989 enum rtx_code code1, code2;
991 /* UNKNOWN comparison codes can happen as a result of trying to revert
993 They can't match anything, so we have to reject them here. */
994 if (code1 == UNKNOWN || code2 == UNKNOWN)
1003 if (code2 == UNLE || code2 == UNGE)
1008 if (code2 == LE || code2 == LEU || code2 == GE || code2 == GEU
1009 || code2 == ORDERED)
1014 if (code2 == UNLE || code2 == NE)
1019 if (code2 == LE || code2 == NE || code2 == ORDERED || code2 == LTGT)
1024 if (code2 == UNGE || code2 == NE)
1029 if (code2 == GE || code2 == NE || code2 == ORDERED || code2 == LTGT)
1035 if (code2 == ORDERED)
1040 if (code2 == NE || code2 == ORDERED)
1045 if (code2 == LEU || code2 == NE)
1050 if (code2 == GEU || code2 == NE)
1055 if (code2 == NE || code2 == UNEQ || code2 == UNLE || code2 == UNLT
1056 || code2 == UNGE || code2 == UNGT)
1067 /* Return 1 if INSN is an unconditional jump and nothing else. */
1073 return (GET_CODE (insn) == JUMP_INSN
1074 && GET_CODE (PATTERN (insn)) == SET
1075 && GET_CODE (SET_DEST (PATTERN (insn))) == PC
1076 && GET_CODE (SET_SRC (PATTERN (insn))) == LABEL_REF);
1079 /* Return nonzero if INSN is a (possibly) conditional jump
1082 Use this function is deprecated, since we need to support combined
1083 branch and compare insns. Use any_condjump_p instead whenever possible. */
1089 rtx x = PATTERN (insn);
1091 if (GET_CODE (x) != SET
1092 || GET_CODE (SET_DEST (x)) != PC)
1096 if (GET_CODE (x) == LABEL_REF)
1099 return (GET_CODE (x) == IF_THEN_ELSE
1100 && ((GET_CODE (XEXP (x, 2)) == PC
1101 && (GET_CODE (XEXP (x, 1)) == LABEL_REF
1102 || GET_CODE (XEXP (x, 1)) == RETURN))
1103 || (GET_CODE (XEXP (x, 1)) == PC
1104 && (GET_CODE (XEXP (x, 2)) == LABEL_REF
1105 || GET_CODE (XEXP (x, 2)) == RETURN))));
1110 /* Return nonzero if INSN is a (possibly) conditional jump inside a
1113 Use this function is deprecated, since we need to support combined
1114 branch and compare insns. Use any_condjump_p instead whenever possible. */
1117 condjump_in_parallel_p (insn)
1120 rtx x = PATTERN (insn);
1122 if (GET_CODE (x) != PARALLEL)
1125 x = XVECEXP (x, 0, 0);
1127 if (GET_CODE (x) != SET)
1129 if (GET_CODE (SET_DEST (x)) != PC)
1131 if (GET_CODE (SET_SRC (x)) == LABEL_REF)
1133 if (GET_CODE (SET_SRC (x)) != IF_THEN_ELSE)
1135 if (XEXP (SET_SRC (x), 2) == pc_rtx
1136 && (GET_CODE (XEXP (SET_SRC (x), 1)) == LABEL_REF
1137 || GET_CODE (XEXP (SET_SRC (x), 1)) == RETURN))
1139 if (XEXP (SET_SRC (x), 1) == pc_rtx
1140 && (GET_CODE (XEXP (SET_SRC (x), 2)) == LABEL_REF
1141 || GET_CODE (XEXP (SET_SRC (x), 2)) == RETURN))
1146 /* Return set of PC, otherwise NULL. */
1153 if (GET_CODE (insn) != JUMP_INSN)
1155 pat = PATTERN (insn);
1157 /* The set is allowed to appear either as the insn pattern or
1158 the first set in a PARALLEL. */
1159 if (GET_CODE (pat) == PARALLEL)
1160 pat = XVECEXP (pat, 0, 0);
1161 if (GET_CODE (pat) == SET && GET_CODE (SET_DEST (pat)) == PC)
1167 /* Return true when insn is an unconditional direct jump,
1168 possibly bundled inside a PARALLEL. */
1171 any_uncondjump_p (insn)
1174 rtx x = pc_set (insn);
1177 if (GET_CODE (SET_SRC (x)) != LABEL_REF)
1182 /* Return true when insn is a conditional jump. This function works for
1183 instructions containing PC sets in PARALLELs. The instruction may have
1184 various other effects so before removing the jump you must verify
1187 Note that unlike condjump_p it returns false for unconditional jumps. */
1190 any_condjump_p (insn)
1193 rtx x = pc_set (insn);
1198 if (GET_CODE (SET_SRC (x)) != IF_THEN_ELSE)
1201 a = GET_CODE (XEXP (SET_SRC (x), 1));
1202 b = GET_CODE (XEXP (SET_SRC (x), 2));
1204 return ((b == PC && (a == LABEL_REF || a == RETURN))
1205 || (a == PC && (b == LABEL_REF || b == RETURN)));
1208 /* Return the label of a conditional jump. */
1211 condjump_label (insn)
1214 rtx x = pc_set (insn);
1219 if (GET_CODE (x) == LABEL_REF)
1221 if (GET_CODE (x) != IF_THEN_ELSE)
1223 if (XEXP (x, 2) == pc_rtx && GET_CODE (XEXP (x, 1)) == LABEL_REF)
1225 if (XEXP (x, 1) == pc_rtx && GET_CODE (XEXP (x, 2)) == LABEL_REF)
1230 /* Return true if INSN is a (possibly conditional) return insn. */
1233 returnjump_p_1 (loc, data)
1235 void *data ATTRIBUTE_UNUSED;
1239 return x && (GET_CODE (x) == RETURN
1240 || (GET_CODE (x) == SET && SET_IS_RETURN_P (x)));
1247 if (GET_CODE (insn) != JUMP_INSN)
1249 return for_each_rtx (&PATTERN (insn), returnjump_p_1, NULL);
1252 /* Return true if INSN is a jump that only transfers control and
1261 if (GET_CODE (insn) != JUMP_INSN)
1264 set = single_set (insn);
1267 if (GET_CODE (SET_DEST (set)) != PC)
1269 if (side_effects_p (SET_SRC (set)))
1277 /* Return non-zero if X is an RTX that only sets the condition codes
1278 and has no side effects. */
1291 return sets_cc0_p (x) == 1 && ! side_effects_p (x);
1294 /* Return 1 if X is an RTX that does nothing but set the condition codes
1295 and CLOBBER or USE registers.
1296 Return -1 if X does explicitly set the condition codes,
1297 but also does other things. */
1310 if (GET_CODE (x) == SET && SET_DEST (x) == cc0_rtx)
1312 if (GET_CODE (x) == PARALLEL)
1316 int other_things = 0;
1317 for (i = XVECLEN (x, 0) - 1; i >= 0; i--)
1319 if (GET_CODE (XVECEXP (x, 0, i)) == SET
1320 && SET_DEST (XVECEXP (x, 0, i)) == cc0_rtx)
1322 else if (GET_CODE (XVECEXP (x, 0, i)) == SET)
1325 return ! sets_cc0 ? 0 : other_things ? -1 : 1;
1331 /* Follow any unconditional jump at LABEL;
1332 return the ultimate label reached by any such chain of jumps.
1333 If LABEL is not followed by a jump, return LABEL.
1334 If the chain loops or we can't find end, return LABEL,
1335 since that tells caller to avoid changing the insn.
1337 If RELOAD_COMPLETED is 0, we do not chain across a NOTE_INSN_LOOP_BEG or
1338 a USE or CLOBBER. */
1341 follow_jumps (label)
1351 && (insn = next_active_insn (value)) != 0
1352 && GET_CODE (insn) == JUMP_INSN
1353 && ((JUMP_LABEL (insn) != 0 && any_uncondjump_p (insn)
1354 && onlyjump_p (insn))
1355 || GET_CODE (PATTERN (insn)) == RETURN)
1356 && (next = NEXT_INSN (insn))
1357 && GET_CODE (next) == BARRIER);
1360 /* Don't chain through the insn that jumps into a loop
1361 from outside the loop,
1362 since that would create multiple loop entry jumps
1363 and prevent loop optimization. */
1365 if (!reload_completed)
1366 for (tem = value; tem != insn; tem = NEXT_INSN (tem))
1367 if (GET_CODE (tem) == NOTE
1368 && (NOTE_LINE_NUMBER (tem) == NOTE_INSN_LOOP_BEG
1369 /* ??? Optional. Disables some optimizations, but makes
1370 gcov output more accurate with -O. */
1371 || (flag_test_coverage && NOTE_LINE_NUMBER (tem) > 0)))
1374 /* If we have found a cycle, make the insn jump to itself. */
1375 if (JUMP_LABEL (insn) == label)
1378 tem = next_active_insn (JUMP_LABEL (insn));
1379 if (tem && (GET_CODE (PATTERN (tem)) == ADDR_VEC
1380 || GET_CODE (PATTERN (tem)) == ADDR_DIFF_VEC))
1383 value = JUMP_LABEL (insn);
1391 /* Find all CODE_LABELs referred to in X, and increment their use counts.
1392 If INSN is a JUMP_INSN and there is at least one CODE_LABEL referenced
1393 in INSN, then store one of them in JUMP_LABEL (INSN).
1394 If INSN is an INSN or a CALL_INSN and there is at least one CODE_LABEL
1395 referenced in INSN, add a REG_LABEL note containing that label to INSN.
1396 Also, when there are consecutive labels, canonicalize on the last of them.
1398 Note that two labels separated by a loop-beginning note
1399 must be kept distinct if we have not yet done loop-optimization,
1400 because the gap between them is where loop-optimize
1401 will want to move invariant code to. CROSS_JUMP tells us
1402 that loop-optimization is done with. */
1405 mark_jump_label (x, insn, in_mem)
1410 RTX_CODE code = GET_CODE (x);
1434 /* If this is a constant-pool reference, see if it is a label. */
1435 if (CONSTANT_POOL_ADDRESS_P (x))
1436 mark_jump_label (get_pool_constant (x), insn, in_mem);
1441 rtx label = XEXP (x, 0);
1443 /* Ignore remaining references to unreachable labels that
1444 have been deleted. */
1445 if (GET_CODE (label) == NOTE
1446 && NOTE_LINE_NUMBER (label) == NOTE_INSN_DELETED_LABEL)
1449 if (GET_CODE (label) != CODE_LABEL)
1452 /* Ignore references to labels of containing functions. */
1453 if (LABEL_REF_NONLOCAL_P (x))
1456 XEXP (x, 0) = label;
1457 if (! insn || ! INSN_DELETED_P (insn))
1458 ++LABEL_NUSES (label);
1462 if (GET_CODE (insn) == JUMP_INSN)
1463 JUMP_LABEL (insn) = label;
1466 /* Add a REG_LABEL note for LABEL unless there already
1467 is one. All uses of a label, except for labels
1468 that are the targets of jumps, must have a
1470 if (! find_reg_note (insn, REG_LABEL, label))
1471 REG_NOTES (insn) = gen_rtx_INSN_LIST (REG_LABEL, label,
1478 /* Do walk the labels in a vector, but not the first operand of an
1479 ADDR_DIFF_VEC. Don't set the JUMP_LABEL of a vector. */
1482 if (! INSN_DELETED_P (insn))
1484 int eltnum = code == ADDR_DIFF_VEC ? 1 : 0;
1486 for (i = 0; i < XVECLEN (x, eltnum); i++)
1487 mark_jump_label (XVECEXP (x, eltnum, i), NULL_RTX, in_mem);
1495 fmt = GET_RTX_FORMAT (code);
1496 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
1499 mark_jump_label (XEXP (x, i), insn, in_mem);
1500 else if (fmt[i] == 'E')
1503 for (j = 0; j < XVECLEN (x, i); j++)
1504 mark_jump_label (XVECEXP (x, i, j), insn, in_mem);
1509 /* If all INSN does is set the pc, delete it,
1510 and delete the insn that set the condition codes for it
1511 if that's what the previous thing was. */
1517 rtx set = single_set (insn);
1519 if (set && GET_CODE (SET_DEST (set)) == PC)
1520 delete_computation (insn);
1523 /* Verify INSN is a BARRIER and delete it. */
1526 delete_barrier (insn)
1529 if (GET_CODE (insn) != BARRIER)
1535 /* Recursively delete prior insns that compute the value (used only by INSN
1536 which the caller is deleting) stored in the register mentioned by NOTE
1537 which is a REG_DEAD note associated with INSN. */
1540 delete_prior_computation (note, insn)
1545 rtx reg = XEXP (note, 0);
1547 for (our_prev = prev_nonnote_insn (insn);
1548 our_prev && (GET_CODE (our_prev) == INSN
1549 || GET_CODE (our_prev) == CALL_INSN);
1550 our_prev = prev_nonnote_insn (our_prev))
1552 rtx pat = PATTERN (our_prev);
1554 /* If we reach a CALL which is not calling a const function
1555 or the callee pops the arguments, then give up. */
1556 if (GET_CODE (our_prev) == CALL_INSN
1557 && (! CONST_OR_PURE_CALL_P (our_prev)
1558 || GET_CODE (pat) != SET || GET_CODE (SET_SRC (pat)) != CALL))
1561 /* If we reach a SEQUENCE, it is too complex to try to
1562 do anything with it, so give up. */
1563 if (GET_CODE (pat) == SEQUENCE)
1566 if (GET_CODE (pat) == USE
1567 && GET_CODE (XEXP (pat, 0)) == INSN)
1568 /* reorg creates USEs that look like this. We leave them
1569 alone because reorg needs them for its own purposes. */
1572 if (reg_set_p (reg, pat))
1574 if (side_effects_p (pat) && GET_CODE (our_prev) != CALL_INSN)
1577 if (GET_CODE (pat) == PARALLEL)
1579 /* If we find a SET of something else, we can't
1584 for (i = 0; i < XVECLEN (pat, 0); i++)
1586 rtx part = XVECEXP (pat, 0, i);
1588 if (GET_CODE (part) == SET
1589 && SET_DEST (part) != reg)
1593 if (i == XVECLEN (pat, 0))
1594 delete_computation (our_prev);
1596 else if (GET_CODE (pat) == SET
1597 && GET_CODE (SET_DEST (pat)) == REG)
1599 int dest_regno = REGNO (SET_DEST (pat));
1602 + (dest_regno < FIRST_PSEUDO_REGISTER
1603 ? HARD_REGNO_NREGS (dest_regno,
1604 GET_MODE (SET_DEST (pat))) : 1));
1605 int regno = REGNO (reg);
1608 + (regno < FIRST_PSEUDO_REGISTER
1609 ? HARD_REGNO_NREGS (regno, GET_MODE (reg)) : 1));
1611 if (dest_regno >= regno
1612 && dest_endregno <= endregno)
1613 delete_computation (our_prev);
1615 /* We may have a multi-word hard register and some, but not
1616 all, of the words of the register are needed in subsequent
1617 insns. Write REG_UNUSED notes for those parts that were not
1619 else if (dest_regno <= regno
1620 && dest_endregno >= endregno)
1624 REG_NOTES (our_prev)
1625 = gen_rtx_EXPR_LIST (REG_UNUSED, reg,
1626 REG_NOTES (our_prev));
1628 for (i = dest_regno; i < dest_endregno; i++)
1629 if (! find_regno_note (our_prev, REG_UNUSED, i))
1632 if (i == dest_endregno)
1633 delete_computation (our_prev);
1640 /* If PAT references the register that dies here, it is an
1641 additional use. Hence any prior SET isn't dead. However, this
1642 insn becomes the new place for the REG_DEAD note. */
1643 if (reg_overlap_mentioned_p (reg, pat))
1645 XEXP (note, 1) = REG_NOTES (our_prev);
1646 REG_NOTES (our_prev) = note;
1652 /* Delete INSN and recursively delete insns that compute values used only
1653 by INSN. This uses the REG_DEAD notes computed during flow analysis.
1654 If we are running before flow.c, we need do nothing since flow.c will
1655 delete dead code. We also can't know if the registers being used are
1656 dead or not at this point.
1658 Otherwise, look at all our REG_DEAD notes. If a previous insn does
1659 nothing other than set a register that dies in this insn, we can delete
1662 On machines with CC0, if CC0 is used in this insn, we may be able to
1663 delete the insn that set it. */
1666 delete_computation (insn)
1672 if (reg_referenced_p (cc0_rtx, PATTERN (insn)))
1674 rtx prev = prev_nonnote_insn (insn);
1675 /* We assume that at this stage
1676 CC's are always set explicitly
1677 and always immediately before the jump that
1678 will use them. So if the previous insn
1679 exists to set the CC's, delete it
1680 (unless it performs auto-increments, etc.). */
1681 if (prev && GET_CODE (prev) == INSN
1682 && sets_cc0_p (PATTERN (prev)))
1684 if (sets_cc0_p (PATTERN (prev)) > 0
1685 && ! side_effects_p (PATTERN (prev)))
1686 delete_computation (prev);
1688 /* Otherwise, show that cc0 won't be used. */
1689 REG_NOTES (prev) = gen_rtx_EXPR_LIST (REG_UNUSED,
1690 cc0_rtx, REG_NOTES (prev));
1695 for (note = REG_NOTES (insn); note; note = next)
1697 next = XEXP (note, 1);
1699 if (REG_NOTE_KIND (note) != REG_DEAD
1700 /* Verify that the REG_NOTE is legitimate. */
1701 || GET_CODE (XEXP (note, 0)) != REG)
1704 delete_prior_computation (note, insn);
1707 delete_related_insns (insn);
1710 /* Delete insn INSN from the chain of insns and update label ref counts
1711 and delete insns now unreachable.
1713 Returns the first insn after INSN that was not deleted.
1715 Usage of this instruction is deprecated. Use delete_insn instead and
1716 subsequent cfg_cleanup pass to delete unreachable code if needed. */
1719 delete_related_insns (insn)
1722 int was_code_label = (GET_CODE (insn) == CODE_LABEL);
1724 rtx next = NEXT_INSN (insn), prev = PREV_INSN (insn);
1726 while (next && INSN_DELETED_P (next))
1727 next = NEXT_INSN (next);
1729 /* This insn is already deleted => return first following nondeleted. */
1730 if (INSN_DELETED_P (insn))
1735 /* If instruction is followed by a barrier,
1736 delete the barrier too. */
1738 if (next != 0 && GET_CODE (next) == BARRIER)
1741 /* If deleting a jump, decrement the count of the label,
1742 and delete the label if it is now unused. */
1744 if (GET_CODE (insn) == JUMP_INSN && JUMP_LABEL (insn))
1746 rtx lab = JUMP_LABEL (insn), lab_next;
1748 if (LABEL_NUSES (lab) == 0)
1750 /* This can delete NEXT or PREV,
1751 either directly if NEXT is JUMP_LABEL (INSN),
1752 or indirectly through more levels of jumps. */
1753 delete_related_insns (lab);
1755 /* I feel a little doubtful about this loop,
1756 but I see no clean and sure alternative way
1757 to find the first insn after INSN that is not now deleted.
1758 I hope this works. */
1759 while (next && INSN_DELETED_P (next))
1760 next = NEXT_INSN (next);
1763 else if ((lab_next = next_nonnote_insn (lab)) != NULL
1764 && GET_CODE (lab_next) == JUMP_INSN
1765 && (GET_CODE (PATTERN (lab_next)) == ADDR_VEC
1766 || GET_CODE (PATTERN (lab_next)) == ADDR_DIFF_VEC))
1768 /* If we're deleting the tablejump, delete the dispatch table.
1769 We may not be able to kill the label immediately preceding
1770 just yet, as it might be referenced in code leading up to
1772 delete_related_insns (lab_next);
1776 /* Likewise if we're deleting a dispatch table. */
1778 if (GET_CODE (insn) == JUMP_INSN
1779 && (GET_CODE (PATTERN (insn)) == ADDR_VEC
1780 || GET_CODE (PATTERN (insn)) == ADDR_DIFF_VEC))
1782 rtx pat = PATTERN (insn);
1783 int i, diff_vec_p = GET_CODE (pat) == ADDR_DIFF_VEC;
1784 int len = XVECLEN (pat, diff_vec_p);
1786 for (i = 0; i < len; i++)
1787 if (LABEL_NUSES (XEXP (XVECEXP (pat, diff_vec_p, i), 0)) == 0)
1788 delete_related_insns (XEXP (XVECEXP (pat, diff_vec_p, i), 0));
1789 while (next && INSN_DELETED_P (next))
1790 next = NEXT_INSN (next);
1794 /* Likewise for an ordinary INSN / CALL_INSN with a REG_LABEL note. */
1795 if (GET_CODE (insn) == INSN || GET_CODE (insn) == CALL_INSN)
1796 for (note = REG_NOTES (insn); note; note = XEXP (note, 1))
1797 if (REG_NOTE_KIND (note) == REG_LABEL
1798 /* This could also be a NOTE_INSN_DELETED_LABEL note. */
1799 && GET_CODE (XEXP (note, 0)) == CODE_LABEL)
1800 if (LABEL_NUSES (XEXP (note, 0)) == 0)
1801 delete_related_insns (XEXP (note, 0));
1803 while (prev && (INSN_DELETED_P (prev) || GET_CODE (prev) == NOTE))
1804 prev = PREV_INSN (prev);
1806 /* If INSN was a label and a dispatch table follows it,
1807 delete the dispatch table. The tablejump must have gone already.
1808 It isn't useful to fall through into a table. */
1811 && NEXT_INSN (insn) != 0
1812 && GET_CODE (NEXT_INSN (insn)) == JUMP_INSN
1813 && (GET_CODE (PATTERN (NEXT_INSN (insn))) == ADDR_VEC
1814 || GET_CODE (PATTERN (NEXT_INSN (insn))) == ADDR_DIFF_VEC))
1815 next = delete_related_insns (NEXT_INSN (insn));
1817 /* If INSN was a label, delete insns following it if now unreachable. */
1819 if (was_code_label && prev && GET_CODE (prev) == BARRIER)
1823 && (GET_RTX_CLASS (code = GET_CODE (next)) == 'i'
1824 || code == NOTE || code == BARRIER
1825 || (code == CODE_LABEL && INSN_DELETED_P (next))))
1828 && NOTE_LINE_NUMBER (next) != NOTE_INSN_FUNCTION_END)
1829 next = NEXT_INSN (next);
1830 /* Keep going past other deleted labels to delete what follows. */
1831 else if (code == CODE_LABEL && INSN_DELETED_P (next))
1832 next = NEXT_INSN (next);
1834 /* Note: if this deletes a jump, it can cause more
1835 deletion of unreachable code, after a different label.
1836 As long as the value from this recursive call is correct,
1837 this invocation functions correctly. */
1838 next = delete_related_insns (next);
1845 /* Advance from INSN till reaching something not deleted
1846 then return that. May return INSN itself. */
1849 next_nondeleted_insn (insn)
1852 while (INSN_DELETED_P (insn))
1853 insn = NEXT_INSN (insn);
1857 /* Delete a range of insns from FROM to TO, inclusive.
1858 This is for the sake of peephole optimization, so assume
1859 that whatever these insns do will still be done by a new
1860 peephole insn that will replace them. */
1863 delete_for_peephole (from, to)
1870 rtx next = NEXT_INSN (insn);
1871 rtx prev = PREV_INSN (insn);
1873 if (GET_CODE (insn) != NOTE)
1875 INSN_DELETED_P (insn) = 1;
1877 /* Patch this insn out of the chain. */
1878 /* We don't do this all at once, because we
1879 must preserve all NOTEs. */
1881 NEXT_INSN (prev) = next;
1884 PREV_INSN (next) = prev;
1892 /* Note that if TO is an unconditional jump
1893 we *do not* delete the BARRIER that follows,
1894 since the peephole that replaces this sequence
1895 is also an unconditional jump in that case. */
1898 /* We have determined that INSN is never reached, and are about to
1899 delete it. Print a warning if the user asked for one.
1901 To try to make this warning more useful, this should only be called
1902 once per basic block not reached, and it only warns when the basic
1903 block contains more than one line from the current function, and
1904 contains at least one operation. CSE and inlining can duplicate insns,
1905 so it's possible to get spurious warnings from this. */
1908 never_reached_warning (avoided_insn, finish)
1909 rtx avoided_insn, finish;
1912 rtx a_line_note = NULL;
1913 int two_avoided_lines = 0, contains_insn = 0, reached_end = 0;
1915 if (! warn_notreached)
1918 /* Scan forwards, looking at LINE_NUMBER notes, until
1919 we hit a LABEL or we run out of insns. */
1921 for (insn = avoided_insn; insn != NULL; insn = NEXT_INSN (insn))
1923 if (finish == NULL && GET_CODE (insn) == CODE_LABEL)
1926 if (GET_CODE (insn) == NOTE /* A line number note? */
1927 && NOTE_LINE_NUMBER (insn) >= 0)
1929 if (a_line_note == NULL)
1932 two_avoided_lines |= (NOTE_LINE_NUMBER (a_line_note)
1933 != NOTE_LINE_NUMBER (insn));
1935 else if (INSN_P (insn))
1945 if (two_avoided_lines && contains_insn)
1946 warning_with_file_and_line (NOTE_SOURCE_FILE (a_line_note),
1947 NOTE_LINE_NUMBER (a_line_note),
1948 "will never be executed");
1951 /* Throughout LOC, redirect OLABEL to NLABEL. Treat null OLABEL or
1952 NLABEL as a return. Accrue modifications into the change group. */
1955 redirect_exp_1 (loc, olabel, nlabel, insn)
1961 RTX_CODE code = GET_CODE (x);
1965 if (code == LABEL_REF)
1967 if (XEXP (x, 0) == olabel)
1971 n = gen_rtx_LABEL_REF (VOIDmode, nlabel);
1973 n = gen_rtx_RETURN (VOIDmode);
1975 validate_change (insn, loc, n, 1);
1979 else if (code == RETURN && olabel == 0)
1981 x = gen_rtx_LABEL_REF (VOIDmode, nlabel);
1982 if (loc == &PATTERN (insn))
1983 x = gen_rtx_SET (VOIDmode, pc_rtx, x);
1984 validate_change (insn, loc, x, 1);
1988 if (code == SET && nlabel == 0 && SET_DEST (x) == pc_rtx
1989 && GET_CODE (SET_SRC (x)) == LABEL_REF
1990 && XEXP (SET_SRC (x), 0) == olabel)
1992 validate_change (insn, loc, gen_rtx_RETURN (VOIDmode), 1);
1996 fmt = GET_RTX_FORMAT (code);
1997 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
2000 redirect_exp_1 (&XEXP (x, i), olabel, nlabel, insn);
2001 else if (fmt[i] == 'E')
2004 for (j = 0; j < XVECLEN (x, i); j++)
2005 redirect_exp_1 (&XVECEXP (x, i, j), olabel, nlabel, insn);
2010 /* Similar, but apply the change group and report success or failure. */
2013 redirect_exp (olabel, nlabel, insn)
2019 if (GET_CODE (PATTERN (insn)) == PARALLEL)
2020 loc = &XVECEXP (PATTERN (insn), 0, 0);
2022 loc = &PATTERN (insn);
2024 redirect_exp_1 (loc, olabel, nlabel, insn);
2025 if (num_validated_changes () == 0)
2028 return apply_change_group ();
2031 /* Make JUMP go to NLABEL instead of where it jumps now. Accrue
2032 the modifications into the change group. Return false if we did
2033 not see how to do that. */
2036 redirect_jump_1 (jump, nlabel)
2039 int ochanges = num_validated_changes ();
2042 if (GET_CODE (PATTERN (jump)) == PARALLEL)
2043 loc = &XVECEXP (PATTERN (jump), 0, 0);
2045 loc = &PATTERN (jump);
2047 redirect_exp_1 (loc, JUMP_LABEL (jump), nlabel, jump);
2048 return num_validated_changes () > ochanges;
2051 /* Make JUMP go to NLABEL instead of where it jumps now. If the old
2052 jump target label is unused as a result, it and the code following
2055 If NLABEL is zero, we are to turn the jump into a (possibly conditional)
2058 The return value will be 1 if the change was made, 0 if it wasn't
2059 (this can only occur for NLABEL == 0). */
2062 redirect_jump (jump, nlabel, delete_unused)
2066 rtx olabel = JUMP_LABEL (jump);
2068 if (nlabel == olabel)
2071 if (! redirect_exp (olabel, nlabel, jump))
2074 JUMP_LABEL (jump) = nlabel;
2076 ++LABEL_NUSES (nlabel);
2078 /* If we're eliding the jump over exception cleanups at the end of a
2079 function, move the function end note so that -Wreturn-type works. */
2080 if (olabel && nlabel
2081 && NEXT_INSN (olabel)
2082 && GET_CODE (NEXT_INSN (olabel)) == NOTE
2083 && NOTE_LINE_NUMBER (NEXT_INSN (olabel)) == NOTE_INSN_FUNCTION_END)
2084 emit_note_after (NOTE_INSN_FUNCTION_END, nlabel);
2086 if (olabel && --LABEL_NUSES (olabel) == 0 && delete_unused
2087 /* Undefined labels will remain outside the insn stream. */
2088 && INSN_UID (olabel))
2089 delete_related_insns (olabel);
2094 /* Invert the jump condition of rtx X contained in jump insn, INSN.
2095 Accrue the modifications into the change group. */
2102 rtx x = pc_set (insn);
2108 code = GET_CODE (x);
2110 if (code == IF_THEN_ELSE)
2112 rtx comp = XEXP (x, 0);
2114 enum rtx_code reversed_code;
2116 /* We can do this in two ways: The preferable way, which can only
2117 be done if this is not an integer comparison, is to reverse
2118 the comparison code. Otherwise, swap the THEN-part and ELSE-part
2119 of the IF_THEN_ELSE. If we can't do either, fail. */
2121 reversed_code = reversed_comparison_code (comp, insn);
2123 if (reversed_code != UNKNOWN)
2125 validate_change (insn, &XEXP (x, 0),
2126 gen_rtx_fmt_ee (reversed_code,
2127 GET_MODE (comp), XEXP (comp, 0),
2134 validate_change (insn, &XEXP (x, 1), XEXP (x, 2), 1);
2135 validate_change (insn, &XEXP (x, 2), tem, 1);
2141 /* Invert the jump condition of conditional jump insn, INSN.
2143 Return 1 if we can do so, 0 if we cannot find a way to do so that
2144 matches a pattern. */
2150 invert_exp_1 (insn);
2151 if (num_validated_changes () == 0)
2154 return apply_change_group ();
2157 /* Invert the condition of the jump JUMP, and make it jump to label
2158 NLABEL instead of where it jumps now. Accrue changes into the
2159 change group. Return false if we didn't see how to perform the
2160 inversion and redirection. */
2163 invert_jump_1 (jump, nlabel)
2168 ochanges = num_validated_changes ();
2169 invert_exp_1 (jump);
2170 if (num_validated_changes () == ochanges)
2173 return redirect_jump_1 (jump, nlabel);
2176 /* Invert the condition of the jump JUMP, and make it jump to label
2177 NLABEL instead of where it jumps now. Return true if successful. */
2180 invert_jump (jump, nlabel, delete_unused)
2184 /* We have to either invert the condition and change the label or
2185 do neither. Either operation could fail. We first try to invert
2186 the jump. If that succeeds, we try changing the label. If that fails,
2187 we invert the jump back to what it was. */
2189 if (! invert_exp (jump))
2192 if (redirect_jump (jump, nlabel, delete_unused))
2194 invert_br_probabilities (jump);
2199 if (! invert_exp (jump))
2200 /* This should just be putting it back the way it was. */
2207 /* Like rtx_equal_p except that it considers two REGs as equal
2208 if they renumber to the same value and considers two commutative
2209 operations to be the same if the order of the operands has been
2212 ??? Addition is not commutative on the PA due to the weird implicit
2213 space register selection rules for memory addresses. Therefore, we
2214 don't consider a + b == b + a.
2216 We could/should make this test a little tighter. Possibly only
2217 disabling it on the PA via some backend macro or only disabling this
2218 case when the PLUS is inside a MEM. */
2221 rtx_renumbered_equal_p (x, y)
2225 RTX_CODE code = GET_CODE (x);
2231 if ((code == REG || (code == SUBREG && GET_CODE (SUBREG_REG (x)) == REG))
2232 && (GET_CODE (y) == REG || (GET_CODE (y) == SUBREG
2233 && GET_CODE (SUBREG_REG (y)) == REG)))
2235 int reg_x = -1, reg_y = -1;
2236 int byte_x = 0, byte_y = 0;
2238 if (GET_MODE (x) != GET_MODE (y))
2241 /* If we haven't done any renumbering, don't
2242 make any assumptions. */
2243 if (reg_renumber == 0)
2244 return rtx_equal_p (x, y);
2248 reg_x = REGNO (SUBREG_REG (x));
2249 byte_x = SUBREG_BYTE (x);
2251 if (reg_renumber[reg_x] >= 0)
2253 reg_x = subreg_regno_offset (reg_renumber[reg_x],
2254 GET_MODE (SUBREG_REG (x)),
2263 if (reg_renumber[reg_x] >= 0)
2264 reg_x = reg_renumber[reg_x];
2267 if (GET_CODE (y) == SUBREG)
2269 reg_y = REGNO (SUBREG_REG (y));
2270 byte_y = SUBREG_BYTE (y);
2272 if (reg_renumber[reg_y] >= 0)
2274 reg_y = subreg_regno_offset (reg_renumber[reg_y],
2275 GET_MODE (SUBREG_REG (y)),
2284 if (reg_renumber[reg_y] >= 0)
2285 reg_y = reg_renumber[reg_y];
2288 return reg_x >= 0 && reg_x == reg_y && byte_x == byte_y;
2291 /* Now we have disposed of all the cases
2292 in which different rtx codes can match. */
2293 if (code != GET_CODE (y))
2305 return INTVAL (x) == INTVAL (y);
2308 /* We can't assume nonlocal labels have their following insns yet. */
2309 if (LABEL_REF_NONLOCAL_P (x) || LABEL_REF_NONLOCAL_P (y))
2310 return XEXP (x, 0) == XEXP (y, 0);
2312 /* Two label-refs are equivalent if they point at labels
2313 in the same position in the instruction stream. */
2314 return (next_real_insn (XEXP (x, 0))
2315 == next_real_insn (XEXP (y, 0)));
2318 return XSTR (x, 0) == XSTR (y, 0);
2321 /* If we didn't match EQ equality above, they aren't the same. */
2328 /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent. */
2330 if (GET_MODE (x) != GET_MODE (y))
2333 /* For commutative operations, the RTX match if the operand match in any
2334 order. Also handle the simple binary and unary cases without a loop.
2336 ??? Don't consider PLUS a commutative operator; see comments above. */
2337 if ((code == EQ || code == NE || GET_RTX_CLASS (code) == 'c')
2339 return ((rtx_renumbered_equal_p (XEXP (x, 0), XEXP (y, 0))
2340 && rtx_renumbered_equal_p (XEXP (x, 1), XEXP (y, 1)))
2341 || (rtx_renumbered_equal_p (XEXP (x, 0), XEXP (y, 1))
2342 && rtx_renumbered_equal_p (XEXP (x, 1), XEXP (y, 0))));
2343 else if (GET_RTX_CLASS (code) == '<' || GET_RTX_CLASS (code) == '2')
2344 return (rtx_renumbered_equal_p (XEXP (x, 0), XEXP (y, 0))
2345 && rtx_renumbered_equal_p (XEXP (x, 1), XEXP (y, 1)));
2346 else if (GET_RTX_CLASS (code) == '1')
2347 return rtx_renumbered_equal_p (XEXP (x, 0), XEXP (y, 0));
2349 /* Compare the elements. If any pair of corresponding elements
2350 fail to match, return 0 for the whole things. */
2352 fmt = GET_RTX_FORMAT (code);
2353 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
2359 if (XWINT (x, i) != XWINT (y, i))
2364 if (XINT (x, i) != XINT (y, i))
2369 if (XTREE (x, i) != XTREE (y, i))
2374 if (strcmp (XSTR (x, i), XSTR (y, i)))
2379 if (! rtx_renumbered_equal_p (XEXP (x, i), XEXP (y, i)))
2384 if (XEXP (x, i) != XEXP (y, i))
2391 if (XVECLEN (x, i) != XVECLEN (y, i))
2393 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
2394 if (!rtx_renumbered_equal_p (XVECEXP (x, i, j), XVECEXP (y, i, j)))
2405 /* If X is a hard register or equivalent to one or a subregister of one,
2406 return the hard register number. If X is a pseudo register that was not
2407 assigned a hard register, return the pseudo register number. Otherwise,
2408 return -1. Any rtx is valid for X. */
2414 if (GET_CODE (x) == REG)
2416 if (REGNO (x) >= FIRST_PSEUDO_REGISTER && reg_renumber[REGNO (x)] >= 0)
2417 return reg_renumber[REGNO (x)];
2420 if (GET_CODE (x) == SUBREG)
2422 int base = true_regnum (SUBREG_REG (x));
2423 if (base >= 0 && base < FIRST_PSEUDO_REGISTER)
2424 return base + subreg_regno_offset (REGNO (SUBREG_REG (x)),
2425 GET_MODE (SUBREG_REG (x)),
2426 SUBREG_BYTE (x), GET_MODE (x));