1 /* Optimize jump instructions, for GNU compiler.
2 Copyright (C) 1987-2016 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"
44 #include "tree-pass.h"
46 #include "insn-config.h"
53 /* Optimize jump y; x: ... y: jumpif... x?
54 Don't know if it is worth bothering with. */
55 /* Optimize two cases of conditional jump to conditional jump?
56 This can never delete any instruction or make anything dead,
57 or even change what is live at any point.
58 So perhaps let combiner do it. */
60 static void init_label_info (rtx_insn
*);
61 static void mark_all_labels (rtx_insn
*);
62 static void mark_jump_label_1 (rtx
, rtx_insn
*, bool, bool);
63 static void mark_jump_label_asm (rtx
, rtx_insn
*);
64 static void redirect_exp_1 (rtx
*, rtx
, rtx
, rtx
);
65 static int invert_exp_1 (rtx
, rtx_insn
*);
67 /* Worker for rebuild_jump_labels and rebuild_jump_labels_chain. */
69 rebuild_jump_labels_1 (rtx_insn
*f
, bool count_forced
)
71 timevar_push (TV_REBUILD_JUMP
);
75 /* Keep track of labels used from static data; we don't track them
76 closely enough to delete them here, so make sure their reference
77 count doesn't drop to zero. */
83 FOR_EACH_VEC_SAFE_ELT (forced_labels
, i
, insn
)
87 timevar_pop (TV_REBUILD_JUMP
);
90 /* This function rebuilds the JUMP_LABEL field and REG_LABEL_TARGET
91 notes in jumping insns and REG_LABEL_OPERAND notes in non-jumping
92 instructions and jumping insns that have labels as operands
95 rebuild_jump_labels (rtx_insn
*f
)
97 rebuild_jump_labels_1 (f
, true);
100 /* This function is like rebuild_jump_labels, but doesn't run over
101 forced_labels. It can be used on insn chains that aren't the
102 main function chain. */
104 rebuild_jump_labels_chain (rtx_insn
*chain
)
106 rebuild_jump_labels_1 (chain
, false);
109 /* Some old code expects exactly one BARRIER as the NEXT_INSN of a
110 non-fallthru insn. This is not generally true, as multiple barriers
111 may have crept in, or the BARRIER may be separated from the last
112 real insn by one or more NOTEs.
114 This simple pass moves barriers and removes duplicates so that the
118 cleanup_barriers (void)
121 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
123 if (BARRIER_P (insn
))
125 rtx_insn
*prev
= prev_nonnote_insn (insn
);
131 /* Make sure we do not split a call and its corresponding
132 CALL_ARG_LOCATION note. */
133 rtx_insn
*next
= NEXT_INSN (prev
);
136 && NOTE_KIND (next
) == NOTE_INSN_CALL_ARG_LOCATION
)
140 if (BARRIER_P (prev
))
142 else if (prev
!= PREV_INSN (insn
))
144 basic_block bb
= BLOCK_FOR_INSN (prev
);
145 rtx_insn
*end
= PREV_INSN (insn
);
146 reorder_insns_nobb (insn
, insn
, prev
);
149 /* If the backend called in machine reorg compute_bb_for_insn
150 and didn't free_bb_for_insn again, preserve basic block
151 boundaries. Move the end of basic block to PREV since
152 it is followed by a barrier now, and clear BLOCK_FOR_INSN
153 on the following notes.
154 ??? Maybe the proper solution for the targets that have
155 cfg around after machine reorg is not to run cleanup_barriers
160 prev
= NEXT_INSN (prev
);
161 if (prev
!= insn
&& BLOCK_FOR_INSN (prev
) == bb
)
162 BLOCK_FOR_INSN (prev
) = NULL
;
174 const pass_data pass_data_cleanup_barriers
=
177 "barriers", /* name */
178 OPTGROUP_NONE
, /* optinfo_flags */
180 0, /* properties_required */
181 0, /* properties_provided */
182 0, /* properties_destroyed */
183 0, /* todo_flags_start */
184 0, /* todo_flags_finish */
187 class pass_cleanup_barriers
: public rtl_opt_pass
190 pass_cleanup_barriers (gcc::context
*ctxt
)
191 : rtl_opt_pass (pass_data_cleanup_barriers
, ctxt
)
194 /* opt_pass methods: */
195 virtual unsigned int execute (function
*) { return cleanup_barriers (); }
197 }; // class pass_cleanup_barriers
202 make_pass_cleanup_barriers (gcc::context
*ctxt
)
204 return new pass_cleanup_barriers (ctxt
);
208 /* Initialize LABEL_NUSES and JUMP_LABEL fields, add REG_LABEL_TARGET
209 for remaining targets for JUMP_P. Delete any REG_LABEL_OPERAND
210 notes whose labels don't occur in the insn any more. */
213 init_label_info (rtx_insn
*f
)
217 for (insn
= f
; insn
; insn
= NEXT_INSN (insn
))
220 LABEL_NUSES (insn
) = (LABEL_PRESERVE_P (insn
) != 0);
222 /* REG_LABEL_TARGET notes (including the JUMP_LABEL field) are
223 sticky and not reset here; that way we won't lose association
224 with a label when e.g. the source for a target register
225 disappears out of reach for targets that may use jump-target
226 registers. Jump transformations are supposed to transform
227 any REG_LABEL_TARGET notes. The target label reference in a
228 branch may disappear from the branch (and from the
229 instruction before it) for other reasons, like register
236 for (note
= REG_NOTES (insn
); note
; note
= next
)
238 next
= XEXP (note
, 1);
239 if (REG_NOTE_KIND (note
) == REG_LABEL_OPERAND
240 && ! reg_mentioned_p (XEXP (note
, 0), PATTERN (insn
)))
241 remove_note (insn
, note
);
247 /* A subroutine of mark_all_labels. Trivially propagate a simple label
248 load into a jump_insn that uses it. */
251 maybe_propagate_label_ref (rtx_insn
*jump_insn
, rtx_insn
*prev_nonjump_insn
)
253 rtx label_note
, pc
, pc_src
;
255 pc
= pc_set (jump_insn
);
256 pc_src
= pc
!= NULL
? SET_SRC (pc
) : NULL
;
257 label_note
= find_reg_note (prev_nonjump_insn
, REG_LABEL_OPERAND
, NULL
);
259 /* If the previous non-jump insn sets something to a label,
260 something that this jump insn uses, make that label the primary
261 target of this insn if we don't yet have any. That previous
262 insn must be a single_set and not refer to more than one label.
263 The jump insn must not refer to other labels as jump targets
264 and must be a plain (set (pc) ...), maybe in a parallel, and
265 may refer to the item being set only directly or as one of the
266 arms in an IF_THEN_ELSE. */
268 if (label_note
!= NULL
&& pc_src
!= NULL
)
270 rtx label_set
= single_set (prev_nonjump_insn
);
271 rtx label_dest
= label_set
!= NULL
? SET_DEST (label_set
) : NULL
;
273 if (label_set
!= NULL
274 /* The source must be the direct LABEL_REF, not a
275 PLUS, UNSPEC, IF_THEN_ELSE etc. */
276 && GET_CODE (SET_SRC (label_set
)) == LABEL_REF
277 && (rtx_equal_p (label_dest
, pc_src
)
278 || (GET_CODE (pc_src
) == IF_THEN_ELSE
279 && (rtx_equal_p (label_dest
, XEXP (pc_src
, 1))
280 || rtx_equal_p (label_dest
, XEXP (pc_src
, 2))))))
282 /* The CODE_LABEL referred to in the note must be the
283 CODE_LABEL in the LABEL_REF of the "set". We can
284 conveniently use it for the marker function, which
285 requires a LABEL_REF wrapping. */
286 gcc_assert (XEXP (label_note
, 0) == LABEL_REF_LABEL (SET_SRC (label_set
)));
288 mark_jump_label_1 (label_set
, jump_insn
, false, true);
290 gcc_assert (JUMP_LABEL (jump_insn
) == XEXP (label_note
, 0));
295 /* Mark the label each jump jumps to.
296 Combine consecutive labels, and count uses of labels. */
299 mark_all_labels (rtx_insn
*f
)
303 if (current_ir_type () == IR_RTL_CFGLAYOUT
)
306 FOR_EACH_BB_FN (bb
, cfun
)
308 /* In cfglayout mode, we don't bother with trivial next-insn
309 propagation of LABEL_REFs into JUMP_LABEL. This will be
310 handled by other optimizers using better algorithms. */
311 FOR_BB_INSNS (bb
, insn
)
313 gcc_assert (! insn
->deleted ());
314 if (NONDEBUG_INSN_P (insn
))
315 mark_jump_label (PATTERN (insn
), insn
, 0);
318 /* In cfglayout mode, there may be non-insns between the
319 basic blocks. If those non-insns represent tablejump data,
320 they contain label references that we must record. */
321 for (insn
= BB_HEADER (bb
); insn
; insn
= NEXT_INSN (insn
))
322 if (JUMP_TABLE_DATA_P (insn
))
323 mark_jump_label (PATTERN (insn
), insn
, 0);
324 for (insn
= BB_FOOTER (bb
); insn
; insn
= NEXT_INSN (insn
))
325 if (JUMP_TABLE_DATA_P (insn
))
326 mark_jump_label (PATTERN (insn
), insn
, 0);
331 rtx_insn
*prev_nonjump_insn
= NULL
;
332 for (insn
= f
; insn
; insn
= NEXT_INSN (insn
))
334 if (insn
->deleted ())
336 else if (LABEL_P (insn
))
337 prev_nonjump_insn
= NULL
;
338 else if (JUMP_TABLE_DATA_P (insn
))
339 mark_jump_label (PATTERN (insn
), insn
, 0);
340 else if (NONDEBUG_INSN_P (insn
))
342 mark_jump_label (PATTERN (insn
), insn
, 0);
345 if (JUMP_LABEL (insn
) == NULL
&& prev_nonjump_insn
!= NULL
)
346 maybe_propagate_label_ref (insn
, prev_nonjump_insn
);
349 prev_nonjump_insn
= insn
;
355 /* Given a comparison (CODE ARG0 ARG1), inside an insn, INSN, return a code
356 of reversed comparison if it is possible to do so. Otherwise return UNKNOWN.
357 UNKNOWN may be returned in case we are having CC_MODE compare and we don't
358 know whether it's source is floating point or integer comparison. Machine
359 description should define REVERSIBLE_CC_MODE and REVERSE_CONDITION macros
360 to help this function avoid overhead in these cases. */
362 reversed_comparison_code_parts (enum rtx_code code
, const_rtx arg0
,
363 const_rtx arg1
, const rtx_insn
*insn
)
367 /* If this is not actually a comparison, we can't reverse it. */
368 if (GET_RTX_CLASS (code
) != RTX_COMPARE
369 && GET_RTX_CLASS (code
) != RTX_COMM_COMPARE
)
372 mode
= GET_MODE (arg0
);
373 if (mode
== VOIDmode
)
374 mode
= GET_MODE (arg1
);
376 /* First see if machine description supplies us way to reverse the
377 comparison. Give it priority over everything else to allow
378 machine description to do tricks. */
379 if (GET_MODE_CLASS (mode
) == MODE_CC
380 && REVERSIBLE_CC_MODE (mode
))
381 return REVERSE_CONDITION (code
, mode
);
383 /* Try a few special cases based on the comparison code. */
392 /* It is always safe to reverse EQ and NE, even for the floating
393 point. Similarly the unsigned comparisons are never used for
394 floating point so we can reverse them in the default way. */
395 return reverse_condition (code
);
400 /* In case we already see unordered comparison, we can be sure to
401 be dealing with floating point so we don't need any more tests. */
402 return reverse_condition_maybe_unordered (code
);
407 /* We don't have safe way to reverse these yet. */
413 if (GET_MODE_CLASS (mode
) == MODE_CC
|| CC0_P (arg0
))
415 /* Try to search for the comparison to determine the real mode.
416 This code is expensive, but with sane machine description it
417 will be never used, since REVERSIBLE_CC_MODE will return true
422 /* These CONST_CAST's are okay because prev_nonnote_insn just
423 returns its argument and we assign it to a const_rtx
425 for (rtx_insn
*prev
= prev_nonnote_insn (const_cast<rtx_insn
*> (insn
));
426 prev
!= 0 && !LABEL_P (prev
);
427 prev
= prev_nonnote_insn (prev
))
429 const_rtx set
= set_of (arg0
, prev
);
430 if (set
&& GET_CODE (set
) == SET
431 && rtx_equal_p (SET_DEST (set
), arg0
))
433 rtx src
= SET_SRC (set
);
435 if (GET_CODE (src
) == COMPARE
)
437 rtx comparison
= src
;
438 arg0
= XEXP (src
, 0);
439 mode
= GET_MODE (arg0
);
440 if (mode
== VOIDmode
)
441 mode
= GET_MODE (XEXP (comparison
, 1));
444 /* We can get past reg-reg moves. This may be useful for model
445 of i387 comparisons that first move flag registers around. */
452 /* If register is clobbered in some ununderstandable way,
459 /* Test for an integer condition, or a floating-point comparison
460 in which NaNs can be ignored. */
461 if (CONST_INT_P (arg0
)
462 || (GET_MODE (arg0
) != VOIDmode
463 && GET_MODE_CLASS (mode
) != MODE_CC
464 && !HONOR_NANS (mode
)))
465 return reverse_condition (code
);
470 /* A wrapper around the previous function to take COMPARISON as rtx
471 expression. This simplifies many callers. */
473 reversed_comparison_code (const_rtx comparison
, const rtx_insn
*insn
)
475 if (!COMPARISON_P (comparison
))
477 return reversed_comparison_code_parts (GET_CODE (comparison
),
478 XEXP (comparison
, 0),
479 XEXP (comparison
, 1), insn
);
482 /* Return comparison with reversed code of EXP.
483 Return NULL_RTX in case we fail to do the reversal. */
485 reversed_comparison (const_rtx exp
, machine_mode mode
)
487 enum rtx_code reversed_code
= reversed_comparison_code (exp
, NULL
);
488 if (reversed_code
== UNKNOWN
)
491 return simplify_gen_relational (reversed_code
, mode
, VOIDmode
,
492 XEXP (exp
, 0), XEXP (exp
, 1));
496 /* Given an rtx-code for a comparison, return the code for the negated
497 comparison. If no such code exists, return UNKNOWN.
499 WATCH OUT! reverse_condition is not safe to use on a jump that might
500 be acting on the results of an IEEE floating point comparison, because
501 of the special treatment of non-signaling nans in comparisons.
502 Use reversed_comparison_code instead. */
505 reverse_condition (enum rtx_code code
)
547 /* Similar, but we're allowed to generate unordered comparisons, which
548 makes it safe for IEEE floating-point. Of course, we have to recognize
549 that the target will support them too... */
552 reverse_condition_maybe_unordered (enum rtx_code code
)
590 /* Similar, but return the code when two operands of a comparison are swapped.
591 This IS safe for IEEE floating-point. */
594 swap_condition (enum rtx_code code
)
636 /* Given a comparison CODE, return the corresponding unsigned comparison.
637 If CODE is an equality comparison or already an unsigned comparison,
641 unsigned_condition (enum rtx_code code
)
667 /* Similarly, return the signed version of a comparison. */
670 signed_condition (enum rtx_code code
)
696 /* Return nonzero if CODE1 is more strict than CODE2, i.e., if the
697 truth of CODE1 implies the truth of CODE2. */
700 comparison_dominates_p (enum rtx_code code1
, enum rtx_code code2
)
702 /* UNKNOWN comparison codes can happen as a result of trying to revert
704 They can't match anything, so we have to reject them here. */
705 if (code1
== UNKNOWN
|| code2
== UNKNOWN
)
714 if (code2
== UNLE
|| code2
== UNGE
)
719 if (code2
== LE
|| code2
== LEU
|| code2
== GE
|| code2
== GEU
725 if (code2
== UNLE
|| code2
== NE
)
730 if (code2
== LE
|| code2
== NE
|| code2
== ORDERED
|| code2
== LTGT
)
735 if (code2
== UNGE
|| code2
== NE
)
740 if (code2
== GE
|| code2
== NE
|| code2
== ORDERED
|| code2
== LTGT
)
746 if (code2
== ORDERED
)
751 if (code2
== NE
|| code2
== ORDERED
)
756 if (code2
== LEU
|| code2
== NE
)
761 if (code2
== GEU
|| code2
== NE
)
766 if (code2
== NE
|| code2
== UNEQ
|| code2
== UNLE
|| code2
== UNLT
767 || code2
== UNGE
|| code2
== UNGT
)
778 /* Return 1 if INSN is an unconditional jump and nothing else. */
781 simplejump_p (const rtx_insn
*insn
)
783 return (JUMP_P (insn
)
784 && GET_CODE (PATTERN (insn
)) == SET
785 && GET_CODE (SET_DEST (PATTERN (insn
))) == PC
786 && GET_CODE (SET_SRC (PATTERN (insn
))) == LABEL_REF
);
789 /* Return nonzero if INSN is a (possibly) conditional jump
792 Use of this function is deprecated, since we need to support combined
793 branch and compare insns. Use any_condjump_p instead whenever possible. */
796 condjump_p (const rtx_insn
*insn
)
798 const_rtx x
= PATTERN (insn
);
800 if (GET_CODE (x
) != SET
801 || GET_CODE (SET_DEST (x
)) != PC
)
805 if (GET_CODE (x
) == LABEL_REF
)
808 return (GET_CODE (x
) == IF_THEN_ELSE
809 && ((GET_CODE (XEXP (x
, 2)) == PC
810 && (GET_CODE (XEXP (x
, 1)) == LABEL_REF
811 || ANY_RETURN_P (XEXP (x
, 1))))
812 || (GET_CODE (XEXP (x
, 1)) == PC
813 && (GET_CODE (XEXP (x
, 2)) == LABEL_REF
814 || ANY_RETURN_P (XEXP (x
, 2))))));
817 /* Return nonzero if INSN is a (possibly) conditional jump inside a
820 Use this function is deprecated, since we need to support combined
821 branch and compare insns. Use any_condjump_p instead whenever possible. */
824 condjump_in_parallel_p (const rtx_insn
*insn
)
826 const_rtx x
= PATTERN (insn
);
828 if (GET_CODE (x
) != PARALLEL
)
831 x
= XVECEXP (x
, 0, 0);
833 if (GET_CODE (x
) != SET
)
835 if (GET_CODE (SET_DEST (x
)) != PC
)
837 if (GET_CODE (SET_SRC (x
)) == LABEL_REF
)
839 if (GET_CODE (SET_SRC (x
)) != IF_THEN_ELSE
)
841 if (XEXP (SET_SRC (x
), 2) == pc_rtx
842 && (GET_CODE (XEXP (SET_SRC (x
), 1)) == LABEL_REF
843 || ANY_RETURN_P (XEXP (SET_SRC (x
), 1))))
845 if (XEXP (SET_SRC (x
), 1) == pc_rtx
846 && (GET_CODE (XEXP (SET_SRC (x
), 2)) == LABEL_REF
847 || ANY_RETURN_P (XEXP (SET_SRC (x
), 2))))
852 /* Return set of PC, otherwise NULL. */
855 pc_set (const rtx_insn
*insn
)
860 pat
= PATTERN (insn
);
862 /* The set is allowed to appear either as the insn pattern or
863 the first set in a PARALLEL. */
864 if (GET_CODE (pat
) == PARALLEL
)
865 pat
= XVECEXP (pat
, 0, 0);
866 if (GET_CODE (pat
) == SET
&& GET_CODE (SET_DEST (pat
)) == PC
)
872 /* Return true when insn is an unconditional direct jump,
873 possibly bundled inside a PARALLEL. */
876 any_uncondjump_p (const rtx_insn
*insn
)
878 const_rtx x
= pc_set (insn
);
881 if (GET_CODE (SET_SRC (x
)) != LABEL_REF
)
883 if (find_reg_note (insn
, REG_NON_LOCAL_GOTO
, NULL_RTX
))
888 /* Return true when insn is a conditional jump. This function works for
889 instructions containing PC sets in PARALLELs. The instruction may have
890 various other effects so before removing the jump you must verify
893 Note that unlike condjump_p it returns false for unconditional jumps. */
896 any_condjump_p (const rtx_insn
*insn
)
898 const_rtx x
= pc_set (insn
);
903 if (GET_CODE (SET_SRC (x
)) != IF_THEN_ELSE
)
906 a
= GET_CODE (XEXP (SET_SRC (x
), 1));
907 b
= GET_CODE (XEXP (SET_SRC (x
), 2));
909 return ((b
== PC
&& (a
== LABEL_REF
|| a
== RETURN
|| a
== SIMPLE_RETURN
))
911 && (b
== LABEL_REF
|| b
== RETURN
|| b
== SIMPLE_RETURN
)));
914 /* Return the label of a conditional jump. */
917 condjump_label (const rtx_insn
*insn
)
919 rtx x
= pc_set (insn
);
924 if (GET_CODE (x
) == LABEL_REF
)
926 if (GET_CODE (x
) != IF_THEN_ELSE
)
928 if (XEXP (x
, 2) == pc_rtx
&& GET_CODE (XEXP (x
, 1)) == LABEL_REF
)
930 if (XEXP (x
, 1) == pc_rtx
&& GET_CODE (XEXP (x
, 2)) == LABEL_REF
)
935 /* Return TRUE if INSN is a return jump. */
938 returnjump_p (const rtx_insn
*insn
)
942 subrtx_iterator::array_type array
;
943 FOR_EACH_SUBRTX (iter
, array
, PATTERN (insn
), NONCONST
)
946 switch (GET_CODE (x
))
954 if (SET_IS_RETURN_P (x
))
966 /* Return true if INSN is a (possibly conditional) return insn. */
969 eh_returnjump_p (rtx_insn
*insn
)
973 subrtx_iterator::array_type array
;
974 FOR_EACH_SUBRTX (iter
, array
, PATTERN (insn
), NONCONST
)
975 if (GET_CODE (*iter
) == EH_RETURN
)
981 /* Return true if INSN is a jump that only transfers control and
985 onlyjump_p (const rtx_insn
*insn
)
992 set
= single_set (insn
);
995 if (GET_CODE (SET_DEST (set
)) != PC
)
997 if (side_effects_p (SET_SRC (set
)))
1003 /* Return true iff INSN is a jump and its JUMP_LABEL is a label, not
1004 NULL or a return. */
1006 jump_to_label_p (const rtx_insn
*insn
)
1008 return (JUMP_P (insn
)
1009 && JUMP_LABEL (insn
) != NULL
&& !ANY_RETURN_P (JUMP_LABEL (insn
)));
1012 /* Return nonzero if X is an RTX that only sets the condition codes
1013 and has no side effects. */
1016 only_sets_cc0_p (const_rtx x
)
1024 return sets_cc0_p (x
) == 1 && ! side_effects_p (x
);
1027 /* Return 1 if X is an RTX that does nothing but set the condition codes
1028 and CLOBBER or USE registers.
1029 Return -1 if X does explicitly set the condition codes,
1030 but also does other things. */
1033 sets_cc0_p (const_rtx x
)
1041 if (GET_CODE (x
) == SET
&& SET_DEST (x
) == cc0_rtx
)
1043 if (GET_CODE (x
) == PARALLEL
)
1047 int other_things
= 0;
1048 for (i
= XVECLEN (x
, 0) - 1; i
>= 0; i
--)
1050 if (GET_CODE (XVECEXP (x
, 0, i
)) == SET
1051 && SET_DEST (XVECEXP (x
, 0, i
)) == cc0_rtx
)
1053 else if (GET_CODE (XVECEXP (x
, 0, i
)) == SET
)
1056 return ! sets_cc0
? 0 : other_things
? -1 : 1;
1061 /* Find all CODE_LABELs referred to in X, and increment their use
1062 counts. If INSN is a JUMP_INSN and there is at least one
1063 CODE_LABEL referenced in INSN as a jump target, then store the last
1064 one in JUMP_LABEL (INSN). For a tablejump, this must be the label
1065 for the ADDR_VEC. Store any other jump targets as REG_LABEL_TARGET
1066 notes. If INSN is an INSN or a CALL_INSN or non-target operands of
1067 a JUMP_INSN, and there is at least one CODE_LABEL referenced in
1068 INSN, add a REG_LABEL_OPERAND note containing that label to INSN.
1069 For returnjumps, the JUMP_LABEL will also be set as appropriate.
1071 Note that two labels separated by a loop-beginning note
1072 must be kept distinct if we have not yet done loop-optimization,
1073 because the gap between them is where loop-optimize
1074 will want to move invariant code to. CROSS_JUMP tells us
1075 that loop-optimization is done with. */
1078 mark_jump_label (rtx x
, rtx_insn
*insn
, int in_mem
)
1080 rtx asmop
= extract_asm_operands (x
);
1082 mark_jump_label_asm (asmop
, insn
);
1084 mark_jump_label_1 (x
, insn
, in_mem
!= 0,
1085 (insn
!= NULL
&& x
== PATTERN (insn
) && JUMP_P (insn
)));
1088 /* Worker function for mark_jump_label. IN_MEM is TRUE when X occurs
1089 within a (MEM ...). IS_TARGET is TRUE when X is to be treated as a
1090 jump-target; when the JUMP_LABEL field of INSN should be set or a
1091 REG_LABEL_TARGET note should be added, not a REG_LABEL_OPERAND
1095 mark_jump_label_1 (rtx x
, rtx_insn
*insn
, bool in_mem
, bool is_target
)
1097 RTX_CODE code
= GET_CODE (x
);
1114 gcc_assert (JUMP_LABEL (insn
) == NULL
|| JUMP_LABEL (insn
) == x
);
1115 JUMP_LABEL (insn
) = x
;
1125 rtx_sequence
*seq
= as_a
<rtx_sequence
*> (x
);
1126 for (i
= 0; i
< seq
->len (); i
++)
1127 mark_jump_label (PATTERN (seq
->insn (i
)),
1136 /* If this is a constant-pool reference, see if it is a label. */
1137 if (CONSTANT_POOL_ADDRESS_P (x
))
1138 mark_jump_label_1 (get_pool_constant (x
), insn
, in_mem
, is_target
);
1141 /* Handle operands in the condition of an if-then-else as for a
1146 mark_jump_label_1 (XEXP (x
, 0), insn
, in_mem
, false);
1147 mark_jump_label_1 (XEXP (x
, 1), insn
, in_mem
, true);
1148 mark_jump_label_1 (XEXP (x
, 2), insn
, in_mem
, true);
1153 rtx label
= LABEL_REF_LABEL (x
);
1155 /* Ignore remaining references to unreachable labels that
1156 have been deleted. */
1158 && NOTE_KIND (label
) == NOTE_INSN_DELETED_LABEL
)
1161 gcc_assert (LABEL_P (label
));
1163 /* Ignore references to labels of containing functions. */
1164 if (LABEL_REF_NONLOCAL_P (x
))
1167 LABEL_REF_LABEL (x
) = label
;
1168 if (! insn
|| ! insn
->deleted ())
1169 ++LABEL_NUSES (label
);
1174 /* Do not change a previous setting of JUMP_LABEL. If the
1175 JUMP_LABEL slot is occupied by a different label,
1176 create a note for this label. */
1177 && (JUMP_LABEL (insn
) == NULL
|| JUMP_LABEL (insn
) == label
))
1178 JUMP_LABEL (insn
) = label
;
1182 = is_target
? REG_LABEL_TARGET
: REG_LABEL_OPERAND
;
1184 /* Add a REG_LABEL_OPERAND or REG_LABEL_TARGET note
1185 for LABEL unless there already is one. All uses of
1186 a label, except for the primary target of a jump,
1187 must have such a note. */
1188 if (! find_reg_note (insn
, kind
, label
))
1189 add_reg_note (insn
, kind
, label
);
1195 /* Do walk the labels in a vector, but not the first operand of an
1196 ADDR_DIFF_VEC. Don't set the JUMP_LABEL of a vector. */
1199 if (! insn
->deleted ())
1201 int eltnum
= code
== ADDR_DIFF_VEC
? 1 : 0;
1203 for (i
= 0; i
< XVECLEN (x
, eltnum
); i
++)
1204 mark_jump_label_1 (XVECEXP (x
, eltnum
, i
), NULL
, in_mem
,
1213 fmt
= GET_RTX_FORMAT (code
);
1215 /* The primary target of a tablejump is the label of the ADDR_VEC,
1216 which is canonically mentioned *last* in the insn. To get it
1217 marked as JUMP_LABEL, we iterate over items in reverse order. */
1218 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
1221 mark_jump_label_1 (XEXP (x
, i
), insn
, in_mem
, is_target
);
1222 else if (fmt
[i
] == 'E')
1226 for (j
= XVECLEN (x
, i
) - 1; j
>= 0; j
--)
1227 mark_jump_label_1 (XVECEXP (x
, i
, j
), insn
, in_mem
,
1233 /* Worker function for mark_jump_label. Handle asm insns specially.
1234 In particular, output operands need not be considered so we can
1235 avoid re-scanning the replicated asm_operand. Also, the asm_labels
1236 need to be considered targets. */
1239 mark_jump_label_asm (rtx asmop
, rtx_insn
*insn
)
1243 for (i
= ASM_OPERANDS_INPUT_LENGTH (asmop
) - 1; i
>= 0; --i
)
1244 mark_jump_label_1 (ASM_OPERANDS_INPUT (asmop
, i
), insn
, false, false);
1246 for (i
= ASM_OPERANDS_LABEL_LENGTH (asmop
) - 1; i
>= 0; --i
)
1247 mark_jump_label_1 (ASM_OPERANDS_LABEL (asmop
, i
), insn
, false, true);
1250 /* Delete insn INSN from the chain of insns and update label ref counts
1251 and delete insns now unreachable.
1253 Returns the first insn after INSN that was not deleted.
1255 Usage of this instruction is deprecated. Use delete_insn instead and
1256 subsequent cfg_cleanup pass to delete unreachable code if needed. */
1259 delete_related_insns (rtx uncast_insn
)
1261 rtx_insn
*insn
= as_a
<rtx_insn
*> (uncast_insn
);
1262 int was_code_label
= (LABEL_P (insn
));
1264 rtx_insn
*next
= NEXT_INSN (insn
), *prev
= PREV_INSN (insn
);
1266 while (next
&& next
->deleted ())
1267 next
= NEXT_INSN (next
);
1269 /* This insn is already deleted => return first following nondeleted. */
1270 if (insn
->deleted ())
1275 /* If instruction is followed by a barrier,
1276 delete the barrier too. */
1278 if (next
!= 0 && BARRIER_P (next
))
1281 /* If this is a call, then we have to remove the var tracking note
1282 for the call arguments. */
1285 || (NONJUMP_INSN_P (insn
)
1286 && GET_CODE (PATTERN (insn
)) == SEQUENCE
1287 && CALL_P (XVECEXP (PATTERN (insn
), 0, 0))))
1291 for (p
= next
&& next
->deleted () ? NEXT_INSN (next
) : next
;
1294 if (NOTE_KIND (p
) == NOTE_INSN_CALL_ARG_LOCATION
)
1301 /* If deleting a jump, decrement the count of the label,
1302 and delete the label if it is now unused. */
1304 if (jump_to_label_p (insn
))
1306 rtx lab
= JUMP_LABEL (insn
);
1307 rtx_jump_table_data
*lab_next
;
1309 if (LABEL_NUSES (lab
) == 0)
1310 /* This can delete NEXT or PREV,
1311 either directly if NEXT is JUMP_LABEL (INSN),
1312 or indirectly through more levels of jumps. */
1313 delete_related_insns (lab
);
1314 else if (tablejump_p (insn
, NULL
, &lab_next
))
1316 /* If we're deleting the tablejump, delete the dispatch table.
1317 We may not be able to kill the label immediately preceding
1318 just yet, as it might be referenced in code leading up to
1320 delete_related_insns (lab_next
);
1324 /* Likewise if we're deleting a dispatch table. */
1326 if (rtx_jump_table_data
*table
= dyn_cast
<rtx_jump_table_data
*> (insn
))
1328 rtvec labels
= table
->get_labels ();
1330 int len
= GET_NUM_ELEM (labels
);
1332 for (i
= 0; i
< len
; i
++)
1333 if (LABEL_NUSES (XEXP (RTVEC_ELT (labels
, i
), 0)) == 0)
1334 delete_related_insns (XEXP (RTVEC_ELT (labels
, i
), 0));
1335 while (next
&& next
->deleted ())
1336 next
= NEXT_INSN (next
);
1340 /* Likewise for any JUMP_P / INSN / CALL_INSN with a
1341 REG_LABEL_OPERAND or REG_LABEL_TARGET note. */
1343 for (note
= REG_NOTES (insn
); note
; note
= XEXP (note
, 1))
1344 if ((REG_NOTE_KIND (note
) == REG_LABEL_OPERAND
1345 || REG_NOTE_KIND (note
) == REG_LABEL_TARGET
)
1346 /* This could also be a NOTE_INSN_DELETED_LABEL note. */
1347 && LABEL_P (XEXP (note
, 0)))
1348 if (LABEL_NUSES (XEXP (note
, 0)) == 0)
1349 delete_related_insns (XEXP (note
, 0));
1351 while (prev
&& (prev
->deleted () || NOTE_P (prev
)))
1352 prev
= PREV_INSN (prev
);
1354 /* If INSN was a label and a dispatch table follows it,
1355 delete the dispatch table. The tablejump must have gone already.
1356 It isn't useful to fall through into a table. */
1359 && NEXT_INSN (insn
) != 0
1360 && JUMP_TABLE_DATA_P (NEXT_INSN (insn
)))
1361 next
= delete_related_insns (NEXT_INSN (insn
));
1363 /* If INSN was a label, delete insns following it if now unreachable. */
1365 if (was_code_label
&& prev
&& BARRIER_P (prev
))
1370 code
= GET_CODE (next
);
1372 next
= NEXT_INSN (next
);
1373 /* Keep going past other deleted labels to delete what follows. */
1374 else if (code
== CODE_LABEL
&& next
->deleted ())
1375 next
= NEXT_INSN (next
);
1376 /* Keep the (use (insn))s created by dbr_schedule, which needs
1377 them in order to track liveness relative to a previous
1379 else if (INSN_P (next
)
1380 && GET_CODE (PATTERN (next
)) == USE
1381 && INSN_P (XEXP (PATTERN (next
), 0)))
1382 next
= NEXT_INSN (next
);
1383 else if (code
== BARRIER
|| INSN_P (next
))
1384 /* Note: if this deletes a jump, it can cause more
1385 deletion of unreachable code, after a different label.
1386 As long as the value from this recursive call is correct,
1387 this invocation functions correctly. */
1388 next
= delete_related_insns (next
);
1394 /* I feel a little doubtful about this loop,
1395 but I see no clean and sure alternative way
1396 to find the first insn after INSN that is not now deleted.
1397 I hope this works. */
1398 while (next
&& next
->deleted ())
1399 next
= NEXT_INSN (next
);
1403 /* Delete a range of insns from FROM to TO, inclusive.
1404 This is for the sake of peephole optimization, so assume
1405 that whatever these insns do will still be done by a new
1406 peephole insn that will replace them. */
1409 delete_for_peephole (rtx_insn
*from
, rtx_insn
*to
)
1411 rtx_insn
*insn
= from
;
1415 rtx_insn
*next
= NEXT_INSN (insn
);
1416 rtx_insn
*prev
= PREV_INSN (insn
);
1420 insn
->set_deleted();
1422 /* Patch this insn out of the chain. */
1423 /* We don't do this all at once, because we
1424 must preserve all NOTEs. */
1426 SET_NEXT_INSN (prev
) = next
;
1429 SET_PREV_INSN (next
) = prev
;
1437 /* Note that if TO is an unconditional jump
1438 we *do not* delete the BARRIER that follows,
1439 since the peephole that replaces this sequence
1440 is also an unconditional jump in that case. */
1443 /* A helper function for redirect_exp_1; examines its input X and returns
1444 either a LABEL_REF around a label, or a RETURN if X was NULL. */
1446 redirect_target (rtx x
)
1450 if (!ANY_RETURN_P (x
))
1451 return gen_rtx_LABEL_REF (Pmode
, x
);
1455 /* Throughout LOC, redirect OLABEL to NLABEL. Treat null OLABEL or
1456 NLABEL as a return. Accrue modifications into the change group. */
1459 redirect_exp_1 (rtx
*loc
, rtx olabel
, rtx nlabel
, rtx insn
)
1462 RTX_CODE code
= GET_CODE (x
);
1466 if ((code
== LABEL_REF
&& LABEL_REF_LABEL (x
) == olabel
)
1469 x
= redirect_target (nlabel
);
1470 if (GET_CODE (x
) == LABEL_REF
&& loc
== &PATTERN (insn
))
1471 x
= gen_rtx_SET (pc_rtx
, x
);
1472 validate_change (insn
, loc
, x
, 1);
1476 if (code
== SET
&& SET_DEST (x
) == pc_rtx
1477 && ANY_RETURN_P (nlabel
)
1478 && GET_CODE (SET_SRC (x
)) == LABEL_REF
1479 && LABEL_REF_LABEL (SET_SRC (x
)) == olabel
)
1481 validate_change (insn
, loc
, nlabel
, 1);
1485 if (code
== IF_THEN_ELSE
)
1487 /* Skip the condition of an IF_THEN_ELSE. We only want to
1488 change jump destinations, not eventual label comparisons. */
1489 redirect_exp_1 (&XEXP (x
, 1), olabel
, nlabel
, insn
);
1490 redirect_exp_1 (&XEXP (x
, 2), olabel
, nlabel
, insn
);
1494 fmt
= GET_RTX_FORMAT (code
);
1495 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
1498 redirect_exp_1 (&XEXP (x
, i
), olabel
, nlabel
, insn
);
1499 else if (fmt
[i
] == 'E')
1502 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
1503 redirect_exp_1 (&XVECEXP (x
, i
, j
), olabel
, nlabel
, insn
);
1508 /* Make JUMP go to NLABEL instead of where it jumps now. Accrue
1509 the modifications into the change group. Return false if we did
1510 not see how to do that. */
1513 redirect_jump_1 (rtx_insn
*jump
, rtx nlabel
)
1515 int ochanges
= num_validated_changes ();
1518 gcc_assert (nlabel
!= NULL_RTX
);
1519 asmop
= extract_asm_operands (PATTERN (jump
));
1524 gcc_assert (ASM_OPERANDS_LABEL_LENGTH (asmop
) == 1);
1525 loc
= &ASM_OPERANDS_LABEL (asmop
, 0);
1527 else if (GET_CODE (PATTERN (jump
)) == PARALLEL
)
1528 loc
= &XVECEXP (PATTERN (jump
), 0, 0);
1530 loc
= &PATTERN (jump
);
1532 redirect_exp_1 (loc
, JUMP_LABEL (jump
), nlabel
, jump
);
1533 return num_validated_changes () > ochanges
;
1536 /* Make JUMP go to NLABEL instead of where it jumps now. If the old
1537 jump target label is unused as a result, it and the code following
1540 Normally, NLABEL will be a label, but it may also be a RETURN rtx;
1541 in that case we are to turn the jump into a (possibly conditional)
1544 The return value will be 1 if the change was made, 0 if it wasn't
1545 (this can only occur when trying to produce return insns). */
1548 redirect_jump (rtx_jump_insn
*jump
, rtx nlabel
, int delete_unused
)
1550 rtx olabel
= jump
->jump_label ();
1554 /* If there is no label, we are asked to redirect to the EXIT block.
1555 When before the epilogue is emitted, return/simple_return cannot be
1556 created so we return 0 immediately. After the epilogue is emitted,
1557 we always expect a label, either a non-null label, or a
1558 return/simple_return RTX. */
1560 if (!epilogue_completed
)
1565 if (nlabel
== olabel
)
1568 if (! redirect_jump_1 (jump
, nlabel
) || ! apply_change_group ())
1571 redirect_jump_2 (jump
, olabel
, nlabel
, delete_unused
, 0);
1575 /* Fix up JUMP_LABEL and label ref counts after OLABEL has been replaced with
1577 If DELETE_UNUSED is positive, delete related insn to OLABEL if its ref
1578 count has dropped to zero. */
1580 redirect_jump_2 (rtx_jump_insn
*jump
, rtx olabel
, rtx nlabel
, int delete_unused
,
1585 gcc_assert (JUMP_LABEL (jump
) == olabel
);
1587 /* Negative DELETE_UNUSED used to be used to signalize behavior on
1588 moving FUNCTION_END note. Just sanity check that no user still worry
1590 gcc_assert (delete_unused
>= 0);
1591 JUMP_LABEL (jump
) = nlabel
;
1592 if (!ANY_RETURN_P (nlabel
))
1593 ++LABEL_NUSES (nlabel
);
1595 /* Update labels in any REG_EQUAL note. */
1596 if ((note
= find_reg_note (jump
, REG_EQUAL
, NULL_RTX
)) != NULL_RTX
)
1598 if (ANY_RETURN_P (nlabel
)
1599 || (invert
&& !invert_exp_1 (XEXP (note
, 0), jump
)))
1600 remove_note (jump
, note
);
1603 redirect_exp_1 (&XEXP (note
, 0), olabel
, nlabel
, jump
);
1604 confirm_change_group ();
1608 /* Handle the case where we had a conditional crossing jump to a return
1609 label and are now changing it into a direct conditional return.
1610 The jump is no longer crossing in that case. */
1611 if (ANY_RETURN_P (nlabel
))
1612 CROSSING_JUMP_P (jump
) = 0;
1614 if (!ANY_RETURN_P (olabel
)
1615 && --LABEL_NUSES (olabel
) == 0 && delete_unused
> 0
1616 /* Undefined labels will remain outside the insn stream. */
1617 && INSN_UID (olabel
))
1618 delete_related_insns (olabel
);
1620 invert_br_probabilities (jump
);
1623 /* Invert the jump condition X contained in jump insn INSN. Accrue the
1624 modifications into the change group. Return nonzero for success. */
1626 invert_exp_1 (rtx x
, rtx_insn
*insn
)
1628 RTX_CODE code
= GET_CODE (x
);
1630 if (code
== IF_THEN_ELSE
)
1632 rtx comp
= XEXP (x
, 0);
1634 enum rtx_code reversed_code
;
1636 /* We can do this in two ways: The preferable way, which can only
1637 be done if this is not an integer comparison, is to reverse
1638 the comparison code. Otherwise, swap the THEN-part and ELSE-part
1639 of the IF_THEN_ELSE. If we can't do either, fail. */
1641 reversed_code
= reversed_comparison_code (comp
, insn
);
1643 if (reversed_code
!= UNKNOWN
)
1645 validate_change (insn
, &XEXP (x
, 0),
1646 gen_rtx_fmt_ee (reversed_code
,
1647 GET_MODE (comp
), XEXP (comp
, 0),
1654 validate_change (insn
, &XEXP (x
, 1), XEXP (x
, 2), 1);
1655 validate_change (insn
, &XEXP (x
, 2), tem
, 1);
1662 /* Invert the condition of the jump JUMP, and make it jump to label
1663 NLABEL instead of where it jumps now. Accrue changes into the
1664 change group. Return false if we didn't see how to perform the
1665 inversion and redirection. */
1668 invert_jump_1 (rtx_jump_insn
*jump
, rtx nlabel
)
1670 rtx x
= pc_set (jump
);
1674 ochanges
= num_validated_changes ();
1677 ok
= invert_exp_1 (SET_SRC (x
), jump
);
1680 if (num_validated_changes () == ochanges
)
1683 /* redirect_jump_1 will fail of nlabel == olabel, and the current use is
1684 in Pmode, so checking this is not merely an optimization. */
1685 return nlabel
== JUMP_LABEL (jump
) || redirect_jump_1 (jump
, nlabel
);
1688 /* Invert the condition of the jump JUMP, and make it jump to label
1689 NLABEL instead of where it jumps now. Return true if successful. */
1692 invert_jump (rtx_jump_insn
*jump
, rtx nlabel
, int delete_unused
)
1694 rtx olabel
= JUMP_LABEL (jump
);
1696 if (invert_jump_1 (jump
, nlabel
) && apply_change_group ())
1698 redirect_jump_2 (jump
, olabel
, nlabel
, delete_unused
, 1);
1706 /* Like rtx_equal_p except that it considers two REGs as equal
1707 if they renumber to the same value and considers two commutative
1708 operations to be the same if the order of the operands has been
1712 rtx_renumbered_equal_p (const_rtx x
, const_rtx y
)
1715 const enum rtx_code code
= GET_CODE (x
);
1721 if ((code
== REG
|| (code
== SUBREG
&& REG_P (SUBREG_REG (x
))))
1722 && (REG_P (y
) || (GET_CODE (y
) == SUBREG
1723 && REG_P (SUBREG_REG (y
)))))
1725 int reg_x
= -1, reg_y
= -1;
1726 int byte_x
= 0, byte_y
= 0;
1727 struct subreg_info info
;
1729 if (GET_MODE (x
) != GET_MODE (y
))
1732 /* If we haven't done any renumbering, don't
1733 make any assumptions. */
1734 if (reg_renumber
== 0)
1735 return rtx_equal_p (x
, y
);
1739 reg_x
= REGNO (SUBREG_REG (x
));
1740 byte_x
= SUBREG_BYTE (x
);
1742 if (reg_renumber
[reg_x
] >= 0)
1744 subreg_get_info (reg_renumber
[reg_x
],
1745 GET_MODE (SUBREG_REG (x
)), byte_x
,
1746 GET_MODE (x
), &info
);
1747 if (!info
.representable_p
)
1749 reg_x
= info
.offset
;
1756 if (reg_renumber
[reg_x
] >= 0)
1757 reg_x
= reg_renumber
[reg_x
];
1760 if (GET_CODE (y
) == SUBREG
)
1762 reg_y
= REGNO (SUBREG_REG (y
));
1763 byte_y
= SUBREG_BYTE (y
);
1765 if (reg_renumber
[reg_y
] >= 0)
1767 subreg_get_info (reg_renumber
[reg_y
],
1768 GET_MODE (SUBREG_REG (y
)), byte_y
,
1769 GET_MODE (y
), &info
);
1770 if (!info
.representable_p
)
1772 reg_y
= info
.offset
;
1779 if (reg_renumber
[reg_y
] >= 0)
1780 reg_y
= reg_renumber
[reg_y
];
1783 return reg_x
>= 0 && reg_x
== reg_y
&& byte_x
== byte_y
;
1786 /* Now we have disposed of all the cases
1787 in which different rtx codes can match. */
1788 if (code
!= GET_CODE (y
))
1801 /* We can't assume nonlocal labels have their following insns yet. */
1802 if (LABEL_REF_NONLOCAL_P (x
) || LABEL_REF_NONLOCAL_P (y
))
1803 return LABEL_REF_LABEL (x
) == LABEL_REF_LABEL (y
);
1805 /* Two label-refs are equivalent if they point at labels
1806 in the same position in the instruction stream. */
1809 rtx_insn
*xi
= next_nonnote_nondebug_insn
1810 (as_a
<rtx_insn
*> (LABEL_REF_LABEL (x
)));
1811 rtx_insn
*yi
= next_nonnote_nondebug_insn
1812 (as_a
<rtx_insn
*> (LABEL_REF_LABEL (y
)));
1813 while (xi
&& LABEL_P (xi
))
1814 xi
= next_nonnote_nondebug_insn (xi
);
1815 while (yi
&& LABEL_P (yi
))
1816 yi
= next_nonnote_nondebug_insn (yi
);
1821 return XSTR (x
, 0) == XSTR (y
, 0);
1824 /* If we didn't match EQ equality above, they aren't the same. */
1831 /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent. */
1833 if (GET_MODE (x
) != GET_MODE (y
))
1836 /* MEMs referring to different address space are not equivalent. */
1837 if (code
== MEM
&& MEM_ADDR_SPACE (x
) != MEM_ADDR_SPACE (y
))
1840 /* For commutative operations, the RTX match if the operand match in any
1841 order. Also handle the simple binary and unary cases without a loop. */
1842 if (targetm
.commutative_p (x
, UNKNOWN
))
1843 return ((rtx_renumbered_equal_p (XEXP (x
, 0), XEXP (y
, 0))
1844 && rtx_renumbered_equal_p (XEXP (x
, 1), XEXP (y
, 1)))
1845 || (rtx_renumbered_equal_p (XEXP (x
, 0), XEXP (y
, 1))
1846 && rtx_renumbered_equal_p (XEXP (x
, 1), XEXP (y
, 0))));
1847 else if (NON_COMMUTATIVE_P (x
))
1848 return (rtx_renumbered_equal_p (XEXP (x
, 0), XEXP (y
, 0))
1849 && rtx_renumbered_equal_p (XEXP (x
, 1), XEXP (y
, 1)));
1850 else if (UNARY_P (x
))
1851 return rtx_renumbered_equal_p (XEXP (x
, 0), XEXP (y
, 0));
1853 /* Compare the elements. If any pair of corresponding elements
1854 fail to match, return 0 for the whole things. */
1856 fmt
= GET_RTX_FORMAT (code
);
1857 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
1863 if (XWINT (x
, i
) != XWINT (y
, i
))
1868 if (XINT (x
, i
) != XINT (y
, i
))
1870 if (((code
== ASM_OPERANDS
&& i
== 6)
1871 || (code
== ASM_INPUT
&& i
== 1)))
1878 if (XTREE (x
, i
) != XTREE (y
, i
))
1883 if (strcmp (XSTR (x
, i
), XSTR (y
, i
)))
1888 if (! rtx_renumbered_equal_p (XEXP (x
, i
), XEXP (y
, i
)))
1893 if (XEXP (x
, i
) != XEXP (y
, i
))
1900 if (XVECLEN (x
, i
) != XVECLEN (y
, i
))
1902 for (j
= XVECLEN (x
, i
) - 1; j
>= 0; j
--)
1903 if (!rtx_renumbered_equal_p (XVECEXP (x
, i
, j
), XVECEXP (y
, i
, j
)))
1914 /* If X is a hard register or equivalent to one or a subregister of one,
1915 return the hard register number. If X is a pseudo register that was not
1916 assigned a hard register, return the pseudo register number. Otherwise,
1917 return -1. Any rtx is valid for X. */
1920 true_regnum (const_rtx x
)
1924 if (REGNO (x
) >= FIRST_PSEUDO_REGISTER
1925 && (lra_in_progress
|| reg_renumber
[REGNO (x
)] >= 0))
1926 return reg_renumber
[REGNO (x
)];
1929 if (GET_CODE (x
) == SUBREG
)
1931 int base
= true_regnum (SUBREG_REG (x
));
1933 && base
< FIRST_PSEUDO_REGISTER
)
1935 struct subreg_info info
;
1937 subreg_get_info (lra_in_progress
1938 ? (unsigned) base
: REGNO (SUBREG_REG (x
)),
1939 GET_MODE (SUBREG_REG (x
)),
1940 SUBREG_BYTE (x
), GET_MODE (x
), &info
);
1942 if (info
.representable_p
)
1943 return base
+ info
.offset
;
1949 /* Return regno of the register REG and handle subregs too. */
1951 reg_or_subregno (const_rtx reg
)
1953 if (GET_CODE (reg
) == SUBREG
)
1954 reg
= SUBREG_REG (reg
);
1955 gcc_assert (REG_P (reg
));