1 /* Optimize jump instructions, for GNU compiler.
2 Copyright (C) 1987-2014 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
20 /* This is the pathetic reminder of old fame of the jump-optimization pass
21 of the compiler. Now it contains basically a set of utility functions to
24 Each CODE_LABEL has a count of the times it is used
25 stored in the LABEL_NUSES internal field, and each JUMP_INSN
26 has one label that it refers to stored in the
27 JUMP_LABEL internal field. With this we can detect labels that
28 become unused because of the deletion of all the jumps that
29 formerly used them. The JUMP_LABEL info is sometimes looked
30 at by later passes. For return insns, it contains either a
31 RETURN or a SIMPLE_RETURN rtx.
33 The subroutines redirect_jump and invert_jump are used
34 from other passes as well. */
38 #include "coretypes.h"
43 #include "hard-reg-set.h"
45 #include "insn-config.h"
46 #include "insn-attr.h"
49 #include "basic-block.h"
52 #include "diagnostic-core.h"
55 #include "tree-pass.h"
58 /* Optimize jump y; x: ... y: jumpif... x?
59 Don't know if it is worth bothering with. */
60 /* Optimize two cases of conditional jump to conditional jump?
61 This can never delete any instruction or make anything dead,
62 or even change what is live at any point.
63 So perhaps let combiner do it. */
65 static void init_label_info (rtx
);
66 static void mark_all_labels (rtx
);
67 static void mark_jump_label_1 (rtx
, rtx
, bool, bool);
68 static void mark_jump_label_asm (rtx
, rtx
);
69 static void redirect_exp_1 (rtx
*, rtx
, rtx
, rtx
);
70 static int invert_exp_1 (rtx
, rtx
);
71 static int returnjump_p_1 (rtx
*, void *);
73 /* Worker for rebuild_jump_labels and rebuild_jump_labels_chain. */
75 rebuild_jump_labels_1 (rtx f
, bool count_forced
)
79 timevar_push (TV_REBUILD_JUMP
);
83 /* Keep track of labels used from static data; we don't track them
84 closely enough to delete them here, so make sure their reference
85 count doesn't drop to zero. */
88 for (insn
= forced_labels
; insn
; insn
= XEXP (insn
, 1))
89 if (LABEL_P (XEXP (insn
, 0)))
90 LABEL_NUSES (XEXP (insn
, 0))++;
91 timevar_pop (TV_REBUILD_JUMP
);
94 /* This function rebuilds the JUMP_LABEL field and REG_LABEL_TARGET
95 notes in jumping insns and REG_LABEL_OPERAND notes in non-jumping
96 instructions and jumping insns that have labels as operands
99 rebuild_jump_labels (rtx f
)
101 rebuild_jump_labels_1 (f
, true);
104 /* This function is like rebuild_jump_labels, but doesn't run over
105 forced_labels. It can be used on insn chains that aren't the
106 main function chain. */
108 rebuild_jump_labels_chain (rtx chain
)
110 rebuild_jump_labels_1 (chain
, false);
113 /* Some old code expects exactly one BARRIER as the NEXT_INSN of a
114 non-fallthru insn. This is not generally true, as multiple barriers
115 may have crept in, or the BARRIER may be separated from the last
116 real insn by one or more NOTEs.
118 This simple pass moves barriers and removes duplicates so that the
122 cleanup_barriers (void)
125 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
127 if (BARRIER_P (insn
))
129 rtx prev
= prev_nonnote_insn (insn
);
135 /* Make sure we do not split a call and its corresponding
136 CALL_ARG_LOCATION note. */
137 rtx next
= NEXT_INSN (prev
);
140 && NOTE_KIND (next
) == NOTE_INSN_CALL_ARG_LOCATION
)
144 if (BARRIER_P (prev
))
146 else if (prev
!= PREV_INSN (insn
))
147 reorder_insns_nobb (insn
, insn
, prev
);
155 const pass_data pass_data_cleanup_barriers
=
158 "barriers", /* name */
159 OPTGROUP_NONE
, /* optinfo_flags */
161 0, /* properties_required */
162 0, /* properties_provided */
163 0, /* properties_destroyed */
164 0, /* todo_flags_start */
165 0, /* todo_flags_finish */
168 class pass_cleanup_barriers
: public rtl_opt_pass
171 pass_cleanup_barriers (gcc::context
*ctxt
)
172 : rtl_opt_pass (pass_data_cleanup_barriers
, ctxt
)
175 /* opt_pass methods: */
176 virtual unsigned int execute (function
*) { return cleanup_barriers (); }
178 }; // class pass_cleanup_barriers
183 make_pass_cleanup_barriers (gcc::context
*ctxt
)
185 return new pass_cleanup_barriers (ctxt
);
189 /* Initialize LABEL_NUSES and JUMP_LABEL fields, add REG_LABEL_TARGET
190 for remaining targets for JUMP_P. Delete any REG_LABEL_OPERAND
191 notes whose labels don't occur in the insn any more. */
194 init_label_info (rtx f
)
198 for (insn
= f
; insn
; insn
= NEXT_INSN (insn
))
201 LABEL_NUSES (insn
) = (LABEL_PRESERVE_P (insn
) != 0);
203 /* REG_LABEL_TARGET notes (including the JUMP_LABEL field) are
204 sticky and not reset here; that way we won't lose association
205 with a label when e.g. the source for a target register
206 disappears out of reach for targets that may use jump-target
207 registers. Jump transformations are supposed to transform
208 any REG_LABEL_TARGET notes. The target label reference in a
209 branch may disappear from the branch (and from the
210 instruction before it) for other reasons, like register
217 for (note
= REG_NOTES (insn
); note
; note
= next
)
219 next
= XEXP (note
, 1);
220 if (REG_NOTE_KIND (note
) == REG_LABEL_OPERAND
221 && ! reg_mentioned_p (XEXP (note
, 0), PATTERN (insn
)))
222 remove_note (insn
, note
);
228 /* A subroutine of mark_all_labels. Trivially propagate a simple label
229 load into a jump_insn that uses it. */
232 maybe_propagate_label_ref (rtx jump_insn
, rtx prev_nonjump_insn
)
234 rtx label_note
, pc
, pc_src
;
236 pc
= pc_set (jump_insn
);
237 pc_src
= pc
!= NULL
? SET_SRC (pc
) : NULL
;
238 label_note
= find_reg_note (prev_nonjump_insn
, REG_LABEL_OPERAND
, NULL
);
240 /* If the previous non-jump insn sets something to a label,
241 something that this jump insn uses, make that label the primary
242 target of this insn if we don't yet have any. That previous
243 insn must be a single_set and not refer to more than one label.
244 The jump insn must not refer to other labels as jump targets
245 and must be a plain (set (pc) ...), maybe in a parallel, and
246 may refer to the item being set only directly or as one of the
247 arms in an IF_THEN_ELSE. */
249 if (label_note
!= NULL
&& pc_src
!= NULL
)
251 rtx label_set
= single_set (prev_nonjump_insn
);
252 rtx label_dest
= label_set
!= NULL
? SET_DEST (label_set
) : NULL
;
254 if (label_set
!= NULL
255 /* The source must be the direct LABEL_REF, not a
256 PLUS, UNSPEC, IF_THEN_ELSE etc. */
257 && GET_CODE (SET_SRC (label_set
)) == LABEL_REF
258 && (rtx_equal_p (label_dest
, pc_src
)
259 || (GET_CODE (pc_src
) == IF_THEN_ELSE
260 && (rtx_equal_p (label_dest
, XEXP (pc_src
, 1))
261 || rtx_equal_p (label_dest
, XEXP (pc_src
, 2))))))
263 /* The CODE_LABEL referred to in the note must be the
264 CODE_LABEL in the LABEL_REF of the "set". We can
265 conveniently use it for the marker function, which
266 requires a LABEL_REF wrapping. */
267 gcc_assert (XEXP (label_note
, 0) == XEXP (SET_SRC (label_set
), 0));
269 mark_jump_label_1 (label_set
, jump_insn
, false, true);
271 gcc_assert (JUMP_LABEL (jump_insn
) == XEXP (label_note
, 0));
276 /* Mark the label each jump jumps to.
277 Combine consecutive labels, and count uses of labels. */
280 mark_all_labels (rtx f
)
284 if (current_ir_type () == IR_RTL_CFGLAYOUT
)
287 FOR_EACH_BB_FN (bb
, cfun
)
289 /* In cfglayout mode, we don't bother with trivial next-insn
290 propagation of LABEL_REFs into JUMP_LABEL. This will be
291 handled by other optimizers using better algorithms. */
292 FOR_BB_INSNS (bb
, insn
)
294 gcc_assert (! INSN_DELETED_P (insn
));
295 if (NONDEBUG_INSN_P (insn
))
296 mark_jump_label (PATTERN (insn
), insn
, 0);
299 /* In cfglayout mode, there may be non-insns between the
300 basic blocks. If those non-insns represent tablejump data,
301 they contain label references that we must record. */
302 for (insn
= BB_HEADER (bb
); insn
; insn
= NEXT_INSN (insn
))
303 if (JUMP_TABLE_DATA_P (insn
))
304 mark_jump_label (PATTERN (insn
), insn
, 0);
305 for (insn
= BB_FOOTER (bb
); insn
; insn
= NEXT_INSN (insn
))
306 if (JUMP_TABLE_DATA_P (insn
))
307 mark_jump_label (PATTERN (insn
), insn
, 0);
312 rtx prev_nonjump_insn
= NULL
;
313 for (insn
= f
; insn
; insn
= NEXT_INSN (insn
))
315 if (INSN_DELETED_P (insn
))
317 else if (LABEL_P (insn
))
318 prev_nonjump_insn
= NULL
;
319 else if (JUMP_TABLE_DATA_P (insn
))
320 mark_jump_label (PATTERN (insn
), insn
, 0);
321 else if (NONDEBUG_INSN_P (insn
))
323 mark_jump_label (PATTERN (insn
), insn
, 0);
326 if (JUMP_LABEL (insn
) == NULL
&& prev_nonjump_insn
!= NULL
)
327 maybe_propagate_label_ref (insn
, prev_nonjump_insn
);
330 prev_nonjump_insn
= insn
;
336 /* Given a comparison (CODE ARG0 ARG1), inside an insn, INSN, return a code
337 of reversed comparison if it is possible to do so. Otherwise return UNKNOWN.
338 UNKNOWN may be returned in case we are having CC_MODE compare and we don't
339 know whether it's source is floating point or integer comparison. Machine
340 description should define REVERSIBLE_CC_MODE and REVERSE_CONDITION macros
341 to help this function avoid overhead in these cases. */
343 reversed_comparison_code_parts (enum rtx_code code
, const_rtx arg0
,
344 const_rtx arg1
, const_rtx insn
)
346 enum machine_mode mode
;
348 /* If this is not actually a comparison, we can't reverse it. */
349 if (GET_RTX_CLASS (code
) != RTX_COMPARE
350 && GET_RTX_CLASS (code
) != RTX_COMM_COMPARE
)
353 mode
= GET_MODE (arg0
);
354 if (mode
== VOIDmode
)
355 mode
= GET_MODE (arg1
);
357 /* First see if machine description supplies us way to reverse the
358 comparison. Give it priority over everything else to allow
359 machine description to do tricks. */
360 if (GET_MODE_CLASS (mode
) == MODE_CC
361 && REVERSIBLE_CC_MODE (mode
))
363 #ifdef REVERSE_CONDITION
364 return REVERSE_CONDITION (code
, mode
);
366 return reverse_condition (code
);
370 /* Try a few special cases based on the comparison code. */
379 /* It is always safe to reverse EQ and NE, even for the floating
380 point. Similarly the unsigned comparisons are never used for
381 floating point so we can reverse them in the default way. */
382 return reverse_condition (code
);
387 /* In case we already see unordered comparison, we can be sure to
388 be dealing with floating point so we don't need any more tests. */
389 return reverse_condition_maybe_unordered (code
);
394 /* We don't have safe way to reverse these yet. */
400 if (GET_MODE_CLASS (mode
) == MODE_CC
|| CC0_P (arg0
))
403 /* Try to search for the comparison to determine the real mode.
404 This code is expensive, but with sane machine description it
405 will be never used, since REVERSIBLE_CC_MODE will return true
410 /* These CONST_CAST's are okay because prev_nonnote_insn just
411 returns its argument and we assign it to a const_rtx
413 for (prev
= prev_nonnote_insn (CONST_CAST_RTX (insn
));
414 prev
!= 0 && !LABEL_P (prev
);
415 prev
= prev_nonnote_insn (CONST_CAST_RTX (prev
)))
417 const_rtx set
= set_of (arg0
, prev
);
418 if (set
&& GET_CODE (set
) == SET
419 && rtx_equal_p (SET_DEST (set
), arg0
))
421 rtx src
= SET_SRC (set
);
423 if (GET_CODE (src
) == COMPARE
)
425 rtx comparison
= src
;
426 arg0
= XEXP (src
, 0);
427 mode
= GET_MODE (arg0
);
428 if (mode
== VOIDmode
)
429 mode
= GET_MODE (XEXP (comparison
, 1));
432 /* We can get past reg-reg moves. This may be useful for model
433 of i387 comparisons that first move flag registers around. */
440 /* If register is clobbered in some ununderstandable way,
447 /* Test for an integer condition, or a floating-point comparison
448 in which NaNs can be ignored. */
449 if (CONST_INT_P (arg0
)
450 || (GET_MODE (arg0
) != VOIDmode
451 && GET_MODE_CLASS (mode
) != MODE_CC
452 && !HONOR_NANS (mode
)))
453 return reverse_condition (code
);
458 /* A wrapper around the previous function to take COMPARISON as rtx
459 expression. This simplifies many callers. */
461 reversed_comparison_code (const_rtx comparison
, const_rtx insn
)
463 if (!COMPARISON_P (comparison
))
465 return reversed_comparison_code_parts (GET_CODE (comparison
),
466 XEXP (comparison
, 0),
467 XEXP (comparison
, 1), insn
);
470 /* Return comparison with reversed code of EXP.
471 Return NULL_RTX in case we fail to do the reversal. */
473 reversed_comparison (const_rtx exp
, enum machine_mode mode
)
475 enum rtx_code reversed_code
= reversed_comparison_code (exp
, NULL_RTX
);
476 if (reversed_code
== UNKNOWN
)
479 return simplify_gen_relational (reversed_code
, mode
, VOIDmode
,
480 XEXP (exp
, 0), XEXP (exp
, 1));
484 /* Given an rtx-code for a comparison, return the code for the negated
485 comparison. If no such code exists, return UNKNOWN.
487 WATCH OUT! reverse_condition is not safe to use on a jump that might
488 be acting on the results of an IEEE floating point comparison, because
489 of the special treatment of non-signaling nans in comparisons.
490 Use reversed_comparison_code instead. */
493 reverse_condition (enum rtx_code code
)
535 /* Similar, but we're allowed to generate unordered comparisons, which
536 makes it safe for IEEE floating-point. Of course, we have to recognize
537 that the target will support them too... */
540 reverse_condition_maybe_unordered (enum rtx_code code
)
578 /* Similar, but return the code when two operands of a comparison are swapped.
579 This IS safe for IEEE floating-point. */
582 swap_condition (enum rtx_code code
)
624 /* Given a comparison CODE, return the corresponding unsigned comparison.
625 If CODE is an equality comparison or already an unsigned comparison,
629 unsigned_condition (enum rtx_code code
)
655 /* Similarly, return the signed version of a comparison. */
658 signed_condition (enum rtx_code code
)
684 /* Return nonzero if CODE1 is more strict than CODE2, i.e., if the
685 truth of CODE1 implies the truth of CODE2. */
688 comparison_dominates_p (enum rtx_code code1
, enum rtx_code code2
)
690 /* UNKNOWN comparison codes can happen as a result of trying to revert
692 They can't match anything, so we have to reject them here. */
693 if (code1
== UNKNOWN
|| code2
== UNKNOWN
)
702 if (code2
== UNLE
|| code2
== UNGE
)
707 if (code2
== LE
|| code2
== LEU
|| code2
== GE
|| code2
== GEU
713 if (code2
== UNLE
|| code2
== NE
)
718 if (code2
== LE
|| code2
== NE
|| code2
== ORDERED
|| code2
== LTGT
)
723 if (code2
== UNGE
|| code2
== NE
)
728 if (code2
== GE
|| code2
== NE
|| code2
== ORDERED
|| code2
== LTGT
)
734 if (code2
== ORDERED
)
739 if (code2
== NE
|| code2
== ORDERED
)
744 if (code2
== LEU
|| code2
== NE
)
749 if (code2
== GEU
|| code2
== NE
)
754 if (code2
== NE
|| code2
== UNEQ
|| code2
== UNLE
|| code2
== UNLT
755 || code2
== UNGE
|| code2
== UNGT
)
766 /* Return 1 if INSN is an unconditional jump and nothing else. */
769 simplejump_p (const_rtx insn
)
771 return (JUMP_P (insn
)
772 && GET_CODE (PATTERN (insn
)) == SET
773 && GET_CODE (SET_DEST (PATTERN (insn
))) == PC
774 && GET_CODE (SET_SRC (PATTERN (insn
))) == LABEL_REF
);
777 /* Return nonzero if INSN is a (possibly) conditional jump
780 Use of this function is deprecated, since we need to support combined
781 branch and compare insns. Use any_condjump_p instead whenever possible. */
784 condjump_p (const_rtx insn
)
786 const_rtx x
= PATTERN (insn
);
788 if (GET_CODE (x
) != SET
789 || GET_CODE (SET_DEST (x
)) != PC
)
793 if (GET_CODE (x
) == LABEL_REF
)
796 return (GET_CODE (x
) == IF_THEN_ELSE
797 && ((GET_CODE (XEXP (x
, 2)) == PC
798 && (GET_CODE (XEXP (x
, 1)) == LABEL_REF
799 || ANY_RETURN_P (XEXP (x
, 1))))
800 || (GET_CODE (XEXP (x
, 1)) == PC
801 && (GET_CODE (XEXP (x
, 2)) == LABEL_REF
802 || ANY_RETURN_P (XEXP (x
, 2))))));
805 /* Return nonzero if INSN is a (possibly) conditional jump inside a
808 Use this function is deprecated, since we need to support combined
809 branch and compare insns. Use any_condjump_p instead whenever possible. */
812 condjump_in_parallel_p (const_rtx insn
)
814 const_rtx x
= PATTERN (insn
);
816 if (GET_CODE (x
) != PARALLEL
)
819 x
= XVECEXP (x
, 0, 0);
821 if (GET_CODE (x
) != SET
)
823 if (GET_CODE (SET_DEST (x
)) != PC
)
825 if (GET_CODE (SET_SRC (x
)) == LABEL_REF
)
827 if (GET_CODE (SET_SRC (x
)) != IF_THEN_ELSE
)
829 if (XEXP (SET_SRC (x
), 2) == pc_rtx
830 && (GET_CODE (XEXP (SET_SRC (x
), 1)) == LABEL_REF
831 || ANY_RETURN_P (XEXP (SET_SRC (x
), 1))))
833 if (XEXP (SET_SRC (x
), 1) == pc_rtx
834 && (GET_CODE (XEXP (SET_SRC (x
), 2)) == LABEL_REF
835 || ANY_RETURN_P (XEXP (SET_SRC (x
), 2))))
840 /* Return set of PC, otherwise NULL. */
843 pc_set (const_rtx insn
)
848 pat
= PATTERN (insn
);
850 /* The set is allowed to appear either as the insn pattern or
851 the first set in a PARALLEL. */
852 if (GET_CODE (pat
) == PARALLEL
)
853 pat
= XVECEXP (pat
, 0, 0);
854 if (GET_CODE (pat
) == SET
&& GET_CODE (SET_DEST (pat
)) == PC
)
860 /* Return true when insn is an unconditional direct jump,
861 possibly bundled inside a PARALLEL. */
864 any_uncondjump_p (const_rtx insn
)
866 const_rtx x
= pc_set (insn
);
869 if (GET_CODE (SET_SRC (x
)) != LABEL_REF
)
871 if (find_reg_note (insn
, REG_NON_LOCAL_GOTO
, NULL_RTX
))
876 /* Return true when insn is a conditional jump. This function works for
877 instructions containing PC sets in PARALLELs. The instruction may have
878 various other effects so before removing the jump you must verify
881 Note that unlike condjump_p it returns false for unconditional jumps. */
884 any_condjump_p (const_rtx insn
)
886 const_rtx x
= pc_set (insn
);
891 if (GET_CODE (SET_SRC (x
)) != IF_THEN_ELSE
)
894 a
= GET_CODE (XEXP (SET_SRC (x
), 1));
895 b
= GET_CODE (XEXP (SET_SRC (x
), 2));
897 return ((b
== PC
&& (a
== LABEL_REF
|| a
== RETURN
|| a
== SIMPLE_RETURN
))
899 && (b
== LABEL_REF
|| b
== RETURN
|| b
== SIMPLE_RETURN
)));
902 /* Return the label of a conditional jump. */
905 condjump_label (const_rtx insn
)
907 rtx x
= pc_set (insn
);
912 if (GET_CODE (x
) == LABEL_REF
)
914 if (GET_CODE (x
) != IF_THEN_ELSE
)
916 if (XEXP (x
, 2) == pc_rtx
&& GET_CODE (XEXP (x
, 1)) == LABEL_REF
)
918 if (XEXP (x
, 1) == pc_rtx
&& GET_CODE (XEXP (x
, 2)) == LABEL_REF
)
923 /* Return true if INSN is a (possibly conditional) return insn. */
926 returnjump_p_1 (rtx
*loc
, void *data ATTRIBUTE_UNUSED
)
933 switch (GET_CODE (x
))
941 return SET_IS_RETURN_P (x
);
948 /* Return TRUE if INSN is a return jump. */
951 returnjump_p (rtx insn
)
955 return for_each_rtx (&PATTERN (insn
), returnjump_p_1
, NULL
);
958 /* Return true if INSN is a (possibly conditional) return insn. */
961 eh_returnjump_p_1 (rtx
*loc
, void *data ATTRIBUTE_UNUSED
)
963 return *loc
&& GET_CODE (*loc
) == EH_RETURN
;
967 eh_returnjump_p (rtx insn
)
971 return for_each_rtx (&PATTERN (insn
), eh_returnjump_p_1
, NULL
);
974 /* Return true if INSN is a jump that only transfers control and
978 onlyjump_p (const_rtx insn
)
985 set
= single_set (insn
);
988 if (GET_CODE (SET_DEST (set
)) != PC
)
990 if (side_effects_p (SET_SRC (set
)))
996 /* Return true iff INSN is a jump and its JUMP_LABEL is a label, not
999 jump_to_label_p (rtx insn
)
1001 return (JUMP_P (insn
)
1002 && JUMP_LABEL (insn
) != NULL
&& !ANY_RETURN_P (JUMP_LABEL (insn
)));
1007 /* Return nonzero if X is an RTX that only sets the condition codes
1008 and has no side effects. */
1011 only_sets_cc0_p (const_rtx x
)
1019 return sets_cc0_p (x
) == 1 && ! side_effects_p (x
);
1022 /* Return 1 if X is an RTX that does nothing but set the condition codes
1023 and CLOBBER or USE registers.
1024 Return -1 if X does explicitly set the condition codes,
1025 but also does other things. */
1028 sets_cc0_p (const_rtx x
)
1036 if (GET_CODE (x
) == SET
&& SET_DEST (x
) == cc0_rtx
)
1038 if (GET_CODE (x
) == PARALLEL
)
1042 int other_things
= 0;
1043 for (i
= XVECLEN (x
, 0) - 1; i
>= 0; i
--)
1045 if (GET_CODE (XVECEXP (x
, 0, i
)) == SET
1046 && SET_DEST (XVECEXP (x
, 0, i
)) == cc0_rtx
)
1048 else if (GET_CODE (XVECEXP (x
, 0, i
)) == SET
)
1051 return ! sets_cc0
? 0 : other_things
? -1 : 1;
1057 /* Find all CODE_LABELs referred to in X, and increment their use
1058 counts. If INSN is a JUMP_INSN and there is at least one
1059 CODE_LABEL referenced in INSN as a jump target, then store the last
1060 one in JUMP_LABEL (INSN). For a tablejump, this must be the label
1061 for the ADDR_VEC. Store any other jump targets as REG_LABEL_TARGET
1062 notes. If INSN is an INSN or a CALL_INSN or non-target operands of
1063 a JUMP_INSN, and there is at least one CODE_LABEL referenced in
1064 INSN, add a REG_LABEL_OPERAND note containing that label to INSN.
1065 For returnjumps, the JUMP_LABEL will also be set as appropriate.
1067 Note that two labels separated by a loop-beginning note
1068 must be kept distinct if we have not yet done loop-optimization,
1069 because the gap between them is where loop-optimize
1070 will want to move invariant code to. CROSS_JUMP tells us
1071 that loop-optimization is done with. */
1074 mark_jump_label (rtx x
, rtx insn
, int in_mem
)
1076 rtx asmop
= extract_asm_operands (x
);
1078 mark_jump_label_asm (asmop
, insn
);
1080 mark_jump_label_1 (x
, insn
, in_mem
!= 0,
1081 (insn
!= NULL
&& x
== PATTERN (insn
) && JUMP_P (insn
)));
1084 /* Worker function for mark_jump_label. IN_MEM is TRUE when X occurs
1085 within a (MEM ...). IS_TARGET is TRUE when X is to be treated as a
1086 jump-target; when the JUMP_LABEL field of INSN should be set or a
1087 REG_LABEL_TARGET note should be added, not a REG_LABEL_OPERAND
1091 mark_jump_label_1 (rtx x
, rtx insn
, bool in_mem
, bool is_target
)
1093 RTX_CODE code
= GET_CODE (x
);
1110 gcc_assert (JUMP_LABEL (insn
) == NULL
|| JUMP_LABEL (insn
) == x
);
1111 JUMP_LABEL (insn
) = x
;
1120 for (i
= 0; i
< XVECLEN (x
, 0); i
++)
1121 mark_jump_label (PATTERN (XVECEXP (x
, 0, i
)),
1122 XVECEXP (x
, 0, i
), 0);
1129 /* If this is a constant-pool reference, see if it is a label. */
1130 if (CONSTANT_POOL_ADDRESS_P (x
))
1131 mark_jump_label_1 (get_pool_constant (x
), insn
, in_mem
, is_target
);
1134 /* Handle operands in the condition of an if-then-else as for a
1139 mark_jump_label_1 (XEXP (x
, 0), insn
, in_mem
, false);
1140 mark_jump_label_1 (XEXP (x
, 1), insn
, in_mem
, true);
1141 mark_jump_label_1 (XEXP (x
, 2), insn
, in_mem
, true);
1146 rtx label
= XEXP (x
, 0);
1148 /* Ignore remaining references to unreachable labels that
1149 have been deleted. */
1151 && NOTE_KIND (label
) == NOTE_INSN_DELETED_LABEL
)
1154 gcc_assert (LABEL_P (label
));
1156 /* Ignore references to labels of containing functions. */
1157 if (LABEL_REF_NONLOCAL_P (x
))
1160 XEXP (x
, 0) = label
;
1161 if (! insn
|| ! INSN_DELETED_P (insn
))
1162 ++LABEL_NUSES (label
);
1167 /* Do not change a previous setting of JUMP_LABEL. If the
1168 JUMP_LABEL slot is occupied by a different label,
1169 create a note for this label. */
1170 && (JUMP_LABEL (insn
) == NULL
|| JUMP_LABEL (insn
) == label
))
1171 JUMP_LABEL (insn
) = label
;
1175 = is_target
? REG_LABEL_TARGET
: REG_LABEL_OPERAND
;
1177 /* Add a REG_LABEL_OPERAND or REG_LABEL_TARGET note
1178 for LABEL unless there already is one. All uses of
1179 a label, except for the primary target of a jump,
1180 must have such a note. */
1181 if (! find_reg_note (insn
, kind
, label
))
1182 add_reg_note (insn
, kind
, label
);
1188 /* Do walk the labels in a vector, but not the first operand of an
1189 ADDR_DIFF_VEC. Don't set the JUMP_LABEL of a vector. */
1192 if (! INSN_DELETED_P (insn
))
1194 int eltnum
= code
== ADDR_DIFF_VEC
? 1 : 0;
1196 for (i
= 0; i
< XVECLEN (x
, eltnum
); i
++)
1197 mark_jump_label_1 (XVECEXP (x
, eltnum
, i
), NULL_RTX
, in_mem
,
1206 fmt
= GET_RTX_FORMAT (code
);
1208 /* The primary target of a tablejump is the label of the ADDR_VEC,
1209 which is canonically mentioned *last* in the insn. To get it
1210 marked as JUMP_LABEL, we iterate over items in reverse order. */
1211 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
1214 mark_jump_label_1 (XEXP (x
, i
), insn
, in_mem
, is_target
);
1215 else if (fmt
[i
] == 'E')
1219 for (j
= XVECLEN (x
, i
) - 1; j
>= 0; j
--)
1220 mark_jump_label_1 (XVECEXP (x
, i
, j
), insn
, in_mem
,
1226 /* Worker function for mark_jump_label. Handle asm insns specially.
1227 In particular, output operands need not be considered so we can
1228 avoid re-scanning the replicated asm_operand. Also, the asm_labels
1229 need to be considered targets. */
1232 mark_jump_label_asm (rtx asmop
, rtx insn
)
1236 for (i
= ASM_OPERANDS_INPUT_LENGTH (asmop
) - 1; i
>= 0; --i
)
1237 mark_jump_label_1 (ASM_OPERANDS_INPUT (asmop
, i
), insn
, false, false);
1239 for (i
= ASM_OPERANDS_LABEL_LENGTH (asmop
) - 1; i
>= 0; --i
)
1240 mark_jump_label_1 (ASM_OPERANDS_LABEL (asmop
, i
), insn
, false, true);
1243 /* Delete insn INSN from the chain of insns and update label ref counts
1244 and delete insns now unreachable.
1246 Returns the first insn after INSN that was not deleted.
1248 Usage of this instruction is deprecated. Use delete_insn instead and
1249 subsequent cfg_cleanup pass to delete unreachable code if needed. */
1252 delete_related_insns (rtx insn
)
1254 int was_code_label
= (LABEL_P (insn
));
1256 rtx next
= NEXT_INSN (insn
), prev
= PREV_INSN (insn
);
1258 while (next
&& INSN_DELETED_P (next
))
1259 next
= NEXT_INSN (next
);
1261 /* This insn is already deleted => return first following nondeleted. */
1262 if (INSN_DELETED_P (insn
))
1267 /* If instruction is followed by a barrier,
1268 delete the barrier too. */
1270 if (next
!= 0 && BARRIER_P (next
))
1273 /* If this is a call, then we have to remove the var tracking note
1274 for the call arguments. */
1277 || (NONJUMP_INSN_P (insn
)
1278 && GET_CODE (PATTERN (insn
)) == SEQUENCE
1279 && CALL_P (XVECEXP (PATTERN (insn
), 0, 0))))
1283 for (p
= next
&& INSN_DELETED_P (next
) ? NEXT_INSN (next
) : next
;
1286 if (NOTE_KIND (p
) == NOTE_INSN_CALL_ARG_LOCATION
)
1293 /* If deleting a jump, decrement the count of the label,
1294 and delete the label if it is now unused. */
1296 if (jump_to_label_p (insn
))
1298 rtx lab
= JUMP_LABEL (insn
);
1299 rtx_jump_table_data
*lab_next
;
1301 if (LABEL_NUSES (lab
) == 0)
1302 /* This can delete NEXT or PREV,
1303 either directly if NEXT is JUMP_LABEL (INSN),
1304 or indirectly through more levels of jumps. */
1305 delete_related_insns (lab
);
1306 else if (tablejump_p (insn
, NULL
, &lab_next
))
1308 /* If we're deleting the tablejump, delete the dispatch table.
1309 We may not be able to kill the label immediately preceding
1310 just yet, as it might be referenced in code leading up to
1312 delete_related_insns (lab_next
);
1316 /* Likewise if we're deleting a dispatch table. */
1318 if (JUMP_TABLE_DATA_P (insn
))
1320 rtx pat
= PATTERN (insn
);
1321 int i
, diff_vec_p
= GET_CODE (pat
) == ADDR_DIFF_VEC
;
1322 int len
= XVECLEN (pat
, diff_vec_p
);
1324 for (i
= 0; i
< len
; i
++)
1325 if (LABEL_NUSES (XEXP (XVECEXP (pat
, diff_vec_p
, i
), 0)) == 0)
1326 delete_related_insns (XEXP (XVECEXP (pat
, diff_vec_p
, i
), 0));
1327 while (next
&& INSN_DELETED_P (next
))
1328 next
= NEXT_INSN (next
);
1332 /* Likewise for any JUMP_P / INSN / CALL_INSN with a
1333 REG_LABEL_OPERAND or REG_LABEL_TARGET note. */
1335 for (note
= REG_NOTES (insn
); note
; note
= XEXP (note
, 1))
1336 if ((REG_NOTE_KIND (note
) == REG_LABEL_OPERAND
1337 || REG_NOTE_KIND (note
) == REG_LABEL_TARGET
)
1338 /* This could also be a NOTE_INSN_DELETED_LABEL note. */
1339 && LABEL_P (XEXP (note
, 0)))
1340 if (LABEL_NUSES (XEXP (note
, 0)) == 0)
1341 delete_related_insns (XEXP (note
, 0));
1343 while (prev
&& (INSN_DELETED_P (prev
) || NOTE_P (prev
)))
1344 prev
= PREV_INSN (prev
);
1346 /* If INSN was a label and a dispatch table follows it,
1347 delete the dispatch table. The tablejump must have gone already.
1348 It isn't useful to fall through into a table. */
1351 && NEXT_INSN (insn
) != 0
1352 && JUMP_TABLE_DATA_P (NEXT_INSN (insn
)))
1353 next
= delete_related_insns (NEXT_INSN (insn
));
1355 /* If INSN was a label, delete insns following it if now unreachable. */
1357 if (was_code_label
&& prev
&& BARRIER_P (prev
))
1362 code
= GET_CODE (next
);
1364 next
= NEXT_INSN (next
);
1365 /* Keep going past other deleted labels to delete what follows. */
1366 else if (code
== CODE_LABEL
&& INSN_DELETED_P (next
))
1367 next
= NEXT_INSN (next
);
1368 /* Keep the (use (insn))s created by dbr_schedule, which needs
1369 them in order to track liveness relative to a previous
1371 else if (INSN_P (next
)
1372 && GET_CODE (PATTERN (next
)) == USE
1373 && INSN_P (XEXP (PATTERN (next
), 0)))
1374 next
= NEXT_INSN (next
);
1375 else if (code
== BARRIER
|| INSN_P (next
))
1376 /* Note: if this deletes a jump, it can cause more
1377 deletion of unreachable code, after a different label.
1378 As long as the value from this recursive call is correct,
1379 this invocation functions correctly. */
1380 next
= delete_related_insns (next
);
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
);
1395 /* Delete a range of insns from FROM to TO, inclusive.
1396 This is for the sake of peephole optimization, so assume
1397 that whatever these insns do will still be done by a new
1398 peephole insn that will replace them. */
1401 delete_for_peephole (rtx from
, rtx to
)
1407 rtx next
= NEXT_INSN (insn
);
1408 rtx prev
= PREV_INSN (insn
);
1412 INSN_DELETED_P (insn
) = 1;
1414 /* Patch this insn out of the chain. */
1415 /* We don't do this all at once, because we
1416 must preserve all NOTEs. */
1418 SET_NEXT_INSN (prev
) = next
;
1421 SET_PREV_INSN (next
) = prev
;
1429 /* Note that if TO is an unconditional jump
1430 we *do not* delete the BARRIER that follows,
1431 since the peephole that replaces this sequence
1432 is also an unconditional jump in that case. */
1435 /* A helper function for redirect_exp_1; examines its input X and returns
1436 either a LABEL_REF around a label, or a RETURN if X was NULL. */
1438 redirect_target (rtx x
)
1442 if (!ANY_RETURN_P (x
))
1443 return gen_rtx_LABEL_REF (Pmode
, x
);
1447 /* Throughout LOC, redirect OLABEL to NLABEL. Treat null OLABEL or
1448 NLABEL as a return. Accrue modifications into the change group. */
1451 redirect_exp_1 (rtx
*loc
, rtx olabel
, rtx nlabel
, rtx insn
)
1454 RTX_CODE code
= GET_CODE (x
);
1458 if ((code
== LABEL_REF
&& XEXP (x
, 0) == olabel
)
1461 x
= redirect_target (nlabel
);
1462 if (GET_CODE (x
) == LABEL_REF
&& loc
== &PATTERN (insn
))
1463 x
= gen_rtx_SET (VOIDmode
, pc_rtx
, x
);
1464 validate_change (insn
, loc
, x
, 1);
1468 if (code
== SET
&& SET_DEST (x
) == pc_rtx
1469 && ANY_RETURN_P (nlabel
)
1470 && GET_CODE (SET_SRC (x
)) == LABEL_REF
1471 && XEXP (SET_SRC (x
), 0) == olabel
)
1473 validate_change (insn
, loc
, nlabel
, 1);
1477 if (code
== IF_THEN_ELSE
)
1479 /* Skip the condition of an IF_THEN_ELSE. We only want to
1480 change jump destinations, not eventual label comparisons. */
1481 redirect_exp_1 (&XEXP (x
, 1), olabel
, nlabel
, insn
);
1482 redirect_exp_1 (&XEXP (x
, 2), olabel
, nlabel
, insn
);
1486 fmt
= GET_RTX_FORMAT (code
);
1487 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
1490 redirect_exp_1 (&XEXP (x
, i
), olabel
, nlabel
, insn
);
1491 else if (fmt
[i
] == 'E')
1494 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
1495 redirect_exp_1 (&XVECEXP (x
, i
, j
), olabel
, nlabel
, insn
);
1500 /* Make JUMP go to NLABEL instead of where it jumps now. Accrue
1501 the modifications into the change group. Return false if we did
1502 not see how to do that. */
1505 redirect_jump_1 (rtx jump
, rtx nlabel
)
1507 int ochanges
= num_validated_changes ();
1510 gcc_assert (nlabel
!= NULL_RTX
);
1511 asmop
= extract_asm_operands (PATTERN (jump
));
1516 gcc_assert (ASM_OPERANDS_LABEL_LENGTH (asmop
) == 1);
1517 loc
= &ASM_OPERANDS_LABEL (asmop
, 0);
1519 else if (GET_CODE (PATTERN (jump
)) == PARALLEL
)
1520 loc
= &XVECEXP (PATTERN (jump
), 0, 0);
1522 loc
= &PATTERN (jump
);
1524 redirect_exp_1 (loc
, JUMP_LABEL (jump
), nlabel
, jump
);
1525 return num_validated_changes () > ochanges
;
1528 /* Make JUMP go to NLABEL instead of where it jumps now. If the old
1529 jump target label is unused as a result, it and the code following
1532 Normally, NLABEL will be a label, but it may also be a RETURN rtx;
1533 in that case we are to turn the jump into a (possibly conditional)
1536 The return value will be 1 if the change was made, 0 if it wasn't
1537 (this can only occur when trying to produce return insns). */
1540 redirect_jump (rtx jump
, rtx nlabel
, int delete_unused
)
1542 rtx olabel
= JUMP_LABEL (jump
);
1546 /* If there is no label, we are asked to redirect to the EXIT block.
1547 When before the epilogue is emitted, return/simple_return cannot be
1548 created so we return 0 immediately. After the epilogue is emitted,
1549 we always expect a label, either a non-null label, or a
1550 return/simple_return RTX. */
1552 if (!epilogue_completed
)
1557 if (nlabel
== olabel
)
1560 if (! redirect_jump_1 (jump
, nlabel
) || ! apply_change_group ())
1563 redirect_jump_2 (jump
, olabel
, nlabel
, delete_unused
, 0);
1567 /* Fix up JUMP_LABEL and label ref counts after OLABEL has been replaced with
1569 If DELETE_UNUSED is positive, delete related insn to OLABEL if its ref
1570 count has dropped to zero. */
1572 redirect_jump_2 (rtx jump
, rtx olabel
, rtx nlabel
, int delete_unused
,
1577 gcc_assert (JUMP_LABEL (jump
) == olabel
);
1579 /* Negative DELETE_UNUSED used to be used to signalize behavior on
1580 moving FUNCTION_END note. Just sanity check that no user still worry
1582 gcc_assert (delete_unused
>= 0);
1583 JUMP_LABEL (jump
) = nlabel
;
1584 if (!ANY_RETURN_P (nlabel
))
1585 ++LABEL_NUSES (nlabel
);
1587 /* Update labels in any REG_EQUAL note. */
1588 if ((note
= find_reg_note (jump
, REG_EQUAL
, NULL_RTX
)) != NULL_RTX
)
1590 if (ANY_RETURN_P (nlabel
)
1591 || (invert
&& !invert_exp_1 (XEXP (note
, 0), jump
)))
1592 remove_note (jump
, note
);
1595 redirect_exp_1 (&XEXP (note
, 0), olabel
, nlabel
, jump
);
1596 confirm_change_group ();
1600 /* Handle the case where we had a conditional crossing jump to a return
1601 label and are now changing it into a direct conditional return.
1602 The jump is no longer crossing in that case. */
1603 if (ANY_RETURN_P (nlabel
))
1604 CROSSING_JUMP_P (jump
) = 0;
1606 if (!ANY_RETURN_P (olabel
)
1607 && --LABEL_NUSES (olabel
) == 0 && delete_unused
> 0
1608 /* Undefined labels will remain outside the insn stream. */
1609 && INSN_UID (olabel
))
1610 delete_related_insns (olabel
);
1612 invert_br_probabilities (jump
);
1615 /* Invert the jump condition X contained in jump insn INSN. Accrue the
1616 modifications into the change group. Return nonzero for success. */
1618 invert_exp_1 (rtx x
, rtx insn
)
1620 RTX_CODE code
= GET_CODE (x
);
1622 if (code
== IF_THEN_ELSE
)
1624 rtx comp
= XEXP (x
, 0);
1626 enum rtx_code reversed_code
;
1628 /* We can do this in two ways: The preferable way, which can only
1629 be done if this is not an integer comparison, is to reverse
1630 the comparison code. Otherwise, swap the THEN-part and ELSE-part
1631 of the IF_THEN_ELSE. If we can't do either, fail. */
1633 reversed_code
= reversed_comparison_code (comp
, insn
);
1635 if (reversed_code
!= UNKNOWN
)
1637 validate_change (insn
, &XEXP (x
, 0),
1638 gen_rtx_fmt_ee (reversed_code
,
1639 GET_MODE (comp
), XEXP (comp
, 0),
1646 validate_change (insn
, &XEXP (x
, 1), XEXP (x
, 2), 1);
1647 validate_change (insn
, &XEXP (x
, 2), tem
, 1);
1654 /* Invert the condition of the jump JUMP, and make it jump to label
1655 NLABEL instead of where it jumps now. Accrue changes into the
1656 change group. Return false if we didn't see how to perform the
1657 inversion and redirection. */
1660 invert_jump_1 (rtx jump
, rtx nlabel
)
1662 rtx x
= pc_set (jump
);
1666 ochanges
= num_validated_changes ();
1669 ok
= invert_exp_1 (SET_SRC (x
), jump
);
1672 if (num_validated_changes () == ochanges
)
1675 /* redirect_jump_1 will fail of nlabel == olabel, and the current use is
1676 in Pmode, so checking this is not merely an optimization. */
1677 return nlabel
== JUMP_LABEL (jump
) || redirect_jump_1 (jump
, nlabel
);
1680 /* Invert the condition of the jump JUMP, and make it jump to label
1681 NLABEL instead of where it jumps now. Return true if successful. */
1684 invert_jump (rtx jump
, rtx nlabel
, int delete_unused
)
1686 rtx olabel
= JUMP_LABEL (jump
);
1688 if (invert_jump_1 (jump
, nlabel
) && apply_change_group ())
1690 redirect_jump_2 (jump
, olabel
, nlabel
, delete_unused
, 1);
1698 /* Like rtx_equal_p except that it considers two REGs as equal
1699 if they renumber to the same value and considers two commutative
1700 operations to be the same if the order of the operands has been
1704 rtx_renumbered_equal_p (const_rtx x
, const_rtx y
)
1707 const enum rtx_code code
= GET_CODE (x
);
1713 if ((code
== REG
|| (code
== SUBREG
&& REG_P (SUBREG_REG (x
))))
1714 && (REG_P (y
) || (GET_CODE (y
) == SUBREG
1715 && REG_P (SUBREG_REG (y
)))))
1717 int reg_x
= -1, reg_y
= -1;
1718 int byte_x
= 0, byte_y
= 0;
1719 struct subreg_info info
;
1721 if (GET_MODE (x
) != GET_MODE (y
))
1724 /* If we haven't done any renumbering, don't
1725 make any assumptions. */
1726 if (reg_renumber
== 0)
1727 return rtx_equal_p (x
, y
);
1731 reg_x
= REGNO (SUBREG_REG (x
));
1732 byte_x
= SUBREG_BYTE (x
);
1734 if (reg_renumber
[reg_x
] >= 0)
1736 subreg_get_info (reg_renumber
[reg_x
],
1737 GET_MODE (SUBREG_REG (x
)), byte_x
,
1738 GET_MODE (x
), &info
);
1739 if (!info
.representable_p
)
1741 reg_x
= info
.offset
;
1748 if (reg_renumber
[reg_x
] >= 0)
1749 reg_x
= reg_renumber
[reg_x
];
1752 if (GET_CODE (y
) == SUBREG
)
1754 reg_y
= REGNO (SUBREG_REG (y
));
1755 byte_y
= SUBREG_BYTE (y
);
1757 if (reg_renumber
[reg_y
] >= 0)
1759 subreg_get_info (reg_renumber
[reg_y
],
1760 GET_MODE (SUBREG_REG (y
)), byte_y
,
1761 GET_MODE (y
), &info
);
1762 if (!info
.representable_p
)
1764 reg_y
= info
.offset
;
1771 if (reg_renumber
[reg_y
] >= 0)
1772 reg_y
= reg_renumber
[reg_y
];
1775 return reg_x
>= 0 && reg_x
== reg_y
&& byte_x
== byte_y
;
1778 /* Now we have disposed of all the cases
1779 in which different rtx codes can match. */
1780 if (code
!= GET_CODE (y
))
1793 /* We can't assume nonlocal labels have their following insns yet. */
1794 if (LABEL_REF_NONLOCAL_P (x
) || LABEL_REF_NONLOCAL_P (y
))
1795 return XEXP (x
, 0) == XEXP (y
, 0);
1797 /* Two label-refs are equivalent if they point at labels
1798 in the same position in the instruction stream. */
1799 return (next_real_insn (XEXP (x
, 0))
1800 == next_real_insn (XEXP (y
, 0)));
1803 return XSTR (x
, 0) == XSTR (y
, 0);
1806 /* If we didn't match EQ equality above, they aren't the same. */
1813 /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent. */
1815 if (GET_MODE (x
) != GET_MODE (y
))
1818 /* MEMs referring to different address space are not equivalent. */
1819 if (code
== MEM
&& MEM_ADDR_SPACE (x
) != MEM_ADDR_SPACE (y
))
1822 /* For commutative operations, the RTX match if the operand match in any
1823 order. Also handle the simple binary and unary cases without a loop. */
1824 if (targetm
.commutative_p (x
, UNKNOWN
))
1825 return ((rtx_renumbered_equal_p (XEXP (x
, 0), XEXP (y
, 0))
1826 && rtx_renumbered_equal_p (XEXP (x
, 1), XEXP (y
, 1)))
1827 || (rtx_renumbered_equal_p (XEXP (x
, 0), XEXP (y
, 1))
1828 && rtx_renumbered_equal_p (XEXP (x
, 1), XEXP (y
, 0))));
1829 else if (NON_COMMUTATIVE_P (x
))
1830 return (rtx_renumbered_equal_p (XEXP (x
, 0), XEXP (y
, 0))
1831 && rtx_renumbered_equal_p (XEXP (x
, 1), XEXP (y
, 1)));
1832 else if (UNARY_P (x
))
1833 return rtx_renumbered_equal_p (XEXP (x
, 0), XEXP (y
, 0));
1835 /* Compare the elements. If any pair of corresponding elements
1836 fail to match, return 0 for the whole things. */
1838 fmt
= GET_RTX_FORMAT (code
);
1839 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
1845 if (XWINT (x
, i
) != XWINT (y
, i
))
1850 if (XINT (x
, i
) != XINT (y
, i
))
1852 if (((code
== ASM_OPERANDS
&& i
== 6)
1853 || (code
== ASM_INPUT
&& i
== 1)))
1860 if (XTREE (x
, i
) != XTREE (y
, i
))
1865 if (strcmp (XSTR (x
, i
), XSTR (y
, i
)))
1870 if (! rtx_renumbered_equal_p (XEXP (x
, i
), XEXP (y
, i
)))
1875 if (XEXP (x
, i
) != XEXP (y
, i
))
1882 if (XVECLEN (x
, i
) != XVECLEN (y
, i
))
1884 for (j
= XVECLEN (x
, i
) - 1; j
>= 0; j
--)
1885 if (!rtx_renumbered_equal_p (XVECEXP (x
, i
, j
), XVECEXP (y
, i
, j
)))
1896 /* If X is a hard register or equivalent to one or a subregister of one,
1897 return the hard register number. If X is a pseudo register that was not
1898 assigned a hard register, return the pseudo register number. Otherwise,
1899 return -1. Any rtx is valid for X. */
1902 true_regnum (const_rtx x
)
1906 if (REGNO (x
) >= FIRST_PSEUDO_REGISTER
1907 && (lra_in_progress
|| reg_renumber
[REGNO (x
)] >= 0))
1908 return reg_renumber
[REGNO (x
)];
1911 if (GET_CODE (x
) == SUBREG
)
1913 int base
= true_regnum (SUBREG_REG (x
));
1915 && base
< FIRST_PSEUDO_REGISTER
)
1917 struct subreg_info info
;
1919 subreg_get_info (lra_in_progress
1920 ? (unsigned) base
: REGNO (SUBREG_REG (x
)),
1921 GET_MODE (SUBREG_REG (x
)),
1922 SUBREG_BYTE (x
), GET_MODE (x
), &info
);
1924 if (info
.representable_p
)
1925 return base
+ info
.offset
;
1931 /* Return regno of the register REG and handle subregs too. */
1933 reg_or_subregno (const_rtx reg
)
1935 if (GET_CODE (reg
) == SUBREG
)
1936 reg
= SUBREG_REG (reg
);
1937 gcc_assert (REG_P (reg
));