1 /* Optimize jump instructions, for GNU compiler.
2 Copyright (C) 1987, 1988, 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997
3 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
22 /* This is the pathetic reminder of old fame of the jump-optimization pass
23 of the compiler. Now it contains basically set of utility function to
26 Each CODE_LABEL has a count of the times it is used
27 stored in the LABEL_NUSES internal field, and each JUMP_INSN
28 has one label that it refers to stored in the
29 JUMP_LABEL internal field. With this we can detect labels that
30 become unused because of the deletion of all the jumps that
31 formerly used them. The JUMP_LABEL info is sometimes looked
34 The subroutines redirect_jump and invert_jump are used
35 from other passes as well. */
39 #include "coretypes.h"
44 #include "hard-reg-set.h"
46 #include "insn-config.h"
47 #include "insn-attr.h"
53 #include "diagnostic.h"
59 /* Optimize jump y; x: ... y: jumpif... x?
60 Don't know if it is worth bothering with. */
61 /* Optimize two cases of conditional jump to conditional jump?
62 This can never delete any instruction or make anything dead,
63 or even change what is live at any point.
64 So perhaps let combiner do it. */
66 static void init_label_info (rtx
);
67 static void mark_all_labels (rtx
);
68 static void delete_computation (rtx
);
69 static void redirect_exp_1 (rtx
*, rtx
, rtx
, rtx
);
70 static int redirect_exp (rtx
, rtx
, rtx
);
71 static void invert_exp_1 (rtx
);
72 static int invert_exp (rtx
);
73 static int returnjump_p_1 (rtx
*, void *);
74 static void delete_prior_computation (rtx
, rtx
);
76 /* Alternate entry into the jump optimizer. This entry point only rebuilds
77 the JUMP_LABEL field in jumping insns and REG_LABEL notes in non-jumping
80 rebuild_jump_labels (rtx f
)
84 timevar_push (TV_REBUILD_JUMP
);
88 /* Keep track of labels used from static data; we don't track them
89 closely enough to delete them here, so make sure their reference
90 count doesn't drop to zero. */
92 for (insn
= forced_labels
; insn
; insn
= XEXP (insn
, 1))
93 if (LABEL_P (XEXP (insn
, 0)))
94 LABEL_NUSES (XEXP (insn
, 0))++;
95 timevar_pop (TV_REBUILD_JUMP
);
98 /* Some old code expects exactly one BARRIER as the NEXT_INSN of a
99 non-fallthru insn. This is not generally true, as multiple barriers
100 may have crept in, or the BARRIER may be separated from the last
101 real insn by one or more NOTEs.
103 This simple pass moves barriers and removes duplicates so that the
107 cleanup_barriers (void)
109 rtx insn
, next
, prev
;
110 for (insn
= get_insns (); insn
; insn
= next
)
112 next
= NEXT_INSN (insn
);
113 if (BARRIER_P (insn
))
115 prev
= prev_nonnote_insn (insn
);
116 if (BARRIER_P (prev
))
118 else if (prev
!= PREV_INSN (insn
))
119 reorder_insns (insn
, insn
, prev
);
125 purge_line_number_notes (rtx f
)
129 /* Delete extraneous line number notes.
130 Note that two consecutive notes for different lines are not really
131 extraneous. There should be some indication where that line belonged,
132 even if it became empty. */
134 for (insn
= f
; insn
; insn
= NEXT_INSN (insn
))
137 if (NOTE_LINE_NUMBER (insn
) == NOTE_INSN_FUNCTION_BEG
)
138 /* Any previous line note was for the prologue; gdb wants a new
139 note after the prologue even if it is for the same line. */
140 last_note
= NULL_RTX
;
141 else if (NOTE_LINE_NUMBER (insn
) >= 0)
143 /* Delete this note if it is identical to previous note. */
145 #ifdef USE_MAPPED_LOCATION
146 && NOTE_SOURCE_LOCATION (insn
) == NOTE_SOURCE_LOCATION (last_note
)
148 && NOTE_SOURCE_FILE (insn
) == NOTE_SOURCE_FILE (last_note
)
149 && NOTE_LINE_NUMBER (insn
) == NOTE_LINE_NUMBER (last_note
)
153 delete_related_insns (insn
);
162 /* Initialize LABEL_NUSES and JUMP_LABEL fields. Delete any REG_LABEL
163 notes whose labels don't occur in the insn any more. Returns the
164 largest INSN_UID found. */
166 init_label_info (rtx f
)
170 for (insn
= f
; insn
; insn
= NEXT_INSN (insn
))
172 LABEL_NUSES (insn
) = (LABEL_PRESERVE_P (insn
) != 0);
173 else if (JUMP_P (insn
))
174 JUMP_LABEL (insn
) = 0;
175 else if (NONJUMP_INSN_P (insn
) || CALL_P (insn
))
179 for (note
= REG_NOTES (insn
); note
; note
= next
)
181 next
= XEXP (note
, 1);
182 if (REG_NOTE_KIND (note
) == REG_LABEL
183 && ! reg_mentioned_p (XEXP (note
, 0), PATTERN (insn
)))
184 remove_note (insn
, note
);
189 /* Mark the label each jump jumps to.
190 Combine consecutive labels, and count uses of labels. */
193 mark_all_labels (rtx f
)
197 for (insn
= f
; insn
; insn
= NEXT_INSN (insn
))
200 mark_jump_label (PATTERN (insn
), insn
, 0);
201 if (! INSN_DELETED_P (insn
) && JUMP_P (insn
))
203 /* When we know the LABEL_REF contained in a REG used in
204 an indirect jump, we'll have a REG_LABEL note so that
205 flow can tell where it's going. */
206 if (JUMP_LABEL (insn
) == 0)
208 rtx label_note
= find_reg_note (insn
, REG_LABEL
, NULL_RTX
);
211 /* But a LABEL_REF around the REG_LABEL note, so
212 that we can canonicalize it. */
213 rtx label_ref
= gen_rtx_LABEL_REF (VOIDmode
,
214 XEXP (label_note
, 0));
216 mark_jump_label (label_ref
, insn
, 0);
217 XEXP (label_note
, 0) = XEXP (label_ref
, 0);
218 JUMP_LABEL (insn
) = XEXP (label_note
, 0);
225 /* Move all block-beg, block-end, loop-beg, loop-cont, loop-vtop, loop-end,
226 notes between START and END out before START. START and END may be such
227 notes. Returns the values of the new starting and ending insns, which
228 may be different if the original ones were such notes.
229 Return true if there were only such notes and no real instructions. */
232 squeeze_notes (rtx
* startp
, rtx
* endp
)
240 rtx past_end
= NEXT_INSN (end
);
242 for (insn
= start
; insn
!= past_end
; insn
= next
)
244 next
= NEXT_INSN (insn
);
246 && (NOTE_LINE_NUMBER (insn
) == NOTE_INSN_BLOCK_END
247 || NOTE_LINE_NUMBER (insn
) == NOTE_INSN_BLOCK_BEG
248 || NOTE_LINE_NUMBER (insn
) == NOTE_INSN_LOOP_BEG
249 || NOTE_LINE_NUMBER (insn
) == NOTE_INSN_LOOP_END
))
255 rtx prev
= PREV_INSN (insn
);
256 PREV_INSN (insn
) = PREV_INSN (start
);
257 NEXT_INSN (insn
) = start
;
258 NEXT_INSN (PREV_INSN (insn
)) = insn
;
259 PREV_INSN (NEXT_INSN (insn
)) = insn
;
260 NEXT_INSN (prev
) = next
;
261 PREV_INSN (next
) = prev
;
268 /* There were no real instructions. */
269 if (start
== past_end
)
279 /* Return the label before INSN, or put a new label there. */
282 get_label_before (rtx insn
)
286 /* Find an existing label at this point
287 or make a new one if there is none. */
288 label
= prev_nonnote_insn (insn
);
290 if (label
== 0 || !LABEL_P (label
))
292 rtx prev
= PREV_INSN (insn
);
294 label
= gen_label_rtx ();
295 emit_label_after (label
, prev
);
296 LABEL_NUSES (label
) = 0;
301 /* Return the label after INSN, or put a new label there. */
304 get_label_after (rtx insn
)
308 /* Find an existing label at this point
309 or make a new one if there is none. */
310 label
= next_nonnote_insn (insn
);
312 if (label
== 0 || !LABEL_P (label
))
314 label
= gen_label_rtx ();
315 emit_label_after (label
, insn
);
316 LABEL_NUSES (label
) = 0;
321 /* Given a comparison (CODE ARG0 ARG1), inside an insn, INSN, return a code
322 of reversed comparison if it is possible to do so. Otherwise return UNKNOWN.
323 UNKNOWN may be returned in case we are having CC_MODE compare and we don't
324 know whether it's source is floating point or integer comparison. Machine
325 description should define REVERSIBLE_CC_MODE and REVERSE_CONDITION macros
326 to help this function avoid overhead in these cases. */
328 reversed_comparison_code_parts (enum rtx_code code
, rtx arg0
, rtx arg1
, rtx insn
)
330 enum machine_mode mode
;
332 /* If this is not actually a comparison, we can't reverse it. */
333 if (GET_RTX_CLASS (code
) != RTX_COMPARE
334 && GET_RTX_CLASS (code
) != RTX_COMM_COMPARE
)
337 mode
= GET_MODE (arg0
);
338 if (mode
== VOIDmode
)
339 mode
= GET_MODE (arg1
);
341 /* First see if machine description supplies us way to reverse the
342 comparison. Give it priority over everything else to allow
343 machine description to do tricks. */
344 if (GET_MODE_CLASS (mode
) == MODE_CC
345 && REVERSIBLE_CC_MODE (mode
))
347 #ifdef REVERSE_CONDITION
348 return REVERSE_CONDITION (code
, mode
);
350 return reverse_condition (code
);
353 /* Try a few special cases based on the comparison code. */
362 /* It is always safe to reverse EQ and NE, even for the floating
363 point. Similarly the unsigned comparisons are never used for
364 floating point so we can reverse them in the default way. */
365 return reverse_condition (code
);
370 /* In case we already see unordered comparison, we can be sure to
371 be dealing with floating point so we don't need any more tests. */
372 return reverse_condition_maybe_unordered (code
);
377 /* We don't have safe way to reverse these yet. */
383 if (GET_MODE_CLASS (mode
) == MODE_CC
|| CC0_P (arg0
))
386 /* Try to search for the comparison to determine the real mode.
387 This code is expensive, but with sane machine description it
388 will be never used, since REVERSIBLE_CC_MODE will return true
393 for (prev
= prev_nonnote_insn (insn
);
394 prev
!= 0 && !LABEL_P (prev
);
395 prev
= prev_nonnote_insn (prev
))
397 rtx set
= set_of (arg0
, prev
);
398 if (set
&& GET_CODE (set
) == SET
399 && rtx_equal_p (SET_DEST (set
), arg0
))
401 rtx src
= SET_SRC (set
);
403 if (GET_CODE (src
) == COMPARE
)
405 rtx comparison
= src
;
406 arg0
= XEXP (src
, 0);
407 mode
= GET_MODE (arg0
);
408 if (mode
== VOIDmode
)
409 mode
= GET_MODE (XEXP (comparison
, 1));
412 /* We can get past reg-reg moves. This may be useful for model
413 of i387 comparisons that first move flag registers around. */
420 /* If register is clobbered in some ununderstandable way,
427 /* Test for an integer condition, or a floating-point comparison
428 in which NaNs can be ignored. */
429 if (GET_CODE (arg0
) == CONST_INT
430 || (GET_MODE (arg0
) != VOIDmode
431 && GET_MODE_CLASS (mode
) != MODE_CC
432 && !HONOR_NANS (mode
)))
433 return reverse_condition (code
);
438 /* A wrapper around the previous function to take COMPARISON as rtx
439 expression. This simplifies many callers. */
441 reversed_comparison_code (rtx comparison
, rtx insn
)
443 if (!COMPARISON_P (comparison
))
445 return reversed_comparison_code_parts (GET_CODE (comparison
),
446 XEXP (comparison
, 0),
447 XEXP (comparison
, 1), insn
);
450 /* Given an rtx-code for a comparison, return the code for the negated
451 comparison. If no such code exists, return UNKNOWN.
453 WATCH OUT! reverse_condition is not safe to use on a jump that might
454 be acting on the results of an IEEE floating point comparison, because
455 of the special treatment of non-signaling nans in comparisons.
456 Use reversed_comparison_code instead. */
459 reverse_condition (enum rtx_code code
)
501 /* Similar, but we're allowed to generate unordered comparisons, which
502 makes it safe for IEEE floating-point. Of course, we have to recognize
503 that the target will support them too... */
506 reverse_condition_maybe_unordered (enum rtx_code code
)
544 /* Similar, but return the code when two operands of a comparison are swapped.
545 This IS safe for IEEE floating-point. */
548 swap_condition (enum rtx_code code
)
590 /* Given a comparison CODE, return the corresponding unsigned comparison.
591 If CODE is an equality comparison or already an unsigned comparison,
595 unsigned_condition (enum rtx_code code
)
621 /* Similarly, return the signed version of a comparison. */
624 signed_condition (enum rtx_code code
)
650 /* Return nonzero if CODE1 is more strict than CODE2, i.e., if the
651 truth of CODE1 implies the truth of CODE2. */
654 comparison_dominates_p (enum rtx_code code1
, enum rtx_code code2
)
656 /* UNKNOWN comparison codes can happen as a result of trying to revert
658 They can't match anything, so we have to reject them here. */
659 if (code1
== UNKNOWN
|| code2
== UNKNOWN
)
668 if (code2
== UNLE
|| code2
== UNGE
)
673 if (code2
== LE
|| code2
== LEU
|| code2
== GE
|| code2
== GEU
679 if (code2
== UNLE
|| code2
== NE
)
684 if (code2
== LE
|| code2
== NE
|| code2
== ORDERED
|| code2
== LTGT
)
689 if (code2
== UNGE
|| code2
== NE
)
694 if (code2
== GE
|| code2
== NE
|| code2
== ORDERED
|| code2
== LTGT
)
700 if (code2
== ORDERED
)
705 if (code2
== NE
|| code2
== ORDERED
)
710 if (code2
== LEU
|| code2
== NE
)
715 if (code2
== GEU
|| code2
== NE
)
720 if (code2
== NE
|| code2
== UNEQ
|| code2
== UNLE
|| code2
== UNLT
721 || code2
== UNGE
|| code2
== UNGT
)
732 /* Return 1 if INSN is an unconditional jump and nothing else. */
735 simplejump_p (rtx insn
)
737 return (JUMP_P (insn
)
738 && GET_CODE (PATTERN (insn
)) == SET
739 && GET_CODE (SET_DEST (PATTERN (insn
))) == PC
740 && GET_CODE (SET_SRC (PATTERN (insn
))) == LABEL_REF
);
743 /* Return nonzero if INSN is a (possibly) conditional jump
746 Use of this function is deprecated, since we need to support combined
747 branch and compare insns. Use any_condjump_p instead whenever possible. */
750 condjump_p (rtx insn
)
752 rtx x
= PATTERN (insn
);
754 if (GET_CODE (x
) != SET
755 || GET_CODE (SET_DEST (x
)) != PC
)
759 if (GET_CODE (x
) == LABEL_REF
)
762 return (GET_CODE (x
) == IF_THEN_ELSE
763 && ((GET_CODE (XEXP (x
, 2)) == PC
764 && (GET_CODE (XEXP (x
, 1)) == LABEL_REF
765 || GET_CODE (XEXP (x
, 1)) == RETURN
))
766 || (GET_CODE (XEXP (x
, 1)) == PC
767 && (GET_CODE (XEXP (x
, 2)) == LABEL_REF
768 || GET_CODE (XEXP (x
, 2)) == RETURN
))));
771 /* Return nonzero if INSN is a (possibly) conditional jump inside a
774 Use this function is deprecated, since we need to support combined
775 branch and compare insns. Use any_condjump_p instead whenever possible. */
778 condjump_in_parallel_p (rtx insn
)
780 rtx x
= PATTERN (insn
);
782 if (GET_CODE (x
) != PARALLEL
)
785 x
= XVECEXP (x
, 0, 0);
787 if (GET_CODE (x
) != SET
)
789 if (GET_CODE (SET_DEST (x
)) != PC
)
791 if (GET_CODE (SET_SRC (x
)) == LABEL_REF
)
793 if (GET_CODE (SET_SRC (x
)) != IF_THEN_ELSE
)
795 if (XEXP (SET_SRC (x
), 2) == pc_rtx
796 && (GET_CODE (XEXP (SET_SRC (x
), 1)) == LABEL_REF
797 || GET_CODE (XEXP (SET_SRC (x
), 1)) == RETURN
))
799 if (XEXP (SET_SRC (x
), 1) == pc_rtx
800 && (GET_CODE (XEXP (SET_SRC (x
), 2)) == LABEL_REF
801 || GET_CODE (XEXP (SET_SRC (x
), 2)) == RETURN
))
806 /* Return set of PC, otherwise NULL. */
814 pat
= PATTERN (insn
);
816 /* The set is allowed to appear either as the insn pattern or
817 the first set in a PARALLEL. */
818 if (GET_CODE (pat
) == PARALLEL
)
819 pat
= XVECEXP (pat
, 0, 0);
820 if (GET_CODE (pat
) == SET
&& GET_CODE (SET_DEST (pat
)) == PC
)
826 /* Return true when insn is an unconditional direct jump,
827 possibly bundled inside a PARALLEL. */
830 any_uncondjump_p (rtx insn
)
832 rtx x
= pc_set (insn
);
835 if (GET_CODE (SET_SRC (x
)) != LABEL_REF
)
837 if (find_reg_note (insn
, REG_NON_LOCAL_GOTO
, NULL_RTX
))
842 /* Return true when insn is a conditional jump. This function works for
843 instructions containing PC sets in PARALLELs. The instruction may have
844 various other effects so before removing the jump you must verify
847 Note that unlike condjump_p it returns false for unconditional jumps. */
850 any_condjump_p (rtx insn
)
852 rtx x
= pc_set (insn
);
857 if (GET_CODE (SET_SRC (x
)) != IF_THEN_ELSE
)
860 a
= GET_CODE (XEXP (SET_SRC (x
), 1));
861 b
= GET_CODE (XEXP (SET_SRC (x
), 2));
863 return ((b
== PC
&& (a
== LABEL_REF
|| a
== RETURN
))
864 || (a
== PC
&& (b
== LABEL_REF
|| b
== RETURN
)));
867 /* Return the label of a conditional jump. */
870 condjump_label (rtx insn
)
872 rtx x
= pc_set (insn
);
877 if (GET_CODE (x
) == LABEL_REF
)
879 if (GET_CODE (x
) != IF_THEN_ELSE
)
881 if (XEXP (x
, 2) == pc_rtx
&& GET_CODE (XEXP (x
, 1)) == LABEL_REF
)
883 if (XEXP (x
, 1) == pc_rtx
&& GET_CODE (XEXP (x
, 2)) == LABEL_REF
)
888 /* Return true if INSN is a (possibly conditional) return insn. */
891 returnjump_p_1 (rtx
*loc
, void *data ATTRIBUTE_UNUSED
)
895 return x
&& (GET_CODE (x
) == RETURN
896 || (GET_CODE (x
) == SET
&& SET_IS_RETURN_P (x
)));
900 returnjump_p (rtx insn
)
904 return for_each_rtx (&PATTERN (insn
), returnjump_p_1
, NULL
);
907 /* Return true if INSN is a jump that only transfers control and
911 onlyjump_p (rtx insn
)
918 set
= single_set (insn
);
921 if (GET_CODE (SET_DEST (set
)) != PC
)
923 if (side_effects_p (SET_SRC (set
)))
931 /* Return nonzero if X is an RTX that only sets the condition codes
932 and has no side effects. */
935 only_sets_cc0_p (rtx x
)
943 return sets_cc0_p (x
) == 1 && ! side_effects_p (x
);
946 /* Return 1 if X is an RTX that does nothing but set the condition codes
947 and CLOBBER or USE registers.
948 Return -1 if X does explicitly set the condition codes,
949 but also does other things. */
960 if (GET_CODE (x
) == SET
&& SET_DEST (x
) == cc0_rtx
)
962 if (GET_CODE (x
) == PARALLEL
)
966 int other_things
= 0;
967 for (i
= XVECLEN (x
, 0) - 1; i
>= 0; i
--)
969 if (GET_CODE (XVECEXP (x
, 0, i
)) == SET
970 && SET_DEST (XVECEXP (x
, 0, i
)) == cc0_rtx
)
972 else if (GET_CODE (XVECEXP (x
, 0, i
)) == SET
)
975 return ! sets_cc0
? 0 : other_things
? -1 : 1;
981 /* Follow any unconditional jump at LABEL;
982 return the ultimate label reached by any such chain of jumps.
983 Return null if the chain ultimately leads to a return instruction.
984 If LABEL is not followed by a jump, return LABEL.
985 If the chain loops or we can't find end, return LABEL,
986 since that tells caller to avoid changing the insn.
988 If RELOAD_COMPLETED is 0, we do not chain across a NOTE_INSN_LOOP_BEG or
992 follow_jumps (rtx label
)
1001 && (insn
= next_active_insn (value
)) != 0
1003 && ((JUMP_LABEL (insn
) != 0 && any_uncondjump_p (insn
)
1004 && onlyjump_p (insn
))
1005 || GET_CODE (PATTERN (insn
)) == RETURN
)
1006 && (next
= NEXT_INSN (insn
))
1007 && BARRIER_P (next
));
1010 /* Don't chain through the insn that jumps into a loop
1011 from outside the loop,
1012 since that would create multiple loop entry jumps
1013 and prevent loop optimization. */
1015 if (!reload_completed
)
1016 for (tem
= value
; tem
!= insn
; tem
= NEXT_INSN (tem
))
1018 && (NOTE_LINE_NUMBER (tem
) == NOTE_INSN_LOOP_BEG
1019 /* ??? Optional. Disables some optimizations, but makes
1020 gcov output more accurate with -O. */
1021 || (flag_test_coverage
&& NOTE_LINE_NUMBER (tem
) > 0)))
1024 /* If we have found a cycle, make the insn jump to itself. */
1025 if (JUMP_LABEL (insn
) == label
)
1028 tem
= next_active_insn (JUMP_LABEL (insn
));
1029 if (tem
&& (GET_CODE (PATTERN (tem
)) == ADDR_VEC
1030 || GET_CODE (PATTERN (tem
)) == ADDR_DIFF_VEC
))
1033 value
= JUMP_LABEL (insn
);
1041 /* Find all CODE_LABELs referred to in X, and increment their use counts.
1042 If INSN is a JUMP_INSN and there is at least one CODE_LABEL referenced
1043 in INSN, then store one of them in JUMP_LABEL (INSN).
1044 If INSN is an INSN or a CALL_INSN and there is at least one CODE_LABEL
1045 referenced in INSN, add a REG_LABEL note containing that label to INSN.
1046 Also, when there are consecutive labels, canonicalize on the last of them.
1048 Note that two labels separated by a loop-beginning note
1049 must be kept distinct if we have not yet done loop-optimization,
1050 because the gap between them is where loop-optimize
1051 will want to move invariant code to. CROSS_JUMP tells us
1052 that loop-optimization is done with. */
1055 mark_jump_label (rtx x
, rtx insn
, int in_mem
)
1057 RTX_CODE code
= GET_CODE (x
);
1080 /* If this is a constant-pool reference, see if it is a label. */
1081 if (CONSTANT_POOL_ADDRESS_P (x
))
1082 mark_jump_label (get_pool_constant (x
), insn
, in_mem
);
1087 rtx label
= XEXP (x
, 0);
1089 /* Ignore remaining references to unreachable labels that
1090 have been deleted. */
1092 && NOTE_LINE_NUMBER (label
) == NOTE_INSN_DELETED_LABEL
)
1095 if (!LABEL_P (label
))
1098 /* Ignore references to labels of containing functions. */
1099 if (LABEL_REF_NONLOCAL_P (x
))
1102 XEXP (x
, 0) = label
;
1103 if (! insn
|| ! INSN_DELETED_P (insn
))
1104 ++LABEL_NUSES (label
);
1109 JUMP_LABEL (insn
) = label
;
1112 /* Add a REG_LABEL note for LABEL unless there already
1113 is one. All uses of a label, except for labels
1114 that are the targets of jumps, must have a
1116 if (! find_reg_note (insn
, REG_LABEL
, label
))
1117 REG_NOTES (insn
) = gen_rtx_INSN_LIST (REG_LABEL
, label
,
1124 /* Do walk the labels in a vector, but not the first operand of an
1125 ADDR_DIFF_VEC. Don't set the JUMP_LABEL of a vector. */
1128 if (! INSN_DELETED_P (insn
))
1130 int eltnum
= code
== ADDR_DIFF_VEC
? 1 : 0;
1132 for (i
= 0; i
< XVECLEN (x
, eltnum
); i
++)
1133 mark_jump_label (XVECEXP (x
, eltnum
, i
), NULL_RTX
, in_mem
);
1141 fmt
= GET_RTX_FORMAT (code
);
1142 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
1145 mark_jump_label (XEXP (x
, i
), insn
, in_mem
);
1146 else if (fmt
[i
] == 'E')
1149 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
1150 mark_jump_label (XVECEXP (x
, i
, j
), insn
, in_mem
);
1155 /* If all INSN does is set the pc, delete it,
1156 and delete the insn that set the condition codes for it
1157 if that's what the previous thing was. */
1160 delete_jump (rtx insn
)
1162 rtx set
= single_set (insn
);
1164 if (set
&& GET_CODE (SET_DEST (set
)) == PC
)
1165 delete_computation (insn
);
1168 /* Recursively delete prior insns that compute the value (used only by INSN
1169 which the caller is deleting) stored in the register mentioned by NOTE
1170 which is a REG_DEAD note associated with INSN. */
1173 delete_prior_computation (rtx note
, rtx insn
)
1176 rtx reg
= XEXP (note
, 0);
1178 for (our_prev
= prev_nonnote_insn (insn
);
1179 our_prev
&& (NONJUMP_INSN_P (our_prev
)
1180 || CALL_P (our_prev
));
1181 our_prev
= prev_nonnote_insn (our_prev
))
1183 rtx pat
= PATTERN (our_prev
);
1185 /* If we reach a CALL which is not calling a const function
1186 or the callee pops the arguments, then give up. */
1187 if (CALL_P (our_prev
)
1188 && (! CONST_OR_PURE_CALL_P (our_prev
)
1189 || GET_CODE (pat
) != SET
|| GET_CODE (SET_SRC (pat
)) != CALL
))
1192 /* If we reach a SEQUENCE, it is too complex to try to
1193 do anything with it, so give up. We can be run during
1194 and after reorg, so SEQUENCE rtl can legitimately show
1196 if (GET_CODE (pat
) == SEQUENCE
)
1199 if (GET_CODE (pat
) == USE
1200 && NONJUMP_INSN_P (XEXP (pat
, 0)))
1201 /* reorg creates USEs that look like this. We leave them
1202 alone because reorg needs them for its own purposes. */
1205 if (reg_set_p (reg
, pat
))
1207 if (side_effects_p (pat
) && !CALL_P (our_prev
))
1210 if (GET_CODE (pat
) == PARALLEL
)
1212 /* If we find a SET of something else, we can't
1217 for (i
= 0; i
< XVECLEN (pat
, 0); i
++)
1219 rtx part
= XVECEXP (pat
, 0, i
);
1221 if (GET_CODE (part
) == SET
1222 && SET_DEST (part
) != reg
)
1226 if (i
== XVECLEN (pat
, 0))
1227 delete_computation (our_prev
);
1229 else if (GET_CODE (pat
) == SET
1230 && REG_P (SET_DEST (pat
)))
1232 int dest_regno
= REGNO (SET_DEST (pat
));
1235 + (dest_regno
< FIRST_PSEUDO_REGISTER
1236 ? hard_regno_nregs
[dest_regno
]
1237 [GET_MODE (SET_DEST (pat
))] : 1));
1238 int regno
= REGNO (reg
);
1241 + (regno
< FIRST_PSEUDO_REGISTER
1242 ? hard_regno_nregs
[regno
][GET_MODE (reg
)] : 1));
1244 if (dest_regno
>= regno
1245 && dest_endregno
<= endregno
)
1246 delete_computation (our_prev
);
1248 /* We may have a multi-word hard register and some, but not
1249 all, of the words of the register are needed in subsequent
1250 insns. Write REG_UNUSED notes for those parts that were not
1252 else if (dest_regno
<= regno
1253 && dest_endregno
>= endregno
)
1257 REG_NOTES (our_prev
)
1258 = gen_rtx_EXPR_LIST (REG_UNUSED
, reg
,
1259 REG_NOTES (our_prev
));
1261 for (i
= dest_regno
; i
< dest_endregno
; i
++)
1262 if (! find_regno_note (our_prev
, REG_UNUSED
, i
))
1265 if (i
== dest_endregno
)
1266 delete_computation (our_prev
);
1273 /* If PAT references the register that dies here, it is an
1274 additional use. Hence any prior SET isn't dead. However, this
1275 insn becomes the new place for the REG_DEAD note. */
1276 if (reg_overlap_mentioned_p (reg
, pat
))
1278 XEXP (note
, 1) = REG_NOTES (our_prev
);
1279 REG_NOTES (our_prev
) = note
;
1285 /* Delete INSN and recursively delete insns that compute values used only
1286 by INSN. This uses the REG_DEAD notes computed during flow analysis.
1287 If we are running before flow.c, we need do nothing since flow.c will
1288 delete dead code. We also can't know if the registers being used are
1289 dead or not at this point.
1291 Otherwise, look at all our REG_DEAD notes. If a previous insn does
1292 nothing other than set a register that dies in this insn, we can delete
1295 On machines with CC0, if CC0 is used in this insn, we may be able to
1296 delete the insn that set it. */
1299 delete_computation (rtx insn
)
1304 if (reg_referenced_p (cc0_rtx
, PATTERN (insn
)))
1306 rtx prev
= prev_nonnote_insn (insn
);
1307 /* We assume that at this stage
1308 CC's are always set explicitly
1309 and always immediately before the jump that
1310 will use them. So if the previous insn
1311 exists to set the CC's, delete it
1312 (unless it performs auto-increments, etc.). */
1313 if (prev
&& NONJUMP_INSN_P (prev
)
1314 && sets_cc0_p (PATTERN (prev
)))
1316 if (sets_cc0_p (PATTERN (prev
)) > 0
1317 && ! side_effects_p (PATTERN (prev
)))
1318 delete_computation (prev
);
1320 /* Otherwise, show that cc0 won't be used. */
1321 REG_NOTES (prev
) = gen_rtx_EXPR_LIST (REG_UNUSED
,
1322 cc0_rtx
, REG_NOTES (prev
));
1327 for (note
= REG_NOTES (insn
); note
; note
= next
)
1329 next
= XEXP (note
, 1);
1331 if (REG_NOTE_KIND (note
) != REG_DEAD
1332 /* Verify that the REG_NOTE is legitimate. */
1333 || !REG_P (XEXP (note
, 0)))
1336 delete_prior_computation (note
, insn
);
1339 delete_related_insns (insn
);
1342 /* Delete insn INSN from the chain of insns and update label ref counts
1343 and delete insns now unreachable.
1345 Returns the first insn after INSN that was not deleted.
1347 Usage of this instruction is deprecated. Use delete_insn instead and
1348 subsequent cfg_cleanup pass to delete unreachable code if needed. */
1351 delete_related_insns (rtx insn
)
1353 int was_code_label
= (LABEL_P (insn
));
1355 rtx next
= NEXT_INSN (insn
), prev
= PREV_INSN (insn
);
1357 while (next
&& INSN_DELETED_P (next
))
1358 next
= NEXT_INSN (next
);
1360 /* This insn is already deleted => return first following nondeleted. */
1361 if (INSN_DELETED_P (insn
))
1366 /* If instruction is followed by a barrier,
1367 delete the barrier too. */
1369 if (next
!= 0 && BARRIER_P (next
))
1372 /* If deleting a jump, decrement the count of the label,
1373 and delete the label if it is now unused. */
1375 if (JUMP_P (insn
) && JUMP_LABEL (insn
))
1377 rtx lab
= JUMP_LABEL (insn
), lab_next
;
1379 if (LABEL_NUSES (lab
) == 0)
1381 /* This can delete NEXT or PREV,
1382 either directly if NEXT is JUMP_LABEL (INSN),
1383 or indirectly through more levels of jumps. */
1384 delete_related_insns (lab
);
1386 /* I feel a little doubtful about this loop,
1387 but I see no clean and sure alternative way
1388 to find the first insn after INSN that is not now deleted.
1389 I hope this works. */
1390 while (next
&& INSN_DELETED_P (next
))
1391 next
= NEXT_INSN (next
);
1394 else if (tablejump_p (insn
, NULL
, &lab_next
))
1396 /* If we're deleting the tablejump, delete the dispatch table.
1397 We may not be able to kill the label immediately preceding
1398 just yet, as it might be referenced in code leading up to
1400 delete_related_insns (lab_next
);
1404 /* Likewise if we're deleting a dispatch table. */
1407 && (GET_CODE (PATTERN (insn
)) == ADDR_VEC
1408 || GET_CODE (PATTERN (insn
)) == ADDR_DIFF_VEC
))
1410 rtx pat
= PATTERN (insn
);
1411 int i
, diff_vec_p
= GET_CODE (pat
) == ADDR_DIFF_VEC
;
1412 int len
= XVECLEN (pat
, diff_vec_p
);
1414 for (i
= 0; i
< len
; i
++)
1415 if (LABEL_NUSES (XEXP (XVECEXP (pat
, diff_vec_p
, i
), 0)) == 0)
1416 delete_related_insns (XEXP (XVECEXP (pat
, diff_vec_p
, i
), 0));
1417 while (next
&& INSN_DELETED_P (next
))
1418 next
= NEXT_INSN (next
);
1422 /* Likewise for an ordinary INSN / CALL_INSN with a REG_LABEL note. */
1423 if (NONJUMP_INSN_P (insn
) || CALL_P (insn
))
1424 for (note
= REG_NOTES (insn
); note
; note
= XEXP (note
, 1))
1425 if (REG_NOTE_KIND (note
) == REG_LABEL
1426 /* This could also be a NOTE_INSN_DELETED_LABEL note. */
1427 && LABEL_P (XEXP (note
, 0)))
1428 if (LABEL_NUSES (XEXP (note
, 0)) == 0)
1429 delete_related_insns (XEXP (note
, 0));
1431 while (prev
&& (INSN_DELETED_P (prev
) || NOTE_P (prev
)))
1432 prev
= PREV_INSN (prev
);
1434 /* If INSN was a label and a dispatch table follows it,
1435 delete the dispatch table. The tablejump must have gone already.
1436 It isn't useful to fall through into a table. */
1439 && NEXT_INSN (insn
) != 0
1440 && JUMP_P (NEXT_INSN (insn
))
1441 && (GET_CODE (PATTERN (NEXT_INSN (insn
))) == ADDR_VEC
1442 || GET_CODE (PATTERN (NEXT_INSN (insn
))) == ADDR_DIFF_VEC
))
1443 next
= delete_related_insns (NEXT_INSN (insn
));
1445 /* If INSN was a label, delete insns following it if now unreachable. */
1447 if (was_code_label
&& prev
&& BARRIER_P (prev
))
1452 code
= GET_CODE (next
);
1454 && NOTE_LINE_NUMBER (next
) != NOTE_INSN_FUNCTION_END
)
1455 next
= NEXT_INSN (next
);
1456 /* Keep going past other deleted labels to delete what follows. */
1457 else if (code
== CODE_LABEL
&& INSN_DELETED_P (next
))
1458 next
= NEXT_INSN (next
);
1459 else if (code
== BARRIER
|| INSN_P (next
))
1460 /* Note: if this deletes a jump, it can cause more
1461 deletion of unreachable code, after a different label.
1462 As long as the value from this recursive call is correct,
1463 this invocation functions correctly. */
1464 next
= delete_related_insns (next
);
1473 /* Delete a range of insns from FROM to TO, inclusive.
1474 This is for the sake of peephole optimization, so assume
1475 that whatever these insns do will still be done by a new
1476 peephole insn that will replace them. */
1479 delete_for_peephole (rtx from
, rtx to
)
1485 rtx next
= NEXT_INSN (insn
);
1486 rtx prev
= PREV_INSN (insn
);
1490 INSN_DELETED_P (insn
) = 1;
1492 /* Patch this insn out of the chain. */
1493 /* We don't do this all at once, because we
1494 must preserve all NOTEs. */
1496 NEXT_INSN (prev
) = next
;
1499 PREV_INSN (next
) = prev
;
1507 /* Note that if TO is an unconditional jump
1508 we *do not* delete the BARRIER that follows,
1509 since the peephole that replaces this sequence
1510 is also an unconditional jump in that case. */
1513 /* Throughout LOC, redirect OLABEL to NLABEL. Treat null OLABEL or
1514 NLABEL as a return. Accrue modifications into the change group. */
1517 redirect_exp_1 (rtx
*loc
, rtx olabel
, rtx nlabel
, rtx insn
)
1520 RTX_CODE code
= GET_CODE (x
);
1524 if (code
== LABEL_REF
)
1526 if (XEXP (x
, 0) == olabel
)
1530 n
= gen_rtx_LABEL_REF (VOIDmode
, nlabel
);
1532 n
= gen_rtx_RETURN (VOIDmode
);
1534 validate_change (insn
, loc
, n
, 1);
1538 else if (code
== RETURN
&& olabel
== 0)
1540 x
= gen_rtx_LABEL_REF (VOIDmode
, nlabel
);
1541 if (loc
== &PATTERN (insn
))
1542 x
= gen_rtx_SET (VOIDmode
, pc_rtx
, x
);
1543 validate_change (insn
, loc
, x
, 1);
1547 if (code
== SET
&& nlabel
== 0 && SET_DEST (x
) == pc_rtx
1548 && GET_CODE (SET_SRC (x
)) == LABEL_REF
1549 && XEXP (SET_SRC (x
), 0) == olabel
)
1551 validate_change (insn
, loc
, gen_rtx_RETURN (VOIDmode
), 1);
1555 fmt
= GET_RTX_FORMAT (code
);
1556 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
1559 redirect_exp_1 (&XEXP (x
, i
), olabel
, nlabel
, insn
);
1560 else if (fmt
[i
] == 'E')
1563 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
1564 redirect_exp_1 (&XVECEXP (x
, i
, j
), olabel
, nlabel
, insn
);
1569 /* Similar, but apply the change group and report success or failure. */
1572 redirect_exp (rtx olabel
, rtx nlabel
, rtx insn
)
1576 if (GET_CODE (PATTERN (insn
)) == PARALLEL
)
1577 loc
= &XVECEXP (PATTERN (insn
), 0, 0);
1579 loc
= &PATTERN (insn
);
1581 redirect_exp_1 (loc
, olabel
, nlabel
, insn
);
1582 if (num_validated_changes () == 0)
1585 return apply_change_group ();
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
);
1623 if (nlabel
== olabel
)
1626 if (! redirect_exp (olabel
, nlabel
, jump
))
1629 JUMP_LABEL (jump
) = nlabel
;
1631 ++LABEL_NUSES (nlabel
);
1633 /* Update labels in any REG_EQUAL note. */
1634 if ((note
= find_reg_note (jump
, REG_EQUAL
, NULL_RTX
)) != NULL_RTX
)
1636 if (nlabel
&& olabel
)
1638 rtx dest
= XEXP (note
, 0);
1640 if (GET_CODE (dest
) == IF_THEN_ELSE
)
1642 if (GET_CODE (XEXP (dest
, 1)) == LABEL_REF
1643 && XEXP (XEXP (dest
, 1), 0) == olabel
)
1644 XEXP (XEXP (dest
, 1), 0) = nlabel
;
1645 if (GET_CODE (XEXP (dest
, 2)) == LABEL_REF
1646 && XEXP (XEXP (dest
, 2), 0) == olabel
)
1647 XEXP (XEXP (dest
, 2), 0) = nlabel
;
1650 remove_note (jump
, note
);
1653 remove_note (jump
, note
);
1656 /* If we're eliding the jump over exception cleanups at the end of a
1657 function, move the function end note so that -Wreturn-type works. */
1658 if (olabel
&& nlabel
1659 && NEXT_INSN (olabel
)
1660 && NOTE_P (NEXT_INSN (olabel
))
1661 && NOTE_LINE_NUMBER (NEXT_INSN (olabel
)) == NOTE_INSN_FUNCTION_END
)
1662 emit_note_after (NOTE_INSN_FUNCTION_END
, nlabel
);
1664 if (olabel
&& --LABEL_NUSES (olabel
) == 0 && delete_unused
1665 /* Undefined labels will remain outside the insn stream. */
1666 && INSN_UID (olabel
))
1667 delete_related_insns (olabel
);
1672 /* Invert the jump condition of rtx X contained in jump insn, INSN.
1673 Accrue the modifications into the change group. */
1676 invert_exp_1 (rtx insn
)
1679 rtx x
= pc_set (insn
);
1685 code
= GET_CODE (x
);
1687 if (code
== IF_THEN_ELSE
)
1689 rtx comp
= XEXP (x
, 0);
1691 enum rtx_code reversed_code
;
1693 /* We can do this in two ways: The preferable way, which can only
1694 be done if this is not an integer comparison, is to reverse
1695 the comparison code. Otherwise, swap the THEN-part and ELSE-part
1696 of the IF_THEN_ELSE. If we can't do either, fail. */
1698 reversed_code
= reversed_comparison_code (comp
, insn
);
1700 if (reversed_code
!= UNKNOWN
)
1702 validate_change (insn
, &XEXP (x
, 0),
1703 gen_rtx_fmt_ee (reversed_code
,
1704 GET_MODE (comp
), XEXP (comp
, 0),
1711 validate_change (insn
, &XEXP (x
, 1), XEXP (x
, 2), 1);
1712 validate_change (insn
, &XEXP (x
, 2), tem
, 1);
1718 /* Invert the jump condition of conditional jump insn, INSN.
1720 Return 1 if we can do so, 0 if we cannot find a way to do so that
1721 matches a pattern. */
1724 invert_exp (rtx insn
)
1726 invert_exp_1 (insn
);
1727 if (num_validated_changes () == 0)
1730 return apply_change_group ();
1733 /* Invert the condition of the jump JUMP, and make it jump to label
1734 NLABEL instead of where it jumps now. Accrue changes into the
1735 change group. Return false if we didn't see how to perform the
1736 inversion and redirection. */
1739 invert_jump_1 (rtx jump
, rtx nlabel
)
1743 ochanges
= num_validated_changes ();
1744 invert_exp_1 (jump
);
1745 if (num_validated_changes () == ochanges
)
1748 return redirect_jump_1 (jump
, nlabel
);
1751 /* Invert the condition of the jump JUMP, and make it jump to label
1752 NLABEL instead of where it jumps now. Return true if successful. */
1755 invert_jump (rtx jump
, rtx nlabel
, int delete_unused
)
1757 /* We have to either invert the condition and change the label or
1758 do neither. Either operation could fail. We first try to invert
1759 the jump. If that succeeds, we try changing the label. If that fails,
1760 we invert the jump back to what it was. */
1762 if (! invert_exp (jump
))
1765 if (redirect_jump (jump
, nlabel
, delete_unused
))
1767 /* Remove REG_EQUAL note if we have one. */
1768 rtx note
= find_reg_note (jump
, REG_EQUAL
, NULL_RTX
);
1770 remove_note (jump
, note
);
1772 invert_br_probabilities (jump
);
1777 if (! invert_exp (jump
))
1778 /* This should just be putting it back the way it was. */
1785 /* Like rtx_equal_p except that it considers two REGs as equal
1786 if they renumber to the same value and considers two commutative
1787 operations to be the same if the order of the operands has been
1790 ??? Addition is not commutative on the PA due to the weird implicit
1791 space register selection rules for memory addresses. Therefore, we
1792 don't consider a + b == b + a.
1794 We could/should make this test a little tighter. Possibly only
1795 disabling it on the PA via some backend macro or only disabling this
1796 case when the PLUS is inside a MEM. */
1799 rtx_renumbered_equal_p (rtx x
, rtx y
)
1802 enum rtx_code code
= GET_CODE (x
);
1808 if ((code
== REG
|| (code
== SUBREG
&& REG_P (SUBREG_REG (x
))))
1809 && (REG_P (y
) || (GET_CODE (y
) == SUBREG
1810 && REG_P (SUBREG_REG (y
)))))
1812 int reg_x
= -1, reg_y
= -1;
1813 int byte_x
= 0, byte_y
= 0;
1815 if (GET_MODE (x
) != GET_MODE (y
))
1818 /* If we haven't done any renumbering, don't
1819 make any assumptions. */
1820 if (reg_renumber
== 0)
1821 return rtx_equal_p (x
, y
);
1825 reg_x
= REGNO (SUBREG_REG (x
));
1826 byte_x
= SUBREG_BYTE (x
);
1828 if (reg_renumber
[reg_x
] >= 0)
1830 reg_x
= subreg_regno_offset (reg_renumber
[reg_x
],
1831 GET_MODE (SUBREG_REG (x
)),
1840 if (reg_renumber
[reg_x
] >= 0)
1841 reg_x
= reg_renumber
[reg_x
];
1844 if (GET_CODE (y
) == SUBREG
)
1846 reg_y
= REGNO (SUBREG_REG (y
));
1847 byte_y
= SUBREG_BYTE (y
);
1849 if (reg_renumber
[reg_y
] >= 0)
1851 reg_y
= subreg_regno_offset (reg_renumber
[reg_y
],
1852 GET_MODE (SUBREG_REG (y
)),
1861 if (reg_renumber
[reg_y
] >= 0)
1862 reg_y
= reg_renumber
[reg_y
];
1865 return reg_x
>= 0 && reg_x
== reg_y
&& byte_x
== byte_y
;
1868 /* Now we have disposed of all the cases
1869 in which different rtx codes can match. */
1870 if (code
!= GET_CODE (y
))
1883 /* We can't assume nonlocal labels have their following insns yet. */
1884 if (LABEL_REF_NONLOCAL_P (x
) || LABEL_REF_NONLOCAL_P (y
))
1885 return XEXP (x
, 0) == XEXP (y
, 0);
1887 /* Two label-refs are equivalent if they point at labels
1888 in the same position in the instruction stream. */
1889 return (next_real_insn (XEXP (x
, 0))
1890 == next_real_insn (XEXP (y
, 0)));
1893 return XSTR (x
, 0) == XSTR (y
, 0);
1896 /* If we didn't match EQ equality above, they aren't the same. */
1903 /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent. */
1905 if (GET_MODE (x
) != GET_MODE (y
))
1908 /* For commutative operations, the RTX match if the operand match in any
1909 order. Also handle the simple binary and unary cases without a loop.
1911 ??? Don't consider PLUS a commutative operator; see comments above. */
1912 if (COMMUTATIVE_P (x
) && code
!= PLUS
)
1913 return ((rtx_renumbered_equal_p (XEXP (x
, 0), XEXP (y
, 0))
1914 && rtx_renumbered_equal_p (XEXP (x
, 1), XEXP (y
, 1)))
1915 || (rtx_renumbered_equal_p (XEXP (x
, 0), XEXP (y
, 1))
1916 && rtx_renumbered_equal_p (XEXP (x
, 1), XEXP (y
, 0))));
1917 else if (NON_COMMUTATIVE_P (x
))
1918 return (rtx_renumbered_equal_p (XEXP (x
, 0), XEXP (y
, 0))
1919 && rtx_renumbered_equal_p (XEXP (x
, 1), XEXP (y
, 1)));
1920 else if (UNARY_P (x
))
1921 return rtx_renumbered_equal_p (XEXP (x
, 0), XEXP (y
, 0));
1923 /* Compare the elements. If any pair of corresponding elements
1924 fail to match, return 0 for the whole things. */
1926 fmt
= GET_RTX_FORMAT (code
);
1927 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
1933 if (XWINT (x
, i
) != XWINT (y
, i
))
1938 if (XINT (x
, i
) != XINT (y
, i
))
1943 if (XTREE (x
, i
) != XTREE (y
, i
))
1948 if (strcmp (XSTR (x
, i
), XSTR (y
, i
)))
1953 if (! rtx_renumbered_equal_p (XEXP (x
, i
), XEXP (y
, i
)))
1958 if (XEXP (x
, i
) != XEXP (y
, i
))
1965 if (XVECLEN (x
, i
) != XVECLEN (y
, i
))
1967 for (j
= XVECLEN (x
, i
) - 1; j
>= 0; j
--)
1968 if (!rtx_renumbered_equal_p (XVECEXP (x
, i
, j
), XVECEXP (y
, i
, j
)))
1979 /* If X is a hard register or equivalent to one or a subregister of one,
1980 return the hard register number. If X is a pseudo register that was not
1981 assigned a hard register, return the pseudo register number. Otherwise,
1982 return -1. Any rtx is valid for X. */
1989 if (REGNO (x
) >= FIRST_PSEUDO_REGISTER
&& reg_renumber
[REGNO (x
)] >= 0)
1990 return reg_renumber
[REGNO (x
)];
1993 if (GET_CODE (x
) == SUBREG
)
1995 int base
= true_regnum (SUBREG_REG (x
));
1996 if (base
>= 0 && base
< FIRST_PSEUDO_REGISTER
)
1997 return base
+ subreg_regno_offset (REGNO (SUBREG_REG (x
)),
1998 GET_MODE (SUBREG_REG (x
)),
1999 SUBREG_BYTE (x
), GET_MODE (x
));
2004 /* Return regno of the register REG and handle subregs too. */
2006 reg_or_subregno (rtx reg
)
2010 if (GET_CODE (reg
) == SUBREG
)
2011 return REGNO (SUBREG_REG (reg
));