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, 2003, 2004 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 redirect_jump and invert_jump are used
35 from other passes as well. */
39 #include "coretypes.h"
44 #include "hard-reg-set.h"
46 #include "insn-config.h"
47 #include "insn-attr.h"
53 #include "diagnostic.h"
59 /* Optimize jump y; x: ... y: jumpif... x?
60 Don't know if it is worth bothering with. */
61 /* Optimize two cases of conditional jump to conditional jump?
62 This can never delete any instruction or make anything dead,
63 or even change what is live at any point.
64 So perhaps let combiner do it. */
66 static rtx
next_nonnote_insn_in_loop (rtx
);
67 static void init_label_info (rtx
);
68 static void mark_all_labels (rtx
);
69 static int duplicate_loop_exit_test (rtx
);
70 static void delete_computation (rtx
);
71 static void redirect_exp_1 (rtx
*, rtx
, rtx
, rtx
);
72 static int redirect_exp (rtx
, rtx
, rtx
);
73 static void invert_exp_1 (rtx
);
74 static int invert_exp (rtx
);
75 static int returnjump_p_1 (rtx
*, void *);
76 static void delete_prior_computation (rtx
, rtx
);
78 /* Alternate entry into the jump optimizer. This entry point only rebuilds
79 the JUMP_LABEL field in jumping insns and REG_LABEL notes in non-jumping
82 rebuild_jump_labels (rtx f
)
86 timevar_push (TV_REBUILD_JUMP
);
90 /* Keep track of labels used from static data; we don't track them
91 closely enough to delete them here, so make sure their reference
92 count doesn't drop to zero. */
94 for (insn
= forced_labels
; insn
; insn
= XEXP (insn
, 1))
95 if (GET_CODE (XEXP (insn
, 0)) == CODE_LABEL
)
96 LABEL_NUSES (XEXP (insn
, 0))++;
97 timevar_pop (TV_REBUILD_JUMP
);
100 /* Some old code expects exactly one BARRIER as the NEXT_INSN of a
101 non-fallthru insn. This is not generally true, as multiple barriers
102 may have crept in, or the BARRIER may be separated from the last
103 real insn by one or more NOTEs.
105 This simple pass moves barriers and removes duplicates so that the
109 cleanup_barriers (void)
111 rtx insn
, next
, prev
;
112 for (insn
= get_insns (); insn
; insn
= next
)
114 next
= NEXT_INSN (insn
);
115 if (GET_CODE (insn
) == BARRIER
)
117 prev
= prev_nonnote_insn (insn
);
118 if (GET_CODE (prev
) == BARRIER
)
119 delete_barrier (insn
);
120 else if (prev
!= PREV_INSN (insn
))
121 reorder_insns (insn
, insn
, prev
);
126 /* Return the next insn after INSN that is not a NOTE and is in the loop,
127 i.e. when there is no such INSN before NOTE_INSN_LOOP_END return NULL_RTX.
128 This routine does not look inside SEQUENCEs. */
131 next_nonnote_insn_in_loop (rtx insn
)
135 insn
= NEXT_INSN (insn
);
136 if (insn
== 0 || GET_CODE (insn
) != NOTE
)
138 if (GET_CODE (insn
) == NOTE
139 && NOTE_LINE_NUMBER (insn
) == NOTE_INSN_LOOP_END
)
147 copy_loop_headers (rtx f
)
150 /* Now iterate optimizing jumps until nothing changes over one pass. */
151 for (insn
= f
; insn
; insn
= next
)
155 next
= NEXT_INSN (insn
);
157 /* See if this is a NOTE_INSN_LOOP_BEG followed by an unconditional
158 jump. Try to optimize by duplicating the loop exit test if so.
159 This is only safe immediately after regscan, because it uses
160 the values of regno_first_uid and regno_last_uid. */
161 if (GET_CODE (insn
) == NOTE
162 && NOTE_LINE_NUMBER (insn
) == NOTE_INSN_LOOP_BEG
163 && (temp1
= next_nonnote_insn_in_loop (insn
)) != 0
164 && any_uncondjump_p (temp1
) && onlyjump_p (temp1
))
166 temp
= PREV_INSN (insn
);
167 if (duplicate_loop_exit_test (insn
))
169 next
= NEXT_INSN (temp
);
176 purge_line_number_notes (rtx f
)
180 /* Delete extraneous line number notes.
181 Note that two consecutive notes for different lines are not really
182 extraneous. There should be some indication where that line belonged,
183 even if it became empty. */
185 for (insn
= f
; insn
; insn
= NEXT_INSN (insn
))
186 if (GET_CODE (insn
) == NOTE
)
188 if (NOTE_LINE_NUMBER (insn
) == NOTE_INSN_FUNCTION_BEG
)
189 /* Any previous line note was for the prologue; gdb wants a new
190 note after the prologue even if it is for the same line. */
191 last_note
= NULL_RTX
;
192 else if (NOTE_LINE_NUMBER (insn
) >= 0)
194 /* Delete this note if it is identical to previous note. */
196 && NOTE_SOURCE_FILE (insn
) == NOTE_SOURCE_FILE (last_note
)
197 && NOTE_LINE_NUMBER (insn
) == NOTE_LINE_NUMBER (last_note
))
199 delete_related_insns (insn
);
208 /* Initialize LABEL_NUSES and JUMP_LABEL fields. Delete any REG_LABEL
209 notes whose labels don't occur in the insn any more. Returns the
210 largest INSN_UID found. */
212 init_label_info (rtx f
)
216 for (insn
= f
; insn
; insn
= NEXT_INSN (insn
))
217 if (GET_CODE (insn
) == CODE_LABEL
)
218 LABEL_NUSES (insn
) = (LABEL_PRESERVE_P (insn
) != 0);
219 else if (GET_CODE (insn
) == JUMP_INSN
)
220 JUMP_LABEL (insn
) = 0;
221 else if (GET_CODE (insn
) == INSN
|| GET_CODE (insn
) == CALL_INSN
)
225 for (note
= REG_NOTES (insn
); note
; note
= next
)
227 next
= XEXP (note
, 1);
228 if (REG_NOTE_KIND (note
) == REG_LABEL
229 && ! reg_mentioned_p (XEXP (note
, 0), PATTERN (insn
)))
230 remove_note (insn
, note
);
235 /* Mark the label each jump jumps to.
236 Combine consecutive labels, and count uses of labels. */
239 mark_all_labels (rtx f
)
243 for (insn
= f
; insn
; insn
= NEXT_INSN (insn
))
246 if (GET_CODE (insn
) == CALL_INSN
247 && GET_CODE (PATTERN (insn
)) == CALL_PLACEHOLDER
)
249 mark_all_labels (XEXP (PATTERN (insn
), 0));
250 mark_all_labels (XEXP (PATTERN (insn
), 1));
251 mark_all_labels (XEXP (PATTERN (insn
), 2));
253 /* Canonicalize the tail recursion label attached to the
254 CALL_PLACEHOLDER insn. */
255 if (XEXP (PATTERN (insn
), 3))
257 rtx label_ref
= gen_rtx_LABEL_REF (VOIDmode
,
258 XEXP (PATTERN (insn
), 3));
259 mark_jump_label (label_ref
, insn
, 0);
260 XEXP (PATTERN (insn
), 3) = XEXP (label_ref
, 0);
266 mark_jump_label (PATTERN (insn
), insn
, 0);
267 if (! INSN_DELETED_P (insn
) && GET_CODE (insn
) == JUMP_INSN
)
269 /* When we know the LABEL_REF contained in a REG used in
270 an indirect jump, we'll have a REG_LABEL note so that
271 flow can tell where it's going. */
272 if (JUMP_LABEL (insn
) == 0)
274 rtx label_note
= find_reg_note (insn
, REG_LABEL
, NULL_RTX
);
277 /* But a LABEL_REF around the REG_LABEL note, so
278 that we can canonicalize it. */
279 rtx label_ref
= gen_rtx_LABEL_REF (VOIDmode
,
280 XEXP (label_note
, 0));
282 mark_jump_label (label_ref
, insn
, 0);
283 XEXP (label_note
, 0) = XEXP (label_ref
, 0);
284 JUMP_LABEL (insn
) = XEXP (label_note
, 0);
291 /* LOOP_START is a NOTE_INSN_LOOP_BEG note that is followed by an unconditional
292 jump. Assume that this unconditional jump is to the exit test code. If
293 the code is sufficiently simple, make a copy of it before INSN,
294 followed by a jump to the exit of the loop. Then delete the unconditional
297 Return 1 if we made the change, else 0.
299 This is only safe immediately after a regscan pass because it uses the
300 values of regno_first_uid and regno_last_uid. */
303 duplicate_loop_exit_test (rtx loop_start
)
305 rtx insn
, set
, reg
, p
, link
;
306 rtx copy
= 0, first_copy
= 0;
309 = NEXT_INSN (JUMP_LABEL (next_nonnote_insn_in_loop (loop_start
)));
311 int max_reg
= max_reg_num ();
313 rtx loop_pre_header_label
;
315 /* Scan the exit code. We do not perform this optimization if any insn:
319 has a REG_RETVAL or REG_LIBCALL note (hard to adjust)
320 is a NOTE_INSN_LOOP_BEG because this means we have a nested loop
322 We also do not do this if we find an insn with ASM_OPERANDS. While
323 this restriction should not be necessary, copying an insn with
324 ASM_OPERANDS can confuse asm_noperands in some cases.
326 Also, don't do this if the exit code is more than 20 insns. */
328 for (insn
= exitcode
;
330 && ! (GET_CODE (insn
) == NOTE
331 && NOTE_LINE_NUMBER (insn
) == NOTE_INSN_LOOP_END
);
332 insn
= NEXT_INSN (insn
))
334 switch (GET_CODE (insn
))
342 && (NOTE_LINE_NUMBER (insn
) == NOTE_INSN_BLOCK_BEG
343 || NOTE_LINE_NUMBER (insn
) == NOTE_INSN_BLOCK_END
))
344 /* If we were to duplicate this code, we would not move
345 the BLOCK notes, and so debugging the moved code would
346 be difficult. Thus, we only move the code with -O2 or
354 || find_reg_note (insn
, REG_RETVAL
, NULL_RTX
)
355 || find_reg_note (insn
, REG_LIBCALL
, NULL_RTX
))
363 /* Unless INSN is zero, we can do the optimization. */
369 /* See if any insn sets a register only used in the loop exit code and
370 not a user variable. If so, replace it with a new register. */
371 for (insn
= exitcode
; insn
!= lastexit
; insn
= NEXT_INSN (insn
))
372 if (GET_CODE (insn
) == INSN
373 && (set
= single_set (insn
)) != 0
374 && ((reg
= SET_DEST (set
), GET_CODE (reg
) == REG
)
375 || (GET_CODE (reg
) == SUBREG
376 && (reg
= SUBREG_REG (reg
), GET_CODE (reg
) == REG
)))
377 && REGNO (reg
) >= FIRST_PSEUDO_REGISTER
378 && REGNO_FIRST_UID (REGNO (reg
)) == INSN_UID (insn
))
380 for (p
= NEXT_INSN (insn
); p
!= lastexit
; p
= NEXT_INSN (p
))
381 if (REGNO_LAST_UID (REGNO (reg
)) == INSN_UID (p
))
386 /* We can do the replacement. Allocate reg_map if this is the
387 first replacement we found. */
389 reg_map
= xcalloc (max_reg
, sizeof (rtx
));
391 REG_LOOP_TEST_P (reg
) = 1;
393 reg_map
[REGNO (reg
)] = gen_reg_rtx (GET_MODE (reg
));
396 loop_pre_header_label
= gen_label_rtx ();
398 /* Now copy each insn. */
399 for (insn
= exitcode
; insn
!= lastexit
; insn
= NEXT_INSN (insn
))
401 switch (GET_CODE (insn
))
404 copy
= emit_barrier_before (loop_start
);
407 /* Only copy line-number notes. */
408 if (NOTE_LINE_NUMBER (insn
) >= 0)
410 copy
= emit_note_before (NOTE_LINE_NUMBER (insn
), loop_start
);
411 NOTE_SOURCE_FILE (copy
) = NOTE_SOURCE_FILE (insn
);
416 copy
= emit_insn_before (copy_insn (PATTERN (insn
)), loop_start
);
418 replace_regs (PATTERN (copy
), reg_map
, max_reg
, 1);
420 mark_jump_label (PATTERN (copy
), copy
, 0);
421 INSN_LOCATOR (copy
) = INSN_LOCATOR (insn
);
423 /* Copy all REG_NOTES except REG_LABEL since mark_jump_label will
425 for (link
= REG_NOTES (insn
); link
; link
= XEXP (link
, 1))
426 if (REG_NOTE_KIND (link
) != REG_LABEL
)
428 if (GET_CODE (link
) == EXPR_LIST
)
430 = copy_insn_1 (gen_rtx_EXPR_LIST (REG_NOTE_KIND (link
),
435 = copy_insn_1 (gen_rtx_INSN_LIST (REG_NOTE_KIND (link
),
440 if (reg_map
&& REG_NOTES (copy
))
441 replace_regs (REG_NOTES (copy
), reg_map
, max_reg
, 1);
445 copy
= emit_jump_insn_before (copy_insn (PATTERN (insn
)),
447 INSN_LOCATOR (copy
) = INSN_LOCATOR (insn
);
449 replace_regs (PATTERN (copy
), reg_map
, max_reg
, 1);
450 mark_jump_label (PATTERN (copy
), copy
, 0);
451 if (REG_NOTES (insn
))
453 REG_NOTES (copy
) = copy_insn_1 (REG_NOTES (insn
));
455 replace_regs (REG_NOTES (copy
), reg_map
, max_reg
, 1);
458 /* Predict conditional jump that do make loop looping as taken.
459 Other jumps are probably exit conditions, so predict
461 if (any_condjump_p (copy
))
463 rtx label
= JUMP_LABEL (copy
);
466 /* The jump_insn after loop_start should be followed
467 by barrier and loopback label. */
468 if (prev_nonnote_insn (label
)
469 && (prev_nonnote_insn (prev_nonnote_insn (label
))
470 == next_nonnote_insn (loop_start
)))
472 predict_insn_def (copy
, PRED_LOOP_HEADER
, TAKEN
);
473 /* To keep pre-header, we need to redirect all loop
474 entrances before the LOOP_BEG note. */
475 redirect_jump (copy
, loop_pre_header_label
, 0);
478 predict_insn_def (copy
, PRED_LOOP_HEADER
, NOT_TAKEN
);
487 /* Record the first insn we copied. We need it so that we can
488 scan the copied insns for new pseudo registers. */
493 /* Now clean up by emitting a jump to the end label and deleting the jump
494 at the start of the loop. */
495 if (! copy
|| GET_CODE (copy
) != BARRIER
)
497 copy
= emit_jump_insn_before (gen_jump (get_label_after (insn
)),
500 /* Record the first insn we copied. We need it so that we can
501 scan the copied insns for new pseudo registers. This may not
502 be strictly necessary since we should have copied at least one
503 insn above. But I am going to be safe. */
507 mark_jump_label (PATTERN (copy
), copy
, 0);
508 emit_barrier_before (loop_start
);
511 emit_label_before (loop_pre_header_label
, loop_start
);
513 /* Now scan from the first insn we copied to the last insn we copied
514 (copy) for new pseudo registers. Do this after the code to jump to
515 the end label since that might create a new pseudo too. */
516 reg_scan_update (first_copy
, copy
, max_reg
);
518 /* Mark the exit code as the virtual top of the converted loop. */
519 emit_note_before (NOTE_INSN_LOOP_VTOP
, exitcode
);
521 delete_related_insns (next_nonnote_insn (loop_start
));
530 /* Move all block-beg, block-end, loop-beg, loop-cont, loop-vtop, loop-end,
531 notes between START and END out before START. START and END may be such
532 notes. Returns the values of the new starting and ending insns, which
533 may be different if the original ones were such notes.
534 Return true if there were only such notes and no real instructions. */
537 squeeze_notes (rtx
* startp
, rtx
* endp
)
545 rtx past_end
= NEXT_INSN (end
);
547 for (insn
= start
; insn
!= past_end
; insn
= next
)
549 next
= NEXT_INSN (insn
);
550 if (GET_CODE (insn
) == NOTE
551 && (NOTE_LINE_NUMBER (insn
) == NOTE_INSN_BLOCK_END
552 || NOTE_LINE_NUMBER (insn
) == NOTE_INSN_BLOCK_BEG
553 || NOTE_LINE_NUMBER (insn
) == NOTE_INSN_LOOP_BEG
554 || NOTE_LINE_NUMBER (insn
) == NOTE_INSN_LOOP_END
555 || NOTE_LINE_NUMBER (insn
) == NOTE_INSN_LOOP_CONT
556 || NOTE_LINE_NUMBER (insn
) == NOTE_INSN_LOOP_VTOP
))
562 rtx prev
= PREV_INSN (insn
);
563 PREV_INSN (insn
) = PREV_INSN (start
);
564 NEXT_INSN (insn
) = start
;
565 NEXT_INSN (PREV_INSN (insn
)) = insn
;
566 PREV_INSN (NEXT_INSN (insn
)) = insn
;
567 NEXT_INSN (prev
) = next
;
568 PREV_INSN (next
) = prev
;
575 /* There were no real instructions. */
576 if (start
== past_end
)
586 /* Return the label before INSN, or put a new label there. */
589 get_label_before (rtx insn
)
593 /* Find an existing label at this point
594 or make a new one if there is none. */
595 label
= prev_nonnote_insn (insn
);
597 if (label
== 0 || GET_CODE (label
) != CODE_LABEL
)
599 rtx prev
= PREV_INSN (insn
);
601 label
= gen_label_rtx ();
602 emit_label_after (label
, prev
);
603 LABEL_NUSES (label
) = 0;
608 /* Return the label after INSN, or put a new label there. */
611 get_label_after (rtx insn
)
615 /* Find an existing label at this point
616 or make a new one if there is none. */
617 label
= next_nonnote_insn (insn
);
619 if (label
== 0 || GET_CODE (label
) != CODE_LABEL
)
621 label
= gen_label_rtx ();
622 emit_label_after (label
, insn
);
623 LABEL_NUSES (label
) = 0;
628 /* Given a comparison (CODE ARG0 ARG1), inside an insn, INSN, return a code
629 of reversed comparison if it is possible to do so. Otherwise return UNKNOWN.
630 UNKNOWN may be returned in case we are having CC_MODE compare and we don't
631 know whether it's source is floating point or integer comparison. Machine
632 description should define REVERSIBLE_CC_MODE and REVERSE_CONDITION macros
633 to help this function avoid overhead in these cases. */
635 reversed_comparison_code_parts (enum rtx_code code
, rtx arg0
, rtx arg1
, rtx insn
)
637 enum machine_mode mode
;
639 /* If this is not actually a comparison, we can't reverse it. */
640 if (GET_RTX_CLASS (code
) != RTX_COMPARE
641 && GET_RTX_CLASS (code
) != RTX_COMM_COMPARE
)
644 mode
= GET_MODE (arg0
);
645 if (mode
== VOIDmode
)
646 mode
= GET_MODE (arg1
);
648 /* First see if machine description supply us way to reverse the comparison.
649 Give it priority over everything else to allow machine description to do
651 #ifdef REVERSIBLE_CC_MODE
652 if (GET_MODE_CLASS (mode
) == MODE_CC
653 && REVERSIBLE_CC_MODE (mode
))
655 #ifdef REVERSE_CONDITION
656 return REVERSE_CONDITION (code
, mode
);
658 return reverse_condition (code
);
662 /* Try a few special cases based on the comparison code. */
671 /* It is always safe to reverse EQ and NE, even for the floating
672 point. Similarly the unsigned comparisons are never used for
673 floating point so we can reverse them in the default way. */
674 return reverse_condition (code
);
679 /* In case we already see unordered comparison, we can be sure to
680 be dealing with floating point so we don't need any more tests. */
681 return reverse_condition_maybe_unordered (code
);
686 /* We don't have safe way to reverse these yet. */
692 if (GET_MODE_CLASS (mode
) == MODE_CC
|| CC0_P (arg0
))
695 /* Try to search for the comparison to determine the real mode.
696 This code is expensive, but with sane machine description it
697 will be never used, since REVERSIBLE_CC_MODE will return true
702 for (prev
= prev_nonnote_insn (insn
);
703 prev
!= 0 && GET_CODE (prev
) != CODE_LABEL
;
704 prev
= prev_nonnote_insn (prev
))
706 rtx set
= set_of (arg0
, prev
);
707 if (set
&& GET_CODE (set
) == SET
708 && rtx_equal_p (SET_DEST (set
), arg0
))
710 rtx src
= SET_SRC (set
);
712 if (GET_CODE (src
) == COMPARE
)
714 rtx comparison
= src
;
715 arg0
= XEXP (src
, 0);
716 mode
= GET_MODE (arg0
);
717 if (mode
== VOIDmode
)
718 mode
= GET_MODE (XEXP (comparison
, 1));
721 /* We can get past reg-reg moves. This may be useful for model
722 of i387 comparisons that first move flag registers around. */
729 /* If register is clobbered in some ununderstandable way,
736 /* Test for an integer condition, or a floating-point comparison
737 in which NaNs can be ignored. */
738 if (GET_CODE (arg0
) == CONST_INT
739 || (GET_MODE (arg0
) != VOIDmode
740 && GET_MODE_CLASS (mode
) != MODE_CC
741 && !HONOR_NANS (mode
)))
742 return reverse_condition (code
);
747 /* A wrapper around the previous function to take COMPARISON as rtx
748 expression. This simplifies many callers. */
750 reversed_comparison_code (rtx comparison
, rtx insn
)
752 if (!COMPARISON_P (comparison
))
754 return reversed_comparison_code_parts (GET_CODE (comparison
),
755 XEXP (comparison
, 0),
756 XEXP (comparison
, 1), insn
);
759 /* Given an rtx-code for a comparison, return the code for the negated
760 comparison. If no such code exists, return UNKNOWN.
762 WATCH OUT! reverse_condition is not safe to use on a jump that might
763 be acting on the results of an IEEE floating point comparison, because
764 of the special treatment of non-signaling nans in comparisons.
765 Use reversed_comparison_code instead. */
768 reverse_condition (enum rtx_code code
)
810 /* Similar, but we're allowed to generate unordered comparisons, which
811 makes it safe for IEEE floating-point. Of course, we have to recognize
812 that the target will support them too... */
815 reverse_condition_maybe_unordered (enum rtx_code code
)
853 /* Similar, but return the code when two operands of a comparison are swapped.
854 This IS safe for IEEE floating-point. */
857 swap_condition (enum rtx_code code
)
899 /* Given a comparison CODE, return the corresponding unsigned comparison.
900 If CODE is an equality comparison or already an unsigned comparison,
904 unsigned_condition (enum rtx_code code
)
930 /* Similarly, return the signed version of a comparison. */
933 signed_condition (enum rtx_code code
)
959 /* Return nonzero if CODE1 is more strict than CODE2, i.e., if the
960 truth of CODE1 implies the truth of CODE2. */
963 comparison_dominates_p (enum rtx_code code1
, enum rtx_code code2
)
965 /* UNKNOWN comparison codes can happen as a result of trying to revert
967 They can't match anything, so we have to reject them here. */
968 if (code1
== UNKNOWN
|| code2
== UNKNOWN
)
977 if (code2
== UNLE
|| code2
== UNGE
)
982 if (code2
== LE
|| code2
== LEU
|| code2
== GE
|| code2
== GEU
988 if (code2
== UNLE
|| code2
== NE
)
993 if (code2
== LE
|| code2
== NE
|| code2
== ORDERED
|| code2
== LTGT
)
998 if (code2
== UNGE
|| code2
== NE
)
1003 if (code2
== GE
|| code2
== NE
|| code2
== ORDERED
|| code2
== LTGT
)
1009 if (code2
== ORDERED
)
1014 if (code2
== NE
|| code2
== ORDERED
)
1019 if (code2
== LEU
|| code2
== NE
)
1024 if (code2
== GEU
|| code2
== NE
)
1029 if (code2
== NE
|| code2
== UNEQ
|| code2
== UNLE
|| code2
== UNLT
1030 || code2
== UNGE
|| code2
== UNGT
)
1041 /* Return 1 if INSN is an unconditional jump and nothing else. */
1044 simplejump_p (rtx insn
)
1046 return (GET_CODE (insn
) == JUMP_INSN
1047 && GET_CODE (PATTERN (insn
)) == SET
1048 && GET_CODE (SET_DEST (PATTERN (insn
))) == PC
1049 && GET_CODE (SET_SRC (PATTERN (insn
))) == LABEL_REF
);
1052 /* Return nonzero if INSN is a (possibly) conditional jump
1055 Use of this function is deprecated, since we need to support combined
1056 branch and compare insns. Use any_condjump_p instead whenever possible. */
1059 condjump_p (rtx insn
)
1061 rtx x
= PATTERN (insn
);
1063 if (GET_CODE (x
) != SET
1064 || GET_CODE (SET_DEST (x
)) != PC
)
1068 if (GET_CODE (x
) == LABEL_REF
)
1071 return (GET_CODE (x
) == IF_THEN_ELSE
1072 && ((GET_CODE (XEXP (x
, 2)) == PC
1073 && (GET_CODE (XEXP (x
, 1)) == LABEL_REF
1074 || GET_CODE (XEXP (x
, 1)) == RETURN
))
1075 || (GET_CODE (XEXP (x
, 1)) == PC
1076 && (GET_CODE (XEXP (x
, 2)) == LABEL_REF
1077 || GET_CODE (XEXP (x
, 2)) == RETURN
))));
1082 /* Return nonzero if INSN is a (possibly) conditional jump inside a
1085 Use this function is deprecated, since we need to support combined
1086 branch and compare insns. Use any_condjump_p instead whenever possible. */
1089 condjump_in_parallel_p (rtx insn
)
1091 rtx x
= PATTERN (insn
);
1093 if (GET_CODE (x
) != PARALLEL
)
1096 x
= XVECEXP (x
, 0, 0);
1098 if (GET_CODE (x
) != SET
)
1100 if (GET_CODE (SET_DEST (x
)) != PC
)
1102 if (GET_CODE (SET_SRC (x
)) == LABEL_REF
)
1104 if (GET_CODE (SET_SRC (x
)) != IF_THEN_ELSE
)
1106 if (XEXP (SET_SRC (x
), 2) == pc_rtx
1107 && (GET_CODE (XEXP (SET_SRC (x
), 1)) == LABEL_REF
1108 || GET_CODE (XEXP (SET_SRC (x
), 1)) == RETURN
))
1110 if (XEXP (SET_SRC (x
), 1) == pc_rtx
1111 && (GET_CODE (XEXP (SET_SRC (x
), 2)) == LABEL_REF
1112 || GET_CODE (XEXP (SET_SRC (x
), 2)) == RETURN
))
1117 /* Return set of PC, otherwise NULL. */
1123 if (GET_CODE (insn
) != JUMP_INSN
)
1125 pat
= PATTERN (insn
);
1127 /* The set is allowed to appear either as the insn pattern or
1128 the first set in a PARALLEL. */
1129 if (GET_CODE (pat
) == PARALLEL
)
1130 pat
= XVECEXP (pat
, 0, 0);
1131 if (GET_CODE (pat
) == SET
&& GET_CODE (SET_DEST (pat
)) == PC
)
1137 /* Return true when insn is an unconditional direct jump,
1138 possibly bundled inside a PARALLEL. */
1141 any_uncondjump_p (rtx insn
)
1143 rtx x
= pc_set (insn
);
1146 if (GET_CODE (SET_SRC (x
)) != LABEL_REF
)
1151 /* Return true when insn is a conditional jump. This function works for
1152 instructions containing PC sets in PARALLELs. The instruction may have
1153 various other effects so before removing the jump you must verify
1156 Note that unlike condjump_p it returns false for unconditional jumps. */
1159 any_condjump_p (rtx insn
)
1161 rtx x
= pc_set (insn
);
1166 if (GET_CODE (SET_SRC (x
)) != IF_THEN_ELSE
)
1169 a
= GET_CODE (XEXP (SET_SRC (x
), 1));
1170 b
= GET_CODE (XEXP (SET_SRC (x
), 2));
1172 return ((b
== PC
&& (a
== LABEL_REF
|| a
== RETURN
))
1173 || (a
== PC
&& (b
== LABEL_REF
|| b
== RETURN
)));
1176 /* Return the label of a conditional jump. */
1179 condjump_label (rtx insn
)
1181 rtx x
= pc_set (insn
);
1186 if (GET_CODE (x
) == LABEL_REF
)
1188 if (GET_CODE (x
) != IF_THEN_ELSE
)
1190 if (XEXP (x
, 2) == pc_rtx
&& GET_CODE (XEXP (x
, 1)) == LABEL_REF
)
1192 if (XEXP (x
, 1) == pc_rtx
&& GET_CODE (XEXP (x
, 2)) == LABEL_REF
)
1197 /* Return true if INSN is a (possibly conditional) return insn. */
1200 returnjump_p_1 (rtx
*loc
, void *data ATTRIBUTE_UNUSED
)
1204 return x
&& (GET_CODE (x
) == RETURN
1205 || (GET_CODE (x
) == SET
&& SET_IS_RETURN_P (x
)));
1209 returnjump_p (rtx insn
)
1211 if (GET_CODE (insn
) != JUMP_INSN
)
1213 return for_each_rtx (&PATTERN (insn
), returnjump_p_1
, NULL
);
1216 /* Return true if INSN is a jump that only transfers control and
1220 onlyjump_p (rtx insn
)
1224 if (GET_CODE (insn
) != JUMP_INSN
)
1227 set
= single_set (insn
);
1230 if (GET_CODE (SET_DEST (set
)) != PC
)
1232 if (side_effects_p (SET_SRC (set
)))
1240 /* Return nonzero if X is an RTX that only sets the condition codes
1241 and has no side effects. */
1244 only_sets_cc0_p (rtx x
)
1252 return sets_cc0_p (x
) == 1 && ! side_effects_p (x
);
1255 /* Return 1 if X is an RTX that does nothing but set the condition codes
1256 and CLOBBER or USE registers.
1257 Return -1 if X does explicitly set the condition codes,
1258 but also does other things. */
1269 if (GET_CODE (x
) == SET
&& SET_DEST (x
) == cc0_rtx
)
1271 if (GET_CODE (x
) == PARALLEL
)
1275 int other_things
= 0;
1276 for (i
= XVECLEN (x
, 0) - 1; i
>= 0; i
--)
1278 if (GET_CODE (XVECEXP (x
, 0, i
)) == SET
1279 && SET_DEST (XVECEXP (x
, 0, i
)) == cc0_rtx
)
1281 else if (GET_CODE (XVECEXP (x
, 0, i
)) == SET
)
1284 return ! sets_cc0
? 0 : other_things
? -1 : 1;
1290 /* Follow any unconditional jump at LABEL;
1291 return the ultimate label reached by any such chain of jumps.
1292 If LABEL is not followed by a jump, return LABEL.
1293 If the chain loops or we can't find end, return LABEL,
1294 since that tells caller to avoid changing the insn.
1296 If RELOAD_COMPLETED is 0, we do not chain across a NOTE_INSN_LOOP_BEG or
1297 a USE or CLOBBER. */
1300 follow_jumps (rtx label
)
1309 && (insn
= next_active_insn (value
)) != 0
1310 && GET_CODE (insn
) == JUMP_INSN
1311 && ((JUMP_LABEL (insn
) != 0 && any_uncondjump_p (insn
)
1312 && onlyjump_p (insn
))
1313 || GET_CODE (PATTERN (insn
)) == RETURN
)
1314 && (next
= NEXT_INSN (insn
))
1315 && GET_CODE (next
) == BARRIER
);
1318 /* Don't chain through the insn that jumps into a loop
1319 from outside the loop,
1320 since that would create multiple loop entry jumps
1321 and prevent loop optimization. */
1323 if (!reload_completed
)
1324 for (tem
= value
; tem
!= insn
; tem
= NEXT_INSN (tem
))
1325 if (GET_CODE (tem
) == NOTE
1326 && (NOTE_LINE_NUMBER (tem
) == NOTE_INSN_LOOP_BEG
1327 /* ??? Optional. Disables some optimizations, but makes
1328 gcov output more accurate with -O. */
1329 || (flag_test_coverage
&& NOTE_LINE_NUMBER (tem
) > 0)))
1332 /* If we have found a cycle, make the insn jump to itself. */
1333 if (JUMP_LABEL (insn
) == label
)
1336 tem
= next_active_insn (JUMP_LABEL (insn
));
1337 if (tem
&& (GET_CODE (PATTERN (tem
)) == ADDR_VEC
1338 || GET_CODE (PATTERN (tem
)) == ADDR_DIFF_VEC
))
1341 value
= JUMP_LABEL (insn
);
1349 /* Find all CODE_LABELs referred to in X, and increment their use counts.
1350 If INSN is a JUMP_INSN and there is at least one CODE_LABEL referenced
1351 in INSN, then store one of them in JUMP_LABEL (INSN).
1352 If INSN is an INSN or a CALL_INSN and there is at least one CODE_LABEL
1353 referenced in INSN, add a REG_LABEL note containing that label to INSN.
1354 Also, when there are consecutive labels, canonicalize on the last of them.
1356 Note that two labels separated by a loop-beginning note
1357 must be kept distinct if we have not yet done loop-optimization,
1358 because the gap between them is where loop-optimize
1359 will want to move invariant code to. CROSS_JUMP tells us
1360 that loop-optimization is done with. */
1363 mark_jump_label (rtx x
, rtx insn
, int in_mem
)
1365 RTX_CODE code
= GET_CODE (x
);
1388 /* If this is a constant-pool reference, see if it is a label. */
1389 if (CONSTANT_POOL_ADDRESS_P (x
))
1390 mark_jump_label (get_pool_constant (x
), insn
, in_mem
);
1395 rtx label
= XEXP (x
, 0);
1397 /* Ignore remaining references to unreachable labels that
1398 have been deleted. */
1399 if (GET_CODE (label
) == NOTE
1400 && NOTE_LINE_NUMBER (label
) == NOTE_INSN_DELETED_LABEL
)
1403 if (GET_CODE (label
) != CODE_LABEL
)
1406 /* Ignore references to labels of containing functions. */
1407 if (LABEL_REF_NONLOCAL_P (x
))
1410 XEXP (x
, 0) = label
;
1411 if (! insn
|| ! INSN_DELETED_P (insn
))
1412 ++LABEL_NUSES (label
);
1416 if (GET_CODE (insn
) == JUMP_INSN
)
1417 JUMP_LABEL (insn
) = label
;
1420 /* Add a REG_LABEL note for LABEL unless there already
1421 is one. All uses of a label, except for labels
1422 that are the targets of jumps, must have a
1424 if (! find_reg_note (insn
, REG_LABEL
, label
))
1425 REG_NOTES (insn
) = gen_rtx_INSN_LIST (REG_LABEL
, label
,
1432 /* Do walk the labels in a vector, but not the first operand of an
1433 ADDR_DIFF_VEC. Don't set the JUMP_LABEL of a vector. */
1436 if (! INSN_DELETED_P (insn
))
1438 int eltnum
= code
== ADDR_DIFF_VEC
? 1 : 0;
1440 for (i
= 0; i
< XVECLEN (x
, eltnum
); i
++)
1441 mark_jump_label (XVECEXP (x
, eltnum
, i
), NULL_RTX
, in_mem
);
1449 fmt
= GET_RTX_FORMAT (code
);
1450 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
1453 mark_jump_label (XEXP (x
, i
), insn
, in_mem
);
1454 else if (fmt
[i
] == 'E')
1457 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
1458 mark_jump_label (XVECEXP (x
, i
, j
), insn
, in_mem
);
1463 /* If all INSN does is set the pc, delete it,
1464 and delete the insn that set the condition codes for it
1465 if that's what the previous thing was. */
1468 delete_jump (rtx insn
)
1470 rtx set
= single_set (insn
);
1472 if (set
&& GET_CODE (SET_DEST (set
)) == PC
)
1473 delete_computation (insn
);
1476 /* Verify INSN is a BARRIER and delete it. */
1479 delete_barrier (rtx insn
)
1481 if (GET_CODE (insn
) != BARRIER
)
1487 /* Recursively delete prior insns that compute the value (used only by INSN
1488 which the caller is deleting) stored in the register mentioned by NOTE
1489 which is a REG_DEAD note associated with INSN. */
1492 delete_prior_computation (rtx note
, rtx insn
)
1495 rtx reg
= XEXP (note
, 0);
1497 for (our_prev
= prev_nonnote_insn (insn
);
1498 our_prev
&& (GET_CODE (our_prev
) == INSN
1499 || GET_CODE (our_prev
) == CALL_INSN
);
1500 our_prev
= prev_nonnote_insn (our_prev
))
1502 rtx pat
= PATTERN (our_prev
);
1504 /* If we reach a CALL which is not calling a const function
1505 or the callee pops the arguments, then give up. */
1506 if (GET_CODE (our_prev
) == CALL_INSN
1507 && (! CONST_OR_PURE_CALL_P (our_prev
)
1508 || GET_CODE (pat
) != SET
|| GET_CODE (SET_SRC (pat
)) != CALL
))
1511 /* If we reach a SEQUENCE, it is too complex to try to
1512 do anything with it, so give up. We can be run during
1513 and after reorg, so SEQUENCE rtl can legitimately show
1515 if (GET_CODE (pat
) == SEQUENCE
)
1518 if (GET_CODE (pat
) == USE
1519 && GET_CODE (XEXP (pat
, 0)) == INSN
)
1520 /* reorg creates USEs that look like this. We leave them
1521 alone because reorg needs them for its own purposes. */
1524 if (reg_set_p (reg
, pat
))
1526 if (side_effects_p (pat
) && GET_CODE (our_prev
) != CALL_INSN
)
1529 if (GET_CODE (pat
) == PARALLEL
)
1531 /* If we find a SET of something else, we can't
1536 for (i
= 0; i
< XVECLEN (pat
, 0); i
++)
1538 rtx part
= XVECEXP (pat
, 0, i
);
1540 if (GET_CODE (part
) == SET
1541 && SET_DEST (part
) != reg
)
1545 if (i
== XVECLEN (pat
, 0))
1546 delete_computation (our_prev
);
1548 else if (GET_CODE (pat
) == SET
1549 && GET_CODE (SET_DEST (pat
)) == REG
)
1551 int dest_regno
= REGNO (SET_DEST (pat
));
1554 + (dest_regno
< FIRST_PSEUDO_REGISTER
1555 ? hard_regno_nregs
[dest_regno
]
1556 [GET_MODE (SET_DEST (pat
))] : 1));
1557 int regno
= REGNO (reg
);
1560 + (regno
< FIRST_PSEUDO_REGISTER
1561 ? hard_regno_nregs
[regno
][GET_MODE (reg
)] : 1));
1563 if (dest_regno
>= regno
1564 && dest_endregno
<= endregno
)
1565 delete_computation (our_prev
);
1567 /* We may have a multi-word hard register and some, but not
1568 all, of the words of the register are needed in subsequent
1569 insns. Write REG_UNUSED notes for those parts that were not
1571 else if (dest_regno
<= regno
1572 && dest_endregno
>= endregno
)
1576 REG_NOTES (our_prev
)
1577 = gen_rtx_EXPR_LIST (REG_UNUSED
, reg
,
1578 REG_NOTES (our_prev
));
1580 for (i
= dest_regno
; i
< dest_endregno
; i
++)
1581 if (! find_regno_note (our_prev
, REG_UNUSED
, i
))
1584 if (i
== dest_endregno
)
1585 delete_computation (our_prev
);
1592 /* If PAT references the register that dies here, it is an
1593 additional use. Hence any prior SET isn't dead. However, this
1594 insn becomes the new place for the REG_DEAD note. */
1595 if (reg_overlap_mentioned_p (reg
, pat
))
1597 XEXP (note
, 1) = REG_NOTES (our_prev
);
1598 REG_NOTES (our_prev
) = note
;
1604 /* Delete INSN and recursively delete insns that compute values used only
1605 by INSN. This uses the REG_DEAD notes computed during flow analysis.
1606 If we are running before flow.c, we need do nothing since flow.c will
1607 delete dead code. We also can't know if the registers being used are
1608 dead or not at this point.
1610 Otherwise, look at all our REG_DEAD notes. If a previous insn does
1611 nothing other than set a register that dies in this insn, we can delete
1614 On machines with CC0, if CC0 is used in this insn, we may be able to
1615 delete the insn that set it. */
1618 delete_computation (rtx insn
)
1623 if (reg_referenced_p (cc0_rtx
, PATTERN (insn
)))
1625 rtx prev
= prev_nonnote_insn (insn
);
1626 /* We assume that at this stage
1627 CC's are always set explicitly
1628 and always immediately before the jump that
1629 will use them. So if the previous insn
1630 exists to set the CC's, delete it
1631 (unless it performs auto-increments, etc.). */
1632 if (prev
&& GET_CODE (prev
) == INSN
1633 && sets_cc0_p (PATTERN (prev
)))
1635 if (sets_cc0_p (PATTERN (prev
)) > 0
1636 && ! side_effects_p (PATTERN (prev
)))
1637 delete_computation (prev
);
1639 /* Otherwise, show that cc0 won't be used. */
1640 REG_NOTES (prev
) = gen_rtx_EXPR_LIST (REG_UNUSED
,
1641 cc0_rtx
, REG_NOTES (prev
));
1646 for (note
= REG_NOTES (insn
); note
; note
= next
)
1648 next
= XEXP (note
, 1);
1650 if (REG_NOTE_KIND (note
) != REG_DEAD
1651 /* Verify that the REG_NOTE is legitimate. */
1652 || GET_CODE (XEXP (note
, 0)) != REG
)
1655 delete_prior_computation (note
, insn
);
1658 delete_related_insns (insn
);
1661 /* Delete insn INSN from the chain of insns and update label ref counts
1662 and delete insns now unreachable.
1664 Returns the first insn after INSN that was not deleted.
1666 Usage of this instruction is deprecated. Use delete_insn instead and
1667 subsequent cfg_cleanup pass to delete unreachable code if needed. */
1670 delete_related_insns (rtx insn
)
1672 int was_code_label
= (GET_CODE (insn
) == CODE_LABEL
);
1674 rtx next
= NEXT_INSN (insn
), prev
= PREV_INSN (insn
);
1676 while (next
&& INSN_DELETED_P (next
))
1677 next
= NEXT_INSN (next
);
1679 /* This insn is already deleted => return first following nondeleted. */
1680 if (INSN_DELETED_P (insn
))
1685 /* If instruction is followed by a barrier,
1686 delete the barrier too. */
1688 if (next
!= 0 && GET_CODE (next
) == BARRIER
)
1691 /* If deleting a jump, decrement the count of the label,
1692 and delete the label if it is now unused. */
1694 if (GET_CODE (insn
) == JUMP_INSN
&& JUMP_LABEL (insn
))
1696 rtx lab
= JUMP_LABEL (insn
), lab_next
;
1698 if (LABEL_NUSES (lab
) == 0)
1700 /* This can delete NEXT or PREV,
1701 either directly if NEXT is JUMP_LABEL (INSN),
1702 or indirectly through more levels of jumps. */
1703 delete_related_insns (lab
);
1705 /* I feel a little doubtful about this loop,
1706 but I see no clean and sure alternative way
1707 to find the first insn after INSN that is not now deleted.
1708 I hope this works. */
1709 while (next
&& INSN_DELETED_P (next
))
1710 next
= NEXT_INSN (next
);
1713 else if (tablejump_p (insn
, NULL
, &lab_next
))
1715 /* If we're deleting the tablejump, delete the dispatch table.
1716 We may not be able to kill the label immediately preceding
1717 just yet, as it might be referenced in code leading up to
1719 delete_related_insns (lab_next
);
1723 /* Likewise if we're deleting a dispatch table. */
1725 if (GET_CODE (insn
) == JUMP_INSN
1726 && (GET_CODE (PATTERN (insn
)) == ADDR_VEC
1727 || GET_CODE (PATTERN (insn
)) == ADDR_DIFF_VEC
))
1729 rtx pat
= PATTERN (insn
);
1730 int i
, diff_vec_p
= GET_CODE (pat
) == ADDR_DIFF_VEC
;
1731 int len
= XVECLEN (pat
, diff_vec_p
);
1733 for (i
= 0; i
< len
; i
++)
1734 if (LABEL_NUSES (XEXP (XVECEXP (pat
, diff_vec_p
, i
), 0)) == 0)
1735 delete_related_insns (XEXP (XVECEXP (pat
, diff_vec_p
, i
), 0));
1736 while (next
&& INSN_DELETED_P (next
))
1737 next
= NEXT_INSN (next
);
1741 /* Likewise for an ordinary INSN / CALL_INSN with a REG_LABEL note. */
1742 if (GET_CODE (insn
) == INSN
|| GET_CODE (insn
) == CALL_INSN
)
1743 for (note
= REG_NOTES (insn
); note
; note
= XEXP (note
, 1))
1744 if (REG_NOTE_KIND (note
) == REG_LABEL
1745 /* This could also be a NOTE_INSN_DELETED_LABEL note. */
1746 && GET_CODE (XEXP (note
, 0)) == CODE_LABEL
)
1747 if (LABEL_NUSES (XEXP (note
, 0)) == 0)
1748 delete_related_insns (XEXP (note
, 0));
1750 while (prev
&& (INSN_DELETED_P (prev
) || GET_CODE (prev
) == NOTE
))
1751 prev
= PREV_INSN (prev
);
1753 /* If INSN was a label and a dispatch table follows it,
1754 delete the dispatch table. The tablejump must have gone already.
1755 It isn't useful to fall through into a table. */
1758 && NEXT_INSN (insn
) != 0
1759 && GET_CODE (NEXT_INSN (insn
)) == JUMP_INSN
1760 && (GET_CODE (PATTERN (NEXT_INSN (insn
))) == ADDR_VEC
1761 || GET_CODE (PATTERN (NEXT_INSN (insn
))) == ADDR_DIFF_VEC
))
1762 next
= delete_related_insns (NEXT_INSN (insn
));
1764 /* If INSN was a label, delete insns following it if now unreachable. */
1766 if (was_code_label
&& prev
&& GET_CODE (prev
) == BARRIER
)
1771 code
= GET_CODE (next
);
1773 && NOTE_LINE_NUMBER (next
) != NOTE_INSN_FUNCTION_END
)
1774 next
= NEXT_INSN (next
);
1775 /* Keep going past other deleted labels to delete what follows. */
1776 else if (code
== CODE_LABEL
&& INSN_DELETED_P (next
))
1777 next
= NEXT_INSN (next
);
1778 else if (code
== BARRIER
|| INSN_P (next
))
1779 /* Note: if this deletes a jump, it can cause more
1780 deletion of unreachable code, after a different label.
1781 As long as the value from this recursive call is correct,
1782 this invocation functions correctly. */
1783 next
= delete_related_insns (next
);
1792 /* Delete a range of insns from FROM to TO, inclusive.
1793 This is for the sake of peephole optimization, so assume
1794 that whatever these insns do will still be done by a new
1795 peephole insn that will replace them. */
1798 delete_for_peephole (rtx from
, rtx to
)
1804 rtx next
= NEXT_INSN (insn
);
1805 rtx prev
= PREV_INSN (insn
);
1807 if (GET_CODE (insn
) != NOTE
)
1809 INSN_DELETED_P (insn
) = 1;
1811 /* Patch this insn out of the chain. */
1812 /* We don't do this all at once, because we
1813 must preserve all NOTEs. */
1815 NEXT_INSN (prev
) = next
;
1818 PREV_INSN (next
) = prev
;
1826 /* Note that if TO is an unconditional jump
1827 we *do not* delete the BARRIER that follows,
1828 since the peephole that replaces this sequence
1829 is also an unconditional jump in that case. */
1832 /* We have determined that AVOIDED_INSN is never reached, and are
1833 about to delete it. If the insn chain between AVOIDED_INSN and
1834 FINISH contains more than one line from the current function, and
1835 contains at least one operation, print a warning if the user asked
1836 for it. If FINISH is NULL, look between AVOIDED_INSN and a LABEL.
1838 CSE and inlining can duplicate insns, so it's possible to get
1839 spurious warnings from this. */
1842 never_reached_warning (rtx avoided_insn
, rtx finish
)
1845 rtx a_line_note
= NULL
;
1846 int two_avoided_lines
= 0, contains_insn
= 0, reached_end
= 0;
1848 if (!warn_notreached
)
1851 /* Back up to the first of any NOTEs preceding avoided_insn; flow passes
1852 us the head of a block, a NOTE_INSN_BASIC_BLOCK, which often follows
1854 insn
= avoided_insn
;
1857 rtx prev
= PREV_INSN (insn
);
1858 if (prev
== NULL_RTX
1859 || GET_CODE (prev
) != NOTE
)
1864 /* Scan forwards, looking at LINE_NUMBER notes, until we hit a LABEL
1865 in case FINISH is NULL, otherwise until we run out of insns. */
1867 for (; insn
!= NULL
; insn
= NEXT_INSN (insn
))
1869 if ((finish
== NULL
&& GET_CODE (insn
) == CODE_LABEL
)
1870 || GET_CODE (insn
) == BARRIER
)
1873 if (GET_CODE (insn
) == NOTE
/* A line number note? */
1874 && NOTE_LINE_NUMBER (insn
) >= 0)
1876 if (a_line_note
== NULL
)
1879 two_avoided_lines
|= (NOTE_LINE_NUMBER (a_line_note
)
1880 != NOTE_LINE_NUMBER (insn
));
1882 else if (INSN_P (insn
))
1892 if (two_avoided_lines
&& contains_insn
)
1895 locus
.file
= NOTE_SOURCE_FILE (a_line_note
);
1896 locus
.line
= NOTE_LINE_NUMBER (a_line_note
);
1897 warning ("%Hwill never be executed", &locus
);
1901 /* Throughout LOC, redirect OLABEL to NLABEL. Treat null OLABEL or
1902 NLABEL as a return. Accrue modifications into the change group. */
1905 redirect_exp_1 (rtx
*loc
, rtx olabel
, rtx nlabel
, rtx insn
)
1908 RTX_CODE code
= GET_CODE (x
);
1912 if (code
== LABEL_REF
)
1914 if (XEXP (x
, 0) == olabel
)
1918 n
= gen_rtx_LABEL_REF (VOIDmode
, nlabel
);
1920 n
= gen_rtx_RETURN (VOIDmode
);
1922 validate_change (insn
, loc
, n
, 1);
1926 else if (code
== RETURN
&& olabel
== 0)
1928 x
= gen_rtx_LABEL_REF (VOIDmode
, nlabel
);
1929 if (loc
== &PATTERN (insn
))
1930 x
= gen_rtx_SET (VOIDmode
, pc_rtx
, x
);
1931 validate_change (insn
, loc
, x
, 1);
1935 if (code
== SET
&& nlabel
== 0 && SET_DEST (x
) == pc_rtx
1936 && GET_CODE (SET_SRC (x
)) == LABEL_REF
1937 && XEXP (SET_SRC (x
), 0) == olabel
)
1939 validate_change (insn
, loc
, gen_rtx_RETURN (VOIDmode
), 1);
1943 fmt
= GET_RTX_FORMAT (code
);
1944 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
1947 redirect_exp_1 (&XEXP (x
, i
), olabel
, nlabel
, insn
);
1948 else if (fmt
[i
] == 'E')
1951 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
1952 redirect_exp_1 (&XVECEXP (x
, i
, j
), olabel
, nlabel
, insn
);
1957 /* Similar, but apply the change group and report success or failure. */
1960 redirect_exp (rtx olabel
, rtx nlabel
, rtx insn
)
1964 if (GET_CODE (PATTERN (insn
)) == PARALLEL
)
1965 loc
= &XVECEXP (PATTERN (insn
), 0, 0);
1967 loc
= &PATTERN (insn
);
1969 redirect_exp_1 (loc
, olabel
, nlabel
, insn
);
1970 if (num_validated_changes () == 0)
1973 return apply_change_group ();
1976 /* Make JUMP go to NLABEL instead of where it jumps now. Accrue
1977 the modifications into the change group. Return false if we did
1978 not see how to do that. */
1981 redirect_jump_1 (rtx jump
, rtx nlabel
)
1983 int ochanges
= num_validated_changes ();
1986 if (GET_CODE (PATTERN (jump
)) == PARALLEL
)
1987 loc
= &XVECEXP (PATTERN (jump
), 0, 0);
1989 loc
= &PATTERN (jump
);
1991 redirect_exp_1 (loc
, JUMP_LABEL (jump
), nlabel
, jump
);
1992 return num_validated_changes () > ochanges
;
1995 /* Make JUMP go to NLABEL instead of where it jumps now. If the old
1996 jump target label is unused as a result, it and the code following
1999 If NLABEL is zero, we are to turn the jump into a (possibly conditional)
2002 The return value will be 1 if the change was made, 0 if it wasn't
2003 (this can only occur for NLABEL == 0). */
2006 redirect_jump (rtx jump
, rtx nlabel
, int delete_unused
)
2008 rtx olabel
= JUMP_LABEL (jump
);
2011 if (nlabel
== olabel
)
2014 if (! redirect_exp (olabel
, nlabel
, jump
))
2017 JUMP_LABEL (jump
) = nlabel
;
2019 ++LABEL_NUSES (nlabel
);
2021 /* Update labels in any REG_EQUAL note. */
2022 if ((note
= find_reg_note (jump
, REG_EQUAL
, NULL_RTX
)) != NULL_RTX
)
2024 if (nlabel
&& olabel
)
2026 rtx dest
= XEXP (note
, 0);
2028 if (GET_CODE (dest
) == IF_THEN_ELSE
)
2030 if (GET_CODE (XEXP (dest
, 1)) == LABEL_REF
2031 && XEXP (XEXP (dest
, 1), 0) == olabel
)
2032 XEXP (XEXP (dest
, 1), 0) = nlabel
;
2033 if (GET_CODE (XEXP (dest
, 2)) == LABEL_REF
2034 && XEXP (XEXP (dest
, 2), 0) == olabel
)
2035 XEXP (XEXP (dest
, 2), 0) = nlabel
;
2038 remove_note (jump
, note
);
2041 remove_note (jump
, note
);
2044 /* If we're eliding the jump over exception cleanups at the end of a
2045 function, move the function end note so that -Wreturn-type works. */
2046 if (olabel
&& nlabel
2047 && NEXT_INSN (olabel
)
2048 && GET_CODE (NEXT_INSN (olabel
)) == NOTE
2049 && NOTE_LINE_NUMBER (NEXT_INSN (olabel
)) == NOTE_INSN_FUNCTION_END
)
2050 emit_note_after (NOTE_INSN_FUNCTION_END
, nlabel
);
2052 if (olabel
&& --LABEL_NUSES (olabel
) == 0 && delete_unused
2053 /* Undefined labels will remain outside the insn stream. */
2054 && INSN_UID (olabel
))
2055 delete_related_insns (olabel
);
2060 /* Invert the jump condition of rtx X contained in jump insn, INSN.
2061 Accrue the modifications into the change group. */
2064 invert_exp_1 (rtx insn
)
2067 rtx x
= pc_set (insn
);
2073 code
= GET_CODE (x
);
2075 if (code
== IF_THEN_ELSE
)
2077 rtx comp
= XEXP (x
, 0);
2079 enum rtx_code reversed_code
;
2081 /* We can do this in two ways: The preferable way, which can only
2082 be done if this is not an integer comparison, is to reverse
2083 the comparison code. Otherwise, swap the THEN-part and ELSE-part
2084 of the IF_THEN_ELSE. If we can't do either, fail. */
2086 reversed_code
= reversed_comparison_code (comp
, insn
);
2088 if (reversed_code
!= UNKNOWN
)
2090 validate_change (insn
, &XEXP (x
, 0),
2091 gen_rtx_fmt_ee (reversed_code
,
2092 GET_MODE (comp
), XEXP (comp
, 0),
2099 validate_change (insn
, &XEXP (x
, 1), XEXP (x
, 2), 1);
2100 validate_change (insn
, &XEXP (x
, 2), tem
, 1);
2106 /* Invert the jump condition of conditional jump insn, INSN.
2108 Return 1 if we can do so, 0 if we cannot find a way to do so that
2109 matches a pattern. */
2112 invert_exp (rtx insn
)
2114 invert_exp_1 (insn
);
2115 if (num_validated_changes () == 0)
2118 return apply_change_group ();
2121 /* Invert the condition of the jump JUMP, and make it jump to label
2122 NLABEL instead of where it jumps now. Accrue changes into the
2123 change group. Return false if we didn't see how to perform the
2124 inversion and redirection. */
2127 invert_jump_1 (rtx jump
, rtx nlabel
)
2131 ochanges
= num_validated_changes ();
2132 invert_exp_1 (jump
);
2133 if (num_validated_changes () == ochanges
)
2136 return redirect_jump_1 (jump
, nlabel
);
2139 /* Invert the condition of the jump JUMP, and make it jump to label
2140 NLABEL instead of where it jumps now. Return true if successful. */
2143 invert_jump (rtx jump
, rtx nlabel
, int delete_unused
)
2145 /* We have to either invert the condition and change the label or
2146 do neither. Either operation could fail. We first try to invert
2147 the jump. If that succeeds, we try changing the label. If that fails,
2148 we invert the jump back to what it was. */
2150 if (! invert_exp (jump
))
2153 if (redirect_jump (jump
, nlabel
, delete_unused
))
2155 /* Remove REG_EQUAL note if we have one. */
2156 rtx note
= find_reg_note (jump
, REG_EQUAL
, NULL_RTX
);
2158 remove_note (jump
, note
);
2160 invert_br_probabilities (jump
);
2165 if (! invert_exp (jump
))
2166 /* This should just be putting it back the way it was. */
2173 /* Like rtx_equal_p except that it considers two REGs as equal
2174 if they renumber to the same value and considers two commutative
2175 operations to be the same if the order of the operands has been
2178 ??? Addition is not commutative on the PA due to the weird implicit
2179 space register selection rules for memory addresses. Therefore, we
2180 don't consider a + b == b + a.
2182 We could/should make this test a little tighter. Possibly only
2183 disabling it on the PA via some backend macro or only disabling this
2184 case when the PLUS is inside a MEM. */
2187 rtx_renumbered_equal_p (rtx x
, rtx y
)
2190 enum rtx_code code
= GET_CODE (x
);
2196 if ((code
== REG
|| (code
== SUBREG
&& GET_CODE (SUBREG_REG (x
)) == REG
))
2197 && (GET_CODE (y
) == REG
|| (GET_CODE (y
) == SUBREG
2198 && GET_CODE (SUBREG_REG (y
)) == REG
)))
2200 int reg_x
= -1, reg_y
= -1;
2201 int byte_x
= 0, byte_y
= 0;
2203 if (GET_MODE (x
) != GET_MODE (y
))
2206 /* If we haven't done any renumbering, don't
2207 make any assumptions. */
2208 if (reg_renumber
== 0)
2209 return rtx_equal_p (x
, y
);
2213 reg_x
= REGNO (SUBREG_REG (x
));
2214 byte_x
= SUBREG_BYTE (x
);
2216 if (reg_renumber
[reg_x
] >= 0)
2218 reg_x
= subreg_regno_offset (reg_renumber
[reg_x
],
2219 GET_MODE (SUBREG_REG (x
)),
2228 if (reg_renumber
[reg_x
] >= 0)
2229 reg_x
= reg_renumber
[reg_x
];
2232 if (GET_CODE (y
) == SUBREG
)
2234 reg_y
= REGNO (SUBREG_REG (y
));
2235 byte_y
= SUBREG_BYTE (y
);
2237 if (reg_renumber
[reg_y
] >= 0)
2239 reg_y
= subreg_regno_offset (reg_renumber
[reg_y
],
2240 GET_MODE (SUBREG_REG (y
)),
2249 if (reg_renumber
[reg_y
] >= 0)
2250 reg_y
= reg_renumber
[reg_y
];
2253 return reg_x
>= 0 && reg_x
== reg_y
&& byte_x
== byte_y
;
2256 /* Now we have disposed of all the cases
2257 in which different rtx codes can match. */
2258 if (code
!= GET_CODE (y
))
2271 /* We can't assume nonlocal labels have their following insns yet. */
2272 if (LABEL_REF_NONLOCAL_P (x
) || LABEL_REF_NONLOCAL_P (y
))
2273 return XEXP (x
, 0) == XEXP (y
, 0);
2275 /* Two label-refs are equivalent if they point at labels
2276 in the same position in the instruction stream. */
2277 return (next_real_insn (XEXP (x
, 0))
2278 == next_real_insn (XEXP (y
, 0)));
2281 return XSTR (x
, 0) == XSTR (y
, 0);
2284 /* If we didn't match EQ equality above, they aren't the same. */
2291 /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent. */
2293 if (GET_MODE (x
) != GET_MODE (y
))
2296 /* For commutative operations, the RTX match if the operand match in any
2297 order. Also handle the simple binary and unary cases without a loop.
2299 ??? Don't consider PLUS a commutative operator; see comments above. */
2300 if (COMMUTATIVE_P (x
) && code
!= PLUS
)
2301 return ((rtx_renumbered_equal_p (XEXP (x
, 0), XEXP (y
, 0))
2302 && rtx_renumbered_equal_p (XEXP (x
, 1), XEXP (y
, 1)))
2303 || (rtx_renumbered_equal_p (XEXP (x
, 0), XEXP (y
, 1))
2304 && rtx_renumbered_equal_p (XEXP (x
, 1), XEXP (y
, 0))));
2305 else if (NON_COMMUTATIVE_P (x
))
2306 return (rtx_renumbered_equal_p (XEXP (x
, 0), XEXP (y
, 0))
2307 && rtx_renumbered_equal_p (XEXP (x
, 1), XEXP (y
, 1)));
2308 else if (UNARY_P (x
))
2309 return rtx_renumbered_equal_p (XEXP (x
, 0), XEXP (y
, 0));
2311 /* Compare the elements. If any pair of corresponding elements
2312 fail to match, return 0 for the whole things. */
2314 fmt
= GET_RTX_FORMAT (code
);
2315 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
2321 if (XWINT (x
, i
) != XWINT (y
, i
))
2326 if (XINT (x
, i
) != XINT (y
, i
))
2331 if (XTREE (x
, i
) != XTREE (y
, i
))
2336 if (strcmp (XSTR (x
, i
), XSTR (y
, i
)))
2341 if (! rtx_renumbered_equal_p (XEXP (x
, i
), XEXP (y
, i
)))
2346 if (XEXP (x
, i
) != XEXP (y
, i
))
2353 if (XVECLEN (x
, i
) != XVECLEN (y
, i
))
2355 for (j
= XVECLEN (x
, i
) - 1; j
>= 0; j
--)
2356 if (!rtx_renumbered_equal_p (XVECEXP (x
, i
, j
), XVECEXP (y
, i
, j
)))
2367 /* If X is a hard register or equivalent to one or a subregister of one,
2368 return the hard register number. If X is a pseudo register that was not
2369 assigned a hard register, return the pseudo register number. Otherwise,
2370 return -1. Any rtx is valid for X. */
2375 if (GET_CODE (x
) == REG
)
2377 if (REGNO (x
) >= FIRST_PSEUDO_REGISTER
&& reg_renumber
[REGNO (x
)] >= 0)
2378 return reg_renumber
[REGNO (x
)];
2381 if (GET_CODE (x
) == SUBREG
)
2383 int base
= true_regnum (SUBREG_REG (x
));
2384 if (base
>= 0 && base
< FIRST_PSEUDO_REGISTER
)
2385 return base
+ subreg_regno_offset (REGNO (SUBREG_REG (x
)),
2386 GET_MODE (SUBREG_REG (x
)),
2387 SUBREG_BYTE (x
), GET_MODE (x
));
2392 /* Return regno of the register REG and handle subregs too. */
2394 reg_or_subregno (rtx reg
)
2398 if (GET_CODE (reg
) == SUBREG
)
2399 return REGNO (SUBREG_REG (reg
));