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, 2005
4 Free Software Foundation, Inc.
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 2, or (at your option) any later
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING. If not, write to the Free
20 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
23 /* This is the pathetic reminder of old fame of the jump-optimization pass
24 of the compiler. Now it contains basically set of utility function to
27 Each CODE_LABEL has a count of the times it is used
28 stored in the LABEL_NUSES internal field, and each JUMP_INSN
29 has one label that it refers to stored in the
30 JUMP_LABEL internal field. With this we can detect labels that
31 become unused because of the deletion of all the jumps that
32 formerly used them. The JUMP_LABEL info is sometimes looked
35 The subroutines redirect_jump and invert_jump are used
36 from other passes as well. */
40 #include "coretypes.h"
45 #include "hard-reg-set.h"
47 #include "insn-config.h"
48 #include "insn-attr.h"
54 #include "diagnostic.h"
60 /* Optimize jump y; x: ... y: jumpif... x?
61 Don't know if it is worth bothering with. */
62 /* Optimize two cases of conditional jump to conditional jump?
63 This can never delete any instruction or make anything dead,
64 or even change what is live at any point.
65 So perhaps let combiner do it. */
67 static void init_label_info (rtx
);
68 static void mark_all_labels (rtx
);
69 static void delete_computation (rtx
);
70 static void redirect_exp_1 (rtx
*, rtx
, rtx
, rtx
);
71 static int invert_exp_1 (rtx
, rtx
);
72 static int returnjump_p_1 (rtx
*, void *);
73 static void delete_prior_computation (rtx
, rtx
);
75 /* Alternate entry into the jump optimizer. This entry point only rebuilds
76 the JUMP_LABEL field in jumping insns and REG_LABEL notes in non-jumping
79 rebuild_jump_labels (rtx f
)
83 timevar_push (TV_REBUILD_JUMP
);
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 (LABEL_P (XEXP (insn
, 0)))
93 LABEL_NUSES (XEXP (insn
, 0))++;
94 timevar_pop (TV_REBUILD_JUMP
);
97 /* Some old code expects exactly one BARRIER as the NEXT_INSN of a
98 non-fallthru insn. This is not generally true, as multiple barriers
99 may have crept in, or the BARRIER may be separated from the last
100 real insn by one or more NOTEs.
102 This simple pass moves barriers and removes duplicates so that the
106 cleanup_barriers (void)
108 rtx insn
, next
, prev
;
109 for (insn
= get_insns (); insn
; insn
= next
)
111 next
= NEXT_INSN (insn
);
112 if (BARRIER_P (insn
))
114 prev
= prev_nonnote_insn (insn
);
115 if (BARRIER_P (prev
))
117 else if (prev
!= PREV_INSN (insn
))
118 reorder_insns (insn
, insn
, prev
);
124 purge_line_number_notes (rtx f
)
128 /* Delete extraneous line number notes.
129 Note that two consecutive notes for different lines are not really
130 extraneous. There should be some indication where that line belonged,
131 even if it became empty. */
133 for (insn
= f
; insn
; insn
= NEXT_INSN (insn
))
136 if (NOTE_LINE_NUMBER (insn
) == NOTE_INSN_FUNCTION_BEG
)
137 /* Any previous line note was for the prologue; gdb wants a new
138 note after the prologue even if it is for the same line. */
139 last_note
= NULL_RTX
;
140 else if (NOTE_LINE_NUMBER (insn
) >= 0)
142 /* Delete this note if it is identical to previous note. */
144 #ifdef USE_MAPPED_LOCATION
145 && NOTE_SOURCE_LOCATION (insn
) == NOTE_SOURCE_LOCATION (last_note
)
147 && NOTE_SOURCE_FILE (insn
) == NOTE_SOURCE_FILE (last_note
)
148 && NOTE_LINE_NUMBER (insn
) == NOTE_LINE_NUMBER (last_note
)
152 delete_related_insns (insn
);
161 /* Initialize LABEL_NUSES and JUMP_LABEL fields. Delete any REG_LABEL
162 notes whose labels don't occur in the insn any more. Returns the
163 largest INSN_UID found. */
165 init_label_info (rtx f
)
169 for (insn
= f
; insn
; insn
= NEXT_INSN (insn
))
171 LABEL_NUSES (insn
) = (LABEL_PRESERVE_P (insn
) != 0);
172 else if (JUMP_P (insn
))
173 JUMP_LABEL (insn
) = 0;
174 else if (NONJUMP_INSN_P (insn
) || CALL_P (insn
))
178 for (note
= REG_NOTES (insn
); note
; note
= next
)
180 next
= XEXP (note
, 1);
181 if (REG_NOTE_KIND (note
) == REG_LABEL
182 && ! reg_mentioned_p (XEXP (note
, 0), PATTERN (insn
)))
183 remove_note (insn
, note
);
188 /* Mark the label each jump jumps to.
189 Combine consecutive labels, and count uses of labels. */
192 mark_all_labels (rtx f
)
196 for (insn
= f
; insn
; insn
= NEXT_INSN (insn
))
199 mark_jump_label (PATTERN (insn
), insn
, 0);
200 if (! INSN_DELETED_P (insn
) && JUMP_P (insn
))
202 /* When we know the LABEL_REF contained in a REG used in
203 an indirect jump, we'll have a REG_LABEL note so that
204 flow can tell where it's going. */
205 if (JUMP_LABEL (insn
) == 0)
207 rtx label_note
= find_reg_note (insn
, REG_LABEL
, NULL_RTX
);
210 /* But a LABEL_REF around the REG_LABEL note, so
211 that we can canonicalize it. */
212 rtx label_ref
= gen_rtx_LABEL_REF (VOIDmode
,
213 XEXP (label_note
, 0));
215 mark_jump_label (label_ref
, insn
, 0);
216 XEXP (label_note
, 0) = XEXP (label_ref
, 0);
217 JUMP_LABEL (insn
) = XEXP (label_note
, 0);
224 /* Move all block-beg, block-end, loop-beg, loop-cont, loop-vtop, loop-end,
225 notes between START and END out before START. START and END may be such
226 notes. Returns the values of the new starting and ending insns, which
227 may be different if the original ones were such notes.
228 Return true if there were only such notes and no real instructions. */
231 squeeze_notes (rtx
* startp
, rtx
* endp
)
239 rtx past_end
= NEXT_INSN (end
);
241 for (insn
= start
; insn
!= past_end
; insn
= next
)
243 next
= NEXT_INSN (insn
);
245 && (NOTE_LINE_NUMBER (insn
) == NOTE_INSN_BLOCK_END
246 || NOTE_LINE_NUMBER (insn
) == NOTE_INSN_BLOCK_BEG
247 || NOTE_LINE_NUMBER (insn
) == NOTE_INSN_LOOP_BEG
248 || NOTE_LINE_NUMBER (insn
) == NOTE_INSN_LOOP_END
))
250 /* BLOCK_BEG or BLOCK_END notes only exist in the `final' pass. */
251 gcc_assert (NOTE_LINE_NUMBER (insn
) != NOTE_INSN_BLOCK_BEG
252 && NOTE_LINE_NUMBER (insn
) != NOTE_INSN_BLOCK_END
);
258 rtx prev
= PREV_INSN (insn
);
259 PREV_INSN (insn
) = PREV_INSN (start
);
260 NEXT_INSN (insn
) = start
;
261 NEXT_INSN (PREV_INSN (insn
)) = insn
;
262 PREV_INSN (NEXT_INSN (insn
)) = insn
;
263 NEXT_INSN (prev
) = next
;
264 PREV_INSN (next
) = prev
;
271 /* There were no real instructions. */
272 if (start
== past_end
)
282 /* Return the label before INSN, or put a new label there. */
285 get_label_before (rtx insn
)
289 /* Find an existing label at this point
290 or make a new one if there is none. */
291 label
= prev_nonnote_insn (insn
);
293 if (label
== 0 || !LABEL_P (label
))
295 rtx prev
= PREV_INSN (insn
);
297 label
= gen_label_rtx ();
298 emit_label_after (label
, prev
);
299 LABEL_NUSES (label
) = 0;
304 /* Return the label after INSN, or put a new label there. */
307 get_label_after (rtx insn
)
311 /* Find an existing label at this point
312 or make a new one if there is none. */
313 label
= next_nonnote_insn (insn
);
315 if (label
== 0 || !LABEL_P (label
))
317 label
= gen_label_rtx ();
318 emit_label_after (label
, insn
);
319 LABEL_NUSES (label
) = 0;
324 /* Given a comparison (CODE ARG0 ARG1), inside an insn, INSN, return a code
325 of reversed comparison if it is possible to do so. Otherwise return UNKNOWN.
326 UNKNOWN may be returned in case we are having CC_MODE compare and we don't
327 know whether it's source is floating point or integer comparison. Machine
328 description should define REVERSIBLE_CC_MODE and REVERSE_CONDITION macros
329 to help this function avoid overhead in these cases. */
331 reversed_comparison_code_parts (enum rtx_code code
, rtx arg0
, rtx arg1
, rtx insn
)
333 enum machine_mode mode
;
335 /* If this is not actually a comparison, we can't reverse it. */
336 if (GET_RTX_CLASS (code
) != RTX_COMPARE
337 && GET_RTX_CLASS (code
) != RTX_COMM_COMPARE
)
340 mode
= GET_MODE (arg0
);
341 if (mode
== VOIDmode
)
342 mode
= GET_MODE (arg1
);
344 /* First see if machine description supplies us way to reverse the
345 comparison. Give it priority over everything else to allow
346 machine description to do tricks. */
347 if (GET_MODE_CLASS (mode
) == MODE_CC
348 && REVERSIBLE_CC_MODE (mode
))
350 #ifdef REVERSE_CONDITION
351 return REVERSE_CONDITION (code
, mode
);
353 return reverse_condition (code
);
356 /* Try a few special cases based on the comparison code. */
365 /* It is always safe to reverse EQ and NE, even for the floating
366 point. Similarly the unsigned comparisons are never used for
367 floating point so we can reverse them in the default way. */
368 return reverse_condition (code
);
373 /* In case we already see unordered comparison, we can be sure to
374 be dealing with floating point so we don't need any more tests. */
375 return reverse_condition_maybe_unordered (code
);
380 /* We don't have safe way to reverse these yet. */
386 if (GET_MODE_CLASS (mode
) == MODE_CC
|| CC0_P (arg0
))
389 /* Try to search for the comparison to determine the real mode.
390 This code is expensive, but with sane machine description it
391 will be never used, since REVERSIBLE_CC_MODE will return true
396 for (prev
= prev_nonnote_insn (insn
);
397 prev
!= 0 && !LABEL_P (prev
);
398 prev
= prev_nonnote_insn (prev
))
400 rtx set
= set_of (arg0
, prev
);
401 if (set
&& GET_CODE (set
) == SET
402 && rtx_equal_p (SET_DEST (set
), arg0
))
404 rtx src
= SET_SRC (set
);
406 if (GET_CODE (src
) == COMPARE
)
408 rtx comparison
= src
;
409 arg0
= XEXP (src
, 0);
410 mode
= GET_MODE (arg0
);
411 if (mode
== VOIDmode
)
412 mode
= GET_MODE (XEXP (comparison
, 1));
415 /* We can get past reg-reg moves. This may be useful for model
416 of i387 comparisons that first move flag registers around. */
423 /* If register is clobbered in some ununderstandable way,
430 /* Test for an integer condition, or a floating-point comparison
431 in which NaNs can be ignored. */
432 if (GET_CODE (arg0
) == CONST_INT
433 || (GET_MODE (arg0
) != VOIDmode
434 && GET_MODE_CLASS (mode
) != MODE_CC
435 && !HONOR_NANS (mode
)))
436 return reverse_condition (code
);
441 /* A wrapper around the previous function to take COMPARISON as rtx
442 expression. This simplifies many callers. */
444 reversed_comparison_code (rtx comparison
, rtx insn
)
446 if (!COMPARISON_P (comparison
))
448 return reversed_comparison_code_parts (GET_CODE (comparison
),
449 XEXP (comparison
, 0),
450 XEXP (comparison
, 1), insn
);
453 /* Return comparison with reversed code of EXP.
454 Return NULL_RTX in case we fail to do the reversal. */
456 reversed_comparison (rtx exp
, enum machine_mode mode
)
458 enum rtx_code reversed_code
= reversed_comparison_code (exp
, NULL_RTX
);
459 if (reversed_code
== UNKNOWN
)
462 return simplify_gen_relational (reversed_code
, mode
, VOIDmode
,
463 XEXP (exp
, 0), XEXP (exp
, 1));
467 /* Given an rtx-code for a comparison, return the code for the negated
468 comparison. If no such code exists, return UNKNOWN.
470 WATCH OUT! reverse_condition is not safe to use on a jump that might
471 be acting on the results of an IEEE floating point comparison, because
472 of the special treatment of non-signaling nans in comparisons.
473 Use reversed_comparison_code instead. */
476 reverse_condition (enum rtx_code code
)
518 /* Similar, but we're allowed to generate unordered comparisons, which
519 makes it safe for IEEE floating-point. Of course, we have to recognize
520 that the target will support them too... */
523 reverse_condition_maybe_unordered (enum rtx_code code
)
561 /* Similar, but return the code when two operands of a comparison are swapped.
562 This IS safe for IEEE floating-point. */
565 swap_condition (enum rtx_code code
)
607 /* Given a comparison CODE, return the corresponding unsigned comparison.
608 If CODE is an equality comparison or already an unsigned comparison,
612 unsigned_condition (enum rtx_code code
)
638 /* Similarly, return the signed version of a comparison. */
641 signed_condition (enum rtx_code code
)
667 /* Return nonzero if CODE1 is more strict than CODE2, i.e., if the
668 truth of CODE1 implies the truth of CODE2. */
671 comparison_dominates_p (enum rtx_code code1
, enum rtx_code code2
)
673 /* UNKNOWN comparison codes can happen as a result of trying to revert
675 They can't match anything, so we have to reject them here. */
676 if (code1
== UNKNOWN
|| code2
== UNKNOWN
)
685 if (code2
== UNLE
|| code2
== UNGE
)
690 if (code2
== LE
|| code2
== LEU
|| code2
== GE
|| code2
== GEU
696 if (code2
== UNLE
|| code2
== NE
)
701 if (code2
== LE
|| code2
== NE
|| code2
== ORDERED
|| code2
== LTGT
)
706 if (code2
== UNGE
|| code2
== NE
)
711 if (code2
== GE
|| code2
== NE
|| code2
== ORDERED
|| code2
== LTGT
)
717 if (code2
== ORDERED
)
722 if (code2
== NE
|| code2
== ORDERED
)
727 if (code2
== LEU
|| code2
== NE
)
732 if (code2
== GEU
|| code2
== NE
)
737 if (code2
== NE
|| code2
== UNEQ
|| code2
== UNLE
|| code2
== UNLT
738 || code2
== UNGE
|| code2
== UNGT
)
749 /* Return 1 if INSN is an unconditional jump and nothing else. */
752 simplejump_p (rtx insn
)
754 return (JUMP_P (insn
)
755 && GET_CODE (PATTERN (insn
)) == SET
756 && GET_CODE (SET_DEST (PATTERN (insn
))) == PC
757 && GET_CODE (SET_SRC (PATTERN (insn
))) == LABEL_REF
);
760 /* Return nonzero if INSN is a (possibly) conditional jump
763 Use of this function is deprecated, since we need to support combined
764 branch and compare insns. Use any_condjump_p instead whenever possible. */
767 condjump_p (rtx insn
)
769 rtx x
= PATTERN (insn
);
771 if (GET_CODE (x
) != SET
772 || GET_CODE (SET_DEST (x
)) != PC
)
776 if (GET_CODE (x
) == LABEL_REF
)
779 return (GET_CODE (x
) == IF_THEN_ELSE
780 && ((GET_CODE (XEXP (x
, 2)) == PC
781 && (GET_CODE (XEXP (x
, 1)) == LABEL_REF
782 || GET_CODE (XEXP (x
, 1)) == RETURN
))
783 || (GET_CODE (XEXP (x
, 1)) == PC
784 && (GET_CODE (XEXP (x
, 2)) == LABEL_REF
785 || GET_CODE (XEXP (x
, 2)) == RETURN
))));
788 /* Return nonzero if INSN is a (possibly) conditional jump inside a
791 Use this function is deprecated, since we need to support combined
792 branch and compare insns. Use any_condjump_p instead whenever possible. */
795 condjump_in_parallel_p (rtx insn
)
797 rtx x
= PATTERN (insn
);
799 if (GET_CODE (x
) != PARALLEL
)
802 x
= XVECEXP (x
, 0, 0);
804 if (GET_CODE (x
) != SET
)
806 if (GET_CODE (SET_DEST (x
)) != PC
)
808 if (GET_CODE (SET_SRC (x
)) == LABEL_REF
)
810 if (GET_CODE (SET_SRC (x
)) != IF_THEN_ELSE
)
812 if (XEXP (SET_SRC (x
), 2) == pc_rtx
813 && (GET_CODE (XEXP (SET_SRC (x
), 1)) == LABEL_REF
814 || GET_CODE (XEXP (SET_SRC (x
), 1)) == RETURN
))
816 if (XEXP (SET_SRC (x
), 1) == pc_rtx
817 && (GET_CODE (XEXP (SET_SRC (x
), 2)) == LABEL_REF
818 || GET_CODE (XEXP (SET_SRC (x
), 2)) == RETURN
))
823 /* Return set of PC, otherwise NULL. */
831 pat
= PATTERN (insn
);
833 /* The set is allowed to appear either as the insn pattern or
834 the first set in a PARALLEL. */
835 if (GET_CODE (pat
) == PARALLEL
)
836 pat
= XVECEXP (pat
, 0, 0);
837 if (GET_CODE (pat
) == SET
&& GET_CODE (SET_DEST (pat
)) == PC
)
843 /* Return true when insn is an unconditional direct jump,
844 possibly bundled inside a PARALLEL. */
847 any_uncondjump_p (rtx insn
)
849 rtx x
= pc_set (insn
);
852 if (GET_CODE (SET_SRC (x
)) != LABEL_REF
)
854 if (find_reg_note (insn
, REG_NON_LOCAL_GOTO
, NULL_RTX
))
859 /* Return true when insn is a conditional jump. This function works for
860 instructions containing PC sets in PARALLELs. The instruction may have
861 various other effects so before removing the jump you must verify
864 Note that unlike condjump_p it returns false for unconditional jumps. */
867 any_condjump_p (rtx insn
)
869 rtx x
= pc_set (insn
);
874 if (GET_CODE (SET_SRC (x
)) != IF_THEN_ELSE
)
877 a
= GET_CODE (XEXP (SET_SRC (x
), 1));
878 b
= GET_CODE (XEXP (SET_SRC (x
), 2));
880 return ((b
== PC
&& (a
== LABEL_REF
|| a
== RETURN
))
881 || (a
== PC
&& (b
== LABEL_REF
|| b
== RETURN
)));
884 /* Return the label of a conditional jump. */
887 condjump_label (rtx insn
)
889 rtx x
= pc_set (insn
);
894 if (GET_CODE (x
) == LABEL_REF
)
896 if (GET_CODE (x
) != IF_THEN_ELSE
)
898 if (XEXP (x
, 2) == pc_rtx
&& GET_CODE (XEXP (x
, 1)) == LABEL_REF
)
900 if (XEXP (x
, 1) == pc_rtx
&& GET_CODE (XEXP (x
, 2)) == LABEL_REF
)
905 /* Return true if INSN is a (possibly conditional) return insn. */
908 returnjump_p_1 (rtx
*loc
, void *data ATTRIBUTE_UNUSED
)
912 return x
&& (GET_CODE (x
) == RETURN
913 || (GET_CODE (x
) == SET
&& SET_IS_RETURN_P (x
)));
917 returnjump_p (rtx insn
)
921 return for_each_rtx (&PATTERN (insn
), returnjump_p_1
, NULL
);
924 /* Return true if INSN is a jump that only transfers control and
928 onlyjump_p (rtx insn
)
935 set
= single_set (insn
);
938 if (GET_CODE (SET_DEST (set
)) != PC
)
940 if (side_effects_p (SET_SRC (set
)))
948 /* Return nonzero if X is an RTX that only sets the condition codes
949 and has no side effects. */
952 only_sets_cc0_p (rtx x
)
960 return sets_cc0_p (x
) == 1 && ! side_effects_p (x
);
963 /* Return 1 if X is an RTX that does nothing but set the condition codes
964 and CLOBBER or USE registers.
965 Return -1 if X does explicitly set the condition codes,
966 but also does other things. */
977 if (GET_CODE (x
) == SET
&& SET_DEST (x
) == cc0_rtx
)
979 if (GET_CODE (x
) == PARALLEL
)
983 int other_things
= 0;
984 for (i
= XVECLEN (x
, 0) - 1; i
>= 0; i
--)
986 if (GET_CODE (XVECEXP (x
, 0, i
)) == SET
987 && SET_DEST (XVECEXP (x
, 0, i
)) == cc0_rtx
)
989 else if (GET_CODE (XVECEXP (x
, 0, i
)) == SET
)
992 return ! sets_cc0
? 0 : other_things
? -1 : 1;
998 /* Follow any unconditional jump at LABEL;
999 return the ultimate label reached by any such chain of jumps.
1000 Return null if the chain ultimately leads to a return instruction.
1001 If LABEL is not followed by a jump, return LABEL.
1002 If the chain loops or we can't find end, return LABEL,
1003 since that tells caller to avoid changing the insn.
1005 If RELOAD_COMPLETED is 0, we do not chain across a NOTE_INSN_LOOP_BEG or
1006 a USE or CLOBBER. */
1009 follow_jumps (rtx label
)
1018 && (insn
= next_active_insn (value
)) != 0
1020 && ((JUMP_LABEL (insn
) != 0 && any_uncondjump_p (insn
)
1021 && onlyjump_p (insn
))
1022 || GET_CODE (PATTERN (insn
)) == RETURN
)
1023 && (next
= NEXT_INSN (insn
))
1024 && BARRIER_P (next
));
1027 /* Don't chain through the insn that jumps into a loop
1028 from outside the loop,
1029 since that would create multiple loop entry jumps
1030 and prevent loop optimization. */
1032 if (!reload_completed
)
1033 for (tem
= value
; tem
!= insn
; tem
= NEXT_INSN (tem
))
1035 && (NOTE_LINE_NUMBER (tem
) == NOTE_INSN_LOOP_BEG
1036 /* ??? Optional. Disables some optimizations, but makes
1037 gcov output more accurate with -O. */
1038 || (flag_test_coverage
&& NOTE_LINE_NUMBER (tem
) > 0)))
1041 /* If we have found a cycle, make the insn jump to itself. */
1042 if (JUMP_LABEL (insn
) == label
)
1045 tem
= next_active_insn (JUMP_LABEL (insn
));
1046 if (tem
&& (GET_CODE (PATTERN (tem
)) == ADDR_VEC
1047 || GET_CODE (PATTERN (tem
)) == ADDR_DIFF_VEC
))
1050 value
= JUMP_LABEL (insn
);
1058 /* Find all CODE_LABELs referred to in X, and increment their use counts.
1059 If INSN is a JUMP_INSN and there is at least one CODE_LABEL referenced
1060 in INSN, then store one of them in JUMP_LABEL (INSN).
1061 If INSN is an INSN or a CALL_INSN and there is at least one CODE_LABEL
1062 referenced in INSN, add a REG_LABEL note containing that label to INSN.
1063 Also, when there are consecutive labels, canonicalize on the last of them.
1065 Note that two labels separated by a loop-beginning note
1066 must be kept distinct if we have not yet done loop-optimization,
1067 because the gap between them is where loop-optimize
1068 will want to move invariant code to. CROSS_JUMP tells us
1069 that loop-optimization is done with. */
1072 mark_jump_label (rtx x
, rtx insn
, int in_mem
)
1074 RTX_CODE code
= GET_CODE (x
);
1097 /* If this is a constant-pool reference, see if it is a label. */
1098 if (CONSTANT_POOL_ADDRESS_P (x
))
1099 mark_jump_label (get_pool_constant (x
), insn
, in_mem
);
1104 rtx label
= XEXP (x
, 0);
1106 /* Ignore remaining references to unreachable labels that
1107 have been deleted. */
1109 && NOTE_LINE_NUMBER (label
) == NOTE_INSN_DELETED_LABEL
)
1112 if (!LABEL_P (label
))
1115 /* Ignore references to labels of containing functions. */
1116 if (LABEL_REF_NONLOCAL_P (x
))
1119 XEXP (x
, 0) = label
;
1120 if (! insn
|| ! INSN_DELETED_P (insn
))
1121 ++LABEL_NUSES (label
);
1126 JUMP_LABEL (insn
) = label
;
1129 /* Add a REG_LABEL note for LABEL unless there already
1130 is one. All uses of a label, except for labels
1131 that are the targets of jumps, must have a
1133 if (! find_reg_note (insn
, REG_LABEL
, label
))
1134 REG_NOTES (insn
) = gen_rtx_INSN_LIST (REG_LABEL
, label
,
1141 /* Do walk the labels in a vector, but not the first operand of an
1142 ADDR_DIFF_VEC. Don't set the JUMP_LABEL of a vector. */
1145 if (! INSN_DELETED_P (insn
))
1147 int eltnum
= code
== ADDR_DIFF_VEC
? 1 : 0;
1149 for (i
= 0; i
< XVECLEN (x
, eltnum
); i
++)
1150 mark_jump_label (XVECEXP (x
, eltnum
, i
), NULL_RTX
, in_mem
);
1158 fmt
= GET_RTX_FORMAT (code
);
1159 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
1162 mark_jump_label (XEXP (x
, i
), insn
, in_mem
);
1163 else if (fmt
[i
] == 'E')
1166 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
1167 mark_jump_label (XVECEXP (x
, i
, j
), insn
, in_mem
);
1172 /* If all INSN does is set the pc, delete it,
1173 and delete the insn that set the condition codes for it
1174 if that's what the previous thing was. */
1177 delete_jump (rtx insn
)
1179 rtx set
= single_set (insn
);
1181 if (set
&& GET_CODE (SET_DEST (set
)) == PC
)
1182 delete_computation (insn
);
1185 /* Recursively delete prior insns that compute the value (used only by INSN
1186 which the caller is deleting) stored in the register mentioned by NOTE
1187 which is a REG_DEAD note associated with INSN. */
1190 delete_prior_computation (rtx note
, rtx insn
)
1193 rtx reg
= XEXP (note
, 0);
1195 for (our_prev
= prev_nonnote_insn (insn
);
1196 our_prev
&& (NONJUMP_INSN_P (our_prev
)
1197 || CALL_P (our_prev
));
1198 our_prev
= prev_nonnote_insn (our_prev
))
1200 rtx pat
= PATTERN (our_prev
);
1202 /* If we reach a CALL which is not calling a const function
1203 or the callee pops the arguments, then give up. */
1204 if (CALL_P (our_prev
)
1205 && (! CONST_OR_PURE_CALL_P (our_prev
)
1206 || GET_CODE (pat
) != SET
|| GET_CODE (SET_SRC (pat
)) != CALL
))
1209 /* If we reach a SEQUENCE, it is too complex to try to
1210 do anything with it, so give up. We can be run during
1211 and after reorg, so SEQUENCE rtl can legitimately show
1213 if (GET_CODE (pat
) == SEQUENCE
)
1216 if (GET_CODE (pat
) == USE
1217 && NONJUMP_INSN_P (XEXP (pat
, 0)))
1218 /* reorg creates USEs that look like this. We leave them
1219 alone because reorg needs them for its own purposes. */
1222 if (reg_set_p (reg
, pat
))
1224 if (side_effects_p (pat
) && !CALL_P (our_prev
))
1227 if (GET_CODE (pat
) == PARALLEL
)
1229 /* If we find a SET of something else, we can't
1234 for (i
= 0; i
< XVECLEN (pat
, 0); i
++)
1236 rtx part
= XVECEXP (pat
, 0, i
);
1238 if (GET_CODE (part
) == SET
1239 && SET_DEST (part
) != reg
)
1243 if (i
== XVECLEN (pat
, 0))
1244 delete_computation (our_prev
);
1246 else if (GET_CODE (pat
) == SET
1247 && REG_P (SET_DEST (pat
)))
1249 int dest_regno
= REGNO (SET_DEST (pat
));
1252 + (dest_regno
< FIRST_PSEUDO_REGISTER
1253 ? hard_regno_nregs
[dest_regno
]
1254 [GET_MODE (SET_DEST (pat
))] : 1));
1255 int regno
= REGNO (reg
);
1258 + (regno
< FIRST_PSEUDO_REGISTER
1259 ? hard_regno_nregs
[regno
][GET_MODE (reg
)] : 1));
1261 if (dest_regno
>= regno
1262 && dest_endregno
<= endregno
)
1263 delete_computation (our_prev
);
1265 /* We may have a multi-word hard register and some, but not
1266 all, of the words of the register are needed in subsequent
1267 insns. Write REG_UNUSED notes for those parts that were not
1269 else if (dest_regno
<= regno
1270 && dest_endregno
>= endregno
)
1274 REG_NOTES (our_prev
)
1275 = gen_rtx_EXPR_LIST (REG_UNUSED
, reg
,
1276 REG_NOTES (our_prev
));
1278 for (i
= dest_regno
; i
< dest_endregno
; i
++)
1279 if (! find_regno_note (our_prev
, REG_UNUSED
, i
))
1282 if (i
== dest_endregno
)
1283 delete_computation (our_prev
);
1290 /* If PAT references the register that dies here, it is an
1291 additional use. Hence any prior SET isn't dead. However, this
1292 insn becomes the new place for the REG_DEAD note. */
1293 if (reg_overlap_mentioned_p (reg
, pat
))
1295 XEXP (note
, 1) = REG_NOTES (our_prev
);
1296 REG_NOTES (our_prev
) = note
;
1302 /* Delete INSN and recursively delete insns that compute values used only
1303 by INSN. This uses the REG_DEAD notes computed during flow analysis.
1304 If we are running before flow.c, we need do nothing since flow.c will
1305 delete dead code. We also can't know if the registers being used are
1306 dead or not at this point.
1308 Otherwise, look at all our REG_DEAD notes. If a previous insn does
1309 nothing other than set a register that dies in this insn, we can delete
1312 On machines with CC0, if CC0 is used in this insn, we may be able to
1313 delete the insn that set it. */
1316 delete_computation (rtx insn
)
1321 if (reg_referenced_p (cc0_rtx
, PATTERN (insn
)))
1323 rtx prev
= prev_nonnote_insn (insn
);
1324 /* We assume that at this stage
1325 CC's are always set explicitly
1326 and always immediately before the jump that
1327 will use them. So if the previous insn
1328 exists to set the CC's, delete it
1329 (unless it performs auto-increments, etc.). */
1330 if (prev
&& NONJUMP_INSN_P (prev
)
1331 && sets_cc0_p (PATTERN (prev
)))
1333 if (sets_cc0_p (PATTERN (prev
)) > 0
1334 && ! side_effects_p (PATTERN (prev
)))
1335 delete_computation (prev
);
1337 /* Otherwise, show that cc0 won't be used. */
1338 REG_NOTES (prev
) = gen_rtx_EXPR_LIST (REG_UNUSED
,
1339 cc0_rtx
, REG_NOTES (prev
));
1344 for (note
= REG_NOTES (insn
); note
; note
= next
)
1346 next
= XEXP (note
, 1);
1348 if (REG_NOTE_KIND (note
) != REG_DEAD
1349 /* Verify that the REG_NOTE is legitimate. */
1350 || !REG_P (XEXP (note
, 0)))
1353 delete_prior_computation (note
, insn
);
1356 delete_related_insns (insn
);
1359 /* Delete insn INSN from the chain of insns and update label ref counts
1360 and delete insns now unreachable.
1362 Returns the first insn after INSN that was not deleted.
1364 Usage of this instruction is deprecated. Use delete_insn instead and
1365 subsequent cfg_cleanup pass to delete unreachable code if needed. */
1368 delete_related_insns (rtx insn
)
1370 int was_code_label
= (LABEL_P (insn
));
1372 rtx next
= NEXT_INSN (insn
), prev
= PREV_INSN (insn
);
1374 while (next
&& INSN_DELETED_P (next
))
1375 next
= NEXT_INSN (next
);
1377 /* This insn is already deleted => return first following nondeleted. */
1378 if (INSN_DELETED_P (insn
))
1383 /* If instruction is followed by a barrier,
1384 delete the barrier too. */
1386 if (next
!= 0 && BARRIER_P (next
))
1389 /* If deleting a jump, decrement the count of the label,
1390 and delete the label if it is now unused. */
1392 if (JUMP_P (insn
) && JUMP_LABEL (insn
))
1394 rtx lab
= JUMP_LABEL (insn
), lab_next
;
1396 if (LABEL_NUSES (lab
) == 0)
1398 /* This can delete NEXT or PREV,
1399 either directly if NEXT is JUMP_LABEL (INSN),
1400 or indirectly through more levels of jumps. */
1401 delete_related_insns (lab
);
1403 /* I feel a little doubtful about this loop,
1404 but I see no clean and sure alternative way
1405 to find the first insn after INSN that is not now deleted.
1406 I hope this works. */
1407 while (next
&& INSN_DELETED_P (next
))
1408 next
= NEXT_INSN (next
);
1411 else if (tablejump_p (insn
, NULL
, &lab_next
))
1413 /* If we're deleting the tablejump, delete the dispatch table.
1414 We may not be able to kill the label immediately preceding
1415 just yet, as it might be referenced in code leading up to
1417 delete_related_insns (lab_next
);
1421 /* Likewise if we're deleting a dispatch table. */
1424 && (GET_CODE (PATTERN (insn
)) == ADDR_VEC
1425 || GET_CODE (PATTERN (insn
)) == ADDR_DIFF_VEC
))
1427 rtx pat
= PATTERN (insn
);
1428 int i
, diff_vec_p
= GET_CODE (pat
) == ADDR_DIFF_VEC
;
1429 int len
= XVECLEN (pat
, diff_vec_p
);
1431 for (i
= 0; i
< len
; i
++)
1432 if (LABEL_NUSES (XEXP (XVECEXP (pat
, diff_vec_p
, i
), 0)) == 0)
1433 delete_related_insns (XEXP (XVECEXP (pat
, diff_vec_p
, i
), 0));
1434 while (next
&& INSN_DELETED_P (next
))
1435 next
= NEXT_INSN (next
);
1439 /* Likewise for an ordinary INSN / CALL_INSN with a REG_LABEL note. */
1440 if (NONJUMP_INSN_P (insn
) || CALL_P (insn
))
1441 for (note
= REG_NOTES (insn
); note
; note
= XEXP (note
, 1))
1442 if (REG_NOTE_KIND (note
) == REG_LABEL
1443 /* This could also be a NOTE_INSN_DELETED_LABEL note. */
1444 && LABEL_P (XEXP (note
, 0)))
1445 if (LABEL_NUSES (XEXP (note
, 0)) == 0)
1446 delete_related_insns (XEXP (note
, 0));
1448 while (prev
&& (INSN_DELETED_P (prev
) || NOTE_P (prev
)))
1449 prev
= PREV_INSN (prev
);
1451 /* If INSN was a label and a dispatch table follows it,
1452 delete the dispatch table. The tablejump must have gone already.
1453 It isn't useful to fall through into a table. */
1456 && NEXT_INSN (insn
) != 0
1457 && JUMP_P (NEXT_INSN (insn
))
1458 && (GET_CODE (PATTERN (NEXT_INSN (insn
))) == ADDR_VEC
1459 || GET_CODE (PATTERN (NEXT_INSN (insn
))) == ADDR_DIFF_VEC
))
1460 next
= delete_related_insns (NEXT_INSN (insn
));
1462 /* If INSN was a label, delete insns following it if now unreachable. */
1464 if (was_code_label
&& prev
&& BARRIER_P (prev
))
1469 code
= GET_CODE (next
);
1471 && NOTE_LINE_NUMBER (next
) != NOTE_INSN_FUNCTION_END
)
1472 next
= NEXT_INSN (next
);
1473 /* Keep going past other deleted labels to delete what follows. */
1474 else if (code
== CODE_LABEL
&& INSN_DELETED_P (next
))
1475 next
= NEXT_INSN (next
);
1476 else if (code
== BARRIER
|| INSN_P (next
))
1477 /* Note: if this deletes a jump, it can cause more
1478 deletion of unreachable code, after a different label.
1479 As long as the value from this recursive call is correct,
1480 this invocation functions correctly. */
1481 next
= delete_related_insns (next
);
1490 /* Delete a range of insns from FROM to TO, inclusive.
1491 This is for the sake of peephole optimization, so assume
1492 that whatever these insns do will still be done by a new
1493 peephole insn that will replace them. */
1496 delete_for_peephole (rtx from
, rtx to
)
1502 rtx next
= NEXT_INSN (insn
);
1503 rtx prev
= PREV_INSN (insn
);
1507 INSN_DELETED_P (insn
) = 1;
1509 /* Patch this insn out of the chain. */
1510 /* We don't do this all at once, because we
1511 must preserve all NOTEs. */
1513 NEXT_INSN (prev
) = next
;
1516 PREV_INSN (next
) = prev
;
1524 /* Note that if TO is an unconditional jump
1525 we *do not* delete the BARRIER that follows,
1526 since the peephole that replaces this sequence
1527 is also an unconditional jump in that case. */
1530 /* Throughout LOC, redirect OLABEL to NLABEL. Treat null OLABEL or
1531 NLABEL as a return. Accrue modifications into the change group. */
1534 redirect_exp_1 (rtx
*loc
, rtx olabel
, rtx nlabel
, rtx insn
)
1537 RTX_CODE code
= GET_CODE (x
);
1541 if (code
== LABEL_REF
)
1543 if (XEXP (x
, 0) == olabel
)
1547 n
= gen_rtx_LABEL_REF (VOIDmode
, nlabel
);
1549 n
= gen_rtx_RETURN (VOIDmode
);
1551 validate_change (insn
, loc
, n
, 1);
1555 else if (code
== RETURN
&& olabel
== 0)
1558 x
= gen_rtx_LABEL_REF (VOIDmode
, nlabel
);
1560 x
= gen_rtx_RETURN (VOIDmode
);
1561 if (loc
== &PATTERN (insn
))
1562 x
= gen_rtx_SET (VOIDmode
, pc_rtx
, x
);
1563 validate_change (insn
, loc
, x
, 1);
1567 if (code
== SET
&& nlabel
== 0 && SET_DEST (x
) == pc_rtx
1568 && GET_CODE (SET_SRC (x
)) == LABEL_REF
1569 && XEXP (SET_SRC (x
), 0) == olabel
)
1571 validate_change (insn
, loc
, gen_rtx_RETURN (VOIDmode
), 1);
1575 fmt
= GET_RTX_FORMAT (code
);
1576 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
1579 redirect_exp_1 (&XEXP (x
, i
), olabel
, nlabel
, insn
);
1580 else if (fmt
[i
] == 'E')
1583 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
1584 redirect_exp_1 (&XVECEXP (x
, i
, j
), olabel
, nlabel
, insn
);
1589 /* Make JUMP go to NLABEL instead of where it jumps now. Accrue
1590 the modifications into the change group. Return false if we did
1591 not see how to do that. */
1594 redirect_jump_1 (rtx jump
, rtx nlabel
)
1596 int ochanges
= num_validated_changes ();
1599 if (GET_CODE (PATTERN (jump
)) == PARALLEL
)
1600 loc
= &XVECEXP (PATTERN (jump
), 0, 0);
1602 loc
= &PATTERN (jump
);
1604 redirect_exp_1 (loc
, JUMP_LABEL (jump
), nlabel
, jump
);
1605 return num_validated_changes () > ochanges
;
1608 /* Make JUMP go to NLABEL instead of where it jumps now. If the old
1609 jump target label is unused as a result, it and the code following
1612 If NLABEL is zero, we are to turn the jump into a (possibly conditional)
1615 The return value will be 1 if the change was made, 0 if it wasn't
1616 (this can only occur for NLABEL == 0). */
1619 redirect_jump (rtx jump
, rtx nlabel
, int delete_unused
)
1621 rtx olabel
= JUMP_LABEL (jump
);
1623 if (nlabel
== olabel
)
1626 if (! redirect_jump_1 (jump
, nlabel
) || ! apply_change_group ())
1629 redirect_jump_2 (jump
, olabel
, nlabel
, delete_unused
, 0);
1633 /* Fix up JUMP_LABEL and label ref counts after OLABEL has been replaced with
1634 NLABEL in JUMP. If DELETE_UNUSED is non-negative, copy a
1635 NOTE_INSN_FUNCTION_END found after OLABEL to the place after NLABEL.
1636 If DELETE_UNUSED is positive, delete related insn to OLABEL if its ref
1637 count has dropped to zero. */
1639 redirect_jump_2 (rtx jump
, rtx olabel
, rtx nlabel
, int delete_unused
,
1644 JUMP_LABEL (jump
) = nlabel
;
1646 ++LABEL_NUSES (nlabel
);
1648 /* Update labels in any REG_EQUAL note. */
1649 if ((note
= find_reg_note (jump
, REG_EQUAL
, NULL_RTX
)) != NULL_RTX
)
1651 if (!nlabel
|| (invert
&& !invert_exp_1 (XEXP (note
, 0), jump
)))
1652 remove_note (jump
, note
);
1655 redirect_exp_1 (&XEXP (note
, 0), olabel
, nlabel
, jump
);
1656 confirm_change_group ();
1660 /* If we're eliding the jump over exception cleanups at the end of a
1661 function, move the function end note so that -Wreturn-type works. */
1662 if (olabel
&& nlabel
1663 && NEXT_INSN (olabel
)
1664 && NOTE_P (NEXT_INSN (olabel
))
1665 && NOTE_LINE_NUMBER (NEXT_INSN (olabel
)) == NOTE_INSN_FUNCTION_END
1666 && delete_unused
>= 0)
1667 emit_note_after (NOTE_INSN_FUNCTION_END
, nlabel
);
1669 if (olabel
&& --LABEL_NUSES (olabel
) == 0 && delete_unused
> 0
1670 /* Undefined labels will remain outside the insn stream. */
1671 && INSN_UID (olabel
))
1672 delete_related_insns (olabel
);
1674 invert_br_probabilities (jump
);
1677 /* Invert the jump condition X contained in jump insn INSN. Accrue the
1678 modifications into the change group. Return nonzero for success. */
1680 invert_exp_1 (rtx x
, rtx insn
)
1682 RTX_CODE code
= GET_CODE (x
);
1684 if (code
== IF_THEN_ELSE
)
1686 rtx comp
= XEXP (x
, 0);
1688 enum rtx_code reversed_code
;
1690 /* We can do this in two ways: The preferable way, which can only
1691 be done if this is not an integer comparison, is to reverse
1692 the comparison code. Otherwise, swap the THEN-part and ELSE-part
1693 of the IF_THEN_ELSE. If we can't do either, fail. */
1695 reversed_code
= reversed_comparison_code (comp
, insn
);
1697 if (reversed_code
!= UNKNOWN
)
1699 validate_change (insn
, &XEXP (x
, 0),
1700 gen_rtx_fmt_ee (reversed_code
,
1701 GET_MODE (comp
), XEXP (comp
, 0),
1708 validate_change (insn
, &XEXP (x
, 1), XEXP (x
, 2), 1);
1709 validate_change (insn
, &XEXP (x
, 2), tem
, 1);
1716 /* Invert the condition of the jump JUMP, and make it jump to label
1717 NLABEL instead of where it jumps now. Accrue changes into the
1718 change group. Return false if we didn't see how to perform the
1719 inversion and redirection. */
1722 invert_jump_1 (rtx jump
, rtx nlabel
)
1724 rtx x
= pc_set (jump
);
1727 ochanges
= num_validated_changes ();
1728 if (!x
|| !invert_exp_1 (SET_SRC (x
), jump
))
1730 if (num_validated_changes () == ochanges
)
1733 /* redirect_jump_1 will fail of nlabel == olabel, and the current use is
1734 in Pmode, so checking this is not merely an optimization. */
1735 return nlabel
== JUMP_LABEL (jump
) || redirect_jump_1 (jump
, nlabel
);
1738 /* Invert the condition of the jump JUMP, and make it jump to label
1739 NLABEL instead of where it jumps now. Return true if successful. */
1742 invert_jump (rtx jump
, rtx nlabel
, int delete_unused
)
1744 rtx olabel
= JUMP_LABEL (jump
);
1746 if (invert_jump_1 (jump
, nlabel
) && apply_change_group ())
1748 redirect_jump_2 (jump
, olabel
, nlabel
, delete_unused
, 1);
1756 /* Like rtx_equal_p except that it considers two REGs as equal
1757 if they renumber to the same value and considers two commutative
1758 operations to be the same if the order of the operands has been
1761 ??? Addition is not commutative on the PA due to the weird implicit
1762 space register selection rules for memory addresses. Therefore, we
1763 don't consider a + b == b + a.
1765 We could/should make this test a little tighter. Possibly only
1766 disabling it on the PA via some backend macro or only disabling this
1767 case when the PLUS is inside a MEM. */
1770 rtx_renumbered_equal_p (rtx x
, rtx y
)
1773 enum rtx_code code
= GET_CODE (x
);
1779 if ((code
== REG
|| (code
== SUBREG
&& REG_P (SUBREG_REG (x
))))
1780 && (REG_P (y
) || (GET_CODE (y
) == SUBREG
1781 && REG_P (SUBREG_REG (y
)))))
1783 int reg_x
= -1, reg_y
= -1;
1784 int byte_x
= 0, byte_y
= 0;
1786 if (GET_MODE (x
) != GET_MODE (y
))
1789 /* If we haven't done any renumbering, don't
1790 make any assumptions. */
1791 if (reg_renumber
== 0)
1792 return rtx_equal_p (x
, y
);
1796 reg_x
= REGNO (SUBREG_REG (x
));
1797 byte_x
= SUBREG_BYTE (x
);
1799 if (reg_renumber
[reg_x
] >= 0)
1801 reg_x
= subreg_regno_offset (reg_renumber
[reg_x
],
1802 GET_MODE (SUBREG_REG (x
)),
1811 if (reg_renumber
[reg_x
] >= 0)
1812 reg_x
= reg_renumber
[reg_x
];
1815 if (GET_CODE (y
) == SUBREG
)
1817 reg_y
= REGNO (SUBREG_REG (y
));
1818 byte_y
= SUBREG_BYTE (y
);
1820 if (reg_renumber
[reg_y
] >= 0)
1822 reg_y
= subreg_regno_offset (reg_renumber
[reg_y
],
1823 GET_MODE (SUBREG_REG (y
)),
1832 if (reg_renumber
[reg_y
] >= 0)
1833 reg_y
= reg_renumber
[reg_y
];
1836 return reg_x
>= 0 && reg_x
== reg_y
&& byte_x
== byte_y
;
1839 /* Now we have disposed of all the cases
1840 in which different rtx codes can match. */
1841 if (code
!= GET_CODE (y
))
1854 /* We can't assume nonlocal labels have their following insns yet. */
1855 if (LABEL_REF_NONLOCAL_P (x
) || LABEL_REF_NONLOCAL_P (y
))
1856 return XEXP (x
, 0) == XEXP (y
, 0);
1858 /* Two label-refs are equivalent if they point at labels
1859 in the same position in the instruction stream. */
1860 return (next_real_insn (XEXP (x
, 0))
1861 == next_real_insn (XEXP (y
, 0)));
1864 return XSTR (x
, 0) == XSTR (y
, 0);
1867 /* If we didn't match EQ equality above, they aren't the same. */
1874 /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent. */
1876 if (GET_MODE (x
) != GET_MODE (y
))
1879 /* For commutative operations, the RTX match if the operand match in any
1880 order. Also handle the simple binary and unary cases without a loop.
1882 ??? Don't consider PLUS a commutative operator; see comments above. */
1883 if (COMMUTATIVE_P (x
) && code
!= PLUS
)
1884 return ((rtx_renumbered_equal_p (XEXP (x
, 0), XEXP (y
, 0))
1885 && rtx_renumbered_equal_p (XEXP (x
, 1), XEXP (y
, 1)))
1886 || (rtx_renumbered_equal_p (XEXP (x
, 0), XEXP (y
, 1))
1887 && rtx_renumbered_equal_p (XEXP (x
, 1), XEXP (y
, 0))));
1888 else if (NON_COMMUTATIVE_P (x
))
1889 return (rtx_renumbered_equal_p (XEXP (x
, 0), XEXP (y
, 0))
1890 && rtx_renumbered_equal_p (XEXP (x
, 1), XEXP (y
, 1)));
1891 else if (UNARY_P (x
))
1892 return rtx_renumbered_equal_p (XEXP (x
, 0), XEXP (y
, 0));
1894 /* Compare the elements. If any pair of corresponding elements
1895 fail to match, return 0 for the whole things. */
1897 fmt
= GET_RTX_FORMAT (code
);
1898 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
1904 if (XWINT (x
, i
) != XWINT (y
, i
))
1909 if (XINT (x
, i
) != XINT (y
, i
))
1914 if (XTREE (x
, i
) != XTREE (y
, i
))
1919 if (strcmp (XSTR (x
, i
), XSTR (y
, i
)))
1924 if (! rtx_renumbered_equal_p (XEXP (x
, i
), XEXP (y
, i
)))
1929 if (XEXP (x
, i
) != XEXP (y
, i
))
1936 if (XVECLEN (x
, i
) != XVECLEN (y
, i
))
1938 for (j
= XVECLEN (x
, i
) - 1; j
>= 0; j
--)
1939 if (!rtx_renumbered_equal_p (XVECEXP (x
, i
, j
), XVECEXP (y
, i
, j
)))
1950 /* If X is a hard register or equivalent to one or a subregister of one,
1951 return the hard register number. If X is a pseudo register that was not
1952 assigned a hard register, return the pseudo register number. Otherwise,
1953 return -1. Any rtx is valid for X. */
1960 if (REGNO (x
) >= FIRST_PSEUDO_REGISTER
&& reg_renumber
[REGNO (x
)] >= 0)
1961 return reg_renumber
[REGNO (x
)];
1964 if (GET_CODE (x
) == SUBREG
)
1966 int base
= true_regnum (SUBREG_REG (x
));
1967 if (base
>= 0 && base
< FIRST_PSEUDO_REGISTER
)
1968 return base
+ subreg_regno_offset (REGNO (SUBREG_REG (x
)),
1969 GET_MODE (SUBREG_REG (x
)),
1970 SUBREG_BYTE (x
), GET_MODE (x
));
1975 /* Return regno of the register REG and handle subregs too. */
1977 reg_or_subregno (rtx reg
)
1981 if (GET_CODE (reg
) == SUBREG
)
1982 return REGNO (SUBREG_REG (reg
));