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))++;
96 /* Some old code expects exactly one BARRIER as the NEXT_INSN of a
97 non-fallthru insn. This is not generally true, as multiple barriers
98 may have crept in, or the BARRIER may be separated from the last
99 real insn by one or more NOTEs.
101 This simple pass moves barriers and removes duplicates so that the
107 rtx insn
, next
, prev
;
108 for (insn
= get_insns (); insn
; insn
= next
)
110 next
= NEXT_INSN (insn
);
111 if (GET_CODE (insn
) == BARRIER
)
113 prev
= prev_nonnote_insn (insn
);
114 if (GET_CODE (prev
) == BARRIER
)
115 delete_barrier (insn
);
116 else if (prev
!= PREV_INSN (insn
))
117 reorder_insns (insn
, insn
, prev
);
123 copy_loop_headers (f
)
127 /* Now iterate optimizing jumps until nothing changes over one pass. */
128 for (insn
= f
; insn
; insn
= next
)
132 next
= NEXT_INSN (insn
);
134 /* See if this is a NOTE_INSN_LOOP_BEG followed by an unconditional
135 jump. Try to optimize by duplicating the loop exit test if so.
136 This is only safe immediately after regscan, because it uses
137 the values of regno_first_uid and regno_last_uid. */
138 if (GET_CODE (insn
) == NOTE
139 && NOTE_LINE_NUMBER (insn
) == NOTE_INSN_LOOP_BEG
140 && (temp1
= next_nonnote_insn (insn
)) != 0
141 && any_uncondjump_p (temp1
) && onlyjump_p (temp1
))
143 temp
= PREV_INSN (insn
);
144 if (duplicate_loop_exit_test (insn
))
146 next
= NEXT_INSN (temp
);
153 purge_line_number_notes (f
)
158 /* Delete extraneous line number notes.
159 Note that two consecutive notes for different lines are not really
160 extraneous. There should be some indication where that line belonged,
161 even if it became empty. */
163 for (insn
= f
; insn
; insn
= NEXT_INSN (insn
))
164 if (GET_CODE (insn
) == NOTE
)
166 if (NOTE_LINE_NUMBER (insn
) == NOTE_INSN_FUNCTION_BEG
)
167 /* Any previous line note was for the prologue; gdb wants a new
168 note after the prologue even if it is for the same line. */
169 last_note
= NULL_RTX
;
170 else if (NOTE_LINE_NUMBER (insn
) >= 0)
172 /* Delete this note if it is identical to previous note. */
174 && NOTE_SOURCE_FILE (insn
) == NOTE_SOURCE_FILE (last_note
)
175 && NOTE_LINE_NUMBER (insn
) == NOTE_LINE_NUMBER (last_note
))
177 delete_related_insns (insn
);
186 /* Initialize LABEL_NUSES and JUMP_LABEL fields. Delete any REG_LABEL
187 notes whose labels don't occur in the insn any more. Returns the
188 largest INSN_UID found. */
196 for (insn
= f
; insn
; insn
= NEXT_INSN (insn
))
198 if (GET_CODE (insn
) == CODE_LABEL
)
199 LABEL_NUSES (insn
) = (LABEL_PRESERVE_P (insn
) != 0);
200 else if (GET_CODE (insn
) == JUMP_INSN
)
201 JUMP_LABEL (insn
) = 0;
202 else if (GET_CODE (insn
) == INSN
|| GET_CODE (insn
) == CALL_INSN
)
206 for (note
= REG_NOTES (insn
); note
; note
= next
)
208 next
= XEXP (note
, 1);
209 if (REG_NOTE_KIND (note
) == REG_LABEL
210 && ! reg_mentioned_p (XEXP (note
, 0), PATTERN (insn
)))
211 remove_note (insn
, note
);
214 if (INSN_UID (insn
) > largest_uid
)
215 largest_uid
= INSN_UID (insn
);
221 /* Mark the label each jump jumps to.
222 Combine consecutive labels, and count uses of labels. */
230 for (insn
= f
; insn
; insn
= NEXT_INSN (insn
))
233 if (GET_CODE (insn
) == CALL_INSN
234 && GET_CODE (PATTERN (insn
)) == CALL_PLACEHOLDER
)
236 mark_all_labels (XEXP (PATTERN (insn
), 0));
237 mark_all_labels (XEXP (PATTERN (insn
), 1));
238 mark_all_labels (XEXP (PATTERN (insn
), 2));
240 /* Canonicalize the tail recursion label attached to the
241 CALL_PLACEHOLDER insn. */
242 if (XEXP (PATTERN (insn
), 3))
244 rtx label_ref
= gen_rtx_LABEL_REF (VOIDmode
,
245 XEXP (PATTERN (insn
), 3));
246 mark_jump_label (label_ref
, insn
, 0);
247 XEXP (PATTERN (insn
), 3) = XEXP (label_ref
, 0);
253 mark_jump_label (PATTERN (insn
), insn
, 0);
254 if (! INSN_DELETED_P (insn
) && GET_CODE (insn
) == JUMP_INSN
)
256 /* When we know the LABEL_REF contained in a REG used in
257 an indirect jump, we'll have a REG_LABEL note so that
258 flow can tell where it's going. */
259 if (JUMP_LABEL (insn
) == 0)
261 rtx label_note
= find_reg_note (insn
, REG_LABEL
, NULL_RTX
);
264 /* But a LABEL_REF around the REG_LABEL note, so
265 that we can canonicalize it. */
266 rtx label_ref
= gen_rtx_LABEL_REF (VOIDmode
,
267 XEXP (label_note
, 0));
269 mark_jump_label (label_ref
, insn
, 0);
270 XEXP (label_note
, 0) = XEXP (label_ref
, 0);
271 JUMP_LABEL (insn
) = XEXP (label_note
, 0);
278 /* LOOP_START is a NOTE_INSN_LOOP_BEG note that is followed by an unconditional
279 jump. Assume that this unconditional jump is to the exit test code. If
280 the code is sufficiently simple, make a copy of it before INSN,
281 followed by a jump to the exit of the loop. Then delete the unconditional
284 Return 1 if we made the change, else 0.
286 This is only safe immediately after a regscan pass because it uses the
287 values of regno_first_uid and regno_last_uid. */
290 duplicate_loop_exit_test (loop_start
)
293 rtx insn
, set
, reg
, p
, link
;
294 rtx copy
= 0, first_copy
= 0;
296 rtx exitcode
= NEXT_INSN (JUMP_LABEL (next_nonnote_insn (loop_start
)));
298 int max_reg
= max_reg_num ();
300 rtx loop_pre_header_label
;
302 /* Scan the exit code. We do not perform this optimization if any insn:
306 has a REG_RETVAL or REG_LIBCALL note (hard to adjust)
307 is a NOTE_INSN_LOOP_BEG because this means we have a nested loop
308 is a NOTE_INSN_BLOCK_{BEG,END} because duplicating these notes
311 We also do not do this if we find an insn with ASM_OPERANDS. While
312 this restriction should not be necessary, copying an insn with
313 ASM_OPERANDS can confuse asm_noperands in some cases.
315 Also, don't do this if the exit code is more than 20 insns. */
317 for (insn
= exitcode
;
319 && ! (GET_CODE (insn
) == NOTE
320 && NOTE_LINE_NUMBER (insn
) == NOTE_INSN_LOOP_END
);
321 insn
= NEXT_INSN (insn
))
323 switch (GET_CODE (insn
))
329 /* We could be in front of the wrong NOTE_INSN_LOOP_END if there is
330 a jump immediately after the loop start that branches outside
331 the loop but within an outer loop, near the exit test.
332 If we copied this exit test and created a phony
333 NOTE_INSN_LOOP_VTOP, this could make instructions immediately
334 before the exit test look like these could be safely moved
335 out of the loop even if they actually may be never executed.
336 This can be avoided by checking here for NOTE_INSN_LOOP_CONT. */
338 if (NOTE_LINE_NUMBER (insn
) == NOTE_INSN_LOOP_BEG
339 || NOTE_LINE_NUMBER (insn
) == NOTE_INSN_LOOP_CONT
)
343 && (NOTE_LINE_NUMBER (insn
) == NOTE_INSN_BLOCK_BEG
344 || NOTE_LINE_NUMBER (insn
) == NOTE_INSN_BLOCK_END
))
345 /* If we were to duplicate this code, we would not move
346 the BLOCK notes, and so debugging the moved code would
347 be difficult. Thus, we only move the code with -O2 or
354 /* The code below would grossly mishandle REG_WAS_0 notes,
355 so get rid of them here. */
356 while ((p
= find_reg_note (insn
, REG_WAS_0
, NULL_RTX
)) != 0)
357 remove_note (insn
, p
);
359 || find_reg_note (insn
, REG_RETVAL
, NULL_RTX
)
360 || find_reg_note (insn
, REG_LIBCALL
, NULL_RTX
))
368 /* Unless INSN is zero, we can do the optimization. */
374 /* See if any insn sets a register only used in the loop exit code and
375 not a user variable. If so, replace it with a new register. */
376 for (insn
= exitcode
; insn
!= lastexit
; insn
= NEXT_INSN (insn
))
377 if (GET_CODE (insn
) == INSN
378 && (set
= single_set (insn
)) != 0
379 && ((reg
= SET_DEST (set
), GET_CODE (reg
) == REG
)
380 || (GET_CODE (reg
) == SUBREG
381 && (reg
= SUBREG_REG (reg
), GET_CODE (reg
) == REG
)))
382 && REGNO (reg
) >= FIRST_PSEUDO_REGISTER
383 && REGNO_FIRST_UID (REGNO (reg
)) == INSN_UID (insn
))
385 for (p
= NEXT_INSN (insn
); p
!= lastexit
; p
= NEXT_INSN (p
))
386 if (REGNO_LAST_UID (REGNO (reg
)) == INSN_UID (p
))
391 /* We can do the replacement. Allocate reg_map if this is the
392 first replacement we found. */
394 reg_map
= (rtx
*) xcalloc (max_reg
, sizeof (rtx
));
396 REG_LOOP_TEST_P (reg
) = 1;
398 reg_map
[REGNO (reg
)] = gen_reg_rtx (GET_MODE (reg
));
401 loop_pre_header_label
= gen_label_rtx ();
403 /* Now copy each insn. */
404 for (insn
= exitcode
; insn
!= lastexit
; insn
= NEXT_INSN (insn
))
406 switch (GET_CODE (insn
))
409 copy
= emit_barrier_before (loop_start
);
412 /* Only copy line-number notes. */
413 if (NOTE_LINE_NUMBER (insn
) >= 0)
415 copy
= emit_note_before (NOTE_LINE_NUMBER (insn
), loop_start
);
416 NOTE_SOURCE_FILE (copy
) = NOTE_SOURCE_FILE (insn
);
421 copy
= emit_insn_before (copy_insn (PATTERN (insn
)), loop_start
);
423 replace_regs (PATTERN (copy
), reg_map
, max_reg
, 1);
425 mark_jump_label (PATTERN (copy
), copy
, 0);
427 /* Copy all REG_NOTES except REG_LABEL since mark_jump_label will
429 for (link
= REG_NOTES (insn
); link
; link
= XEXP (link
, 1))
430 if (REG_NOTE_KIND (link
) != REG_LABEL
)
432 if (GET_CODE (link
) == EXPR_LIST
)
434 = copy_insn_1 (gen_rtx_EXPR_LIST (REG_NOTE_KIND (link
),
439 = copy_insn_1 (gen_rtx_INSN_LIST (REG_NOTE_KIND (link
),
444 if (reg_map
&& REG_NOTES (copy
))
445 replace_regs (REG_NOTES (copy
), reg_map
, max_reg
, 1);
449 copy
= emit_jump_insn_before (copy_insn (PATTERN (insn
)),
452 replace_regs (PATTERN (copy
), reg_map
, max_reg
, 1);
453 mark_jump_label (PATTERN (copy
), copy
, 0);
454 if (REG_NOTES (insn
))
456 REG_NOTES (copy
) = copy_insn_1 (REG_NOTES (insn
));
458 replace_regs (REG_NOTES (copy
), reg_map
, max_reg
, 1);
461 /* Predict conditional jump that do make loop looping as taken.
462 Other jumps are probably exit conditions, so predict
464 if (any_condjump_p (copy
))
466 rtx label
= JUMP_LABEL (copy
);
469 /* The jump_insn after loop_start should be followed
470 by barrier and loopback label. */
471 if (prev_nonnote_insn (label
)
472 && (prev_nonnote_insn (prev_nonnote_insn (label
))
473 == next_nonnote_insn (loop_start
)))
475 predict_insn_def (copy
, PRED_LOOP_HEADER
, TAKEN
);
476 /* To keep pre-header, we need to redirect all loop
477 entrances before the LOOP_BEG note. */
478 redirect_jump (copy
, loop_pre_header_label
, 0);
481 predict_insn_def (copy
, PRED_LOOP_HEADER
, NOT_TAKEN
);
490 /* Record the first insn we copied. We need it so that we can
491 scan the copied insns for new pseudo registers. */
496 /* Now clean up by emitting a jump to the end label and deleting the jump
497 at the start of the loop. */
498 if (! copy
|| GET_CODE (copy
) != BARRIER
)
500 copy
= emit_jump_insn_before (gen_jump (get_label_after (insn
)),
503 /* Record the first insn we copied. We need it so that we can
504 scan the copied insns for new pseudo registers. This may not
505 be strictly necessary since we should have copied at least one
506 insn above. But I am going to be safe. */
510 mark_jump_label (PATTERN (copy
), copy
, 0);
511 emit_barrier_before (loop_start
);
514 emit_label_before (loop_pre_header_label
, loop_start
);
516 /* Now scan from the first insn we copied to the last insn we copied
517 (copy) for new pseudo registers. Do this after the code to jump to
518 the end label since that might create a new pseudo too. */
519 reg_scan_update (first_copy
, copy
, max_reg
);
521 /* Mark the exit code as the virtual top of the converted loop. */
522 emit_note_before (NOTE_INSN_LOOP_VTOP
, exitcode
);
524 delete_related_insns (next_nonnote_insn (loop_start
));
533 /* Move all block-beg, block-end, loop-beg, loop-cont, loop-vtop, loop-end,
534 notes between START and END out before START. START and END may be such
535 notes. Returns the values of the new starting and ending insns, which
536 may be different if the original ones were such notes.
537 Return true if there were only such notes and no real instructions. */
540 squeeze_notes (startp
, endp
)
550 rtx past_end
= NEXT_INSN (end
);
552 for (insn
= start
; insn
!= past_end
; insn
= next
)
554 next
= NEXT_INSN (insn
);
555 if (GET_CODE (insn
) == NOTE
556 && (NOTE_LINE_NUMBER (insn
) == NOTE_INSN_BLOCK_END
557 || NOTE_LINE_NUMBER (insn
) == NOTE_INSN_BLOCK_BEG
558 || NOTE_LINE_NUMBER (insn
) == NOTE_INSN_LOOP_BEG
559 || NOTE_LINE_NUMBER (insn
) == NOTE_INSN_LOOP_END
560 || NOTE_LINE_NUMBER (insn
) == NOTE_INSN_LOOP_CONT
561 || NOTE_LINE_NUMBER (insn
) == NOTE_INSN_LOOP_VTOP
))
567 rtx prev
= PREV_INSN (insn
);
568 PREV_INSN (insn
) = PREV_INSN (start
);
569 NEXT_INSN (insn
) = start
;
570 NEXT_INSN (PREV_INSN (insn
)) = insn
;
571 PREV_INSN (NEXT_INSN (insn
)) = insn
;
572 NEXT_INSN (prev
) = next
;
573 PREV_INSN (next
) = prev
;
580 /* There were no real instructions. */
581 if (start
== past_end
)
591 /* Return the label before INSN, or put a new label there. */
594 get_label_before (insn
)
599 /* Find an existing label at this point
600 or make a new one if there is none. */
601 label
= prev_nonnote_insn (insn
);
603 if (label
== 0 || GET_CODE (label
) != CODE_LABEL
)
605 rtx prev
= PREV_INSN (insn
);
607 label
= gen_label_rtx ();
608 emit_label_after (label
, prev
);
609 LABEL_NUSES (label
) = 0;
614 /* Return the label after INSN, or put a new label there. */
617 get_label_after (insn
)
622 /* Find an existing label at this point
623 or make a new one if there is none. */
624 label
= next_nonnote_insn (insn
);
626 if (label
== 0 || GET_CODE (label
) != CODE_LABEL
)
628 label
= gen_label_rtx ();
629 emit_label_after (label
, insn
);
630 LABEL_NUSES (label
) = 0;
635 /* Given a comparison (CODE ARG0 ARG1), inside an insn, INSN, return a code
636 of reversed comparison if it is possible to do so. Otherwise return UNKNOWN.
637 UNKNOWN may be returned in case we are having CC_MODE compare and we don't
638 know whether it's source is floating point or integer comparison. Machine
639 description should define REVERSIBLE_CC_MODE and REVERSE_CONDITION macros
640 to help this function avoid overhead in these cases. */
642 reversed_comparison_code_parts (code
, arg0
, arg1
, insn
)
643 rtx insn
, arg0
, arg1
;
646 enum machine_mode mode
;
648 /* If this is not actually a comparison, we can't reverse it. */
649 if (GET_RTX_CLASS (code
) != '<')
652 mode
= GET_MODE (arg0
);
653 if (mode
== VOIDmode
)
654 mode
= GET_MODE (arg1
);
656 /* First see if machine description supply us way to reverse the comparison.
657 Give it priority over everything else to allow machine description to do
659 #ifdef REVERSIBLE_CC_MODE
660 if (GET_MODE_CLASS (mode
) == MODE_CC
661 && REVERSIBLE_CC_MODE (mode
))
663 #ifdef REVERSE_CONDITION
664 return REVERSE_CONDITION (code
, mode
);
666 return reverse_condition (code
);
670 /* Try a few special cases based on the comparison code. */
679 /* It is always safe to reverse EQ and NE, even for the floating
680 point. Similary the unsigned comparisons are never used for
681 floating point so we can reverse them in the default way. */
682 return reverse_condition (code
);
687 /* In case we already see unordered comparison, we can be sure to
688 be dealing with floating point so we don't need any more tests. */
689 return reverse_condition_maybe_unordered (code
);
694 /* We don't have safe way to reverse these yet. */
700 /* In case we give up IEEE compatibility, all comparisons are reversible. */
701 if (TARGET_FLOAT_FORMAT
!= IEEE_FLOAT_FORMAT
702 || flag_unsafe_math_optimizations
)
703 return reverse_condition (code
);
705 if (GET_MODE_CLASS (mode
) == MODE_CC
712 /* Try to search for the comparison to determine the real mode.
713 This code is expensive, but with sane machine description it
714 will be never used, since REVERSIBLE_CC_MODE will return true
719 for (prev
= prev_nonnote_insn (insn
);
720 prev
!= 0 && GET_CODE (prev
) != CODE_LABEL
;
721 prev
= prev_nonnote_insn (prev
))
723 rtx set
= set_of (arg0
, prev
);
724 if (set
&& GET_CODE (set
) == SET
725 && rtx_equal_p (SET_DEST (set
), arg0
))
727 rtx src
= SET_SRC (set
);
729 if (GET_CODE (src
) == COMPARE
)
731 rtx comparison
= src
;
732 arg0
= XEXP (src
, 0);
733 mode
= GET_MODE (arg0
);
734 if (mode
== VOIDmode
)
735 mode
= GET_MODE (XEXP (comparison
, 1));
738 /* We can get past reg-reg moves. This may be useful for model
739 of i387 comparisons that first move flag registers around. */
746 /* If register is clobbered in some ununderstandable way,
753 /* An integer condition. */
754 if (GET_CODE (arg0
) == CONST_INT
755 || (GET_MODE (arg0
) != VOIDmode
756 && GET_MODE_CLASS (mode
) != MODE_CC
757 && ! FLOAT_MODE_P (mode
)))
758 return reverse_condition (code
);
763 /* An wrapper around the previous function to take COMPARISON as rtx
764 expression. This simplifies many callers. */
766 reversed_comparison_code (comparison
, insn
)
767 rtx comparison
, insn
;
769 if (GET_RTX_CLASS (GET_CODE (comparison
)) != '<')
771 return reversed_comparison_code_parts (GET_CODE (comparison
),
772 XEXP (comparison
, 0),
773 XEXP (comparison
, 1), insn
);
776 /* Given an rtx-code for a comparison, return the code for the negated
777 comparison. If no such code exists, return UNKNOWN.
779 WATCH OUT! reverse_condition is not safe to use on a jump that might
780 be acting on the results of an IEEE floating point comparison, because
781 of the special treatment of non-signaling nans in comparisons.
782 Use reversed_comparison_code instead. */
785 reverse_condition (code
)
828 /* Similar, but we're allowed to generate unordered comparisons, which
829 makes it safe for IEEE floating-point. Of course, we have to recognize
830 that the target will support them too... */
833 reverse_condition_maybe_unordered (code
)
836 /* Non-IEEE formats don't have unordered conditions. */
837 if (TARGET_FLOAT_FORMAT
!= IEEE_FLOAT_FORMAT
)
838 return reverse_condition (code
);
876 /* Similar, but return the code when two operands of a comparison are swapped.
877 This IS safe for IEEE floating-point. */
880 swap_condition (code
)
923 /* Given a comparison CODE, return the corresponding unsigned comparison.
924 If CODE is an equality comparison or already an unsigned comparison,
928 unsigned_condition (code
)
955 /* Similarly, return the signed version of a comparison. */
958 signed_condition (code
)
985 /* Return non-zero if CODE1 is more strict than CODE2, i.e., if the
986 truth of CODE1 implies the truth of CODE2. */
989 comparison_dominates_p (code1
, code2
)
990 enum rtx_code code1
, code2
;
992 /* UNKNOWN comparison codes can happen as a result of trying to revert
994 They can't match anything, so we have to reject them here. */
995 if (code1
== UNKNOWN
|| code2
== UNKNOWN
)
1004 if (code2
== UNLE
|| code2
== UNGE
)
1009 if (code2
== LE
|| code2
== LEU
|| code2
== GE
|| code2
== GEU
1010 || code2
== ORDERED
)
1015 if (code2
== UNLE
|| code2
== NE
)
1020 if (code2
== LE
|| code2
== NE
|| code2
== ORDERED
|| code2
== LTGT
)
1025 if (code2
== UNGE
|| code2
== NE
)
1030 if (code2
== GE
|| code2
== NE
|| code2
== ORDERED
|| code2
== LTGT
)
1036 if (code2
== ORDERED
)
1041 if (code2
== NE
|| code2
== ORDERED
)
1046 if (code2
== LEU
|| code2
== NE
)
1051 if (code2
== GEU
|| code2
== NE
)
1056 if (code2
== NE
|| code2
== UNEQ
|| code2
== UNLE
|| code2
== UNLT
1057 || code2
== UNGE
|| code2
== UNGT
)
1068 /* Return 1 if INSN is an unconditional jump and nothing else. */
1074 return (GET_CODE (insn
) == JUMP_INSN
1075 && GET_CODE (PATTERN (insn
)) == SET
1076 && GET_CODE (SET_DEST (PATTERN (insn
))) == PC
1077 && GET_CODE (SET_SRC (PATTERN (insn
))) == LABEL_REF
);
1080 /* Return nonzero if INSN is a (possibly) conditional jump
1083 Use this function is deprecated, since we need to support combined
1084 branch and compare insns. Use any_condjump_p instead whenever possible. */
1090 rtx x
= PATTERN (insn
);
1092 if (GET_CODE (x
) != SET
1093 || GET_CODE (SET_DEST (x
)) != PC
)
1097 if (GET_CODE (x
) == LABEL_REF
)
1100 return (GET_CODE (x
) == IF_THEN_ELSE
1101 && ((GET_CODE (XEXP (x
, 2)) == PC
1102 && (GET_CODE (XEXP (x
, 1)) == LABEL_REF
1103 || GET_CODE (XEXP (x
, 1)) == RETURN
))
1104 || (GET_CODE (XEXP (x
, 1)) == PC
1105 && (GET_CODE (XEXP (x
, 2)) == LABEL_REF
1106 || GET_CODE (XEXP (x
, 2)) == RETURN
))));
1111 /* Return nonzero if INSN is a (possibly) conditional jump inside a
1114 Use this function is deprecated, since we need to support combined
1115 branch and compare insns. Use any_condjump_p instead whenever possible. */
1118 condjump_in_parallel_p (insn
)
1121 rtx x
= PATTERN (insn
);
1123 if (GET_CODE (x
) != PARALLEL
)
1126 x
= XVECEXP (x
, 0, 0);
1128 if (GET_CODE (x
) != SET
)
1130 if (GET_CODE (SET_DEST (x
)) != PC
)
1132 if (GET_CODE (SET_SRC (x
)) == LABEL_REF
)
1134 if (GET_CODE (SET_SRC (x
)) != IF_THEN_ELSE
)
1136 if (XEXP (SET_SRC (x
), 2) == pc_rtx
1137 && (GET_CODE (XEXP (SET_SRC (x
), 1)) == LABEL_REF
1138 || GET_CODE (XEXP (SET_SRC (x
), 1)) == RETURN
))
1140 if (XEXP (SET_SRC (x
), 1) == pc_rtx
1141 && (GET_CODE (XEXP (SET_SRC (x
), 2)) == LABEL_REF
1142 || GET_CODE (XEXP (SET_SRC (x
), 2)) == RETURN
))
1147 /* Return set of PC, otherwise NULL. */
1154 if (GET_CODE (insn
) != JUMP_INSN
)
1156 pat
= PATTERN (insn
);
1158 /* The set is allowed to appear either as the insn pattern or
1159 the first set in a PARALLEL. */
1160 if (GET_CODE (pat
) == PARALLEL
)
1161 pat
= XVECEXP (pat
, 0, 0);
1162 if (GET_CODE (pat
) == SET
&& GET_CODE (SET_DEST (pat
)) == PC
)
1168 /* Return true when insn is an unconditional direct jump,
1169 possibly bundled inside a PARALLEL. */
1172 any_uncondjump_p (insn
)
1175 rtx x
= pc_set (insn
);
1178 if (GET_CODE (SET_SRC (x
)) != LABEL_REF
)
1183 /* Return true when insn is a conditional jump. This function works for
1184 instructions containing PC sets in PARALLELs. The instruction may have
1185 various other effects so before removing the jump you must verify
1188 Note that unlike condjump_p it returns false for unconditional jumps. */
1191 any_condjump_p (insn
)
1194 rtx x
= pc_set (insn
);
1199 if (GET_CODE (SET_SRC (x
)) != IF_THEN_ELSE
)
1202 a
= GET_CODE (XEXP (SET_SRC (x
), 1));
1203 b
= GET_CODE (XEXP (SET_SRC (x
), 2));
1205 return ((b
== PC
&& (a
== LABEL_REF
|| a
== RETURN
))
1206 || (a
== PC
&& (b
== LABEL_REF
|| b
== RETURN
)));
1209 /* Return the label of a conditional jump. */
1212 condjump_label (insn
)
1215 rtx x
= pc_set (insn
);
1220 if (GET_CODE (x
) == LABEL_REF
)
1222 if (GET_CODE (x
) != IF_THEN_ELSE
)
1224 if (XEXP (x
, 2) == pc_rtx
&& GET_CODE (XEXP (x
, 1)) == LABEL_REF
)
1226 if (XEXP (x
, 1) == pc_rtx
&& GET_CODE (XEXP (x
, 2)) == LABEL_REF
)
1231 /* Return true if INSN is a (possibly conditional) return insn. */
1234 returnjump_p_1 (loc
, data
)
1236 void *data ATTRIBUTE_UNUSED
;
1240 return x
&& (GET_CODE (x
) == RETURN
1241 || (GET_CODE (x
) == SET
&& SET_IS_RETURN_P (x
)));
1248 if (GET_CODE (insn
) != JUMP_INSN
)
1250 return for_each_rtx (&PATTERN (insn
), returnjump_p_1
, NULL
);
1253 /* Return true if INSN is a jump that only transfers control and
1262 if (GET_CODE (insn
) != JUMP_INSN
)
1265 set
= single_set (insn
);
1268 if (GET_CODE (SET_DEST (set
)) != PC
)
1270 if (side_effects_p (SET_SRC (set
)))
1278 /* Return non-zero if X is an RTX that only sets the condition codes
1279 and has no side effects. */
1292 return sets_cc0_p (x
) == 1 && ! side_effects_p (x
);
1295 /* Return 1 if X is an RTX that does nothing but set the condition codes
1296 and CLOBBER or USE registers.
1297 Return -1 if X does explicitly set the condition codes,
1298 but also does other things. */
1311 if (GET_CODE (x
) == SET
&& SET_DEST (x
) == cc0_rtx
)
1313 if (GET_CODE (x
) == PARALLEL
)
1317 int other_things
= 0;
1318 for (i
= XVECLEN (x
, 0) - 1; i
>= 0; i
--)
1320 if (GET_CODE (XVECEXP (x
, 0, i
)) == SET
1321 && SET_DEST (XVECEXP (x
, 0, i
)) == cc0_rtx
)
1323 else if (GET_CODE (XVECEXP (x
, 0, i
)) == SET
)
1326 return ! sets_cc0
? 0 : other_things
? -1 : 1;
1332 /* Follow any unconditional jump at LABEL;
1333 return the ultimate label reached by any such chain of jumps.
1334 If LABEL is not followed by a jump, return LABEL.
1335 If the chain loops or we can't find end, return LABEL,
1336 since that tells caller to avoid changing the insn.
1338 If RELOAD_COMPLETED is 0, we do not chain across a NOTE_INSN_LOOP_BEG or
1339 a USE or CLOBBER. */
1342 follow_jumps (label
)
1352 && (insn
= next_active_insn (value
)) != 0
1353 && GET_CODE (insn
) == JUMP_INSN
1354 && ((JUMP_LABEL (insn
) != 0 && any_uncondjump_p (insn
)
1355 && onlyjump_p (insn
))
1356 || GET_CODE (PATTERN (insn
)) == RETURN
)
1357 && (next
= NEXT_INSN (insn
))
1358 && GET_CODE (next
) == BARRIER
);
1361 /* Don't chain through the insn that jumps into a loop
1362 from outside the loop,
1363 since that would create multiple loop entry jumps
1364 and prevent loop optimization. */
1366 if (!reload_completed
)
1367 for (tem
= value
; tem
!= insn
; tem
= NEXT_INSN (tem
))
1368 if (GET_CODE (tem
) == NOTE
1369 && (NOTE_LINE_NUMBER (tem
) == NOTE_INSN_LOOP_BEG
1370 /* ??? Optional. Disables some optimizations, but makes
1371 gcov output more accurate with -O. */
1372 || (flag_test_coverage
&& NOTE_LINE_NUMBER (tem
) > 0)))
1375 /* If we have found a cycle, make the insn jump to itself. */
1376 if (JUMP_LABEL (insn
) == label
)
1379 tem
= next_active_insn (JUMP_LABEL (insn
));
1380 if (tem
&& (GET_CODE (PATTERN (tem
)) == ADDR_VEC
1381 || GET_CODE (PATTERN (tem
)) == ADDR_DIFF_VEC
))
1384 value
= JUMP_LABEL (insn
);
1392 /* Find all CODE_LABELs referred to in X, and increment their use counts.
1393 If INSN is a JUMP_INSN and there is at least one CODE_LABEL referenced
1394 in INSN, then store one of them in JUMP_LABEL (INSN).
1395 If INSN is an INSN or a CALL_INSN and there is at least one CODE_LABEL
1396 referenced in INSN, add a REG_LABEL note containing that label to INSN.
1397 Also, when there are consecutive labels, canonicalize on the last of them.
1399 Note that two labels separated by a loop-beginning note
1400 must be kept distinct if we have not yet done loop-optimization,
1401 because the gap between them is where loop-optimize
1402 will want to move invariant code to. CROSS_JUMP tells us
1403 that loop-optimization is done with. */
1406 mark_jump_label (x
, insn
, in_mem
)
1411 RTX_CODE code
= GET_CODE (x
);
1435 /* If this is a constant-pool reference, see if it is a label. */
1436 if (CONSTANT_POOL_ADDRESS_P (x
))
1437 mark_jump_label (get_pool_constant (x
), insn
, in_mem
);
1442 rtx label
= XEXP (x
, 0);
1444 /* Ignore remaining references to unreachable labels that
1445 have been deleted. */
1446 if (GET_CODE (label
) == NOTE
1447 && NOTE_LINE_NUMBER (label
) == NOTE_INSN_DELETED_LABEL
)
1450 if (GET_CODE (label
) != CODE_LABEL
)
1453 /* Ignore references to labels of containing functions. */
1454 if (LABEL_REF_NONLOCAL_P (x
))
1457 XEXP (x
, 0) = label
;
1458 if (! insn
|| ! INSN_DELETED_P (insn
))
1459 ++LABEL_NUSES (label
);
1463 if (GET_CODE (insn
) == JUMP_INSN
)
1464 JUMP_LABEL (insn
) = label
;
1467 /* Add a REG_LABEL note for LABEL unless there already
1468 is one. All uses of a label, except for labels
1469 that are the targets of jumps, must have a
1471 if (! find_reg_note (insn
, REG_LABEL
, label
))
1472 REG_NOTES (insn
) = gen_rtx_INSN_LIST (REG_LABEL
, label
,
1479 /* Do walk the labels in a vector, but not the first operand of an
1480 ADDR_DIFF_VEC. Don't set the JUMP_LABEL of a vector. */
1483 if (! INSN_DELETED_P (insn
))
1485 int eltnum
= code
== ADDR_DIFF_VEC
? 1 : 0;
1487 for (i
= 0; i
< XVECLEN (x
, eltnum
); i
++)
1488 mark_jump_label (XVECEXP (x
, eltnum
, i
), NULL_RTX
, in_mem
);
1496 fmt
= GET_RTX_FORMAT (code
);
1497 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
1500 mark_jump_label (XEXP (x
, i
), insn
, in_mem
);
1501 else if (fmt
[i
] == 'E')
1504 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
1505 mark_jump_label (XVECEXP (x
, i
, j
), insn
, in_mem
);
1510 /* If all INSN does is set the pc, delete it,
1511 and delete the insn that set the condition codes for it
1512 if that's what the previous thing was. */
1518 rtx set
= single_set (insn
);
1520 if (set
&& GET_CODE (SET_DEST (set
)) == PC
)
1521 delete_computation (insn
);
1524 /* Verify INSN is a BARRIER and delete it. */
1527 delete_barrier (insn
)
1530 if (GET_CODE (insn
) != BARRIER
)
1536 /* Recursively delete prior insns that compute the value (used only by INSN
1537 which the caller is deleting) stored in the register mentioned by NOTE
1538 which is a REG_DEAD note associated with INSN. */
1541 delete_prior_computation (note
, insn
)
1546 rtx reg
= XEXP (note
, 0);
1548 for (our_prev
= prev_nonnote_insn (insn
);
1549 our_prev
&& (GET_CODE (our_prev
) == INSN
1550 || GET_CODE (our_prev
) == CALL_INSN
);
1551 our_prev
= prev_nonnote_insn (our_prev
))
1553 rtx pat
= PATTERN (our_prev
);
1555 /* If we reach a CALL which is not calling a const function
1556 or the callee pops the arguments, then give up. */
1557 if (GET_CODE (our_prev
) == CALL_INSN
1558 && (! CONST_OR_PURE_CALL_P (our_prev
)
1559 || GET_CODE (pat
) != SET
|| GET_CODE (SET_SRC (pat
)) != CALL
))
1562 /* If we reach a SEQUENCE, it is too complex to try to
1563 do anything with it, so give up. */
1564 if (GET_CODE (pat
) == SEQUENCE
)
1567 if (GET_CODE (pat
) == USE
1568 && GET_CODE (XEXP (pat
, 0)) == INSN
)
1569 /* reorg creates USEs that look like this. We leave them
1570 alone because reorg needs them for its own purposes. */
1573 if (reg_set_p (reg
, pat
))
1575 if (side_effects_p (pat
) && GET_CODE (our_prev
) != CALL_INSN
)
1578 if (GET_CODE (pat
) == PARALLEL
)
1580 /* If we find a SET of something else, we can't
1585 for (i
= 0; i
< XVECLEN (pat
, 0); i
++)
1587 rtx part
= XVECEXP (pat
, 0, i
);
1589 if (GET_CODE (part
) == SET
1590 && SET_DEST (part
) != reg
)
1594 if (i
== XVECLEN (pat
, 0))
1595 delete_computation (our_prev
);
1597 else if (GET_CODE (pat
) == SET
1598 && GET_CODE (SET_DEST (pat
)) == REG
)
1600 int dest_regno
= REGNO (SET_DEST (pat
));
1603 + (dest_regno
< FIRST_PSEUDO_REGISTER
1604 ? HARD_REGNO_NREGS (dest_regno
,
1605 GET_MODE (SET_DEST (pat
))) : 1));
1606 int regno
= REGNO (reg
);
1609 + (regno
< FIRST_PSEUDO_REGISTER
1610 ? HARD_REGNO_NREGS (regno
, GET_MODE (reg
)) : 1));
1612 if (dest_regno
>= regno
1613 && dest_endregno
<= endregno
)
1614 delete_computation (our_prev
);
1616 /* We may have a multi-word hard register and some, but not
1617 all, of the words of the register are needed in subsequent
1618 insns. Write REG_UNUSED notes for those parts that were not
1620 else if (dest_regno
<= regno
1621 && dest_endregno
>= endregno
)
1625 REG_NOTES (our_prev
)
1626 = gen_rtx_EXPR_LIST (REG_UNUSED
, reg
,
1627 REG_NOTES (our_prev
));
1629 for (i
= dest_regno
; i
< dest_endregno
; i
++)
1630 if (! find_regno_note (our_prev
, REG_UNUSED
, i
))
1633 if (i
== dest_endregno
)
1634 delete_computation (our_prev
);
1641 /* If PAT references the register that dies here, it is an
1642 additional use. Hence any prior SET isn't dead. However, this
1643 insn becomes the new place for the REG_DEAD note. */
1644 if (reg_overlap_mentioned_p (reg
, pat
))
1646 XEXP (note
, 1) = REG_NOTES (our_prev
);
1647 REG_NOTES (our_prev
) = note
;
1653 /* Delete INSN and recursively delete insns that compute values used only
1654 by INSN. This uses the REG_DEAD notes computed during flow analysis.
1655 If we are running before flow.c, we need do nothing since flow.c will
1656 delete dead code. We also can't know if the registers being used are
1657 dead or not at this point.
1659 Otherwise, look at all our REG_DEAD notes. If a previous insn does
1660 nothing other than set a register that dies in this insn, we can delete
1663 On machines with CC0, if CC0 is used in this insn, we may be able to
1664 delete the insn that set it. */
1667 delete_computation (insn
)
1673 if (reg_referenced_p (cc0_rtx
, PATTERN (insn
)))
1675 rtx prev
= prev_nonnote_insn (insn
);
1676 /* We assume that at this stage
1677 CC's are always set explicitly
1678 and always immediately before the jump that
1679 will use them. So if the previous insn
1680 exists to set the CC's, delete it
1681 (unless it performs auto-increments, etc.). */
1682 if (prev
&& GET_CODE (prev
) == INSN
1683 && sets_cc0_p (PATTERN (prev
)))
1685 if (sets_cc0_p (PATTERN (prev
)) > 0
1686 && ! side_effects_p (PATTERN (prev
)))
1687 delete_computation (prev
);
1689 /* Otherwise, show that cc0 won't be used. */
1690 REG_NOTES (prev
) = gen_rtx_EXPR_LIST (REG_UNUSED
,
1691 cc0_rtx
, REG_NOTES (prev
));
1696 for (note
= REG_NOTES (insn
); note
; note
= next
)
1698 next
= XEXP (note
, 1);
1700 if (REG_NOTE_KIND (note
) != REG_DEAD
1701 /* Verify that the REG_NOTE is legitimate. */
1702 || GET_CODE (XEXP (note
, 0)) != REG
)
1705 delete_prior_computation (note
, insn
);
1708 delete_related_insns (insn
);
1711 /* Delete insn INSN from the chain of insns and update label ref counts
1712 and delete insns now unreachable.
1714 Returns the first insn after INSN that was not deleted.
1716 Usage of this instruction is deprecated. Use delete_insn instead and
1717 subsequent cfg_cleanup pass to delete unreachable code if needed. */
1720 delete_related_insns (insn
)
1723 int was_code_label
= (GET_CODE (insn
) == CODE_LABEL
);
1725 rtx next
= NEXT_INSN (insn
), prev
= PREV_INSN (insn
);
1727 while (next
&& INSN_DELETED_P (next
))
1728 next
= NEXT_INSN (next
);
1730 /* This insn is already deleted => return first following nondeleted. */
1731 if (INSN_DELETED_P (insn
))
1736 /* If instruction is followed by a barrier,
1737 delete the barrier too. */
1739 if (next
!= 0 && GET_CODE (next
) == BARRIER
)
1742 /* If deleting a jump, decrement the count of the label,
1743 and delete the label if it is now unused. */
1745 if (GET_CODE (insn
) == JUMP_INSN
&& JUMP_LABEL (insn
))
1747 rtx lab
= JUMP_LABEL (insn
), lab_next
;
1749 if (LABEL_NUSES (lab
) == 0)
1751 /* This can delete NEXT or PREV,
1752 either directly if NEXT is JUMP_LABEL (INSN),
1753 or indirectly through more levels of jumps. */
1754 delete_related_insns (lab
);
1756 /* I feel a little doubtful about this loop,
1757 but I see no clean and sure alternative way
1758 to find the first insn after INSN that is not now deleted.
1759 I hope this works. */
1760 while (next
&& INSN_DELETED_P (next
))
1761 next
= NEXT_INSN (next
);
1764 else if ((lab_next
= next_nonnote_insn (lab
)) != NULL
1765 && GET_CODE (lab_next
) == JUMP_INSN
1766 && (GET_CODE (PATTERN (lab_next
)) == ADDR_VEC
1767 || GET_CODE (PATTERN (lab_next
)) == ADDR_DIFF_VEC
))
1769 /* If we're deleting the tablejump, delete the dispatch table.
1770 We may not be able to kill the label immediately preceding
1771 just yet, as it might be referenced in code leading up to
1773 delete_related_insns (lab_next
);
1777 /* Likewise if we're deleting a dispatch table. */
1779 if (GET_CODE (insn
) == JUMP_INSN
1780 && (GET_CODE (PATTERN (insn
)) == ADDR_VEC
1781 || GET_CODE (PATTERN (insn
)) == ADDR_DIFF_VEC
))
1783 rtx pat
= PATTERN (insn
);
1784 int i
, diff_vec_p
= GET_CODE (pat
) == ADDR_DIFF_VEC
;
1785 int len
= XVECLEN (pat
, diff_vec_p
);
1787 for (i
= 0; i
< len
; i
++)
1788 if (LABEL_NUSES (XEXP (XVECEXP (pat
, diff_vec_p
, i
), 0)) == 0)
1789 delete_related_insns (XEXP (XVECEXP (pat
, diff_vec_p
, i
), 0));
1790 while (next
&& INSN_DELETED_P (next
))
1791 next
= NEXT_INSN (next
);
1795 /* Likewise for an ordinary INSN / CALL_INSN with a REG_LABEL note. */
1796 if (GET_CODE (insn
) == INSN
|| GET_CODE (insn
) == CALL_INSN
)
1797 for (note
= REG_NOTES (insn
); note
; note
= XEXP (note
, 1))
1798 if (REG_NOTE_KIND (note
) == REG_LABEL
1799 /* This could also be a NOTE_INSN_DELETED_LABEL note. */
1800 && GET_CODE (XEXP (note
, 0)) == CODE_LABEL
)
1801 if (LABEL_NUSES (XEXP (note
, 0)) == 0)
1802 delete_related_insns (XEXP (note
, 0));
1804 while (prev
&& (INSN_DELETED_P (prev
) || GET_CODE (prev
) == NOTE
))
1805 prev
= PREV_INSN (prev
);
1807 /* If INSN was a label and a dispatch table follows it,
1808 delete the dispatch table. The tablejump must have gone already.
1809 It isn't useful to fall through into a table. */
1812 && NEXT_INSN (insn
) != 0
1813 && GET_CODE (NEXT_INSN (insn
)) == JUMP_INSN
1814 && (GET_CODE (PATTERN (NEXT_INSN (insn
))) == ADDR_VEC
1815 || GET_CODE (PATTERN (NEXT_INSN (insn
))) == ADDR_DIFF_VEC
))
1816 next
= delete_related_insns (NEXT_INSN (insn
));
1818 /* If INSN was a label, delete insns following it if now unreachable. */
1820 if (was_code_label
&& prev
&& GET_CODE (prev
) == BARRIER
)
1824 && (GET_RTX_CLASS (code
= GET_CODE (next
)) == 'i'
1825 || code
== NOTE
|| code
== BARRIER
1826 || (code
== CODE_LABEL
&& INSN_DELETED_P (next
))))
1829 && NOTE_LINE_NUMBER (next
) != NOTE_INSN_FUNCTION_END
)
1830 next
= NEXT_INSN (next
);
1831 /* Keep going past other deleted labels to delete what follows. */
1832 else if (code
== CODE_LABEL
&& INSN_DELETED_P (next
))
1833 next
= NEXT_INSN (next
);
1835 /* Note: if this deletes a jump, it can cause more
1836 deletion of unreachable code, after a different label.
1837 As long as the value from this recursive call is correct,
1838 this invocation functions correctly. */
1839 next
= delete_related_insns (next
);
1846 /* Advance from INSN till reaching something not deleted
1847 then return that. May return INSN itself. */
1850 next_nondeleted_insn (insn
)
1853 while (INSN_DELETED_P (insn
))
1854 insn
= NEXT_INSN (insn
);
1858 /* Delete a range of insns from FROM to TO, inclusive.
1859 This is for the sake of peephole optimization, so assume
1860 that whatever these insns do will still be done by a new
1861 peephole insn that will replace them. */
1864 delete_for_peephole (from
, to
)
1871 rtx next
= NEXT_INSN (insn
);
1872 rtx prev
= PREV_INSN (insn
);
1874 if (GET_CODE (insn
) != NOTE
)
1876 INSN_DELETED_P (insn
) = 1;
1878 /* Patch this insn out of the chain. */
1879 /* We don't do this all at once, because we
1880 must preserve all NOTEs. */
1882 NEXT_INSN (prev
) = next
;
1885 PREV_INSN (next
) = prev
;
1893 /* Note that if TO is an unconditional jump
1894 we *do not* delete the BARRIER that follows,
1895 since the peephole that replaces this sequence
1896 is also an unconditional jump in that case. */
1899 /* We have determined that INSN is never reached, and are about to
1900 delete it. Print a warning if the user asked for one.
1902 To try to make this warning more useful, this should only be called
1903 once per basic block not reached, and it only warns when the basic
1904 block contains more than one line from the current function, and
1905 contains at least one operation. CSE and inlining can duplicate insns,
1906 so it's possible to get spurious warnings from this. */
1909 never_reached_warning (avoided_insn
, finish
)
1910 rtx avoided_insn
, finish
;
1913 rtx a_line_note
= NULL
;
1914 int two_avoided_lines
= 0, contains_insn
= 0, reached_end
= 0;
1916 if (! warn_notreached
)
1919 /* Scan forwards, looking at LINE_NUMBER notes, until
1920 we hit a LABEL or we run out of insns. */
1922 for (insn
= avoided_insn
; insn
!= NULL
; insn
= NEXT_INSN (insn
))
1924 if (finish
== NULL
&& GET_CODE (insn
) == CODE_LABEL
)
1927 if (GET_CODE (insn
) == NOTE
/* A line number note? */
1928 && NOTE_LINE_NUMBER (insn
) >= 0)
1930 if (a_line_note
== NULL
)
1933 two_avoided_lines
|= (NOTE_LINE_NUMBER (a_line_note
)
1934 != NOTE_LINE_NUMBER (insn
));
1936 else if (INSN_P (insn
))
1946 if (two_avoided_lines
&& contains_insn
)
1947 warning_with_file_and_line (NOTE_SOURCE_FILE (a_line_note
),
1948 NOTE_LINE_NUMBER (a_line_note
),
1949 "will never be executed");
1952 /* Throughout LOC, redirect OLABEL to NLABEL. Treat null OLABEL or
1953 NLABEL as a return. Accrue modifications into the change group. */
1956 redirect_exp_1 (loc
, olabel
, nlabel
, insn
)
1962 RTX_CODE code
= GET_CODE (x
);
1966 if (code
== LABEL_REF
)
1968 if (XEXP (x
, 0) == olabel
)
1972 n
= gen_rtx_LABEL_REF (VOIDmode
, nlabel
);
1974 n
= gen_rtx_RETURN (VOIDmode
);
1976 validate_change (insn
, loc
, n
, 1);
1980 else if (code
== RETURN
&& olabel
== 0)
1982 x
= gen_rtx_LABEL_REF (VOIDmode
, nlabel
);
1983 if (loc
== &PATTERN (insn
))
1984 x
= gen_rtx_SET (VOIDmode
, pc_rtx
, x
);
1985 validate_change (insn
, loc
, x
, 1);
1989 if (code
== SET
&& nlabel
== 0 && SET_DEST (x
) == pc_rtx
1990 && GET_CODE (SET_SRC (x
)) == LABEL_REF
1991 && XEXP (SET_SRC (x
), 0) == olabel
)
1993 validate_change (insn
, loc
, gen_rtx_RETURN (VOIDmode
), 1);
1997 fmt
= GET_RTX_FORMAT (code
);
1998 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
2001 redirect_exp_1 (&XEXP (x
, i
), olabel
, nlabel
, insn
);
2002 else if (fmt
[i
] == 'E')
2005 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
2006 redirect_exp_1 (&XVECEXP (x
, i
, j
), olabel
, nlabel
, insn
);
2011 /* Similar, but apply the change group and report success or failure. */
2014 redirect_exp (olabel
, nlabel
, insn
)
2020 if (GET_CODE (PATTERN (insn
)) == PARALLEL
)
2021 loc
= &XVECEXP (PATTERN (insn
), 0, 0);
2023 loc
= &PATTERN (insn
);
2025 redirect_exp_1 (loc
, olabel
, nlabel
, insn
);
2026 if (num_validated_changes () == 0)
2029 return apply_change_group ();
2032 /* Make JUMP go to NLABEL instead of where it jumps now. Accrue
2033 the modifications into the change group. Return false if we did
2034 not see how to do that. */
2037 redirect_jump_1 (jump
, nlabel
)
2040 int ochanges
= num_validated_changes ();
2043 if (GET_CODE (PATTERN (jump
)) == PARALLEL
)
2044 loc
= &XVECEXP (PATTERN (jump
), 0, 0);
2046 loc
= &PATTERN (jump
);
2048 redirect_exp_1 (loc
, JUMP_LABEL (jump
), nlabel
, jump
);
2049 return num_validated_changes () > ochanges
;
2052 /* Make JUMP go to NLABEL instead of where it jumps now. If the old
2053 jump target label is unused as a result, it and the code following
2056 If NLABEL is zero, we are to turn the jump into a (possibly conditional)
2059 The return value will be 1 if the change was made, 0 if it wasn't
2060 (this can only occur for NLABEL == 0). */
2063 redirect_jump (jump
, nlabel
, delete_unused
)
2067 rtx olabel
= JUMP_LABEL (jump
);
2069 if (nlabel
== olabel
)
2072 if (! redirect_exp (olabel
, nlabel
, jump
))
2075 JUMP_LABEL (jump
) = nlabel
;
2077 ++LABEL_NUSES (nlabel
);
2079 /* If we're eliding the jump over exception cleanups at the end of a
2080 function, move the function end note so that -Wreturn-type works. */
2081 if (olabel
&& nlabel
2082 && NEXT_INSN (olabel
)
2083 && GET_CODE (NEXT_INSN (olabel
)) == NOTE
2084 && NOTE_LINE_NUMBER (NEXT_INSN (olabel
)) == NOTE_INSN_FUNCTION_END
)
2085 emit_note_after (NOTE_INSN_FUNCTION_END
, nlabel
);
2087 if (olabel
&& --LABEL_NUSES (olabel
) == 0 && delete_unused
2088 /* Undefined labels will remain outside the insn stream. */
2089 && INSN_UID (olabel
))
2090 delete_related_insns (olabel
);
2095 /* Invert the jump condition of rtx X contained in jump insn, INSN.
2096 Accrue the modifications into the change group. */
2103 rtx x
= pc_set (insn
);
2109 code
= GET_CODE (x
);
2111 if (code
== IF_THEN_ELSE
)
2113 rtx comp
= XEXP (x
, 0);
2115 enum rtx_code reversed_code
;
2117 /* We can do this in two ways: The preferable way, which can only
2118 be done if this is not an integer comparison, is to reverse
2119 the comparison code. Otherwise, swap the THEN-part and ELSE-part
2120 of the IF_THEN_ELSE. If we can't do either, fail. */
2122 reversed_code
= reversed_comparison_code (comp
, insn
);
2124 if (reversed_code
!= UNKNOWN
)
2126 validate_change (insn
, &XEXP (x
, 0),
2127 gen_rtx_fmt_ee (reversed_code
,
2128 GET_MODE (comp
), XEXP (comp
, 0),
2135 validate_change (insn
, &XEXP (x
, 1), XEXP (x
, 2), 1);
2136 validate_change (insn
, &XEXP (x
, 2), tem
, 1);
2142 /* Invert the jump condition of conditional jump insn, INSN.
2144 Return 1 if we can do so, 0 if we cannot find a way to do so that
2145 matches a pattern. */
2151 invert_exp_1 (insn
);
2152 if (num_validated_changes () == 0)
2155 return apply_change_group ();
2158 /* Invert the condition of the jump JUMP, and make it jump to label
2159 NLABEL instead of where it jumps now. Accrue changes into the
2160 change group. Return false if we didn't see how to perform the
2161 inversion and redirection. */
2164 invert_jump_1 (jump
, nlabel
)
2169 ochanges
= num_validated_changes ();
2170 invert_exp_1 (jump
);
2171 if (num_validated_changes () == ochanges
)
2174 return redirect_jump_1 (jump
, nlabel
);
2177 /* Invert the condition of the jump JUMP, and make it jump to label
2178 NLABEL instead of where it jumps now. Return true if successful. */
2181 invert_jump (jump
, nlabel
, delete_unused
)
2185 /* We have to either invert the condition and change the label or
2186 do neither. Either operation could fail. We first try to invert
2187 the jump. If that succeeds, we try changing the label. If that fails,
2188 we invert the jump back to what it was. */
2190 if (! invert_exp (jump
))
2193 if (redirect_jump (jump
, nlabel
, delete_unused
))
2195 invert_br_probabilities (jump
);
2200 if (! invert_exp (jump
))
2201 /* This should just be putting it back the way it was. */
2208 /* Like rtx_equal_p except that it considers two REGs as equal
2209 if they renumber to the same value and considers two commutative
2210 operations to be the same if the order of the operands has been
2213 ??? Addition is not commutative on the PA due to the weird implicit
2214 space register selection rules for memory addresses. Therefore, we
2215 don't consider a + b == b + a.
2217 We could/should make this test a little tighter. Possibly only
2218 disabling it on the PA via some backend macro or only disabling this
2219 case when the PLUS is inside a MEM. */
2222 rtx_renumbered_equal_p (x
, y
)
2226 RTX_CODE code
= GET_CODE (x
);
2232 if ((code
== REG
|| (code
== SUBREG
&& GET_CODE (SUBREG_REG (x
)) == REG
))
2233 && (GET_CODE (y
) == REG
|| (GET_CODE (y
) == SUBREG
2234 && GET_CODE (SUBREG_REG (y
)) == REG
)))
2236 int reg_x
= -1, reg_y
= -1;
2237 int byte_x
= 0, byte_y
= 0;
2239 if (GET_MODE (x
) != GET_MODE (y
))
2242 /* If we haven't done any renumbering, don't
2243 make any assumptions. */
2244 if (reg_renumber
== 0)
2245 return rtx_equal_p (x
, y
);
2249 reg_x
= REGNO (SUBREG_REG (x
));
2250 byte_x
= SUBREG_BYTE (x
);
2252 if (reg_renumber
[reg_x
] >= 0)
2254 reg_x
= subreg_regno_offset (reg_renumber
[reg_x
],
2255 GET_MODE (SUBREG_REG (x
)),
2264 if (reg_renumber
[reg_x
] >= 0)
2265 reg_x
= reg_renumber
[reg_x
];
2268 if (GET_CODE (y
) == SUBREG
)
2270 reg_y
= REGNO (SUBREG_REG (y
));
2271 byte_y
= SUBREG_BYTE (y
);
2273 if (reg_renumber
[reg_y
] >= 0)
2275 reg_y
= subreg_regno_offset (reg_renumber
[reg_y
],
2276 GET_MODE (SUBREG_REG (y
)),
2285 if (reg_renumber
[reg_y
] >= 0)
2286 reg_y
= reg_renumber
[reg_y
];
2289 return reg_x
>= 0 && reg_x
== reg_y
&& byte_x
== byte_y
;
2292 /* Now we have disposed of all the cases
2293 in which different rtx codes can match. */
2294 if (code
!= GET_CODE (y
))
2306 return INTVAL (x
) == INTVAL (y
);
2309 /* We can't assume nonlocal labels have their following insns yet. */
2310 if (LABEL_REF_NONLOCAL_P (x
) || LABEL_REF_NONLOCAL_P (y
))
2311 return XEXP (x
, 0) == XEXP (y
, 0);
2313 /* Two label-refs are equivalent if they point at labels
2314 in the same position in the instruction stream. */
2315 return (next_real_insn (XEXP (x
, 0))
2316 == next_real_insn (XEXP (y
, 0)));
2319 return XSTR (x
, 0) == XSTR (y
, 0);
2322 /* If we didn't match EQ equality above, they aren't the same. */
2329 /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent. */
2331 if (GET_MODE (x
) != GET_MODE (y
))
2334 /* For commutative operations, the RTX match if the operand match in any
2335 order. Also handle the simple binary and unary cases without a loop.
2337 ??? Don't consider PLUS a commutative operator; see comments above. */
2338 if ((code
== EQ
|| code
== NE
|| GET_RTX_CLASS (code
) == 'c')
2340 return ((rtx_renumbered_equal_p (XEXP (x
, 0), XEXP (y
, 0))
2341 && rtx_renumbered_equal_p (XEXP (x
, 1), XEXP (y
, 1)))
2342 || (rtx_renumbered_equal_p (XEXP (x
, 0), XEXP (y
, 1))
2343 && rtx_renumbered_equal_p (XEXP (x
, 1), XEXP (y
, 0))));
2344 else if (GET_RTX_CLASS (code
) == '<' || GET_RTX_CLASS (code
) == '2')
2345 return (rtx_renumbered_equal_p (XEXP (x
, 0), XEXP (y
, 0))
2346 && rtx_renumbered_equal_p (XEXP (x
, 1), XEXP (y
, 1)));
2347 else if (GET_RTX_CLASS (code
) == '1')
2348 return rtx_renumbered_equal_p (XEXP (x
, 0), XEXP (y
, 0));
2350 /* Compare the elements. If any pair of corresponding elements
2351 fail to match, return 0 for the whole things. */
2353 fmt
= GET_RTX_FORMAT (code
);
2354 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
2360 if (XWINT (x
, i
) != XWINT (y
, i
))
2365 if (XINT (x
, i
) != XINT (y
, i
))
2370 if (XTREE (x
, i
) != XTREE (y
, i
))
2375 if (strcmp (XSTR (x
, i
), XSTR (y
, i
)))
2380 if (! rtx_renumbered_equal_p (XEXP (x
, i
), XEXP (y
, i
)))
2385 if (XEXP (x
, i
) != XEXP (y
, i
))
2392 if (XVECLEN (x
, i
) != XVECLEN (y
, i
))
2394 for (j
= XVECLEN (x
, i
) - 1; j
>= 0; j
--)
2395 if (!rtx_renumbered_equal_p (XVECEXP (x
, i
, j
), XVECEXP (y
, i
, j
)))
2406 /* If X is a hard register or equivalent to one or a subregister of one,
2407 return the hard register number. If X is a pseudo register that was not
2408 assigned a hard register, return the pseudo register number. Otherwise,
2409 return -1. Any rtx is valid for X. */
2415 if (GET_CODE (x
) == REG
)
2417 if (REGNO (x
) >= FIRST_PSEUDO_REGISTER
&& reg_renumber
[REGNO (x
)] >= 0)
2418 return reg_renumber
[REGNO (x
)];
2421 if (GET_CODE (x
) == SUBREG
)
2423 int base
= true_regnum (SUBREG_REG (x
));
2424 if (base
>= 0 && base
< FIRST_PSEUDO_REGISTER
)
2425 return base
+ subreg_regno_offset (REGNO (SUBREG_REG (x
)),
2426 GET_MODE (SUBREG_REG (x
)),
2427 SUBREG_BYTE (x
), GET_MODE (x
));