74a6c69b861220ea67a4deba66abf788456a91d9
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 gcc_assert (LABEL_P (label
));
1114 /* Ignore references to labels of containing functions. */
1115 if (LABEL_REF_NONLOCAL_P (x
))
1118 XEXP (x
, 0) = label
;
1119 if (! insn
|| ! INSN_DELETED_P (insn
))
1120 ++LABEL_NUSES (label
);
1125 JUMP_LABEL (insn
) = label
;
1128 /* Add a REG_LABEL note for LABEL unless there already
1129 is one. All uses of a label, except for labels
1130 that are the targets of jumps, must have a
1132 if (! find_reg_note (insn
, REG_LABEL
, label
))
1133 REG_NOTES (insn
) = gen_rtx_INSN_LIST (REG_LABEL
, label
,
1140 /* Do walk the labels in a vector, but not the first operand of an
1141 ADDR_DIFF_VEC. Don't set the JUMP_LABEL of a vector. */
1144 if (! INSN_DELETED_P (insn
))
1146 int eltnum
= code
== ADDR_DIFF_VEC
? 1 : 0;
1148 for (i
= 0; i
< XVECLEN (x
, eltnum
); i
++)
1149 mark_jump_label (XVECEXP (x
, eltnum
, i
), NULL_RTX
, in_mem
);
1157 fmt
= GET_RTX_FORMAT (code
);
1158 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
1161 mark_jump_label (XEXP (x
, i
), insn
, in_mem
);
1162 else if (fmt
[i
] == 'E')
1165 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
1166 mark_jump_label (XVECEXP (x
, i
, j
), insn
, in_mem
);
1171 /* If all INSN does is set the pc, delete it,
1172 and delete the insn that set the condition codes for it
1173 if that's what the previous thing was. */
1176 delete_jump (rtx insn
)
1178 rtx set
= single_set (insn
);
1180 if (set
&& GET_CODE (SET_DEST (set
)) == PC
)
1181 delete_computation (insn
);
1184 /* Recursively delete prior insns that compute the value (used only by INSN
1185 which the caller is deleting) stored in the register mentioned by NOTE
1186 which is a REG_DEAD note associated with INSN. */
1189 delete_prior_computation (rtx note
, rtx insn
)
1192 rtx reg
= XEXP (note
, 0);
1194 for (our_prev
= prev_nonnote_insn (insn
);
1195 our_prev
&& (NONJUMP_INSN_P (our_prev
)
1196 || CALL_P (our_prev
));
1197 our_prev
= prev_nonnote_insn (our_prev
))
1199 rtx pat
= PATTERN (our_prev
);
1201 /* If we reach a CALL which is not calling a const function
1202 or the callee pops the arguments, then give up. */
1203 if (CALL_P (our_prev
)
1204 && (! CONST_OR_PURE_CALL_P (our_prev
)
1205 || GET_CODE (pat
) != SET
|| GET_CODE (SET_SRC (pat
)) != CALL
))
1208 /* If we reach a SEQUENCE, it is too complex to try to
1209 do anything with it, so give up. We can be run during
1210 and after reorg, so SEQUENCE rtl can legitimately show
1212 if (GET_CODE (pat
) == SEQUENCE
)
1215 if (GET_CODE (pat
) == USE
1216 && NONJUMP_INSN_P (XEXP (pat
, 0)))
1217 /* reorg creates USEs that look like this. We leave them
1218 alone because reorg needs them for its own purposes. */
1221 if (reg_set_p (reg
, pat
))
1223 if (side_effects_p (pat
) && !CALL_P (our_prev
))
1226 if (GET_CODE (pat
) == PARALLEL
)
1228 /* If we find a SET of something else, we can't
1233 for (i
= 0; i
< XVECLEN (pat
, 0); i
++)
1235 rtx part
= XVECEXP (pat
, 0, i
);
1237 if (GET_CODE (part
) == SET
1238 && SET_DEST (part
) != reg
)
1242 if (i
== XVECLEN (pat
, 0))
1243 delete_computation (our_prev
);
1245 else if (GET_CODE (pat
) == SET
1246 && REG_P (SET_DEST (pat
)))
1248 int dest_regno
= REGNO (SET_DEST (pat
));
1251 + (dest_regno
< FIRST_PSEUDO_REGISTER
1252 ? hard_regno_nregs
[dest_regno
]
1253 [GET_MODE (SET_DEST (pat
))] : 1));
1254 int regno
= REGNO (reg
);
1257 + (regno
< FIRST_PSEUDO_REGISTER
1258 ? hard_regno_nregs
[regno
][GET_MODE (reg
)] : 1));
1260 if (dest_regno
>= regno
1261 && dest_endregno
<= endregno
)
1262 delete_computation (our_prev
);
1264 /* We may have a multi-word hard register and some, but not
1265 all, of the words of the register are needed in subsequent
1266 insns. Write REG_UNUSED notes for those parts that were not
1268 else if (dest_regno
<= regno
1269 && dest_endregno
>= endregno
)
1273 REG_NOTES (our_prev
)
1274 = gen_rtx_EXPR_LIST (REG_UNUSED
, reg
,
1275 REG_NOTES (our_prev
));
1277 for (i
= dest_regno
; i
< dest_endregno
; i
++)
1278 if (! find_regno_note (our_prev
, REG_UNUSED
, i
))
1281 if (i
== dest_endregno
)
1282 delete_computation (our_prev
);
1289 /* If PAT references the register that dies here, it is an
1290 additional use. Hence any prior SET isn't dead. However, this
1291 insn becomes the new place for the REG_DEAD note. */
1292 if (reg_overlap_mentioned_p (reg
, pat
))
1294 XEXP (note
, 1) = REG_NOTES (our_prev
);
1295 REG_NOTES (our_prev
) = note
;
1301 /* Delete INSN and recursively delete insns that compute values used only
1302 by INSN. This uses the REG_DEAD notes computed during flow analysis.
1303 If we are running before flow.c, we need do nothing since flow.c will
1304 delete dead code. We also can't know if the registers being used are
1305 dead or not at this point.
1307 Otherwise, look at all our REG_DEAD notes. If a previous insn does
1308 nothing other than set a register that dies in this insn, we can delete
1311 On machines with CC0, if CC0 is used in this insn, we may be able to
1312 delete the insn that set it. */
1315 delete_computation (rtx insn
)
1320 if (reg_referenced_p (cc0_rtx
, PATTERN (insn
)))
1322 rtx prev
= prev_nonnote_insn (insn
);
1323 /* We assume that at this stage
1324 CC's are always set explicitly
1325 and always immediately before the jump that
1326 will use them. So if the previous insn
1327 exists to set the CC's, delete it
1328 (unless it performs auto-increments, etc.). */
1329 if (prev
&& NONJUMP_INSN_P (prev
)
1330 && sets_cc0_p (PATTERN (prev
)))
1332 if (sets_cc0_p (PATTERN (prev
)) > 0
1333 && ! side_effects_p (PATTERN (prev
)))
1334 delete_computation (prev
);
1336 /* Otherwise, show that cc0 won't be used. */
1337 REG_NOTES (prev
) = gen_rtx_EXPR_LIST (REG_UNUSED
,
1338 cc0_rtx
, REG_NOTES (prev
));
1343 for (note
= REG_NOTES (insn
); note
; note
= next
)
1345 next
= XEXP (note
, 1);
1347 if (REG_NOTE_KIND (note
) != REG_DEAD
1348 /* Verify that the REG_NOTE is legitimate. */
1349 || !REG_P (XEXP (note
, 0)))
1352 delete_prior_computation (note
, insn
);
1355 delete_related_insns (insn
);
1358 /* Delete insn INSN from the chain of insns and update label ref counts
1359 and delete insns now unreachable.
1361 Returns the first insn after INSN that was not deleted.
1363 Usage of this instruction is deprecated. Use delete_insn instead and
1364 subsequent cfg_cleanup pass to delete unreachable code if needed. */
1367 delete_related_insns (rtx insn
)
1369 int was_code_label
= (LABEL_P (insn
));
1371 rtx next
= NEXT_INSN (insn
), prev
= PREV_INSN (insn
);
1373 while (next
&& INSN_DELETED_P (next
))
1374 next
= NEXT_INSN (next
);
1376 /* This insn is already deleted => return first following nondeleted. */
1377 if (INSN_DELETED_P (insn
))
1382 /* If instruction is followed by a barrier,
1383 delete the barrier too. */
1385 if (next
!= 0 && BARRIER_P (next
))
1388 /* If deleting a jump, decrement the count of the label,
1389 and delete the label if it is now unused. */
1391 if (JUMP_P (insn
) && JUMP_LABEL (insn
))
1393 rtx lab
= JUMP_LABEL (insn
), lab_next
;
1395 if (LABEL_NUSES (lab
) == 0)
1397 /* This can delete NEXT or PREV,
1398 either directly if NEXT is JUMP_LABEL (INSN),
1399 or indirectly through more levels of jumps. */
1400 delete_related_insns (lab
);
1402 /* I feel a little doubtful about this loop,
1403 but I see no clean and sure alternative way
1404 to find the first insn after INSN that is not now deleted.
1405 I hope this works. */
1406 while (next
&& INSN_DELETED_P (next
))
1407 next
= NEXT_INSN (next
);
1410 else if (tablejump_p (insn
, NULL
, &lab_next
))
1412 /* If we're deleting the tablejump, delete the dispatch table.
1413 We may not be able to kill the label immediately preceding
1414 just yet, as it might be referenced in code leading up to
1416 delete_related_insns (lab_next
);
1420 /* Likewise if we're deleting a dispatch table. */
1423 && (GET_CODE (PATTERN (insn
)) == ADDR_VEC
1424 || GET_CODE (PATTERN (insn
)) == ADDR_DIFF_VEC
))
1426 rtx pat
= PATTERN (insn
);
1427 int i
, diff_vec_p
= GET_CODE (pat
) == ADDR_DIFF_VEC
;
1428 int len
= XVECLEN (pat
, diff_vec_p
);
1430 for (i
= 0; i
< len
; i
++)
1431 if (LABEL_NUSES (XEXP (XVECEXP (pat
, diff_vec_p
, i
), 0)) == 0)
1432 delete_related_insns (XEXP (XVECEXP (pat
, diff_vec_p
, i
), 0));
1433 while (next
&& INSN_DELETED_P (next
))
1434 next
= NEXT_INSN (next
);
1438 /* Likewise for an ordinary INSN / CALL_INSN with a REG_LABEL note. */
1439 if (NONJUMP_INSN_P (insn
) || CALL_P (insn
))
1440 for (note
= REG_NOTES (insn
); note
; note
= XEXP (note
, 1))
1441 if (REG_NOTE_KIND (note
) == REG_LABEL
1442 /* This could also be a NOTE_INSN_DELETED_LABEL note. */
1443 && LABEL_P (XEXP (note
, 0)))
1444 if (LABEL_NUSES (XEXP (note
, 0)) == 0)
1445 delete_related_insns (XEXP (note
, 0));
1447 while (prev
&& (INSN_DELETED_P (prev
) || NOTE_P (prev
)))
1448 prev
= PREV_INSN (prev
);
1450 /* If INSN was a label and a dispatch table follows it,
1451 delete the dispatch table. The tablejump must have gone already.
1452 It isn't useful to fall through into a table. */
1455 && NEXT_INSN (insn
) != 0
1456 && JUMP_P (NEXT_INSN (insn
))
1457 && (GET_CODE (PATTERN (NEXT_INSN (insn
))) == ADDR_VEC
1458 || GET_CODE (PATTERN (NEXT_INSN (insn
))) == ADDR_DIFF_VEC
))
1459 next
= delete_related_insns (NEXT_INSN (insn
));
1461 /* If INSN was a label, delete insns following it if now unreachable. */
1463 if (was_code_label
&& prev
&& BARRIER_P (prev
))
1468 code
= GET_CODE (next
);
1470 && NOTE_LINE_NUMBER (next
) != NOTE_INSN_FUNCTION_END
)
1471 next
= NEXT_INSN (next
);
1472 /* Keep going past other deleted labels to delete what follows. */
1473 else if (code
== CODE_LABEL
&& INSN_DELETED_P (next
))
1474 next
= NEXT_INSN (next
);
1475 else if (code
== BARRIER
|| INSN_P (next
))
1476 /* Note: if this deletes a jump, it can cause more
1477 deletion of unreachable code, after a different label.
1478 As long as the value from this recursive call is correct,
1479 this invocation functions correctly. */
1480 next
= delete_related_insns (next
);
1489 /* Delete a range of insns from FROM to TO, inclusive.
1490 This is for the sake of peephole optimization, so assume
1491 that whatever these insns do will still be done by a new
1492 peephole insn that will replace them. */
1495 delete_for_peephole (rtx from
, rtx to
)
1501 rtx next
= NEXT_INSN (insn
);
1502 rtx prev
= PREV_INSN (insn
);
1506 INSN_DELETED_P (insn
) = 1;
1508 /* Patch this insn out of the chain. */
1509 /* We don't do this all at once, because we
1510 must preserve all NOTEs. */
1512 NEXT_INSN (prev
) = next
;
1515 PREV_INSN (next
) = prev
;
1523 /* Note that if TO is an unconditional jump
1524 we *do not* delete the BARRIER that follows,
1525 since the peephole that replaces this sequence
1526 is also an unconditional jump in that case. */
1529 /* Throughout LOC, redirect OLABEL to NLABEL. Treat null OLABEL or
1530 NLABEL as a return. Accrue modifications into the change group. */
1533 redirect_exp_1 (rtx
*loc
, rtx olabel
, rtx nlabel
, rtx insn
)
1536 RTX_CODE code
= GET_CODE (x
);
1540 if (code
== LABEL_REF
)
1542 if (XEXP (x
, 0) == olabel
)
1546 n
= gen_rtx_LABEL_REF (VOIDmode
, nlabel
);
1548 n
= gen_rtx_RETURN (VOIDmode
);
1550 validate_change (insn
, loc
, n
, 1);
1554 else if (code
== RETURN
&& olabel
== 0)
1557 x
= gen_rtx_LABEL_REF (VOIDmode
, nlabel
);
1559 x
= gen_rtx_RETURN (VOIDmode
);
1560 if (loc
== &PATTERN (insn
))
1561 x
= gen_rtx_SET (VOIDmode
, pc_rtx
, x
);
1562 validate_change (insn
, loc
, x
, 1);
1566 if (code
== SET
&& nlabel
== 0 && SET_DEST (x
) == pc_rtx
1567 && GET_CODE (SET_SRC (x
)) == LABEL_REF
1568 && XEXP (SET_SRC (x
), 0) == olabel
)
1570 validate_change (insn
, loc
, gen_rtx_RETURN (VOIDmode
), 1);
1574 fmt
= GET_RTX_FORMAT (code
);
1575 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
1578 redirect_exp_1 (&XEXP (x
, i
), olabel
, nlabel
, insn
);
1579 else if (fmt
[i
] == 'E')
1582 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
1583 redirect_exp_1 (&XVECEXP (x
, i
, j
), olabel
, nlabel
, insn
);
1588 /* Make JUMP go to NLABEL instead of where it jumps now. Accrue
1589 the modifications into the change group. Return false if we did
1590 not see how to do that. */
1593 redirect_jump_1 (rtx jump
, rtx nlabel
)
1595 int ochanges
= num_validated_changes ();
1598 if (GET_CODE (PATTERN (jump
)) == PARALLEL
)
1599 loc
= &XVECEXP (PATTERN (jump
), 0, 0);
1601 loc
= &PATTERN (jump
);
1603 redirect_exp_1 (loc
, JUMP_LABEL (jump
), nlabel
, jump
);
1604 return num_validated_changes () > ochanges
;
1607 /* Make JUMP go to NLABEL instead of where it jumps now. If the old
1608 jump target label is unused as a result, it and the code following
1611 If NLABEL is zero, we are to turn the jump into a (possibly conditional)
1614 The return value will be 1 if the change was made, 0 if it wasn't
1615 (this can only occur for NLABEL == 0). */
1618 redirect_jump (rtx jump
, rtx nlabel
, int delete_unused
)
1620 rtx olabel
= JUMP_LABEL (jump
);
1622 if (nlabel
== olabel
)
1625 if (! redirect_jump_1 (jump
, nlabel
) || ! apply_change_group ())
1628 redirect_jump_2 (jump
, olabel
, nlabel
, delete_unused
, 0);
1632 /* Fix up JUMP_LABEL and label ref counts after OLABEL has been replaced with
1633 NLABEL in JUMP. If DELETE_UNUSED is non-negative, copy a
1634 NOTE_INSN_FUNCTION_END found after OLABEL to the place after NLABEL.
1635 If DELETE_UNUSED is positive, delete related insn to OLABEL if its ref
1636 count has dropped to zero. */
1638 redirect_jump_2 (rtx jump
, rtx olabel
, rtx nlabel
, int delete_unused
,
1643 JUMP_LABEL (jump
) = nlabel
;
1645 ++LABEL_NUSES (nlabel
);
1647 /* Update labels in any REG_EQUAL note. */
1648 if ((note
= find_reg_note (jump
, REG_EQUAL
, NULL_RTX
)) != NULL_RTX
)
1650 if (!nlabel
|| (invert
&& !invert_exp_1 (XEXP (note
, 0), jump
)))
1651 remove_note (jump
, note
);
1654 redirect_exp_1 (&XEXP (note
, 0), olabel
, nlabel
, jump
);
1655 confirm_change_group ();
1659 /* If we're eliding the jump over exception cleanups at the end of a
1660 function, move the function end note so that -Wreturn-type works. */
1661 if (olabel
&& nlabel
1662 && NEXT_INSN (olabel
)
1663 && NOTE_P (NEXT_INSN (olabel
))
1664 && NOTE_LINE_NUMBER (NEXT_INSN (olabel
)) == NOTE_INSN_FUNCTION_END
1665 && delete_unused
>= 0)
1666 emit_note_after (NOTE_INSN_FUNCTION_END
, nlabel
);
1668 if (olabel
&& --LABEL_NUSES (olabel
) == 0 && delete_unused
> 0
1669 /* Undefined labels will remain outside the insn stream. */
1670 && INSN_UID (olabel
))
1671 delete_related_insns (olabel
);
1673 invert_br_probabilities (jump
);
1676 /* Invert the jump condition X contained in jump insn INSN. Accrue the
1677 modifications into the change group. Return nonzero for success. */
1679 invert_exp_1 (rtx x
, rtx insn
)
1681 RTX_CODE code
= GET_CODE (x
);
1683 if (code
== IF_THEN_ELSE
)
1685 rtx comp
= XEXP (x
, 0);
1687 enum rtx_code reversed_code
;
1689 /* We can do this in two ways: The preferable way, which can only
1690 be done if this is not an integer comparison, is to reverse
1691 the comparison code. Otherwise, swap the THEN-part and ELSE-part
1692 of the IF_THEN_ELSE. If we can't do either, fail. */
1694 reversed_code
= reversed_comparison_code (comp
, insn
);
1696 if (reversed_code
!= UNKNOWN
)
1698 validate_change (insn
, &XEXP (x
, 0),
1699 gen_rtx_fmt_ee (reversed_code
,
1700 GET_MODE (comp
), XEXP (comp
, 0),
1707 validate_change (insn
, &XEXP (x
, 1), XEXP (x
, 2), 1);
1708 validate_change (insn
, &XEXP (x
, 2), tem
, 1);
1715 /* Invert the condition of the jump JUMP, and make it jump to label
1716 NLABEL instead of where it jumps now. Accrue changes into the
1717 change group. Return false if we didn't see how to perform the
1718 inversion and redirection. */
1721 invert_jump_1 (rtx jump
, rtx nlabel
)
1723 rtx x
= pc_set (jump
);
1727 ochanges
= num_validated_changes ();
1729 ok
= invert_exp_1 (SET_SRC (x
), jump
);
1732 if (num_validated_changes () == ochanges
)
1735 /* redirect_jump_1 will fail of nlabel == olabel, and the current use is
1736 in Pmode, so checking this is not merely an optimization. */
1737 return nlabel
== JUMP_LABEL (jump
) || redirect_jump_1 (jump
, nlabel
);
1740 /* Invert the condition of the jump JUMP, and make it jump to label
1741 NLABEL instead of where it jumps now. Return true if successful. */
1744 invert_jump (rtx jump
, rtx nlabel
, int delete_unused
)
1746 rtx olabel
= JUMP_LABEL (jump
);
1748 if (invert_jump_1 (jump
, nlabel
) && apply_change_group ())
1750 redirect_jump_2 (jump
, olabel
, nlabel
, delete_unused
, 1);
1758 /* Like rtx_equal_p except that it considers two REGs as equal
1759 if they renumber to the same value and considers two commutative
1760 operations to be the same if the order of the operands has been
1763 ??? Addition is not commutative on the PA due to the weird implicit
1764 space register selection rules for memory addresses. Therefore, we
1765 don't consider a + b == b + a.
1767 We could/should make this test a little tighter. Possibly only
1768 disabling it on the PA via some backend macro or only disabling this
1769 case when the PLUS is inside a MEM. */
1772 rtx_renumbered_equal_p (rtx x
, rtx y
)
1775 enum rtx_code code
= GET_CODE (x
);
1781 if ((code
== REG
|| (code
== SUBREG
&& REG_P (SUBREG_REG (x
))))
1782 && (REG_P (y
) || (GET_CODE (y
) == SUBREG
1783 && REG_P (SUBREG_REG (y
)))))
1785 int reg_x
= -1, reg_y
= -1;
1786 int byte_x
= 0, byte_y
= 0;
1788 if (GET_MODE (x
) != GET_MODE (y
))
1791 /* If we haven't done any renumbering, don't
1792 make any assumptions. */
1793 if (reg_renumber
== 0)
1794 return rtx_equal_p (x
, y
);
1798 reg_x
= REGNO (SUBREG_REG (x
));
1799 byte_x
= SUBREG_BYTE (x
);
1801 if (reg_renumber
[reg_x
] >= 0)
1803 reg_x
= subreg_regno_offset (reg_renumber
[reg_x
],
1804 GET_MODE (SUBREG_REG (x
)),
1813 if (reg_renumber
[reg_x
] >= 0)
1814 reg_x
= reg_renumber
[reg_x
];
1817 if (GET_CODE (y
) == SUBREG
)
1819 reg_y
= REGNO (SUBREG_REG (y
));
1820 byte_y
= SUBREG_BYTE (y
);
1822 if (reg_renumber
[reg_y
] >= 0)
1824 reg_y
= subreg_regno_offset (reg_renumber
[reg_y
],
1825 GET_MODE (SUBREG_REG (y
)),
1834 if (reg_renumber
[reg_y
] >= 0)
1835 reg_y
= reg_renumber
[reg_y
];
1838 return reg_x
>= 0 && reg_x
== reg_y
&& byte_x
== byte_y
;
1841 /* Now we have disposed of all the cases
1842 in which different rtx codes can match. */
1843 if (code
!= GET_CODE (y
))
1856 /* We can't assume nonlocal labels have their following insns yet. */
1857 if (LABEL_REF_NONLOCAL_P (x
) || LABEL_REF_NONLOCAL_P (y
))
1858 return XEXP (x
, 0) == XEXP (y
, 0);
1860 /* Two label-refs are equivalent if they point at labels
1861 in the same position in the instruction stream. */
1862 return (next_real_insn (XEXP (x
, 0))
1863 == next_real_insn (XEXP (y
, 0)));
1866 return XSTR (x
, 0) == XSTR (y
, 0);
1869 /* If we didn't match EQ equality above, they aren't the same. */
1876 /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent. */
1878 if (GET_MODE (x
) != GET_MODE (y
))
1881 /* For commutative operations, the RTX match if the operand match in any
1882 order. Also handle the simple binary and unary cases without a loop.
1884 ??? Don't consider PLUS a commutative operator; see comments above. */
1885 if (COMMUTATIVE_P (x
) && code
!= PLUS
)
1886 return ((rtx_renumbered_equal_p (XEXP (x
, 0), XEXP (y
, 0))
1887 && rtx_renumbered_equal_p (XEXP (x
, 1), XEXP (y
, 1)))
1888 || (rtx_renumbered_equal_p (XEXP (x
, 0), XEXP (y
, 1))
1889 && rtx_renumbered_equal_p (XEXP (x
, 1), XEXP (y
, 0))));
1890 else if (NON_COMMUTATIVE_P (x
))
1891 return (rtx_renumbered_equal_p (XEXP (x
, 0), XEXP (y
, 0))
1892 && rtx_renumbered_equal_p (XEXP (x
, 1), XEXP (y
, 1)));
1893 else if (UNARY_P (x
))
1894 return rtx_renumbered_equal_p (XEXP (x
, 0), XEXP (y
, 0));
1896 /* Compare the elements. If any pair of corresponding elements
1897 fail to match, return 0 for the whole things. */
1899 fmt
= GET_RTX_FORMAT (code
);
1900 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
1906 if (XWINT (x
, i
) != XWINT (y
, i
))
1911 if (XINT (x
, i
) != XINT (y
, i
))
1916 if (XTREE (x
, i
) != XTREE (y
, i
))
1921 if (strcmp (XSTR (x
, i
), XSTR (y
, i
)))
1926 if (! rtx_renumbered_equal_p (XEXP (x
, i
), XEXP (y
, i
)))
1931 if (XEXP (x
, i
) != XEXP (y
, i
))
1938 if (XVECLEN (x
, i
) != XVECLEN (y
, i
))
1940 for (j
= XVECLEN (x
, i
) - 1; j
>= 0; j
--)
1941 if (!rtx_renumbered_equal_p (XVECEXP (x
, i
, j
), XVECEXP (y
, i
, j
)))
1952 /* If X is a hard register or equivalent to one or a subregister of one,
1953 return the hard register number. If X is a pseudo register that was not
1954 assigned a hard register, return the pseudo register number. Otherwise,
1955 return -1. Any rtx is valid for X. */
1962 if (REGNO (x
) >= FIRST_PSEUDO_REGISTER
&& reg_renumber
[REGNO (x
)] >= 0)
1963 return reg_renumber
[REGNO (x
)];
1966 if (GET_CODE (x
) == SUBREG
)
1968 int base
= true_regnum (SUBREG_REG (x
));
1969 if (base
>= 0 && base
< FIRST_PSEUDO_REGISTER
)
1970 return base
+ subreg_regno_offset (REGNO (SUBREG_REG (x
)),
1971 GET_MODE (SUBREG_REG (x
)),
1972 SUBREG_BYTE (x
), GET_MODE (x
));
1977 /* Return regno of the register REG and handle subregs too. */
1979 reg_or_subregno (rtx reg
)
1981 if (GET_CODE (reg
) == SUBREG
)
1982 reg
= SUBREG_REG (reg
);
1983 gcc_assert (REG_P (reg
));