1 /* Analyze RTL for C-Compiler
2 Copyright (C) 1987, 88, 92-97, 1998 Free Software Foundation, Inc.
4 This file is part of GNU CC.
6 GNU CC is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GNU CC is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU CC; see the file COPYING. If not, write to
18 the Free Software Foundation, 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
26 static int rtx_addr_can_trap_p PROTO((rtx));
27 static void reg_set_p_1 PROTO((rtx, rtx));
28 static void reg_set_last_1 PROTO((rtx, rtx));
31 /* Forward declarations */
32 static int jmp_uses_reg_or_mem PROTO((rtx));
34 /* Bit flags that specify the machine subtype we are compiling for.
35 Bits are tested using macros TARGET_... defined in the tm.h file
36 and set by `-m...' switches. Must be defined in rtlanal.c. */
40 /* Return 1 if the value of X is unstable
41 (would be different at a different point in the program).
42 The frame pointer, arg pointer, etc. are considered stable
43 (within one function) and so is anything marked `unchanging'. */
49 register RTX_CODE code = GET_CODE (x);
54 return ! RTX_UNCHANGING_P (x);
59 if (code == CONST || code == CONST_INT)
63 return ! (REGNO (x) == FRAME_POINTER_REGNUM
64 || REGNO (x) == HARD_FRAME_POINTER_REGNUM
65 || REGNO (x) == ARG_POINTER_REGNUM
66 || RTX_UNCHANGING_P (x));
68 fmt = GET_RTX_FORMAT (code);
69 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
71 if (rtx_unstable_p (XEXP (x, i)))
76 /* Return 1 if X has a value that can vary even between two
77 executions of the program. 0 means X can be compared reliably
78 against certain constants or near-constants.
79 The frame pointer and the arg pointer are considered constant. */
85 register RTX_CODE code = GET_CODE (x);
103 /* Note that we have to test for the actual rtx used for the frame
104 and arg pointers and not just the register number in case we have
105 eliminated the frame and/or arg pointer and are using it
107 return ! (x == frame_pointer_rtx || x == hard_frame_pointer_rtx
108 || x == arg_pointer_rtx || x == pic_offset_table_rtx);
111 /* The operand 0 of a LO_SUM is considered constant
112 (in fact is it related specifically to operand 1). */
113 return rtx_varies_p (XEXP (x, 1));
119 fmt = GET_RTX_FORMAT (code);
120 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
122 if (rtx_varies_p (XEXP (x, i)))
127 /* Return 0 if the use of X as an address in a MEM can cause a trap. */
130 rtx_addr_can_trap_p (x)
133 register enum rtx_code code = GET_CODE (x);
139 /* SYMBOL_REF is problematic due to the possible presence of
140 a #pragma weak, but to say that loads from symbols can trap is
141 *very* costly. It's not at all clear what's best here. For
142 now, we ignore the impact of #pragma weak. */
146 /* As in rtx_varies_p, we have to use the actual rtx, not reg number. */
147 return ! (x == frame_pointer_rtx || x == hard_frame_pointer_rtx
148 || x == stack_pointer_rtx || x == arg_pointer_rtx);
151 return rtx_addr_can_trap_p (XEXP (x, 0));
154 /* An address is assumed not to trap if it is an address that can't
155 trap plus a constant integer. */
156 return (rtx_addr_can_trap_p (XEXP (x, 0))
157 || GET_CODE (XEXP (x, 1)) != CONST_INT);
160 return rtx_addr_can_trap_p (XEXP (x, 1));
166 /* If it isn't one of the case above, it can cause a trap. */
170 /* Return 1 if X refers to a memory location whose address
171 cannot be compared reliably with constant addresses,
172 or if X refers to a BLKmode memory object. */
175 rtx_addr_varies_p (x)
178 register enum rtx_code code;
187 return GET_MODE (x) == BLKmode || rtx_varies_p (XEXP (x, 0));
189 fmt = GET_RTX_FORMAT (code);
190 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
193 if (rtx_addr_varies_p (XEXP (x, i)))
196 else if (fmt[i] == 'E')
199 for (j = 0; j < XVECLEN (x, i); j++)
200 if (rtx_addr_varies_p (XVECEXP (x, i, j)))
206 /* Return the value of the integer term in X, if one is apparent;
208 Only obvious integer terms are detected.
209 This is used in cse.c with the `related_value' field.*/
215 if (GET_CODE (x) == CONST)
218 if (GET_CODE (x) == MINUS
219 && GET_CODE (XEXP (x, 1)) == CONST_INT)
220 return - INTVAL (XEXP (x, 1));
221 if (GET_CODE (x) == PLUS
222 && GET_CODE (XEXP (x, 1)) == CONST_INT)
223 return INTVAL (XEXP (x, 1));
227 /* If X is a constant, return the value sans apparent integer term;
229 Only obvious integer terms are detected. */
232 get_related_value (x)
235 if (GET_CODE (x) != CONST)
238 if (GET_CODE (x) == PLUS
239 && GET_CODE (XEXP (x, 1)) == CONST_INT)
241 else if (GET_CODE (x) == MINUS
242 && GET_CODE (XEXP (x, 1)) == CONST_INT)
247 /* Nonzero if register REG appears somewhere within IN.
248 Also works if REG is not a register; in this case it checks
249 for a subexpression of IN that is Lisp "equal" to REG. */
252 reg_mentioned_p (reg, in)
253 register rtx reg, in;
257 register enum rtx_code code;
265 if (GET_CODE (in) == LABEL_REF)
266 return reg == XEXP (in, 0);
268 code = GET_CODE (in);
272 /* Compare registers by number. */
274 return GET_CODE (reg) == REG && REGNO (in) == REGNO (reg);
276 /* These codes have no constituent expressions
284 return GET_CODE (reg) == CONST_INT && INTVAL (in) == INTVAL (reg);
287 /* These are kept unique for a given value. */
294 if (GET_CODE (reg) == code && rtx_equal_p (reg, in))
297 fmt = GET_RTX_FORMAT (code);
299 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
304 for (j = XVECLEN (in, i) - 1; j >= 0; j--)
305 if (reg_mentioned_p (reg, XVECEXP (in, i, j)))
308 else if (fmt[i] == 'e'
309 && reg_mentioned_p (reg, XEXP (in, i)))
315 /* Return 1 if in between BEG and END, exclusive of BEG and END, there is
316 no CODE_LABEL insn. */
319 no_labels_between_p (beg, end)
323 for (p = NEXT_INSN (beg); p != end; p = NEXT_INSN (p))
324 if (GET_CODE (p) == CODE_LABEL)
329 /* Nonzero if register REG is used in an insn between
330 FROM_INSN and TO_INSN (exclusive of those two). */
333 reg_used_between_p (reg, from_insn, to_insn)
334 rtx reg, from_insn, to_insn;
338 if (from_insn == to_insn)
341 for (insn = NEXT_INSN (from_insn); insn != to_insn; insn = NEXT_INSN (insn))
342 if (GET_RTX_CLASS (GET_CODE (insn)) == 'i'
343 && (reg_overlap_mentioned_p (reg, PATTERN (insn))
344 || (GET_CODE (insn) == CALL_INSN
345 && (find_reg_fusage (insn, USE, reg)
346 || find_reg_fusage (insn, CLOBBER, reg)))))
351 /* Nonzero if the old value of X, a register, is referenced in BODY. If X
352 is entirely replaced by a new value and the only use is as a SET_DEST,
353 we do not consider it a reference. */
356 reg_referenced_p (x, body)
362 switch (GET_CODE (body))
365 if (reg_overlap_mentioned_p (x, SET_SRC (body)))
368 /* If the destination is anything other than CC0, PC, a REG or a SUBREG
369 of a REG that occupies all of the REG, the insn references X if
370 it is mentioned in the destination. */
371 if (GET_CODE (SET_DEST (body)) != CC0
372 && GET_CODE (SET_DEST (body)) != PC
373 && GET_CODE (SET_DEST (body)) != REG
374 && ! (GET_CODE (SET_DEST (body)) == SUBREG
375 && GET_CODE (SUBREG_REG (SET_DEST (body))) == REG
376 && (((GET_MODE_SIZE (GET_MODE (SUBREG_REG (SET_DEST (body))))
377 + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD)
378 == ((GET_MODE_SIZE (GET_MODE (SET_DEST (body)))
379 + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD)))
380 && reg_overlap_mentioned_p (x, SET_DEST (body)))
385 for (i = ASM_OPERANDS_INPUT_LENGTH (body) - 1; i >= 0; i--)
386 if (reg_overlap_mentioned_p (x, ASM_OPERANDS_INPUT (body, i)))
392 return reg_overlap_mentioned_p (x, body);
395 return reg_overlap_mentioned_p (x, TRAP_CONDITION (body));
398 case UNSPEC_VOLATILE:
400 for (i = XVECLEN (body, 0) - 1; i >= 0; i--)
401 if (reg_referenced_p (x, XVECEXP (body, 0, i)))
410 /* Nonzero if register REG is referenced in an insn between
411 FROM_INSN and TO_INSN (exclusive of those two). Sets of REG do
415 reg_referenced_between_p (reg, from_insn, to_insn)
416 rtx reg, from_insn, to_insn;
420 if (from_insn == to_insn)
423 for (insn = NEXT_INSN (from_insn); insn != to_insn; insn = NEXT_INSN (insn))
424 if (GET_RTX_CLASS (GET_CODE (insn)) == 'i'
425 && (reg_referenced_p (reg, PATTERN (insn))
426 || (GET_CODE (insn) == CALL_INSN
427 && find_reg_fusage (insn, USE, reg))))
432 /* Nonzero if register REG is set or clobbered in an insn between
433 FROM_INSN and TO_INSN (exclusive of those two). */
436 reg_set_between_p (reg, from_insn, to_insn)
437 rtx reg, from_insn, to_insn;
441 if (from_insn == to_insn)
444 for (insn = NEXT_INSN (from_insn); insn != to_insn; insn = NEXT_INSN (insn))
445 if (GET_RTX_CLASS (GET_CODE (insn)) == 'i'
446 && reg_set_p (reg, insn))
451 /* Internals of reg_set_between_p. */
453 static rtx reg_set_reg;
454 static int reg_set_flag;
459 rtx pat ATTRIBUTE_UNUSED;
461 /* We don't want to return 1 if X is a MEM that contains a register
462 within REG_SET_REG. */
464 if ((GET_CODE (x) != MEM)
465 && reg_overlap_mentioned_p (reg_set_reg, x))
470 reg_set_p (reg, insn)
475 /* We can be passed an insn or part of one. If we are passed an insn,
476 check if a side-effect of the insn clobbers REG. */
477 if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
479 if (FIND_REG_INC_NOTE (insn, reg)
480 || (GET_CODE (insn) == CALL_INSN
481 /* We'd like to test call_used_regs here, but rtlanal.c can't
482 reference that variable due to its use in genattrtab. So
483 we'll just be more conservative.
485 ??? Unless we could ensure that the CALL_INSN_FUNCTION_USAGE
486 information holds all clobbered registers. */
487 && ((GET_CODE (reg) == REG
488 && REGNO (reg) < FIRST_PSEUDO_REGISTER)
489 || GET_CODE (reg) == MEM
490 || find_reg_fusage (insn, CLOBBER, reg))))
493 body = PATTERN (insn);
498 note_stores (body, reg_set_p_1);
502 /* Similar to reg_set_between_p, but check all registers in X. Return 0
503 only if none of them are modified between START and END. Do not
504 consider non-registers one way or the other. */
507 regs_set_between_p (x, start, end)
511 enum rtx_code code = GET_CODE (x);
527 return reg_set_between_p (x, start, end);
533 fmt = GET_RTX_FORMAT (code);
534 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
536 if (fmt[i] == 'e' && regs_set_between_p (XEXP (x, i), start, end))
539 else if (fmt[i] == 'E')
540 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
541 if (regs_set_between_p (XVECEXP (x, i, j), start, end))
548 /* Similar to reg_set_between_p, but check all registers in X. Return 0
549 only if none of them are modified between START and END. Return 1 if
550 X contains a MEM; this routine does not perform any memory aliasing. */
553 modified_between_p (x, start, end)
557 enum rtx_code code = GET_CODE (x);
575 /* If the memory is not constant, assume it is modified. If it is
576 constant, we still have to check the address. */
577 if (! RTX_UNCHANGING_P (x))
582 return reg_set_between_p (x, start, end);
588 fmt = GET_RTX_FORMAT (code);
589 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
591 if (fmt[i] == 'e' && modified_between_p (XEXP (x, i), start, end))
595 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
596 if (modified_between_p (XVECEXP (x, i, j), start, end))
603 /* Similar to reg_set_p, but check all registers in X. Return 0 only if none
604 of them are modified in INSN. Return 1 if X contains a MEM; this routine
605 does not perform any memory aliasing. */
608 modified_in_p (x, insn)
612 enum rtx_code code = GET_CODE (x);
630 /* If the memory is not constant, assume it is modified. If it is
631 constant, we still have to check the address. */
632 if (! RTX_UNCHANGING_P (x))
637 return reg_set_p (x, insn);
643 fmt = GET_RTX_FORMAT (code);
644 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
646 if (fmt[i] == 'e' && modified_in_p (XEXP (x, i), insn))
650 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
651 if (modified_in_p (XVECEXP (x, i, j), insn))
658 /* Given an INSN, return a SET expression if this insn has only a single SET.
659 It may also have CLOBBERs, USEs, or SET whose output
660 will not be used, which we ignore. */
669 if (GET_RTX_CLASS (GET_CODE (insn)) != 'i')
672 if (GET_CODE (PATTERN (insn)) == SET)
673 return PATTERN (insn);
675 else if (GET_CODE (PATTERN (insn)) == PARALLEL)
677 for (i = 0, set = 0; i < XVECLEN (PATTERN (insn), 0); i++)
678 if (GET_CODE (XVECEXP (PATTERN (insn), 0, i)) == SET
679 && (! find_reg_note (insn, REG_UNUSED,
680 SET_DEST (XVECEXP (PATTERN (insn), 0, i)))
681 || side_effects_p (XVECEXP (PATTERN (insn), 0, i))))
686 set = XVECEXP (PATTERN (insn), 0, i);
694 /* Given an INSN, return nonzero if it has more than one SET, else return
704 /* INSN must be an insn. */
705 if (GET_RTX_CLASS (GET_CODE (insn)) != 'i')
708 /* Only a PARALLEL can have multiple SETs. */
709 if (GET_CODE (PATTERN (insn)) == PARALLEL)
711 for (i = 0, found = 0; i < XVECLEN (PATTERN (insn), 0); i++)
712 if (GET_CODE (XVECEXP (PATTERN (insn), 0, i)) == SET)
714 /* If we have already found a SET, then return now. */
722 /* Either zero or one SET. */
726 /* Return the last thing that X was assigned from before *PINSN. Verify that
727 the object is not modified up to VALID_TO. If it was, if we hit
728 a partial assignment to X, or hit a CODE_LABEL first, return X. If we
729 found an assignment, update *PINSN to point to it. */
732 find_last_value (x, pinsn, valid_to)
739 for (p = PREV_INSN (*pinsn); p && GET_CODE (p) != CODE_LABEL;
741 if (GET_RTX_CLASS (GET_CODE (p)) == 'i')
743 rtx set = single_set (p);
744 rtx note = find_reg_note (p, REG_EQUAL, NULL_RTX);
746 if (set && rtx_equal_p (x, SET_DEST (set)))
748 rtx src = SET_SRC (set);
750 if (note && GET_CODE (XEXP (note, 0)) != EXPR_LIST)
751 src = XEXP (note, 0);
753 if (! modified_between_p (src, PREV_INSN (p), valid_to)
754 /* Reject hard registers because we don't usually want
755 to use them; we'd rather use a pseudo. */
756 && ! (GET_CODE (src) == REG
757 && REGNO (src) < FIRST_PSEUDO_REGISTER))
764 /* If set in non-simple way, we don't have a value. */
765 if (reg_set_p (x, p))
772 /* Return nonzero if register in range [REGNO, ENDREGNO)
773 appears either explicitly or implicitly in X
774 other than being stored into.
776 References contained within the substructure at LOC do not count.
777 LOC may be zero, meaning don't ignore anything. */
780 refers_to_regno_p (regno, endregno, x, loc)
786 register RTX_CODE code;
790 /* The contents of a REG_NONNEG note is always zero, so we must come here
791 upon repeat in case the last REG_NOTE is a REG_NONNEG note. */
802 /* If we modifying the stack, frame, or argument pointer, it will
803 clobber a virtual register. In fact, we could be more precise,
804 but it isn't worth it. */
805 if ((i == STACK_POINTER_REGNUM
806 #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
807 || i == ARG_POINTER_REGNUM
809 || i == FRAME_POINTER_REGNUM)
810 && regno >= FIRST_VIRTUAL_REGISTER && regno <= LAST_VIRTUAL_REGISTER)
814 && regno < i + (i < FIRST_PSEUDO_REGISTER
815 ? HARD_REGNO_NREGS (i, GET_MODE (x))
819 /* If this is a SUBREG of a hard reg, we can see exactly which
820 registers are being modified. Otherwise, handle normally. */
821 if (GET_CODE (SUBREG_REG (x)) == REG
822 && REGNO (SUBREG_REG (x)) < FIRST_PSEUDO_REGISTER)
824 int inner_regno = REGNO (SUBREG_REG (x)) + SUBREG_WORD (x);
826 = inner_regno + (inner_regno < FIRST_PSEUDO_REGISTER
827 ? HARD_REGNO_NREGS (regno, GET_MODE (x)) : 1);
829 return endregno > inner_regno && regno < inner_endregno;
835 if (&SET_DEST (x) != loc
836 /* Note setting a SUBREG counts as referring to the REG it is in for
837 a pseudo but not for hard registers since we can
838 treat each word individually. */
839 && ((GET_CODE (SET_DEST (x)) == SUBREG
840 && loc != &SUBREG_REG (SET_DEST (x))
841 && GET_CODE (SUBREG_REG (SET_DEST (x))) == REG
842 && REGNO (SUBREG_REG (SET_DEST (x))) >= FIRST_PSEUDO_REGISTER
843 && refers_to_regno_p (regno, endregno,
844 SUBREG_REG (SET_DEST (x)), loc))
845 || (GET_CODE (SET_DEST (x)) != REG
846 && refers_to_regno_p (regno, endregno, SET_DEST (x), loc))))
849 if (code == CLOBBER || loc == &SET_SRC (x))
858 /* X does not match, so try its subexpressions. */
860 fmt = GET_RTX_FORMAT (code);
861 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
863 if (fmt[i] == 'e' && loc != &XEXP (x, i))
871 if (refers_to_regno_p (regno, endregno, XEXP (x, i), loc))
874 else if (fmt[i] == 'E')
877 for (j = XVECLEN (x, i) - 1; j >=0; j--)
878 if (loc != &XVECEXP (x, i, j)
879 && refers_to_regno_p (regno, endregno, XVECEXP (x, i, j), loc))
886 /* Nonzero if modifying X will affect IN. If X is a register or a SUBREG,
887 we check if any register number in X conflicts with the relevant register
888 numbers. If X is a constant, return 0. If X is a MEM, return 1 iff IN
889 contains a MEM (we don't bother checking for memory addresses that can't
890 conflict because we expect this to be a rare case. */
893 reg_overlap_mentioned_p (x, in)
898 /* Overly conservative. */
899 if (GET_CODE (x) == STRICT_LOW_PART)
902 /* If either argument is a constant, then modifying X can not affect IN. */
903 if (CONSTANT_P (x) || CONSTANT_P (in))
905 else if (GET_CODE (x) == SUBREG)
907 regno = REGNO (SUBREG_REG (x));
908 if (regno < FIRST_PSEUDO_REGISTER)
909 regno += SUBREG_WORD (x);
911 else if (GET_CODE (x) == REG)
913 else if (GET_CODE (x) == MEM)
918 if (GET_CODE (in) == MEM)
921 fmt = GET_RTX_FORMAT (GET_CODE (in));
923 for (i = GET_RTX_LENGTH (GET_CODE (in)) - 1; i >= 0; i--)
924 if (fmt[i] == 'e' && reg_overlap_mentioned_p (x, XEXP (in, i)))
929 else if (GET_CODE (x) == SCRATCH || GET_CODE (x) == PC
930 || GET_CODE (x) == CC0)
931 return reg_mentioned_p (x, in);
932 else if (GET_CODE (x) == PARALLEL
933 && GET_MODE (x) == BLKmode)
937 /* If any register in here refers to it
939 for (i = XVECLEN (x, 0) - 1; i >= 0; i--)
940 if (reg_overlap_mentioned_p (SET_DEST (XVECEXP (x, 0, i)), in))
947 endregno = regno + (regno < FIRST_PSEUDO_REGISTER
948 ? HARD_REGNO_NREGS (regno, GET_MODE (x)) : 1);
950 return refers_to_regno_p (regno, endregno, in, NULL_PTR);
953 /* Used for communications between the next few functions. */
955 static int reg_set_last_unknown;
956 static rtx reg_set_last_value;
957 static int reg_set_last_first_regno, reg_set_last_last_regno;
959 /* Called via note_stores from reg_set_last. */
962 reg_set_last_1 (x, pat)
968 /* If X is not a register, or is not one in the range we care
970 if (GET_CODE (x) != REG)
974 last = first + (first < FIRST_PSEUDO_REGISTER
975 ? HARD_REGNO_NREGS (first, GET_MODE (x)) : 1);
977 if (first >= reg_set_last_last_regno
978 || last <= reg_set_last_first_regno)
981 /* If this is a CLOBBER or is some complex LHS, or doesn't modify
982 exactly the registers we care about, show we don't know the value. */
983 if (GET_CODE (pat) == CLOBBER || SET_DEST (pat) != x
984 || first != reg_set_last_first_regno
985 || last != reg_set_last_last_regno)
986 reg_set_last_unknown = 1;
988 reg_set_last_value = SET_SRC (pat);
991 /* Return the last value to which REG was set prior to INSN. If we can't
992 find it easily, return 0.
994 We only return a REG, SUBREG, or constant because it is too hard to
995 check if a MEM remains unchanged. */
998 reg_set_last (x, insn)
1002 rtx orig_insn = insn;
1004 reg_set_last_first_regno = REGNO (x);
1006 reg_set_last_last_regno
1007 = reg_set_last_first_regno
1008 + (reg_set_last_first_regno < FIRST_PSEUDO_REGISTER
1009 ? HARD_REGNO_NREGS (reg_set_last_first_regno, GET_MODE (x)) : 1);
1011 reg_set_last_unknown = 0;
1012 reg_set_last_value = 0;
1014 /* Scan backwards until reg_set_last_1 changed one of the above flags.
1015 Stop when we reach a label or X is a hard reg and we reach a
1016 CALL_INSN (if reg_set_last_last_regno is a hard reg).
1018 If we find a set of X, ensure that its SET_SRC remains unchanged. */
1020 /* We compare with <= here, because reg_set_last_last_regno
1021 is actually the number of the first reg *not* in X. */
1023 insn && GET_CODE (insn) != CODE_LABEL
1024 && ! (GET_CODE (insn) == CALL_INSN
1025 && reg_set_last_last_regno <= FIRST_PSEUDO_REGISTER);
1026 insn = PREV_INSN (insn))
1027 if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
1029 note_stores (PATTERN (insn), reg_set_last_1);
1030 if (reg_set_last_unknown)
1032 else if (reg_set_last_value)
1034 if (CONSTANT_P (reg_set_last_value)
1035 || ((GET_CODE (reg_set_last_value) == REG
1036 || GET_CODE (reg_set_last_value) == SUBREG)
1037 && ! reg_set_between_p (reg_set_last_value,
1039 return reg_set_last_value;
1048 /* This is 1 until after the rtl generation pass. */
1049 int rtx_equal_function_value_matters;
1051 /* Return 1 if X and Y are identical-looking rtx's.
1052 This is the Lisp function EQUAL for rtx arguments. */
1060 register enum rtx_code code;
1065 if (x == 0 || y == 0)
1068 code = GET_CODE (x);
1069 /* Rtx's of different codes cannot be equal. */
1070 if (code != GET_CODE (y))
1073 /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent.
1074 (REG:SI x) and (REG:HI x) are NOT equivalent. */
1076 if (GET_MODE (x) != GET_MODE (y))
1079 /* REG, LABEL_REF, and SYMBOL_REF can be compared nonrecursively. */
1082 /* Until rtl generation is complete, don't consider a reference to the
1083 return register of the current function the same as the return from a
1084 called function. This eases the job of function integration. Once the
1085 distinction is no longer needed, they can be considered equivalent. */
1086 return (REGNO (x) == REGNO (y)
1087 && (! rtx_equal_function_value_matters
1088 || REG_FUNCTION_VALUE_P (x) == REG_FUNCTION_VALUE_P (y)));
1089 else if (code == LABEL_REF)
1090 return XEXP (x, 0) == XEXP (y, 0);
1091 else if (code == SYMBOL_REF)
1092 return XSTR (x, 0) == XSTR (y, 0);
1093 else if (code == SCRATCH || code == CONST_DOUBLE)
1096 /* Compare the elements. If any pair of corresponding elements
1097 fail to match, return 0 for the whole things. */
1099 fmt = GET_RTX_FORMAT (code);
1100 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
1105 if (XWINT (x, i) != XWINT (y, i))
1111 if (XINT (x, i) != XINT (y, i))
1117 /* Two vectors must have the same length. */
1118 if (XVECLEN (x, i) != XVECLEN (y, i))
1121 /* And the corresponding elements must match. */
1122 for (j = 0; j < XVECLEN (x, i); j++)
1123 if (rtx_equal_p (XVECEXP (x, i, j), XVECEXP (y, i, j)) == 0)
1128 if (rtx_equal_p (XEXP (x, i), XEXP (y, i)) == 0)
1134 if (strcmp (XSTR (x, i), XSTR (y, i)))
1139 /* These are just backpointers, so they don't matter. */
1145 /* It is believed that rtx's at this level will never
1146 contain anything but integers and other rtx's,
1147 except for within LABEL_REFs and SYMBOL_REFs. */
1155 /* Call FUN on each register or MEM that is stored into or clobbered by X.
1156 (X would be the pattern of an insn).
1157 FUN receives two arguments:
1158 the REG, MEM, CC0 or PC being stored in or clobbered,
1159 the SET or CLOBBER rtx that does the store.
1161 If the item being stored in or clobbered is a SUBREG of a hard register,
1162 the SUBREG will be passed. */
1165 note_stores (x, fun)
1169 if ((GET_CODE (x) == SET || GET_CODE (x) == CLOBBER))
1171 register rtx dest = SET_DEST (x);
1172 while ((GET_CODE (dest) == SUBREG
1173 && (GET_CODE (SUBREG_REG (dest)) != REG
1174 || REGNO (SUBREG_REG (dest)) >= FIRST_PSEUDO_REGISTER))
1175 || GET_CODE (dest) == ZERO_EXTRACT
1176 || GET_CODE (dest) == SIGN_EXTRACT
1177 || GET_CODE (dest) == STRICT_LOW_PART)
1178 dest = XEXP (dest, 0);
1180 if (GET_CODE (dest) == PARALLEL
1181 && GET_MODE (dest) == BLKmode)
1184 for (i = XVECLEN (dest, 0) - 1; i >= 0; i--)
1185 (*fun) (SET_DEST (XVECEXP (dest, 0, i)), x);
1190 else if (GET_CODE (x) == PARALLEL)
1193 for (i = XVECLEN (x, 0) - 1; i >= 0; i--)
1195 register rtx y = XVECEXP (x, 0, i);
1196 if (GET_CODE (y) == SET || GET_CODE (y) == CLOBBER)
1198 register rtx dest = SET_DEST (y);
1199 while ((GET_CODE (dest) == SUBREG
1200 && (GET_CODE (SUBREG_REG (dest)) != REG
1201 || (REGNO (SUBREG_REG (dest))
1202 >= FIRST_PSEUDO_REGISTER)))
1203 || GET_CODE (dest) == ZERO_EXTRACT
1204 || GET_CODE (dest) == SIGN_EXTRACT
1205 || GET_CODE (dest) == STRICT_LOW_PART)
1206 dest = XEXP (dest, 0);
1207 if (GET_CODE (dest) == PARALLEL
1208 && GET_MODE (dest) == BLKmode)
1211 for (i = XVECLEN (dest, 0) - 1; i >= 0; i--)
1212 (*fun) (SET_DEST (XVECEXP (dest, 0, i)), y);
1221 /* Return nonzero if X's old contents don't survive after INSN.
1222 This will be true if X is (cc0) or if X is a register and
1223 X dies in INSN or because INSN entirely sets X.
1225 "Entirely set" means set directly and not through a SUBREG,
1226 ZERO_EXTRACT or SIGN_EXTRACT, so no trace of the old contents remains.
1227 Likewise, REG_INC does not count.
1229 REG may be a hard or pseudo reg. Renumbering is not taken into account,
1230 but for this use that makes no difference, since regs don't overlap
1231 during their lifetimes. Therefore, this function may be used
1232 at any time after deaths have been computed (in flow.c).
1234 If REG is a hard reg that occupies multiple machine registers, this
1235 function will only return 1 if each of those registers will be replaced
1239 dead_or_set_p (insn, x)
1243 register int regno, last_regno;
1246 /* Can't use cc0_rtx below since this file is used by genattrtab.c. */
1247 if (GET_CODE (x) == CC0)
1250 if (GET_CODE (x) != REG)
1254 last_regno = (regno >= FIRST_PSEUDO_REGISTER ? regno
1255 : regno + HARD_REGNO_NREGS (regno, GET_MODE (x)) - 1);
1257 for (i = regno; i <= last_regno; i++)
1258 if (! dead_or_set_regno_p (insn, i))
1264 /* Utility function for dead_or_set_p to check an individual register. Also
1265 called from flow.c. */
1268 dead_or_set_regno_p (insn, test_regno)
1272 int regno, endregno;
1275 /* See if there is a death note for something that includes
1277 for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
1279 if (REG_NOTE_KIND (link) != REG_DEAD
1280 || GET_CODE (XEXP (link, 0)) != REG)
1283 regno = REGNO (XEXP (link, 0));
1284 endregno = (regno >= FIRST_PSEUDO_REGISTER ? regno + 1
1285 : regno + HARD_REGNO_NREGS (regno,
1286 GET_MODE (XEXP (link, 0))));
1288 if (test_regno >= regno && test_regno < endregno)
1292 if (GET_CODE (insn) == CALL_INSN
1293 && find_regno_fusage (insn, CLOBBER, test_regno))
1296 if (GET_CODE (PATTERN (insn)) == SET)
1298 rtx dest = SET_DEST (PATTERN (insn));
1300 /* A value is totally replaced if it is the destination or the
1301 destination is a SUBREG of REGNO that does not change the number of
1303 if (GET_CODE (dest) == SUBREG
1304 && (((GET_MODE_SIZE (GET_MODE (dest))
1305 + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
1306 == ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (dest)))
1307 + UNITS_PER_WORD - 1) / UNITS_PER_WORD)))
1308 dest = SUBREG_REG (dest);
1310 if (GET_CODE (dest) != REG)
1313 regno = REGNO (dest);
1314 endregno = (regno >= FIRST_PSEUDO_REGISTER ? regno + 1
1315 : regno + HARD_REGNO_NREGS (regno, GET_MODE (dest)));
1317 return (test_regno >= regno && test_regno < endregno);
1319 else if (GET_CODE (PATTERN (insn)) == PARALLEL)
1323 for (i = XVECLEN (PATTERN (insn), 0) - 1; i >= 0; i--)
1325 rtx body = XVECEXP (PATTERN (insn), 0, i);
1327 if (GET_CODE (body) == SET || GET_CODE (body) == CLOBBER)
1329 rtx dest = SET_DEST (body);
1331 if (GET_CODE (dest) == SUBREG
1332 && (((GET_MODE_SIZE (GET_MODE (dest))
1333 + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
1334 == ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (dest)))
1335 + UNITS_PER_WORD - 1) / UNITS_PER_WORD)))
1336 dest = SUBREG_REG (dest);
1338 if (GET_CODE (dest) != REG)
1341 regno = REGNO (dest);
1342 endregno = (regno >= FIRST_PSEUDO_REGISTER ? regno + 1
1343 : regno + HARD_REGNO_NREGS (regno, GET_MODE (dest)));
1345 if (test_regno >= regno && test_regno < endregno)
1354 /* Return the reg-note of kind KIND in insn INSN, if there is one.
1355 If DATUM is nonzero, look for one whose datum is DATUM. */
1358 find_reg_note (insn, kind, datum)
1365 /* Ignore anything that is not an INSN, JUMP_INSN or CALL_INSN. */
1366 if (GET_RTX_CLASS (GET_CODE (insn)) != 'i')
1369 for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
1370 if (REG_NOTE_KIND (link) == kind
1371 && (datum == 0 || datum == XEXP (link, 0)))
1376 /* Return the reg-note of kind KIND in insn INSN which applies to register
1377 number REGNO, if any. Return 0 if there is no such reg-note. Note that
1378 the REGNO of this NOTE need not be REGNO if REGNO is a hard register;
1379 it might be the case that the note overlaps REGNO. */
1382 find_regno_note (insn, kind, regno)
1389 /* Ignore anything that is not an INSN, JUMP_INSN or CALL_INSN. */
1390 if (GET_RTX_CLASS (GET_CODE (insn)) != 'i')
1393 for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
1394 if (REG_NOTE_KIND (link) == kind
1395 /* Verify that it is a register, so that scratch and MEM won't cause a
1397 && GET_CODE (XEXP (link, 0)) == REG
1398 && REGNO (XEXP (link, 0)) <= regno
1399 && ((REGNO (XEXP (link, 0))
1400 + (REGNO (XEXP (link, 0)) >= FIRST_PSEUDO_REGISTER ? 1
1401 : HARD_REGNO_NREGS (REGNO (XEXP (link, 0)),
1402 GET_MODE (XEXP (link, 0)))))
1408 /* Return true if DATUM, or any overlap of DATUM, of kind CODE is found
1409 in the CALL_INSN_FUNCTION_USAGE information of INSN. */
1412 find_reg_fusage (insn, code, datum)
1417 /* If it's not a CALL_INSN, it can't possibly have a
1418 CALL_INSN_FUNCTION_USAGE field, so don't bother checking. */
1419 if (GET_CODE (insn) != CALL_INSN)
1425 if (GET_CODE (datum) != REG)
1429 for (link = CALL_INSN_FUNCTION_USAGE (insn);
1431 link = XEXP (link, 1))
1432 if (GET_CODE (XEXP (link, 0)) == code
1433 && rtx_equal_p (datum, SET_DEST (XEXP (link, 0))))
1438 register int regno = REGNO (datum);
1440 /* CALL_INSN_FUNCTION_USAGE information cannot contain references
1441 to pseudo registers, so don't bother checking. */
1443 if (regno < FIRST_PSEUDO_REGISTER)
1445 int end_regno = regno + HARD_REGNO_NREGS (regno, GET_MODE (datum));
1448 for (i = regno; i < end_regno; i++)
1449 if (find_regno_fusage (insn, code, i))
1457 /* Return true if REGNO, or any overlap of REGNO, of kind CODE is found
1458 in the CALL_INSN_FUNCTION_USAGE information of INSN. */
1461 find_regno_fusage (insn, code, regno)
1468 /* CALL_INSN_FUNCTION_USAGE information cannot contain references
1469 to pseudo registers, so don't bother checking. */
1471 if (regno >= FIRST_PSEUDO_REGISTER
1472 || GET_CODE (insn) != CALL_INSN )
1475 for (link = CALL_INSN_FUNCTION_USAGE (insn); link; link = XEXP (link, 1))
1477 register int regnote;
1480 if (GET_CODE (op = XEXP (link, 0)) == code
1481 && GET_CODE (SET_DEST (op)) == REG
1482 && (regnote = REGNO (SET_DEST (op))) <= regno
1484 + HARD_REGNO_NREGS (regnote, GET_MODE (SET_DEST (op)))
1492 /* Remove register note NOTE from the REG_NOTES of INSN. */
1495 remove_note (insn, note)
1501 if (REG_NOTES (insn) == note)
1503 REG_NOTES (insn) = XEXP (note, 1);
1507 for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
1508 if (XEXP (link, 1) == note)
1510 XEXP (link, 1) = XEXP (note, 1);
1517 /* Nonzero if X contains any volatile instructions. These are instructions
1518 which may cause unpredictable machine state instructions, and thus no
1519 instructions should be moved or combined across them. This includes
1520 only volatile asms and UNSPEC_VOLATILE instructions. */
1526 register RTX_CODE code;
1528 code = GET_CODE (x);
1548 case UNSPEC_VOLATILE:
1549 /* case TRAP_IF: This isn't clear yet. */
1553 if (MEM_VOLATILE_P (x))
1560 /* Recursively scan the operands of this expression. */
1563 register char *fmt = GET_RTX_FORMAT (code);
1566 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
1570 if (volatile_insn_p (XEXP (x, i)))
1576 for (j = 0; j < XVECLEN (x, i); j++)
1577 if (volatile_insn_p (XVECEXP (x, i, j)))
1585 /* Nonzero if X contains any volatile memory references
1586 UNSPEC_VOLATILE operations or volatile ASM_OPERANDS expressions. */
1592 register RTX_CODE code;
1594 code = GET_CODE (x);
1613 case UNSPEC_VOLATILE:
1614 /* case TRAP_IF: This isn't clear yet. */
1619 if (MEM_VOLATILE_P (x))
1626 /* Recursively scan the operands of this expression. */
1629 register char *fmt = GET_RTX_FORMAT (code);
1632 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
1636 if (volatile_refs_p (XEXP (x, i)))
1642 for (j = 0; j < XVECLEN (x, i); j++)
1643 if (volatile_refs_p (XVECEXP (x, i, j)))
1651 /* Similar to above, except that it also rejects register pre- and post-
1658 register RTX_CODE code;
1660 code = GET_CODE (x);
1678 /* Reject CLOBBER with a non-VOID mode. These are made by combine.c
1679 when some combination can't be done. If we see one, don't think
1680 that we can simplify the expression. */
1681 return (GET_MODE (x) != VOIDmode);
1688 case UNSPEC_VOLATILE:
1689 /* case TRAP_IF: This isn't clear yet. */
1694 if (MEM_VOLATILE_P (x))
1701 /* Recursively scan the operands of this expression. */
1704 register char *fmt = GET_RTX_FORMAT (code);
1707 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
1711 if (side_effects_p (XEXP (x, i)))
1717 for (j = 0; j < XVECLEN (x, i); j++)
1718 if (side_effects_p (XVECEXP (x, i, j)))
1726 /* Return nonzero if evaluating rtx X might cause a trap. */
1738 code = GET_CODE (x);
1741 /* Handle these cases quickly. */
1753 /* Conditional trap can trap! */
1754 case UNSPEC_VOLATILE:
1758 /* Memory ref can trap unless it's a static var or a stack slot. */
1760 return rtx_addr_can_trap_p (XEXP (x, 0));
1762 /* Division by a non-constant might trap. */
1767 if (! CONSTANT_P (XEXP (x, 1))
1768 || GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT)
1770 /* This was const0_rtx, but by not using that,
1771 we can link this file into other programs. */
1772 if (GET_CODE (XEXP (x, 1)) == CONST_INT && INTVAL (XEXP (x, 1)) == 0)
1777 /* An EXPR_LIST is used to represent a function call. This
1778 certainly may trap. */
1782 /* Any floating arithmetic may trap. */
1783 if (GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT)
1787 fmt = GET_RTX_FORMAT (code);
1788 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
1792 if (may_trap_p (XEXP (x, i)))
1795 else if (fmt[i] == 'E')
1798 for (j = 0; j < XVECLEN (x, i); j++)
1799 if (may_trap_p (XVECEXP (x, i, j)))
1806 /* Return nonzero if X contains a comparison that is not either EQ or NE,
1807 i.e., an inequality. */
1810 inequality_comparisons_p (x)
1814 register int len, i;
1815 register enum rtx_code code = GET_CODE (x);
1844 len = GET_RTX_LENGTH (code);
1845 fmt = GET_RTX_FORMAT (code);
1847 for (i = 0; i < len; i++)
1851 if (inequality_comparisons_p (XEXP (x, i)))
1854 else if (fmt[i] == 'E')
1857 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
1858 if (inequality_comparisons_p (XVECEXP (x, i, j)))
1866 /* Replace any occurrence of FROM in X with TO. The function does
1867 not enter into CONST_DOUBLE for the replace.
1869 Note that copying is not done so X must not be shared unless all copies
1870 are to be modified. */
1873 replace_rtx (x, from, to)
1879 /* The following prevents loops occurrence when we change MEM in
1880 CONST_DOUBLE onto the same CONST_DOUBLE. */
1881 if (x != 0 && GET_CODE (x) == CONST_DOUBLE)
1887 /* Allow this function to make replacements in EXPR_LISTs. */
1891 fmt = GET_RTX_FORMAT (GET_CODE (x));
1892 for (i = GET_RTX_LENGTH (GET_CODE (x)) - 1; i >= 0; i--)
1895 XEXP (x, i) = replace_rtx (XEXP (x, i), from, to);
1896 else if (fmt[i] == 'E')
1897 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
1898 XVECEXP (x, i, j) = replace_rtx (XVECEXP (x, i, j), from, to);
1904 /* Throughout the rtx X, replace many registers according to REG_MAP.
1905 Return the replacement for X (which may be X with altered contents).
1906 REG_MAP[R] is the replacement for register R, or 0 for don't replace.
1907 NREGS is the length of REG_MAP; regs >= NREGS are not mapped.
1909 We only support REG_MAP entries of REG or SUBREG. Also, hard registers
1910 should not be mapped to pseudos or vice versa since validate_change
1913 If REPLACE_DEST is 1, replacements are also done in destinations;
1914 otherwise, only sources are replaced. */
1917 replace_regs (x, reg_map, nregs, replace_dest)
1923 register enum rtx_code code;
1930 code = GET_CODE (x);
1944 /* Verify that the register has an entry before trying to access it. */
1945 if (REGNO (x) < nregs && reg_map[REGNO (x)] != 0)
1947 /* SUBREGs can't be shared. Always return a copy to ensure that if
1948 this replacement occurs more than once then each instance will
1949 get distinct rtx. */
1950 if (GET_CODE (reg_map[REGNO (x)]) == SUBREG)
1951 return copy_rtx (reg_map[REGNO (x)]);
1952 return reg_map[REGNO (x)];
1957 /* Prevent making nested SUBREGs. */
1958 if (GET_CODE (SUBREG_REG (x)) == REG && REGNO (SUBREG_REG (x)) < nregs
1959 && reg_map[REGNO (SUBREG_REG (x))] != 0
1960 && GET_CODE (reg_map[REGNO (SUBREG_REG (x))]) == SUBREG)
1962 rtx map_val = reg_map[REGNO (SUBREG_REG (x))];
1963 rtx map_inner = SUBREG_REG (map_val);
1965 if (GET_MODE (x) == GET_MODE (map_inner))
1969 /* We cannot call gen_rtx here since we may be linked with
1971 /* Let's try clobbering the incoming SUBREG and see
1972 if this is really safe. */
1973 SUBREG_REG (x) = map_inner;
1974 SUBREG_WORD (x) += SUBREG_WORD (map_val);
1977 rtx new = rtx_alloc (SUBREG);
1978 PUT_MODE (new, GET_MODE (x));
1979 SUBREG_REG (new) = map_inner;
1980 SUBREG_WORD (new) = SUBREG_WORD (x) + SUBREG_WORD (map_val);
1988 SET_DEST (x) = replace_regs (SET_DEST (x), reg_map, nregs, 0);
1990 else if (GET_CODE (SET_DEST (x)) == MEM
1991 || GET_CODE (SET_DEST (x)) == STRICT_LOW_PART)
1992 /* Even if we are not to replace destinations, replace register if it
1993 is CONTAINED in destination (destination is memory or
1994 STRICT_LOW_PART). */
1995 XEXP (SET_DEST (x), 0) = replace_regs (XEXP (SET_DEST (x), 0),
1997 else if (GET_CODE (SET_DEST (x)) == ZERO_EXTRACT)
1998 /* Similarly, for ZERO_EXTRACT we replace all operands. */
2001 SET_SRC (x) = replace_regs (SET_SRC (x), reg_map, nregs, 0);
2008 fmt = GET_RTX_FORMAT (code);
2009 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
2012 XEXP (x, i) = replace_regs (XEXP (x, i), reg_map, nregs, replace_dest);
2016 for (j = 0; j < XVECLEN (x, i); j++)
2017 XVECEXP (x, i, j) = replace_regs (XVECEXP (x, i, j), reg_map,
2018 nregs, replace_dest);
2024 /* Return 1 if X, the SRC_SRC of SET of (pc) contain a REG or MEM that is
2025 not in the constant pool and not in the condition of an IF_THEN_ELSE. */
2028 jmp_uses_reg_or_mem (x)
2031 enum rtx_code code = GET_CODE (x);
2046 return ! (GET_CODE (XEXP (x, 0)) == SYMBOL_REF
2047 && CONSTANT_POOL_ADDRESS_P (XEXP (x, 0)));
2050 return (jmp_uses_reg_or_mem (XEXP (x, 1))
2051 || jmp_uses_reg_or_mem (XEXP (x, 2)));
2053 case PLUS: case MINUS: case MULT:
2054 return (jmp_uses_reg_or_mem (XEXP (x, 0))
2055 || jmp_uses_reg_or_mem (XEXP (x, 1)));
2061 fmt = GET_RTX_FORMAT (code);
2062 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
2065 && jmp_uses_reg_or_mem (XEXP (x, i)))
2069 for (j = 0; j < XVECLEN (x, i); j++)
2070 if (jmp_uses_reg_or_mem (XVECEXP (x, i, j)))
2077 /* Return nonzero if INSN is an indirect jump (aka computed jump).
2079 Tablejumps and casesi insns are not considered indirect jumps;
2080 we can recognize them by a (use (lael_ref)). */
2083 computed_jump_p (insn)
2087 if (GET_CODE (insn) == JUMP_INSN)
2089 rtx pat = PATTERN (insn);
2091 if (GET_CODE (pat) == PARALLEL)
2093 int len = XVECLEN (pat, 0);
2094 int has_use_labelref = 0;
2096 for (i = len - 1; i >= 0; i--)
2097 if (GET_CODE (XVECEXP (pat, 0, i)) == USE
2098 && (GET_CODE (XEXP (XVECEXP (pat, 0, i), 0))
2100 has_use_labelref = 1;
2102 if (! has_use_labelref)
2103 for (i = len - 1; i >= 0; i--)
2104 if (GET_CODE (XVECEXP (pat, 0, i)) == SET
2105 && SET_DEST (XVECEXP (pat, 0, i)) == pc_rtx
2106 && jmp_uses_reg_or_mem (SET_SRC (XVECEXP (pat, 0, i))))
2109 else if (GET_CODE (pat) == SET
2110 && SET_DEST (pat) == pc_rtx
2111 && jmp_uses_reg_or_mem (SET_SRC (pat)))
2117 /* Traverse X via depth-first search, calling F for each
2118 sub-expression (including X itself). F is also passed the DATA.
2119 If F returns -1, do not traverse sub-expressions, but continue
2120 traversing the rest of the tree. If F ever returns any other
2121 non-zero value, stop the traversal, and return the value returned
2122 by F. Otherwise, return 0. This function does not traverse inside
2123 tree structure that contains RTX_EXPRs, or into sub-expressions
2124 whose format code is `0' since it is not known whether or not those
2125 codes are actually RTL.
2127 This routine is very general, and could (should?) be used to
2128 implement many of the other routines in this file. */
2131 for_each_rtx (x, f, data)
2142 result = (*f)(x, data);
2144 /* Do not traverse sub-expressions. */
2146 else if (result != 0)
2147 /* Stop the traversal. */
2151 /* There are no sub-expressions. */
2154 length = GET_RTX_LENGTH (GET_CODE (*x));
2155 format = GET_RTX_FORMAT (GET_CODE (*x));
2157 for (i = 0; i < length; ++i)
2162 result = for_each_rtx (&XEXP (*x, i), f, data);
2169 if (XVEC (*x, i) != 0)
2172 for (j = 0; j < XVECLEN (*x, i); ++j)
2174 result = for_each_rtx (&XVECEXP (*x, i, j), f, data);
2182 /* Nothing to do. */