1 /* Analyze RTL for C-Compiler
2 Copyright (C) 1987, 88, 92-98, 1999 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 /* Return 1 if in between BEG and END, exclusive of BEG and END, there is
330 no JUMP_INSN insn. */
333 no_jumps_between_p (beg, end)
337 for (p = NEXT_INSN (beg); p != end; p = NEXT_INSN (p))
338 if (GET_CODE (p) == JUMP_INSN)
343 /* Nonzero if register REG is used in an insn between
344 FROM_INSN and TO_INSN (exclusive of those two). */
347 reg_used_between_p (reg, from_insn, to_insn)
348 rtx reg, from_insn, to_insn;
352 if (from_insn == to_insn)
355 for (insn = NEXT_INSN (from_insn); insn != to_insn; insn = NEXT_INSN (insn))
356 if (GET_RTX_CLASS (GET_CODE (insn)) == 'i'
357 && (reg_overlap_mentioned_p (reg, PATTERN (insn))
358 || (GET_CODE (insn) == CALL_INSN
359 && (find_reg_fusage (insn, USE, reg)
360 || find_reg_fusage (insn, CLOBBER, reg)))))
365 /* Nonzero if the old value of X, a register, is referenced in BODY. If X
366 is entirely replaced by a new value and the only use is as a SET_DEST,
367 we do not consider it a reference. */
370 reg_referenced_p (x, body)
376 switch (GET_CODE (body))
379 if (reg_overlap_mentioned_p (x, SET_SRC (body)))
382 /* If the destination is anything other than CC0, PC, a REG or a SUBREG
383 of a REG that occupies all of the REG, the insn references X if
384 it is mentioned in the destination. */
385 if (GET_CODE (SET_DEST (body)) != CC0
386 && GET_CODE (SET_DEST (body)) != PC
387 && GET_CODE (SET_DEST (body)) != REG
388 && ! (GET_CODE (SET_DEST (body)) == SUBREG
389 && GET_CODE (SUBREG_REG (SET_DEST (body))) == REG
390 && (((GET_MODE_SIZE (GET_MODE (SUBREG_REG (SET_DEST (body))))
391 + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD)
392 == ((GET_MODE_SIZE (GET_MODE (SET_DEST (body)))
393 + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD)))
394 && reg_overlap_mentioned_p (x, SET_DEST (body)))
399 for (i = ASM_OPERANDS_INPUT_LENGTH (body) - 1; i >= 0; i--)
400 if (reg_overlap_mentioned_p (x, ASM_OPERANDS_INPUT (body, i)))
406 return reg_overlap_mentioned_p (x, body);
409 return reg_overlap_mentioned_p (x, TRAP_CONDITION (body));
412 case UNSPEC_VOLATILE:
414 for (i = XVECLEN (body, 0) - 1; i >= 0; i--)
415 if (reg_referenced_p (x, XVECEXP (body, 0, i)))
424 /* Nonzero if register REG is referenced in an insn between
425 FROM_INSN and TO_INSN (exclusive of those two). Sets of REG do
429 reg_referenced_between_p (reg, from_insn, to_insn)
430 rtx reg, from_insn, to_insn;
434 if (from_insn == to_insn)
437 for (insn = NEXT_INSN (from_insn); insn != to_insn; insn = NEXT_INSN (insn))
438 if (GET_RTX_CLASS (GET_CODE (insn)) == 'i'
439 && (reg_referenced_p (reg, PATTERN (insn))
440 || (GET_CODE (insn) == CALL_INSN
441 && find_reg_fusage (insn, USE, reg))))
446 /* Nonzero if register REG is set or clobbered in an insn between
447 FROM_INSN and TO_INSN (exclusive of those two). */
450 reg_set_between_p (reg, from_insn, to_insn)
451 rtx reg, from_insn, to_insn;
455 if (from_insn == to_insn)
458 for (insn = NEXT_INSN (from_insn); insn != to_insn; insn = NEXT_INSN (insn))
459 if (GET_RTX_CLASS (GET_CODE (insn)) == 'i'
460 && reg_set_p (reg, insn))
465 /* Internals of reg_set_between_p. */
467 static rtx reg_set_reg;
468 static int reg_set_flag;
473 rtx pat ATTRIBUTE_UNUSED;
475 /* We don't want to return 1 if X is a MEM that contains a register
476 within REG_SET_REG. */
478 if ((GET_CODE (x) != MEM)
479 && reg_overlap_mentioned_p (reg_set_reg, x))
484 reg_set_p (reg, insn)
489 /* We can be passed an insn or part of one. If we are passed an insn,
490 check if a side-effect of the insn clobbers REG. */
491 if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
493 if (FIND_REG_INC_NOTE (insn, reg)
494 || (GET_CODE (insn) == CALL_INSN
495 /* We'd like to test call_used_regs here, but rtlanal.c can't
496 reference that variable due to its use in genattrtab. So
497 we'll just be more conservative.
499 ??? Unless we could ensure that the CALL_INSN_FUNCTION_USAGE
500 information holds all clobbered registers. */
501 && ((GET_CODE (reg) == REG
502 && REGNO (reg) < FIRST_PSEUDO_REGISTER)
503 || GET_CODE (reg) == MEM
504 || find_reg_fusage (insn, CLOBBER, reg))))
507 body = PATTERN (insn);
512 note_stores (body, reg_set_p_1);
516 /* Similar to reg_set_between_p, but check all registers in X. Return 0
517 only if none of them are modified between START and END. Do not
518 consider non-registers one way or the other. */
521 regs_set_between_p (x, start, end)
525 enum rtx_code code = GET_CODE (x);
541 return reg_set_between_p (x, start, end);
547 fmt = GET_RTX_FORMAT (code);
548 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
550 if (fmt[i] == 'e' && regs_set_between_p (XEXP (x, i), start, end))
553 else if (fmt[i] == 'E')
554 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
555 if (regs_set_between_p (XVECEXP (x, i, j), start, end))
562 /* Similar to reg_set_between_p, but check all registers in X. Return 0
563 only if none of them are modified between START and END. Return 1 if
564 X contains a MEM; this routine does not perform any memory aliasing. */
567 modified_between_p (x, start, end)
571 enum rtx_code code = GET_CODE (x);
589 /* If the memory is not constant, assume it is modified. If it is
590 constant, we still have to check the address. */
591 if (! RTX_UNCHANGING_P (x))
596 return reg_set_between_p (x, start, end);
602 fmt = GET_RTX_FORMAT (code);
603 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
605 if (fmt[i] == 'e' && modified_between_p (XEXP (x, i), start, end))
609 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
610 if (modified_between_p (XVECEXP (x, i, j), start, end))
617 /* Similar to reg_set_p, but check all registers in X. Return 0 only if none
618 of them are modified in INSN. Return 1 if X contains a MEM; this routine
619 does not perform any memory aliasing. */
622 modified_in_p (x, insn)
626 enum rtx_code code = GET_CODE (x);
644 /* If the memory is not constant, assume it is modified. If it is
645 constant, we still have to check the address. */
646 if (! RTX_UNCHANGING_P (x))
651 return reg_set_p (x, insn);
657 fmt = GET_RTX_FORMAT (code);
658 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
660 if (fmt[i] == 'e' && modified_in_p (XEXP (x, i), insn))
664 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
665 if (modified_in_p (XVECEXP (x, i, j), insn))
672 /* Given an INSN, return a SET expression if this insn has only a single SET.
673 It may also have CLOBBERs, USEs, or SET whose output
674 will not be used, which we ignore. */
683 if (GET_RTX_CLASS (GET_CODE (insn)) != 'i')
686 if (GET_CODE (PATTERN (insn)) == SET)
687 return PATTERN (insn);
689 else if (GET_CODE (PATTERN (insn)) == PARALLEL)
691 for (i = 0, set = 0; i < XVECLEN (PATTERN (insn), 0); i++)
692 if (GET_CODE (XVECEXP (PATTERN (insn), 0, i)) == SET
693 && (! find_reg_note (insn, REG_UNUSED,
694 SET_DEST (XVECEXP (PATTERN (insn), 0, i)))
695 || side_effects_p (XVECEXP (PATTERN (insn), 0, i))))
700 set = XVECEXP (PATTERN (insn), 0, i);
708 /* Given an INSN, return nonzero if it has more than one SET, else return
718 /* INSN must be an insn. */
719 if (GET_RTX_CLASS (GET_CODE (insn)) != 'i')
722 /* Only a PARALLEL can have multiple SETs. */
723 if (GET_CODE (PATTERN (insn)) == PARALLEL)
725 for (i = 0, found = 0; i < XVECLEN (PATTERN (insn), 0); i++)
726 if (GET_CODE (XVECEXP (PATTERN (insn), 0, i)) == SET)
728 /* If we have already found a SET, then return now. */
736 /* Either zero or one SET. */
740 /* Return the last thing that X was assigned from before *PINSN. Verify that
741 the object is not modified up to VALID_TO. If it was, if we hit
742 a partial assignment to X, or hit a CODE_LABEL first, return X. If we
743 found an assignment, update *PINSN to point to it. */
746 find_last_value (x, pinsn, valid_to)
753 for (p = PREV_INSN (*pinsn); p && GET_CODE (p) != CODE_LABEL;
755 if (GET_RTX_CLASS (GET_CODE (p)) == 'i')
757 rtx set = single_set (p);
758 rtx note = find_reg_note (p, REG_EQUAL, NULL_RTX);
760 if (set && rtx_equal_p (x, SET_DEST (set)))
762 rtx src = SET_SRC (set);
764 if (note && GET_CODE (XEXP (note, 0)) != EXPR_LIST)
765 src = XEXP (note, 0);
767 if (! modified_between_p (src, PREV_INSN (p), valid_to)
768 /* Reject hard registers because we don't usually want
769 to use them; we'd rather use a pseudo. */
770 && ! (GET_CODE (src) == REG
771 && REGNO (src) < FIRST_PSEUDO_REGISTER))
778 /* If set in non-simple way, we don't have a value. */
779 if (reg_set_p (x, p))
786 /* Return nonzero if register in range [REGNO, ENDREGNO)
787 appears either explicitly or implicitly in X
788 other than being stored into.
790 References contained within the substructure at LOC do not count.
791 LOC may be zero, meaning don't ignore anything. */
794 refers_to_regno_p (regno, endregno, x, loc)
800 register RTX_CODE code;
804 /* The contents of a REG_NONNEG note is always zero, so we must come here
805 upon repeat in case the last REG_NOTE is a REG_NONNEG note. */
816 /* If we modifying the stack, frame, or argument pointer, it will
817 clobber a virtual register. In fact, we could be more precise,
818 but it isn't worth it. */
819 if ((i == STACK_POINTER_REGNUM
820 #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
821 || i == ARG_POINTER_REGNUM
823 || i == FRAME_POINTER_REGNUM)
824 && regno >= FIRST_VIRTUAL_REGISTER && regno <= LAST_VIRTUAL_REGISTER)
828 && regno < i + (i < FIRST_PSEUDO_REGISTER
829 ? HARD_REGNO_NREGS (i, GET_MODE (x))
833 /* If this is a SUBREG of a hard reg, we can see exactly which
834 registers are being modified. Otherwise, handle normally. */
835 if (GET_CODE (SUBREG_REG (x)) == REG
836 && REGNO (SUBREG_REG (x)) < FIRST_PSEUDO_REGISTER)
838 int inner_regno = REGNO (SUBREG_REG (x)) + SUBREG_WORD (x);
840 = inner_regno + (inner_regno < FIRST_PSEUDO_REGISTER
841 ? HARD_REGNO_NREGS (regno, GET_MODE (x)) : 1);
843 return endregno > inner_regno && regno < inner_endregno;
849 if (&SET_DEST (x) != loc
850 /* Note setting a SUBREG counts as referring to the REG it is in for
851 a pseudo but not for hard registers since we can
852 treat each word individually. */
853 && ((GET_CODE (SET_DEST (x)) == SUBREG
854 && loc != &SUBREG_REG (SET_DEST (x))
855 && GET_CODE (SUBREG_REG (SET_DEST (x))) == REG
856 && REGNO (SUBREG_REG (SET_DEST (x))) >= FIRST_PSEUDO_REGISTER
857 && refers_to_regno_p (regno, endregno,
858 SUBREG_REG (SET_DEST (x)), loc))
859 || (GET_CODE (SET_DEST (x)) != REG
860 && refers_to_regno_p (regno, endregno, SET_DEST (x), loc))))
863 if (code == CLOBBER || loc == &SET_SRC (x))
872 /* X does not match, so try its subexpressions. */
874 fmt = GET_RTX_FORMAT (code);
875 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
877 if (fmt[i] == 'e' && loc != &XEXP (x, i))
885 if (refers_to_regno_p (regno, endregno, XEXP (x, i), loc))
888 else if (fmt[i] == 'E')
891 for (j = XVECLEN (x, i) - 1; j >=0; j--)
892 if (loc != &XVECEXP (x, i, j)
893 && refers_to_regno_p (regno, endregno, XVECEXP (x, i, j), loc))
900 /* Nonzero if modifying X will affect IN. If X is a register or a SUBREG,
901 we check if any register number in X conflicts with the relevant register
902 numbers. If X is a constant, return 0. If X is a MEM, return 1 iff IN
903 contains a MEM (we don't bother checking for memory addresses that can't
904 conflict because we expect this to be a rare case. */
907 reg_overlap_mentioned_p (x, in)
912 /* Overly conservative. */
913 if (GET_CODE (x) == STRICT_LOW_PART)
916 /* If either argument is a constant, then modifying X can not affect IN. */
917 if (CONSTANT_P (x) || CONSTANT_P (in))
919 else if (GET_CODE (x) == SUBREG)
921 regno = REGNO (SUBREG_REG (x));
922 if (regno < FIRST_PSEUDO_REGISTER)
923 regno += SUBREG_WORD (x);
925 else if (GET_CODE (x) == REG)
927 else if (GET_CODE (x) == MEM)
932 if (GET_CODE (in) == MEM)
935 fmt = GET_RTX_FORMAT (GET_CODE (in));
937 for (i = GET_RTX_LENGTH (GET_CODE (in)) - 1; i >= 0; i--)
938 if (fmt[i] == 'e' && reg_overlap_mentioned_p (x, XEXP (in, i)))
943 else if (GET_CODE (x) == SCRATCH || GET_CODE (x) == PC
944 || GET_CODE (x) == CC0)
945 return reg_mentioned_p (x, in);
946 else if (GET_CODE (x) == PARALLEL
947 && GET_MODE (x) == BLKmode)
951 /* If any register in here refers to it
953 for (i = XVECLEN (x, 0) - 1; i >= 0; i--)
954 if (reg_overlap_mentioned_p (SET_DEST (XVECEXP (x, 0, i)), in))
961 endregno = regno + (regno < FIRST_PSEUDO_REGISTER
962 ? HARD_REGNO_NREGS (regno, GET_MODE (x)) : 1);
964 return refers_to_regno_p (regno, endregno, in, NULL_PTR);
967 /* Used for communications between the next few functions. */
969 static int reg_set_last_unknown;
970 static rtx reg_set_last_value;
971 static int reg_set_last_first_regno, reg_set_last_last_regno;
973 /* Called via note_stores from reg_set_last. */
976 reg_set_last_1 (x, pat)
982 /* If X is not a register, or is not one in the range we care
984 if (GET_CODE (x) != REG)
988 last = first + (first < FIRST_PSEUDO_REGISTER
989 ? HARD_REGNO_NREGS (first, GET_MODE (x)) : 1);
991 if (first >= reg_set_last_last_regno
992 || last <= reg_set_last_first_regno)
995 /* If this is a CLOBBER or is some complex LHS, or doesn't modify
996 exactly the registers we care about, show we don't know the value. */
997 if (GET_CODE (pat) == CLOBBER || SET_DEST (pat) != x
998 || first != reg_set_last_first_regno
999 || last != reg_set_last_last_regno)
1000 reg_set_last_unknown = 1;
1002 reg_set_last_value = SET_SRC (pat);
1005 /* Return the last value to which REG was set prior to INSN. If we can't
1006 find it easily, return 0.
1008 We only return a REG, SUBREG, or constant because it is too hard to
1009 check if a MEM remains unchanged. */
1012 reg_set_last (x, insn)
1016 rtx orig_insn = insn;
1018 reg_set_last_first_regno = REGNO (x);
1020 reg_set_last_last_regno
1021 = reg_set_last_first_regno
1022 + (reg_set_last_first_regno < FIRST_PSEUDO_REGISTER
1023 ? HARD_REGNO_NREGS (reg_set_last_first_regno, GET_MODE (x)) : 1);
1025 reg_set_last_unknown = 0;
1026 reg_set_last_value = 0;
1028 /* Scan backwards until reg_set_last_1 changed one of the above flags.
1029 Stop when we reach a label or X is a hard reg and we reach a
1030 CALL_INSN (if reg_set_last_last_regno is a hard reg).
1032 If we find a set of X, ensure that its SET_SRC remains unchanged. */
1034 /* We compare with <= here, because reg_set_last_last_regno
1035 is actually the number of the first reg *not* in X. */
1037 insn && GET_CODE (insn) != CODE_LABEL
1038 && ! (GET_CODE (insn) == CALL_INSN
1039 && reg_set_last_last_regno <= FIRST_PSEUDO_REGISTER);
1040 insn = PREV_INSN (insn))
1041 if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
1043 note_stores (PATTERN (insn), reg_set_last_1);
1044 if (reg_set_last_unknown)
1046 else if (reg_set_last_value)
1048 if (CONSTANT_P (reg_set_last_value)
1049 || ((GET_CODE (reg_set_last_value) == REG
1050 || GET_CODE (reg_set_last_value) == SUBREG)
1051 && ! reg_set_between_p (reg_set_last_value,
1053 return reg_set_last_value;
1062 /* This is 1 until after the rtl generation pass. */
1063 int rtx_equal_function_value_matters;
1065 /* Return 1 if X and Y are identical-looking rtx's.
1066 This is the Lisp function EQUAL for rtx arguments. */
1074 register enum rtx_code code;
1079 if (x == 0 || y == 0)
1082 code = GET_CODE (x);
1083 /* Rtx's of different codes cannot be equal. */
1084 if (code != GET_CODE (y))
1087 /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent.
1088 (REG:SI x) and (REG:HI x) are NOT equivalent. */
1090 if (GET_MODE (x) != GET_MODE (y))
1093 /* REG, LABEL_REF, and SYMBOL_REF can be compared nonrecursively. */
1096 /* Until rtl generation is complete, don't consider a reference to the
1097 return register of the current function the same as the return from a
1098 called function. This eases the job of function integration. Once the
1099 distinction is no longer needed, they can be considered equivalent. */
1100 return (REGNO (x) == REGNO (y)
1101 && (! rtx_equal_function_value_matters
1102 || REG_FUNCTION_VALUE_P (x) == REG_FUNCTION_VALUE_P (y)));
1103 else if (code == LABEL_REF)
1104 return XEXP (x, 0) == XEXP (y, 0);
1105 else if (code == SYMBOL_REF)
1106 return XSTR (x, 0) == XSTR (y, 0);
1107 else if (code == SCRATCH || code == CONST_DOUBLE)
1110 /* Compare the elements. If any pair of corresponding elements
1111 fail to match, return 0 for the whole things. */
1113 fmt = GET_RTX_FORMAT (code);
1114 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
1119 if (XWINT (x, i) != XWINT (y, i))
1125 if (XINT (x, i) != XINT (y, i))
1131 /* Two vectors must have the same length. */
1132 if (XVECLEN (x, i) != XVECLEN (y, i))
1135 /* And the corresponding elements must match. */
1136 for (j = 0; j < XVECLEN (x, i); j++)
1137 if (rtx_equal_p (XVECEXP (x, i, j), XVECEXP (y, i, j)) == 0)
1142 if (rtx_equal_p (XEXP (x, i), XEXP (y, i)) == 0)
1148 if (strcmp (XSTR (x, i), XSTR (y, i)))
1153 /* These are just backpointers, so they don't matter. */
1159 /* It is believed that rtx's at this level will never
1160 contain anything but integers and other rtx's,
1161 except for within LABEL_REFs and SYMBOL_REFs. */
1169 /* Call FUN on each register or MEM that is stored into or clobbered by X.
1170 (X would be the pattern of an insn).
1171 FUN receives two arguments:
1172 the REG, MEM, CC0 or PC being stored in or clobbered,
1173 the SET or CLOBBER rtx that does the store.
1175 If the item being stored in or clobbered is a SUBREG of a hard register,
1176 the SUBREG will be passed. */
1179 note_stores (x, fun)
1183 if ((GET_CODE (x) == SET || GET_CODE (x) == CLOBBER))
1185 register rtx dest = SET_DEST (x);
1186 while ((GET_CODE (dest) == SUBREG
1187 && (GET_CODE (SUBREG_REG (dest)) != REG
1188 || REGNO (SUBREG_REG (dest)) >= FIRST_PSEUDO_REGISTER))
1189 || GET_CODE (dest) == ZERO_EXTRACT
1190 || GET_CODE (dest) == SIGN_EXTRACT
1191 || GET_CODE (dest) == STRICT_LOW_PART)
1192 dest = XEXP (dest, 0);
1194 if (GET_CODE (dest) == PARALLEL
1195 && GET_MODE (dest) == BLKmode)
1198 for (i = XVECLEN (dest, 0) - 1; i >= 0; i--)
1199 (*fun) (SET_DEST (XVECEXP (dest, 0, i)), x);
1204 else if (GET_CODE (x) == PARALLEL)
1207 for (i = XVECLEN (x, 0) - 1; i >= 0; i--)
1209 register rtx y = XVECEXP (x, 0, i);
1210 if (GET_CODE (y) == SET || GET_CODE (y) == CLOBBER)
1212 register rtx dest = SET_DEST (y);
1213 while ((GET_CODE (dest) == SUBREG
1214 && (GET_CODE (SUBREG_REG (dest)) != REG
1215 || (REGNO (SUBREG_REG (dest))
1216 >= FIRST_PSEUDO_REGISTER)))
1217 || GET_CODE (dest) == ZERO_EXTRACT
1218 || GET_CODE (dest) == SIGN_EXTRACT
1219 || GET_CODE (dest) == STRICT_LOW_PART)
1220 dest = XEXP (dest, 0);
1221 if (GET_CODE (dest) == PARALLEL
1222 && GET_MODE (dest) == BLKmode)
1225 for (i = XVECLEN (dest, 0) - 1; i >= 0; i--)
1226 (*fun) (SET_DEST (XVECEXP (dest, 0, i)), y);
1235 /* Return nonzero if X's old contents don't survive after INSN.
1236 This will be true if X is (cc0) or if X is a register and
1237 X dies in INSN or because INSN entirely sets X.
1239 "Entirely set" means set directly and not through a SUBREG,
1240 ZERO_EXTRACT or SIGN_EXTRACT, so no trace of the old contents remains.
1241 Likewise, REG_INC does not count.
1243 REG may be a hard or pseudo reg. Renumbering is not taken into account,
1244 but for this use that makes no difference, since regs don't overlap
1245 during their lifetimes. Therefore, this function may be used
1246 at any time after deaths have been computed (in flow.c).
1248 If REG is a hard reg that occupies multiple machine registers, this
1249 function will only return 1 if each of those registers will be replaced
1253 dead_or_set_p (insn, x)
1257 register int regno, last_regno;
1260 /* Can't use cc0_rtx below since this file is used by genattrtab.c. */
1261 if (GET_CODE (x) == CC0)
1264 if (GET_CODE (x) != REG)
1268 last_regno = (regno >= FIRST_PSEUDO_REGISTER ? regno
1269 : regno + HARD_REGNO_NREGS (regno, GET_MODE (x)) - 1);
1271 for (i = regno; i <= last_regno; i++)
1272 if (! dead_or_set_regno_p (insn, i))
1278 /* Utility function for dead_or_set_p to check an individual register. Also
1279 called from flow.c. */
1282 dead_or_set_regno_p (insn, test_regno)
1286 int regno, endregno;
1289 /* See if there is a death note for something that includes
1291 for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
1293 if (REG_NOTE_KIND (link) != REG_DEAD
1294 || GET_CODE (XEXP (link, 0)) != REG)
1297 regno = REGNO (XEXP (link, 0));
1298 endregno = (regno >= FIRST_PSEUDO_REGISTER ? regno + 1
1299 : regno + HARD_REGNO_NREGS (regno,
1300 GET_MODE (XEXP (link, 0))));
1302 if (test_regno >= regno && test_regno < endregno)
1306 if (GET_CODE (insn) == CALL_INSN
1307 && find_regno_fusage (insn, CLOBBER, test_regno))
1310 if (GET_CODE (PATTERN (insn)) == SET)
1312 rtx dest = SET_DEST (PATTERN (insn));
1314 /* A value is totally replaced if it is the destination or the
1315 destination is a SUBREG of REGNO that does not change the number of
1317 if (GET_CODE (dest) == SUBREG
1318 && (((GET_MODE_SIZE (GET_MODE (dest))
1319 + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
1320 == ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (dest)))
1321 + UNITS_PER_WORD - 1) / UNITS_PER_WORD)))
1322 dest = SUBREG_REG (dest);
1324 if (GET_CODE (dest) != REG)
1327 regno = REGNO (dest);
1328 endregno = (regno >= FIRST_PSEUDO_REGISTER ? regno + 1
1329 : regno + HARD_REGNO_NREGS (regno, GET_MODE (dest)));
1331 return (test_regno >= regno && test_regno < endregno);
1333 else if (GET_CODE (PATTERN (insn)) == PARALLEL)
1337 for (i = XVECLEN (PATTERN (insn), 0) - 1; i >= 0; i--)
1339 rtx body = XVECEXP (PATTERN (insn), 0, i);
1341 if (GET_CODE (body) == SET || GET_CODE (body) == CLOBBER)
1343 rtx dest = SET_DEST (body);
1345 if (GET_CODE (dest) == SUBREG
1346 && (((GET_MODE_SIZE (GET_MODE (dest))
1347 + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
1348 == ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (dest)))
1349 + UNITS_PER_WORD - 1) / UNITS_PER_WORD)))
1350 dest = SUBREG_REG (dest);
1352 if (GET_CODE (dest) != REG)
1355 regno = REGNO (dest);
1356 endregno = (regno >= FIRST_PSEUDO_REGISTER ? regno + 1
1357 : regno + HARD_REGNO_NREGS (regno, GET_MODE (dest)));
1359 if (test_regno >= regno && test_regno < endregno)
1368 /* Return the reg-note of kind KIND in insn INSN, if there is one.
1369 If DATUM is nonzero, look for one whose datum is DATUM. */
1372 find_reg_note (insn, kind, datum)
1379 /* Ignore anything that is not an INSN, JUMP_INSN or CALL_INSN. */
1380 if (GET_RTX_CLASS (GET_CODE (insn)) != 'i')
1383 for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
1384 if (REG_NOTE_KIND (link) == kind
1385 && (datum == 0 || datum == XEXP (link, 0)))
1390 /* Return the reg-note of kind KIND in insn INSN which applies to register
1391 number REGNO, if any. Return 0 if there is no such reg-note. Note that
1392 the REGNO of this NOTE need not be REGNO if REGNO is a hard register;
1393 it might be the case that the note overlaps REGNO. */
1396 find_regno_note (insn, kind, regno)
1403 /* Ignore anything that is not an INSN, JUMP_INSN or CALL_INSN. */
1404 if (GET_RTX_CLASS (GET_CODE (insn)) != 'i')
1407 for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
1408 if (REG_NOTE_KIND (link) == kind
1409 /* Verify that it is a register, so that scratch and MEM won't cause a
1411 && GET_CODE (XEXP (link, 0)) == REG
1412 && REGNO (XEXP (link, 0)) <= regno
1413 && ((REGNO (XEXP (link, 0))
1414 + (REGNO (XEXP (link, 0)) >= FIRST_PSEUDO_REGISTER ? 1
1415 : HARD_REGNO_NREGS (REGNO (XEXP (link, 0)),
1416 GET_MODE (XEXP (link, 0)))))
1422 /* Return true if DATUM, or any overlap of DATUM, of kind CODE is found
1423 in the CALL_INSN_FUNCTION_USAGE information of INSN. */
1426 find_reg_fusage (insn, code, datum)
1431 /* If it's not a CALL_INSN, it can't possibly have a
1432 CALL_INSN_FUNCTION_USAGE field, so don't bother checking. */
1433 if (GET_CODE (insn) != CALL_INSN)
1439 if (GET_CODE (datum) != REG)
1443 for (link = CALL_INSN_FUNCTION_USAGE (insn);
1445 link = XEXP (link, 1))
1446 if (GET_CODE (XEXP (link, 0)) == code
1447 && rtx_equal_p (datum, SET_DEST (XEXP (link, 0))))
1452 register int regno = REGNO (datum);
1454 /* CALL_INSN_FUNCTION_USAGE information cannot contain references
1455 to pseudo registers, so don't bother checking. */
1457 if (regno < FIRST_PSEUDO_REGISTER)
1459 int end_regno = regno + HARD_REGNO_NREGS (regno, GET_MODE (datum));
1462 for (i = regno; i < end_regno; i++)
1463 if (find_regno_fusage (insn, code, i))
1471 /* Return true if REGNO, or any overlap of REGNO, of kind CODE is found
1472 in the CALL_INSN_FUNCTION_USAGE information of INSN. */
1475 find_regno_fusage (insn, code, regno)
1482 /* CALL_INSN_FUNCTION_USAGE information cannot contain references
1483 to pseudo registers, so don't bother checking. */
1485 if (regno >= FIRST_PSEUDO_REGISTER
1486 || GET_CODE (insn) != CALL_INSN )
1489 for (link = CALL_INSN_FUNCTION_USAGE (insn); link; link = XEXP (link, 1))
1491 register int regnote;
1494 if (GET_CODE (op = XEXP (link, 0)) == code
1495 && GET_CODE (SET_DEST (op)) == REG
1496 && (regnote = REGNO (SET_DEST (op))) <= regno
1498 + HARD_REGNO_NREGS (regnote, GET_MODE (SET_DEST (op)))
1506 /* Remove register note NOTE from the REG_NOTES of INSN. */
1509 remove_note (insn, note)
1515 if (REG_NOTES (insn) == note)
1517 REG_NOTES (insn) = XEXP (note, 1);
1521 for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
1522 if (XEXP (link, 1) == note)
1524 XEXP (link, 1) = XEXP (note, 1);
1531 /* Nonzero if X contains any volatile instructions. These are instructions
1532 which may cause unpredictable machine state instructions, and thus no
1533 instructions should be moved or combined across them. This includes
1534 only volatile asms and UNSPEC_VOLATILE instructions. */
1540 register RTX_CODE code;
1542 code = GET_CODE (x);
1562 case UNSPEC_VOLATILE:
1563 /* case TRAP_IF: This isn't clear yet. */
1567 if (MEM_VOLATILE_P (x))
1574 /* Recursively scan the operands of this expression. */
1577 register char *fmt = GET_RTX_FORMAT (code);
1580 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
1584 if (volatile_insn_p (XEXP (x, i)))
1590 for (j = 0; j < XVECLEN (x, i); j++)
1591 if (volatile_insn_p (XVECEXP (x, i, j)))
1599 /* Nonzero if X contains any volatile memory references
1600 UNSPEC_VOLATILE operations or volatile ASM_OPERANDS expressions. */
1606 register RTX_CODE code;
1608 code = GET_CODE (x);
1627 case UNSPEC_VOLATILE:
1628 /* case TRAP_IF: This isn't clear yet. */
1633 if (MEM_VOLATILE_P (x))
1640 /* Recursively scan the operands of this expression. */
1643 register char *fmt = GET_RTX_FORMAT (code);
1646 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
1650 if (volatile_refs_p (XEXP (x, i)))
1656 for (j = 0; j < XVECLEN (x, i); j++)
1657 if (volatile_refs_p (XVECEXP (x, i, j)))
1665 /* Similar to above, except that it also rejects register pre- and post-
1672 register RTX_CODE code;
1674 code = GET_CODE (x);
1692 /* Reject CLOBBER with a non-VOID mode. These are made by combine.c
1693 when some combination can't be done. If we see one, don't think
1694 that we can simplify the expression. */
1695 return (GET_MODE (x) != VOIDmode);
1702 case UNSPEC_VOLATILE:
1703 /* case TRAP_IF: This isn't clear yet. */
1708 if (MEM_VOLATILE_P (x))
1715 /* Recursively scan the operands of this expression. */
1718 register char *fmt = GET_RTX_FORMAT (code);
1721 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
1725 if (side_effects_p (XEXP (x, i)))
1731 for (j = 0; j < XVECLEN (x, i); j++)
1732 if (side_effects_p (XVECEXP (x, i, j)))
1740 /* Return nonzero if evaluating rtx X might cause a trap. */
1752 code = GET_CODE (x);
1755 /* Handle these cases quickly. */
1767 /* Conditional trap can trap! */
1768 case UNSPEC_VOLATILE:
1772 /* Memory ref can trap unless it's a static var or a stack slot. */
1774 return rtx_addr_can_trap_p (XEXP (x, 0));
1776 /* Division by a non-constant might trap. */
1781 if (! CONSTANT_P (XEXP (x, 1))
1782 || GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT)
1784 /* This was const0_rtx, but by not using that,
1785 we can link this file into other programs. */
1786 if (GET_CODE (XEXP (x, 1)) == CONST_INT && INTVAL (XEXP (x, 1)) == 0)
1791 /* An EXPR_LIST is used to represent a function call. This
1792 certainly may trap. */
1796 /* Any floating arithmetic may trap. */
1797 if (GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT)
1801 fmt = GET_RTX_FORMAT (code);
1802 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
1806 if (may_trap_p (XEXP (x, i)))
1809 else if (fmt[i] == 'E')
1812 for (j = 0; j < XVECLEN (x, i); j++)
1813 if (may_trap_p (XVECEXP (x, i, j)))
1820 /* Return nonzero if X contains a comparison that is not either EQ or NE,
1821 i.e., an inequality. */
1824 inequality_comparisons_p (x)
1828 register int len, i;
1829 register enum rtx_code code = GET_CODE (x);
1858 len = GET_RTX_LENGTH (code);
1859 fmt = GET_RTX_FORMAT (code);
1861 for (i = 0; i < len; i++)
1865 if (inequality_comparisons_p (XEXP (x, i)))
1868 else if (fmt[i] == 'E')
1871 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
1872 if (inequality_comparisons_p (XVECEXP (x, i, j)))
1880 /* Replace any occurrence of FROM in X with TO. The function does
1881 not enter into CONST_DOUBLE for the replace.
1883 Note that copying is not done so X must not be shared unless all copies
1884 are to be modified. */
1887 replace_rtx (x, from, to)
1893 /* The following prevents loops occurrence when we change MEM in
1894 CONST_DOUBLE onto the same CONST_DOUBLE. */
1895 if (x != 0 && GET_CODE (x) == CONST_DOUBLE)
1901 /* Allow this function to make replacements in EXPR_LISTs. */
1905 fmt = GET_RTX_FORMAT (GET_CODE (x));
1906 for (i = GET_RTX_LENGTH (GET_CODE (x)) - 1; i >= 0; i--)
1909 XEXP (x, i) = replace_rtx (XEXP (x, i), from, to);
1910 else if (fmt[i] == 'E')
1911 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
1912 XVECEXP (x, i, j) = replace_rtx (XVECEXP (x, i, j), from, to);
1918 /* Throughout the rtx X, replace many registers according to REG_MAP.
1919 Return the replacement for X (which may be X with altered contents).
1920 REG_MAP[R] is the replacement for register R, or 0 for don't replace.
1921 NREGS is the length of REG_MAP; regs >= NREGS are not mapped.
1923 We only support REG_MAP entries of REG or SUBREG. Also, hard registers
1924 should not be mapped to pseudos or vice versa since validate_change
1927 If REPLACE_DEST is 1, replacements are also done in destinations;
1928 otherwise, only sources are replaced. */
1931 replace_regs (x, reg_map, nregs, replace_dest)
1937 register enum rtx_code code;
1944 code = GET_CODE (x);
1958 /* Verify that the register has an entry before trying to access it. */
1959 if (REGNO (x) < nregs && reg_map[REGNO (x)] != 0)
1961 /* SUBREGs can't be shared. Always return a copy to ensure that if
1962 this replacement occurs more than once then each instance will
1963 get distinct rtx. */
1964 if (GET_CODE (reg_map[REGNO (x)]) == SUBREG)
1965 return copy_rtx (reg_map[REGNO (x)]);
1966 return reg_map[REGNO (x)];
1971 /* Prevent making nested SUBREGs. */
1972 if (GET_CODE (SUBREG_REG (x)) == REG && REGNO (SUBREG_REG (x)) < nregs
1973 && reg_map[REGNO (SUBREG_REG (x))] != 0
1974 && GET_CODE (reg_map[REGNO (SUBREG_REG (x))]) == SUBREG)
1976 rtx map_val = reg_map[REGNO (SUBREG_REG (x))];
1977 rtx map_inner = SUBREG_REG (map_val);
1979 if (GET_MODE (x) == GET_MODE (map_inner))
1983 /* We cannot call gen_rtx here since we may be linked with
1985 /* Let's try clobbering the incoming SUBREG and see
1986 if this is really safe. */
1987 SUBREG_REG (x) = map_inner;
1988 SUBREG_WORD (x) += SUBREG_WORD (map_val);
1991 rtx new = rtx_alloc (SUBREG);
1992 PUT_MODE (new, GET_MODE (x));
1993 SUBREG_REG (new) = map_inner;
1994 SUBREG_WORD (new) = SUBREG_WORD (x) + SUBREG_WORD (map_val);
2002 SET_DEST (x) = replace_regs (SET_DEST (x), reg_map, nregs, 0);
2004 else if (GET_CODE (SET_DEST (x)) == MEM
2005 || GET_CODE (SET_DEST (x)) == STRICT_LOW_PART)
2006 /* Even if we are not to replace destinations, replace register if it
2007 is CONTAINED in destination (destination is memory or
2008 STRICT_LOW_PART). */
2009 XEXP (SET_DEST (x), 0) = replace_regs (XEXP (SET_DEST (x), 0),
2011 else if (GET_CODE (SET_DEST (x)) == ZERO_EXTRACT)
2012 /* Similarly, for ZERO_EXTRACT we replace all operands. */
2015 SET_SRC (x) = replace_regs (SET_SRC (x), reg_map, nregs, 0);
2022 fmt = GET_RTX_FORMAT (code);
2023 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
2026 XEXP (x, i) = replace_regs (XEXP (x, i), reg_map, nregs, replace_dest);
2030 for (j = 0; j < XVECLEN (x, i); j++)
2031 XVECEXP (x, i, j) = replace_regs (XVECEXP (x, i, j), reg_map,
2032 nregs, replace_dest);
2038 /* Return 1 if X, the SRC_SRC of SET of (pc) contain a REG or MEM that is
2039 not in the constant pool and not in the condition of an IF_THEN_ELSE. */
2042 jmp_uses_reg_or_mem (x)
2045 enum rtx_code code = GET_CODE (x);
2060 return ! (GET_CODE (XEXP (x, 0)) == SYMBOL_REF
2061 && CONSTANT_POOL_ADDRESS_P (XEXP (x, 0)));
2064 return (jmp_uses_reg_or_mem (XEXP (x, 1))
2065 || jmp_uses_reg_or_mem (XEXP (x, 2)));
2067 case PLUS: case MINUS: case MULT:
2068 return (jmp_uses_reg_or_mem (XEXP (x, 0))
2069 || jmp_uses_reg_or_mem (XEXP (x, 1)));
2075 fmt = GET_RTX_FORMAT (code);
2076 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
2079 && jmp_uses_reg_or_mem (XEXP (x, i)))
2083 for (j = 0; j < XVECLEN (x, i); j++)
2084 if (jmp_uses_reg_or_mem (XVECEXP (x, i, j)))
2091 /* Return nonzero if INSN is an indirect jump (aka computed jump).
2093 Tablejumps and casesi insns are not considered indirect jumps;
2094 we can recognize them by a (use (lael_ref)). */
2097 computed_jump_p (insn)
2101 if (GET_CODE (insn) == JUMP_INSN)
2103 rtx pat = PATTERN (insn);
2105 if (GET_CODE (pat) == PARALLEL)
2107 int len = XVECLEN (pat, 0);
2108 int has_use_labelref = 0;
2110 for (i = len - 1; i >= 0; i--)
2111 if (GET_CODE (XVECEXP (pat, 0, i)) == USE
2112 && (GET_CODE (XEXP (XVECEXP (pat, 0, i), 0))
2114 has_use_labelref = 1;
2116 if (! has_use_labelref)
2117 for (i = len - 1; i >= 0; i--)
2118 if (GET_CODE (XVECEXP (pat, 0, i)) == SET
2119 && SET_DEST (XVECEXP (pat, 0, i)) == pc_rtx
2120 && jmp_uses_reg_or_mem (SET_SRC (XVECEXP (pat, 0, i))))
2123 else if (GET_CODE (pat) == SET
2124 && SET_DEST (pat) == pc_rtx
2125 && jmp_uses_reg_or_mem (SET_SRC (pat)))
2131 /* Traverse X via depth-first search, calling F for each
2132 sub-expression (including X itself). F is also passed the DATA.
2133 If F returns -1, do not traverse sub-expressions, but continue
2134 traversing the rest of the tree. If F ever returns any other
2135 non-zero value, stop the traversal, and return the value returned
2136 by F. Otherwise, return 0. This function does not traverse inside
2137 tree structure that contains RTX_EXPRs, or into sub-expressions
2138 whose format code is `0' since it is not known whether or not those
2139 codes are actually RTL.
2141 This routine is very general, and could (should?) be used to
2142 implement many of the other routines in this file. */
2145 for_each_rtx (x, f, data)
2156 result = (*f)(x, data);
2158 /* Do not traverse sub-expressions. */
2160 else if (result != 0)
2161 /* Stop the traversal. */
2165 /* There are no sub-expressions. */
2168 length = GET_RTX_LENGTH (GET_CODE (*x));
2169 format = GET_RTX_FORMAT (GET_CODE (*x));
2171 for (i = 0; i < length; ++i)
2176 result = for_each_rtx (&XEXP (*x, i), f, data);
2183 if (XVEC (*x, i) != 0)
2186 for (j = 0; j < XVECLEN (*x, i); ++j)
2188 result = for_each_rtx (&XVECEXP (*x, i, j), f, data);
2196 /* Nothing to do. */
2205 /* INSN and REFERENCE are instructions in the same insn chain.
2206 Return non-zero if INSN is first. */
2208 insn_first_p (insn, reference)
2209 rtx insn, reference;
2213 for (p = insn, q = reference; ; p = NEXT_INSN (p), q = NEXT_INSN (q))
2215 if (p == reference || ! q)
2217 if (q == insn || ! p)
2223 /* Searches X for any reference to REGNO, returning the rtx of the
2224 reference found if any. Otherwise, returns NULL_RTX. */
2227 regno_use_in (regno, x)
2235 if (GET_CODE (x) == REG && REGNO (x) == regno)
2238 fmt = GET_RTX_FORMAT (GET_CODE (x));
2239 for (i = GET_RTX_LENGTH (GET_CODE (x)) - 1; i >= 0; i--)
2243 if ((tem = regno_use_in (regno, XEXP (x, i))))
2246 else if (fmt[i] == 'E')
2247 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
2248 if ((tem = regno_use_in (regno , XVECEXP (x, i, j))))