1 /* Analyze RTL for C-Compiler
2 Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000 Free Software Foundation, Inc.
5 This file is part of GNU CC.
7 GNU CC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU CC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU CC; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
27 static int rtx_addr_can_trap_p PARAMS ((rtx));
28 static void reg_set_p_1 PARAMS ((rtx, rtx, void *));
29 static void reg_set_last_1 PARAMS ((rtx, rtx, void *));
32 /* Forward declarations */
33 static int jmp_uses_reg_or_mem PARAMS ((rtx));
35 /* Bit flags that specify the machine subtype we are compiling for.
36 Bits are tested using macros TARGET_... defined in the tm.h file
37 and set by `-m...' switches. Must be defined in rtlanal.c. */
41 /* Return 1 if the value of X is unstable
42 (would be different at a different point in the program).
43 The frame pointer, arg pointer, etc. are considered stable
44 (within one function) and so is anything marked `unchanging'. */
50 register RTX_CODE code = GET_CODE (x);
52 register const char *fmt;
55 return ! RTX_UNCHANGING_P (x);
60 if (code == CONST || code == CONST_INT)
64 return ! (REGNO (x) == FRAME_POINTER_REGNUM
65 || REGNO (x) == HARD_FRAME_POINTER_REGNUM
66 || REGNO (x) == ARG_POINTER_REGNUM
67 || RTX_UNCHANGING_P (x));
69 fmt = GET_RTX_FORMAT (code);
70 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
72 if (rtx_unstable_p (XEXP (x, i)))
77 /* Return 1 if X has a value that can vary even between two
78 executions of the program. 0 means X can be compared reliably
79 against certain constants or near-constants.
80 The frame pointer and the arg pointer are considered constant. */
86 register RTX_CODE code = GET_CODE (x);
88 register const char *fmt;
104 /* Note that we have to test for the actual rtx used for the frame
105 and arg pointers and not just the register number in case we have
106 eliminated the frame and/or arg pointer and are using it
108 return ! (x == frame_pointer_rtx || x == hard_frame_pointer_rtx
109 || x == arg_pointer_rtx || x == pic_offset_table_rtx);
112 /* The operand 0 of a LO_SUM is considered constant
113 (in fact is it related specifically to operand 1). */
114 return rtx_varies_p (XEXP (x, 1));
120 fmt = GET_RTX_FORMAT (code);
121 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
123 if (rtx_varies_p (XEXP (x, i)))
128 /* Return 0 if the use of X as an address in a MEM can cause a trap. */
131 rtx_addr_can_trap_p (x)
134 register enum rtx_code code = GET_CODE (x);
140 /* SYMBOL_REF is problematic due to the possible presence of
141 a #pragma weak, but to say that loads from symbols can trap is
142 *very* costly. It's not at all clear what's best here. For
143 now, we ignore the impact of #pragma weak. */
147 /* As in rtx_varies_p, we have to use the actual rtx, not reg number. */
148 return ! (x == frame_pointer_rtx || x == hard_frame_pointer_rtx
149 || x == stack_pointer_rtx || x == arg_pointer_rtx);
152 return rtx_addr_can_trap_p (XEXP (x, 0));
155 /* An address is assumed not to trap if it is an address that can't
156 trap plus a constant integer. */
157 return (rtx_addr_can_trap_p (XEXP (x, 0))
158 || GET_CODE (XEXP (x, 1)) != CONST_INT);
161 return rtx_addr_can_trap_p (XEXP (x, 1));
167 /* If it isn't one of the case above, it can cause a trap. */
171 /* Return 1 if X refers to a memory location whose address
172 cannot be compared reliably with constant addresses,
173 or if X refers to a BLKmode memory object. */
176 rtx_addr_varies_p (x)
179 register enum rtx_code code;
181 register const char *fmt;
188 return GET_MODE (x) == BLKmode || rtx_varies_p (XEXP (x, 0));
190 fmt = GET_RTX_FORMAT (code);
191 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
194 if (rtx_addr_varies_p (XEXP (x, i)))
197 else if (fmt[i] == 'E')
200 for (j = 0; j < XVECLEN (x, i); j++)
201 if (rtx_addr_varies_p (XVECEXP (x, i, j)))
207 /* Return the value of the integer term in X, if one is apparent;
209 Only obvious integer terms are detected.
210 This is used in cse.c with the `related_value' field.*/
216 if (GET_CODE (x) == CONST)
219 if (GET_CODE (x) == MINUS
220 && GET_CODE (XEXP (x, 1)) == CONST_INT)
221 return - INTVAL (XEXP (x, 1));
222 if (GET_CODE (x) == PLUS
223 && GET_CODE (XEXP (x, 1)) == CONST_INT)
224 return INTVAL (XEXP (x, 1));
228 /* If X is a constant, return the value sans apparent integer term;
230 Only obvious integer terms are detected. */
233 get_related_value (x)
236 if (GET_CODE (x) != CONST)
239 if (GET_CODE (x) == PLUS
240 && GET_CODE (XEXP (x, 1)) == CONST_INT)
242 else if (GET_CODE (x) == MINUS
243 && GET_CODE (XEXP (x, 1)) == CONST_INT)
248 /* Nonzero if register REG appears somewhere within IN.
249 Also works if REG is not a register; in this case it checks
250 for a subexpression of IN that is Lisp "equal" to REG. */
253 reg_mentioned_p (reg, in)
254 register rtx reg, in;
256 register const char *fmt;
258 register enum rtx_code code;
266 if (GET_CODE (in) == LABEL_REF)
267 return reg == XEXP (in, 0);
269 code = GET_CODE (in);
273 /* Compare registers by number. */
275 return GET_CODE (reg) == REG && REGNO (in) == REGNO (reg);
277 /* These codes have no constituent expressions
285 return GET_CODE (reg) == CONST_INT && INTVAL (in) == INTVAL (reg);
288 /* These are kept unique for a given value. */
295 if (GET_CODE (reg) == code && rtx_equal_p (reg, in))
298 fmt = GET_RTX_FORMAT (code);
300 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
305 for (j = XVECLEN (in, i) - 1; j >= 0; j--)
306 if (reg_mentioned_p (reg, XVECEXP (in, i, j)))
309 else if (fmt[i] == 'e'
310 && reg_mentioned_p (reg, XEXP (in, i)))
316 /* Return 1 if in between BEG and END, exclusive of BEG and END, there is
317 no CODE_LABEL insn. */
320 no_labels_between_p (beg, end)
324 for (p = NEXT_INSN (beg); p != end; p = NEXT_INSN (p))
325 if (GET_CODE (p) == CODE_LABEL)
330 /* Return 1 if in between BEG and END, exclusive of BEG and END, there is
331 no JUMP_INSN insn. */
334 no_jumps_between_p (beg, end)
338 for (p = NEXT_INSN (beg); p != end; p = NEXT_INSN (p))
339 if (GET_CODE (p) == JUMP_INSN)
344 /* Nonzero if register REG is used in an insn between
345 FROM_INSN and TO_INSN (exclusive of those two). */
348 reg_used_between_p (reg, from_insn, to_insn)
349 rtx reg, from_insn, to_insn;
353 if (from_insn == to_insn)
356 for (insn = NEXT_INSN (from_insn); insn != to_insn; insn = NEXT_INSN (insn))
357 if (GET_RTX_CLASS (GET_CODE (insn)) == 'i'
358 && (reg_overlap_mentioned_p (reg, PATTERN (insn))
359 || (GET_CODE (insn) == CALL_INSN
360 && (find_reg_fusage (insn, USE, reg)
361 || find_reg_fusage (insn, CLOBBER, reg)))))
366 /* Nonzero if the old value of X, a register, is referenced in BODY. If X
367 is entirely replaced by a new value and the only use is as a SET_DEST,
368 we do not consider it a reference. */
371 reg_referenced_p (x, body)
377 switch (GET_CODE (body))
380 if (reg_overlap_mentioned_p (x, SET_SRC (body)))
383 /* If the destination is anything other than CC0, PC, a REG or a SUBREG
384 of a REG that occupies all of the REG, the insn references X if
385 it is mentioned in the destination. */
386 if (GET_CODE (SET_DEST (body)) != CC0
387 && GET_CODE (SET_DEST (body)) != PC
388 && GET_CODE (SET_DEST (body)) != REG
389 && ! (GET_CODE (SET_DEST (body)) == SUBREG
390 && GET_CODE (SUBREG_REG (SET_DEST (body))) == REG
391 && (((GET_MODE_SIZE (GET_MODE (SUBREG_REG (SET_DEST (body))))
392 + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD)
393 == ((GET_MODE_SIZE (GET_MODE (SET_DEST (body)))
394 + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD)))
395 && reg_overlap_mentioned_p (x, SET_DEST (body)))
400 for (i = ASM_OPERANDS_INPUT_LENGTH (body) - 1; i >= 0; i--)
401 if (reg_overlap_mentioned_p (x, ASM_OPERANDS_INPUT (body, i)))
408 return reg_overlap_mentioned_p (x, body);
411 return reg_overlap_mentioned_p (x, TRAP_CONDITION (body));
414 case UNSPEC_VOLATILE:
415 for (i = XVECLEN (body, 0) - 1; i >= 0; i--)
416 if (reg_overlap_mentioned_p (x, XVECEXP (body, 0, i)))
421 for (i = XVECLEN (body, 0) - 1; i >= 0; i--)
422 if (reg_referenced_p (x, XVECEXP (body, 0, i)))
427 if (GET_CODE (XEXP (body, 0)) == MEM)
428 if (reg_overlap_mentioned_p (x, XEXP (XEXP (body, 0), 0)))
433 if (reg_overlap_mentioned_p (x, COND_EXEC_TEST (body)))
435 return reg_referenced_p (x, COND_EXEC_CODE (body));
442 /* Nonzero if register REG is referenced in an insn between
443 FROM_INSN and TO_INSN (exclusive of those two). Sets of REG do
447 reg_referenced_between_p (reg, from_insn, to_insn)
448 rtx reg, from_insn, to_insn;
452 if (from_insn == to_insn)
455 for (insn = NEXT_INSN (from_insn); insn != to_insn; insn = NEXT_INSN (insn))
456 if (GET_RTX_CLASS (GET_CODE (insn)) == 'i'
457 && (reg_referenced_p (reg, PATTERN (insn))
458 || (GET_CODE (insn) == CALL_INSN
459 && find_reg_fusage (insn, USE, reg))))
464 /* Nonzero if register REG is set or clobbered in an insn between
465 FROM_INSN and TO_INSN (exclusive of those two). */
468 reg_set_between_p (reg, from_insn, to_insn)
469 rtx reg, from_insn, to_insn;
473 if (from_insn == to_insn)
476 for (insn = NEXT_INSN (from_insn); insn != to_insn; insn = NEXT_INSN (insn))
477 if (GET_RTX_CLASS (GET_CODE (insn)) == 'i'
478 && reg_set_p (reg, insn))
483 /* Internals of reg_set_between_p. */
485 static rtx reg_set_reg;
486 static int reg_set_flag;
489 reg_set_p_1 (x, pat, data)
491 rtx pat ATTRIBUTE_UNUSED;
492 void *data ATTRIBUTE_UNUSED;
494 /* We don't want to return 1 if X is a MEM that contains a register
495 within REG_SET_REG. */
497 if ((GET_CODE (x) != MEM)
498 && reg_overlap_mentioned_p (reg_set_reg, x))
503 reg_set_p (reg, insn)
508 /* We can be passed an insn or part of one. If we are passed an insn,
509 check if a side-effect of the insn clobbers REG. */
510 if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
512 if (FIND_REG_INC_NOTE (insn, reg)
513 || (GET_CODE (insn) == CALL_INSN
514 /* We'd like to test call_used_regs here, but rtlanal.c can't
515 reference that variable due to its use in genattrtab. So
516 we'll just be more conservative.
518 ??? Unless we could ensure that the CALL_INSN_FUNCTION_USAGE
519 information holds all clobbered registers. */
520 && ((GET_CODE (reg) == REG
521 && REGNO (reg) < FIRST_PSEUDO_REGISTER)
522 || GET_CODE (reg) == MEM
523 || find_reg_fusage (insn, CLOBBER, reg))))
526 body = PATTERN (insn);
531 note_stores (body, reg_set_p_1, NULL);
535 /* Similar to reg_set_between_p, but check all registers in X. Return 0
536 only if none of them are modified between START and END. Do not
537 consider non-registers one way or the other. */
540 regs_set_between_p (x, start, end)
544 enum rtx_code code = GET_CODE (x);
560 return reg_set_between_p (x, start, end);
566 fmt = GET_RTX_FORMAT (code);
567 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
569 if (fmt[i] == 'e' && regs_set_between_p (XEXP (x, i), start, end))
572 else if (fmt[i] == 'E')
573 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
574 if (regs_set_between_p (XVECEXP (x, i, j), start, end))
581 /* Similar to reg_set_between_p, but check all registers in X. Return 0
582 only if none of them are modified between START and END. Return 1 if
583 X contains a MEM; this routine does not perform any memory aliasing. */
586 modified_between_p (x, start, end)
590 enum rtx_code code = GET_CODE (x);
608 /* If the memory is not constant, assume it is modified. If it is
609 constant, we still have to check the address. */
610 if (! RTX_UNCHANGING_P (x))
615 return reg_set_between_p (x, start, end);
621 fmt = GET_RTX_FORMAT (code);
622 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
624 if (fmt[i] == 'e' && modified_between_p (XEXP (x, i), start, end))
627 else if (fmt[i] == 'E')
628 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
629 if (modified_between_p (XVECEXP (x, i, j), start, end))
636 /* Similar to reg_set_p, but check all registers in X. Return 0 only if none
637 of them are modified in INSN. Return 1 if X contains a MEM; this routine
638 does not perform any memory aliasing. */
641 modified_in_p (x, insn)
645 enum rtx_code code = GET_CODE (x);
663 /* If the memory is not constant, assume it is modified. If it is
664 constant, we still have to check the address. */
665 if (! RTX_UNCHANGING_P (x))
670 return reg_set_p (x, insn);
676 fmt = GET_RTX_FORMAT (code);
677 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
679 if (fmt[i] == 'e' && modified_in_p (XEXP (x, i), insn))
682 else if (fmt[i] == 'E')
683 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
684 if (modified_in_p (XVECEXP (x, i, j), insn))
691 /* Given an INSN, return a SET expression if this insn has only a single SET.
692 It may also have CLOBBERs, USEs, or SET whose output
693 will not be used, which we ignore. */
702 if (GET_RTX_CLASS (GET_CODE (insn)) != 'i')
705 if (GET_CODE (PATTERN (insn)) == SET)
706 return PATTERN (insn);
708 else if (GET_CODE (PATTERN (insn)) == PARALLEL)
710 for (i = 0, set = 0; i < XVECLEN (PATTERN (insn), 0); i++)
712 rtx sub = XVECEXP (PATTERN (insn), 0, i);
714 switch (GET_CODE (sub))
721 if (! find_reg_note (insn, REG_UNUSED, SET_DEST (sub))
722 || side_effects_p (sub))
741 /* Given an INSN, return nonzero if it has more than one SET, else return
751 /* INSN must be an insn. */
752 if (GET_RTX_CLASS (GET_CODE (insn)) != 'i')
755 /* Only a PARALLEL can have multiple SETs. */
756 if (GET_CODE (PATTERN (insn)) == PARALLEL)
758 for (i = 0, found = 0; i < XVECLEN (PATTERN (insn), 0); i++)
759 if (GET_CODE (XVECEXP (PATTERN (insn), 0, i)) == SET)
761 /* If we have already found a SET, then return now. */
769 /* Either zero or one SET. */
773 /* Return the last thing that X was assigned from before *PINSN. If VALID_TO
774 is not NULL_RTX then verify that the object is not modified up to VALID_TO.
775 If the object was modified, if we hit a partial assignment to X, or hit a
776 CODE_LABEL first, return X. If we found an assignment, update *PINSN to
777 point to it. ALLOW_HWREG is set to 1 if hardware registers are allowed to
781 find_last_value (x, pinsn, valid_to, allow_hwreg)
789 for (p = PREV_INSN (*pinsn); p && GET_CODE (p) != CODE_LABEL;
791 if (GET_RTX_CLASS (GET_CODE (p)) == 'i')
793 rtx set = single_set (p);
794 rtx note = find_reg_note (p, REG_EQUAL, NULL_RTX);
796 if (set && rtx_equal_p (x, SET_DEST (set)))
798 rtx src = SET_SRC (set);
800 if (note && GET_CODE (XEXP (note, 0)) != EXPR_LIST)
801 src = XEXP (note, 0);
803 if ((valid_to == NULL_RTX
804 || ! modified_between_p (src, PREV_INSN (p), valid_to))
805 /* Reject hard registers because we don't usually want
806 to use them; we'd rather use a pseudo. */
807 && (! (GET_CODE (src) == REG
808 && REGNO (src) < FIRST_PSEUDO_REGISTER) || allow_hwreg))
815 /* If set in non-simple way, we don't have a value. */
816 if (reg_set_p (x, p))
823 /* Return nonzero if register in range [REGNO, ENDREGNO)
824 appears either explicitly or implicitly in X
825 other than being stored into.
827 References contained within the substructure at LOC do not count.
828 LOC may be zero, meaning don't ignore anything. */
831 refers_to_regno_p (regno, endregno, x, loc)
832 unsigned int regno, endregno;
837 unsigned int x_regno;
842 /* The contents of a REG_NONNEG note is always zero, so we must come here
843 upon repeat in case the last REG_NOTE is a REG_NONNEG note. */
854 /* If we modifying the stack, frame, or argument pointer, it will
855 clobber a virtual register. In fact, we could be more precise,
856 but it isn't worth it. */
857 if ((x_regno == STACK_POINTER_REGNUM
858 #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
859 || x_regno == ARG_POINTER_REGNUM
861 || x_regno == FRAME_POINTER_REGNUM)
862 && regno >= FIRST_VIRTUAL_REGISTER && regno <= LAST_VIRTUAL_REGISTER)
865 return (endregno > x_regno
866 && regno < x_regno + (x_regno < FIRST_PSEUDO_REGISTER
867 ? HARD_REGNO_NREGS (x_regno, GET_MODE (x))
871 /* If this is a SUBREG of a hard reg, we can see exactly which
872 registers are being modified. Otherwise, handle normally. */
873 if (GET_CODE (SUBREG_REG (x)) == REG
874 && REGNO (SUBREG_REG (x)) < FIRST_PSEUDO_REGISTER)
876 unsigned int inner_regno = REGNO (SUBREG_REG (x)) + SUBREG_WORD (x);
877 unsigned int inner_endregno
878 = inner_regno + (inner_regno < FIRST_PSEUDO_REGISTER
879 ? HARD_REGNO_NREGS (regno, GET_MODE (x)) : 1);
881 return endregno > inner_regno && regno < inner_endregno;
887 if (&SET_DEST (x) != loc
888 /* Note setting a SUBREG counts as referring to the REG it is in for
889 a pseudo but not for hard registers since we can
890 treat each word individually. */
891 && ((GET_CODE (SET_DEST (x)) == SUBREG
892 && loc != &SUBREG_REG (SET_DEST (x))
893 && GET_CODE (SUBREG_REG (SET_DEST (x))) == REG
894 && REGNO (SUBREG_REG (SET_DEST (x))) >= FIRST_PSEUDO_REGISTER
895 && refers_to_regno_p (regno, endregno,
896 SUBREG_REG (SET_DEST (x)), loc))
897 || (GET_CODE (SET_DEST (x)) != REG
898 && refers_to_regno_p (regno, endregno, SET_DEST (x), loc))))
901 if (code == CLOBBER || loc == &SET_SRC (x))
910 /* X does not match, so try its subexpressions. */
912 fmt = GET_RTX_FORMAT (code);
913 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
915 if (fmt[i] == 'e' && loc != &XEXP (x, i))
923 if (refers_to_regno_p (regno, endregno, XEXP (x, i), loc))
926 else if (fmt[i] == 'E')
929 for (j = XVECLEN (x, i) - 1; j >=0; j--)
930 if (loc != &XVECEXP (x, i, j)
931 && refers_to_regno_p (regno, endregno, XVECEXP (x, i, j), loc))
938 /* Nonzero if modifying X will affect IN. If X is a register or a SUBREG,
939 we check if any register number in X conflicts with the relevant register
940 numbers. If X is a constant, return 0. If X is a MEM, return 1 iff IN
941 contains a MEM (we don't bother checking for memory addresses that can't
942 conflict because we expect this to be a rare case. */
945 reg_overlap_mentioned_p (x, in)
948 unsigned int regno, endregno;
950 /* Overly conservative. */
951 if (GET_CODE (x) == STRICT_LOW_PART)
954 /* If either argument is a constant, then modifying X can not affect IN. */
955 if (CONSTANT_P (x) || CONSTANT_P (in))
958 switch (GET_CODE (x))
961 regno = REGNO (SUBREG_REG (x));
962 if (regno < FIRST_PSEUDO_REGISTER)
963 regno += SUBREG_WORD (x);
969 endregno = regno + (regno < FIRST_PSEUDO_REGISTER
970 ? HARD_REGNO_NREGS (regno, GET_MODE (x)) : 1);
971 return refers_to_regno_p (regno, endregno, in, NULL_PTR);
978 if (GET_CODE (in) == MEM)
981 fmt = GET_RTX_FORMAT (GET_CODE (in));
982 for (i = GET_RTX_LENGTH (GET_CODE (in)) - 1; i >= 0; i--)
983 if (fmt[i] == 'e' && reg_overlap_mentioned_p (x, XEXP (in, i)))
992 return reg_mentioned_p (x, in);
995 if (GET_MODE (x) == BLKmode)
999 /* If any register in here refers to it we return true. */
1000 for (i = XVECLEN (x, 0) - 1; i >= 0; i--)
1001 if (reg_overlap_mentioned_p (SET_DEST (XVECEXP (x, 0, i)), in))
1014 /* Used for communications between the next few functions. */
1016 static int reg_set_last_unknown;
1017 static rtx reg_set_last_value;
1018 static unsigned int reg_set_last_first_regno, reg_set_last_last_regno;
1020 /* Called via note_stores from reg_set_last. */
1023 reg_set_last_1 (x, pat, data)
1026 void *data ATTRIBUTE_UNUSED;
1028 unsigned int first, last;
1030 /* If X is not a register, or is not one in the range we care
1032 if (GET_CODE (x) != REG)
1036 last = first + (first < FIRST_PSEUDO_REGISTER
1037 ? HARD_REGNO_NREGS (first, GET_MODE (x)) : 1);
1039 if (first >= reg_set_last_last_regno
1040 || last <= reg_set_last_first_regno)
1043 /* If this is a CLOBBER or is some complex LHS, or doesn't modify
1044 exactly the registers we care about, show we don't know the value. */
1045 if (GET_CODE (pat) == CLOBBER || SET_DEST (pat) != x
1046 || first != reg_set_last_first_regno
1047 || last != reg_set_last_last_regno)
1048 reg_set_last_unknown = 1;
1050 reg_set_last_value = SET_SRC (pat);
1053 /* Return the last value to which REG was set prior to INSN. If we can't
1054 find it easily, return 0.
1056 We only return a REG, SUBREG, or constant because it is too hard to
1057 check if a MEM remains unchanged. */
1060 reg_set_last (x, insn)
1064 rtx orig_insn = insn;
1066 reg_set_last_first_regno = REGNO (x);
1068 reg_set_last_last_regno
1069 = reg_set_last_first_regno
1070 + (reg_set_last_first_regno < FIRST_PSEUDO_REGISTER
1071 ? HARD_REGNO_NREGS (reg_set_last_first_regno, GET_MODE (x)) : 1);
1073 reg_set_last_unknown = 0;
1074 reg_set_last_value = 0;
1076 /* Scan backwards until reg_set_last_1 changed one of the above flags.
1077 Stop when we reach a label or X is a hard reg and we reach a
1078 CALL_INSN (if reg_set_last_last_regno is a hard reg).
1080 If we find a set of X, ensure that its SET_SRC remains unchanged. */
1082 /* We compare with <= here, because reg_set_last_last_regno
1083 is actually the number of the first reg *not* in X. */
1085 insn && GET_CODE (insn) != CODE_LABEL
1086 && ! (GET_CODE (insn) == CALL_INSN
1087 && reg_set_last_last_regno <= FIRST_PSEUDO_REGISTER);
1088 insn = PREV_INSN (insn))
1089 if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
1091 note_stores (PATTERN (insn), reg_set_last_1, NULL);
1092 if (reg_set_last_unknown)
1094 else if (reg_set_last_value)
1096 if (CONSTANT_P (reg_set_last_value)
1097 || ((GET_CODE (reg_set_last_value) == REG
1098 || GET_CODE (reg_set_last_value) == SUBREG)
1099 && ! reg_set_between_p (reg_set_last_value,
1101 return reg_set_last_value;
1110 /* Call FUN on each register or MEM that is stored into or clobbered by X.
1111 (X would be the pattern of an insn).
1112 FUN receives two arguments:
1113 the REG, MEM, CC0 or PC being stored in or clobbered,
1114 the SET or CLOBBER rtx that does the store.
1116 If the item being stored in or clobbered is a SUBREG of a hard register,
1117 the SUBREG will be passed. */
1120 note_stores (x, fun, data)
1122 void (*fun) PARAMS ((rtx, rtx, void *));
1125 if (GET_CODE (x) == COND_EXEC)
1126 x = COND_EXEC_CODE (x);
1127 if (GET_CODE (x) == SET || GET_CODE (x) == CLOBBER)
1129 register rtx dest = SET_DEST (x);
1130 while ((GET_CODE (dest) == SUBREG
1131 && (GET_CODE (SUBREG_REG (dest)) != REG
1132 || REGNO (SUBREG_REG (dest)) >= FIRST_PSEUDO_REGISTER))
1133 || GET_CODE (dest) == ZERO_EXTRACT
1134 || GET_CODE (dest) == SIGN_EXTRACT
1135 || GET_CODE (dest) == STRICT_LOW_PART)
1136 dest = XEXP (dest, 0);
1138 if (GET_CODE (dest) == PARALLEL
1139 && GET_MODE (dest) == BLKmode)
1142 for (i = XVECLEN (dest, 0) - 1; i >= 0; i--)
1143 (*fun) (SET_DEST (XVECEXP (dest, 0, i)), x, data);
1146 (*fun) (dest, x, data);
1148 else if (GET_CODE (x) == PARALLEL)
1151 for (i = XVECLEN (x, 0) - 1; i >= 0; i--)
1153 register rtx y = XVECEXP (x, 0, i);
1154 if (GET_CODE (y) == COND_EXEC)
1155 y = COND_EXEC_CODE (y);
1156 if (GET_CODE (y) == SET || GET_CODE (y) == CLOBBER)
1158 register rtx dest = SET_DEST (y);
1159 while ((GET_CODE (dest) == SUBREG
1160 && (GET_CODE (SUBREG_REG (dest)) != REG
1161 || (REGNO (SUBREG_REG (dest))
1162 >= FIRST_PSEUDO_REGISTER)))
1163 || GET_CODE (dest) == ZERO_EXTRACT
1164 || GET_CODE (dest) == SIGN_EXTRACT
1165 || GET_CODE (dest) == STRICT_LOW_PART)
1166 dest = XEXP (dest, 0);
1167 if (GET_CODE (dest) == PARALLEL
1168 && GET_MODE (dest) == BLKmode)
1172 for (i = XVECLEN (dest, 0) - 1; i >= 0; i--)
1173 (*fun) (SET_DEST (XVECEXP (dest, 0, i)), y, data);
1176 (*fun) (dest, y, data);
1182 /* Return nonzero if X's old contents don't survive after INSN.
1183 This will be true if X is (cc0) or if X is a register and
1184 X dies in INSN or because INSN entirely sets X.
1186 "Entirely set" means set directly and not through a SUBREG,
1187 ZERO_EXTRACT or SIGN_EXTRACT, so no trace of the old contents remains.
1188 Likewise, REG_INC does not count.
1190 REG may be a hard or pseudo reg. Renumbering is not taken into account,
1191 but for this use that makes no difference, since regs don't overlap
1192 during their lifetimes. Therefore, this function may be used
1193 at any time after deaths have been computed (in flow.c).
1195 If REG is a hard reg that occupies multiple machine registers, this
1196 function will only return 1 if each of those registers will be replaced
1200 dead_or_set_p (insn, x)
1204 unsigned int regno, last_regno;
1207 /* Can't use cc0_rtx below since this file is used by genattrtab.c. */
1208 if (GET_CODE (x) == CC0)
1211 if (GET_CODE (x) != REG)
1215 last_regno = (regno >= FIRST_PSEUDO_REGISTER ? regno
1216 : regno + HARD_REGNO_NREGS (regno, GET_MODE (x)) - 1);
1218 for (i = regno; i <= last_regno; i++)
1219 if (! dead_or_set_regno_p (insn, i))
1225 /* Utility function for dead_or_set_p to check an individual register. Also
1226 called from flow.c. */
1229 dead_or_set_regno_p (insn, test_regno)
1231 unsigned int test_regno;
1233 unsigned int regno, endregno;
1236 /* See if there is a death note for something that includes TEST_REGNO. */
1237 if (find_regno_note (insn, REG_DEAD, test_regno))
1240 if (GET_CODE (insn) == CALL_INSN
1241 && find_regno_fusage (insn, CLOBBER, test_regno))
1244 pattern = PATTERN (insn);
1246 if (GET_CODE (pattern) == COND_EXEC)
1247 pattern = COND_EXEC_CODE (pattern);
1249 if (GET_CODE (pattern) == SET)
1251 rtx dest = SET_DEST (PATTERN (insn));
1253 /* A value is totally replaced if it is the destination or the
1254 destination is a SUBREG of REGNO that does not change the number of
1256 if (GET_CODE (dest) == SUBREG
1257 && (((GET_MODE_SIZE (GET_MODE (dest))
1258 + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
1259 == ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (dest)))
1260 + UNITS_PER_WORD - 1) / UNITS_PER_WORD)))
1261 dest = SUBREG_REG (dest);
1263 if (GET_CODE (dest) != REG)
1266 regno = REGNO (dest);
1267 endregno = (regno >= FIRST_PSEUDO_REGISTER ? regno + 1
1268 : regno + HARD_REGNO_NREGS (regno, GET_MODE (dest)));
1270 return (test_regno >= regno && test_regno < endregno);
1272 else if (GET_CODE (pattern) == PARALLEL)
1276 for (i = XVECLEN (pattern, 0) - 1; i >= 0; i--)
1278 rtx body = XVECEXP (pattern, 0, i);
1280 if (GET_CODE (body) == COND_EXEC)
1281 body = COND_EXEC_CODE (body);
1283 if (GET_CODE (body) == SET || GET_CODE (body) == CLOBBER)
1285 rtx dest = SET_DEST (body);
1287 if (GET_CODE (dest) == SUBREG
1288 && (((GET_MODE_SIZE (GET_MODE (dest))
1289 + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
1290 == ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (dest)))
1291 + UNITS_PER_WORD - 1) / UNITS_PER_WORD)))
1292 dest = SUBREG_REG (dest);
1294 if (GET_CODE (dest) != REG)
1297 regno = REGNO (dest);
1298 endregno = (regno >= FIRST_PSEUDO_REGISTER ? regno + 1
1299 : regno + HARD_REGNO_NREGS (regno, GET_MODE (dest)));
1301 if (test_regno >= regno && test_regno < endregno)
1310 /* Return the reg-note of kind KIND in insn INSN, if there is one.
1311 If DATUM is nonzero, look for one whose datum is DATUM. */
1314 find_reg_note (insn, kind, datum)
1321 /* Ignore anything that is not an INSN, JUMP_INSN or CALL_INSN. */
1322 if (GET_RTX_CLASS (GET_CODE (insn)) != 'i')
1325 for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
1326 if (REG_NOTE_KIND (link) == kind
1327 && (datum == 0 || datum == XEXP (link, 0)))
1332 /* Return the reg-note of kind KIND in insn INSN which applies to register
1333 number REGNO, if any. Return 0 if there is no such reg-note. Note that
1334 the REGNO of this NOTE need not be REGNO if REGNO is a hard register;
1335 it might be the case that the note overlaps REGNO. */
1338 find_regno_note (insn, kind, regno)
1345 /* Ignore anything that is not an INSN, JUMP_INSN or CALL_INSN. */
1346 if (GET_RTX_CLASS (GET_CODE (insn)) != 'i')
1349 for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
1350 if (REG_NOTE_KIND (link) == kind
1351 /* Verify that it is a register, so that scratch and MEM won't cause a
1353 && GET_CODE (XEXP (link, 0)) == REG
1354 && REGNO (XEXP (link, 0)) <= regno
1355 && ((REGNO (XEXP (link, 0))
1356 + (REGNO (XEXP (link, 0)) >= FIRST_PSEUDO_REGISTER ? 1
1357 : HARD_REGNO_NREGS (REGNO (XEXP (link, 0)),
1358 GET_MODE (XEXP (link, 0)))))
1364 /* Return true if DATUM, or any overlap of DATUM, of kind CODE is found
1365 in the CALL_INSN_FUNCTION_USAGE information of INSN. */
1368 find_reg_fusage (insn, code, datum)
1373 /* If it's not a CALL_INSN, it can't possibly have a
1374 CALL_INSN_FUNCTION_USAGE field, so don't bother checking. */
1375 if (GET_CODE (insn) != CALL_INSN)
1381 if (GET_CODE (datum) != REG)
1385 for (link = CALL_INSN_FUNCTION_USAGE (insn);
1387 link = XEXP (link, 1))
1388 if (GET_CODE (XEXP (link, 0)) == code
1389 && rtx_equal_p (datum, SET_DEST (XEXP (link, 0))))
1394 unsigned int regno = REGNO (datum);
1396 /* CALL_INSN_FUNCTION_USAGE information cannot contain references
1397 to pseudo registers, so don't bother checking. */
1399 if (regno < FIRST_PSEUDO_REGISTER)
1401 unsigned int end_regno
1402 = regno + HARD_REGNO_NREGS (regno, GET_MODE (datum));
1405 for (i = regno; i < end_regno; i++)
1406 if (find_regno_fusage (insn, code, i))
1414 /* Return true if REGNO, or any overlap of REGNO, of kind CODE is found
1415 in the CALL_INSN_FUNCTION_USAGE information of INSN. */
1418 find_regno_fusage (insn, code, regno)
1425 /* CALL_INSN_FUNCTION_USAGE information cannot contain references
1426 to pseudo registers, so don't bother checking. */
1428 if (regno >= FIRST_PSEUDO_REGISTER
1429 || GET_CODE (insn) != CALL_INSN )
1432 for (link = CALL_INSN_FUNCTION_USAGE (insn); link; link = XEXP (link, 1))
1434 unsigned int regnote;
1437 if (GET_CODE (op = XEXP (link, 0)) == code
1438 && GET_CODE (reg = XEXP (op, 0)) == REG
1439 && (regnote = REGNO (reg)) <= regno
1440 && regnote + HARD_REGNO_NREGS (regnote, GET_MODE (reg)) > regno)
1447 /* Remove register note NOTE from the REG_NOTES of INSN. */
1450 remove_note (insn, note)
1456 if (note == NULL_RTX)
1459 if (REG_NOTES (insn) == note)
1461 REG_NOTES (insn) = XEXP (note, 1);
1465 for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
1466 if (XEXP (link, 1) == note)
1468 XEXP (link, 1) = XEXP (note, 1);
1475 /* Search LISTP (an EXPR_LIST) for NODE and remove NODE from the list
1478 A simple equality test is used to determine if NODE is on the
1482 remove_node_from_expr_list (node, listp)
1487 rtx prev = NULL_RTX;
1491 if (node == XEXP (temp, 0))
1493 /* Splice the node out of the list. */
1495 XEXP (prev, 1) = XEXP (temp, 1);
1497 *listp = XEXP (temp, 1);
1501 temp = XEXP (temp, 1);
1505 /* Nonzero if X contains any volatile instructions. These are instructions
1506 which may cause unpredictable machine state instructions, and thus no
1507 instructions should be moved or combined across them. This includes
1508 only volatile asms and UNSPEC_VOLATILE instructions. */
1514 register RTX_CODE code;
1516 code = GET_CODE (x);
1536 case UNSPEC_VOLATILE:
1537 /* case TRAP_IF: This isn't clear yet. */
1541 if (MEM_VOLATILE_P (x))
1548 /* Recursively scan the operands of this expression. */
1551 register const char *fmt = GET_RTX_FORMAT (code);
1554 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
1558 if (volatile_insn_p (XEXP (x, i)))
1561 else if (fmt[i] == 'E')
1564 for (j = 0; j < XVECLEN (x, i); j++)
1565 if (volatile_insn_p (XVECEXP (x, i, j)))
1573 /* Nonzero if X contains any volatile memory references
1574 UNSPEC_VOLATILE operations or volatile ASM_OPERANDS expressions. */
1580 register RTX_CODE code;
1582 code = GET_CODE (x);
1601 case UNSPEC_VOLATILE:
1602 /* case TRAP_IF: This isn't clear yet. */
1607 if (MEM_VOLATILE_P (x))
1614 /* Recursively scan the operands of this expression. */
1617 register const char *fmt = GET_RTX_FORMAT (code);
1620 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
1624 if (volatile_refs_p (XEXP (x, i)))
1627 else if (fmt[i] == 'E')
1630 for (j = 0; j < XVECLEN (x, i); j++)
1631 if (volatile_refs_p (XVECEXP (x, i, j)))
1639 /* Similar to above, except that it also rejects register pre- and post-
1646 register RTX_CODE code;
1648 code = GET_CODE (x);
1666 /* Reject CLOBBER with a non-VOID mode. These are made by combine.c
1667 when some combination can't be done. If we see one, don't think
1668 that we can simplify the expression. */
1669 return (GET_MODE (x) != VOIDmode);
1676 case UNSPEC_VOLATILE:
1677 /* case TRAP_IF: This isn't clear yet. */
1682 if (MEM_VOLATILE_P (x))
1689 /* Recursively scan the operands of this expression. */
1692 register const char *fmt = GET_RTX_FORMAT (code);
1695 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
1699 if (side_effects_p (XEXP (x, i)))
1702 else if (fmt[i] == 'E')
1705 for (j = 0; j < XVECLEN (x, i); j++)
1706 if (side_effects_p (XVECEXP (x, i, j)))
1714 /* Return nonzero if evaluating rtx X might cause a trap. */
1726 code = GET_CODE (x);
1729 /* Handle these cases quickly. */
1741 /* Conditional trap can trap! */
1742 case UNSPEC_VOLATILE:
1746 /* Memory ref can trap unless it's a static var or a stack slot. */
1748 return rtx_addr_can_trap_p (XEXP (x, 0));
1750 /* Division by a non-constant might trap. */
1755 if (! CONSTANT_P (XEXP (x, 1))
1756 || GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT)
1758 /* This was const0_rtx, but by not using that,
1759 we can link this file into other programs. */
1760 if (GET_CODE (XEXP (x, 1)) == CONST_INT && INTVAL (XEXP (x, 1)) == 0)
1765 /* An EXPR_LIST is used to represent a function call. This
1766 certainly may trap. */
1770 /* Any floating arithmetic may trap. */
1771 if (GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT)
1775 fmt = GET_RTX_FORMAT (code);
1776 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
1780 if (may_trap_p (XEXP (x, i)))
1783 else if (fmt[i] == 'E')
1786 for (j = 0; j < XVECLEN (x, i); j++)
1787 if (may_trap_p (XVECEXP (x, i, j)))
1794 /* Return nonzero if X contains a comparison that is not either EQ or NE,
1795 i.e., an inequality. */
1798 inequality_comparisons_p (x)
1801 register const char *fmt;
1802 register int len, i;
1803 register enum rtx_code code = GET_CODE (x);
1832 len = GET_RTX_LENGTH (code);
1833 fmt = GET_RTX_FORMAT (code);
1835 for (i = 0; i < len; i++)
1839 if (inequality_comparisons_p (XEXP (x, i)))
1842 else if (fmt[i] == 'E')
1845 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
1846 if (inequality_comparisons_p (XVECEXP (x, i, j)))
1854 /* Replace any occurrence of FROM in X with TO. The function does
1855 not enter into CONST_DOUBLE for the replace.
1857 Note that copying is not done so X must not be shared unless all copies
1858 are to be modified. */
1861 replace_rtx (x, from, to)
1865 register const char *fmt;
1867 /* The following prevents loops occurrence when we change MEM in
1868 CONST_DOUBLE onto the same CONST_DOUBLE. */
1869 if (x != 0 && GET_CODE (x) == CONST_DOUBLE)
1875 /* Allow this function to make replacements in EXPR_LISTs. */
1879 fmt = GET_RTX_FORMAT (GET_CODE (x));
1880 for (i = GET_RTX_LENGTH (GET_CODE (x)) - 1; i >= 0; i--)
1883 XEXP (x, i) = replace_rtx (XEXP (x, i), from, to);
1884 else if (fmt[i] == 'E')
1885 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
1886 XVECEXP (x, i, j) = replace_rtx (XVECEXP (x, i, j), from, to);
1892 /* Throughout the rtx X, replace many registers according to REG_MAP.
1893 Return the replacement for X (which may be X with altered contents).
1894 REG_MAP[R] is the replacement for register R, or 0 for don't replace.
1895 NREGS is the length of REG_MAP; regs >= NREGS are not mapped.
1897 We only support REG_MAP entries of REG or SUBREG. Also, hard registers
1898 should not be mapped to pseudos or vice versa since validate_change
1901 If REPLACE_DEST is 1, replacements are also done in destinations;
1902 otherwise, only sources are replaced. */
1905 replace_regs (x, reg_map, nregs, replace_dest)
1911 register enum rtx_code code;
1913 register const char *fmt;
1918 code = GET_CODE (x);
1932 /* Verify that the register has an entry before trying to access it. */
1933 if (REGNO (x) < nregs && reg_map[REGNO (x)] != 0)
1935 /* SUBREGs can't be shared. Always return a copy to ensure that if
1936 this replacement occurs more than once then each instance will
1937 get distinct rtx. */
1938 if (GET_CODE (reg_map[REGNO (x)]) == SUBREG)
1939 return copy_rtx (reg_map[REGNO (x)]);
1940 return reg_map[REGNO (x)];
1945 /* Prevent making nested SUBREGs. */
1946 if (GET_CODE (SUBREG_REG (x)) == REG && REGNO (SUBREG_REG (x)) < nregs
1947 && reg_map[REGNO (SUBREG_REG (x))] != 0
1948 && GET_CODE (reg_map[REGNO (SUBREG_REG (x))]) == SUBREG)
1950 rtx map_val = reg_map[REGNO (SUBREG_REG (x))];
1951 rtx map_inner = SUBREG_REG (map_val);
1953 if (GET_MODE (x) == GET_MODE (map_inner))
1957 /* We cannot call gen_rtx here since we may be linked with
1959 /* Let's try clobbering the incoming SUBREG and see
1960 if this is really safe. */
1961 SUBREG_REG (x) = map_inner;
1962 SUBREG_WORD (x) += SUBREG_WORD (map_val);
1965 rtx new = rtx_alloc (SUBREG);
1966 PUT_MODE (new, GET_MODE (x));
1967 SUBREG_REG (new) = map_inner;
1968 SUBREG_WORD (new) = SUBREG_WORD (x) + SUBREG_WORD (map_val);
1976 SET_DEST (x) = replace_regs (SET_DEST (x), reg_map, nregs, 0);
1978 else if (GET_CODE (SET_DEST (x)) == MEM
1979 || GET_CODE (SET_DEST (x)) == STRICT_LOW_PART)
1980 /* Even if we are not to replace destinations, replace register if it
1981 is CONTAINED in destination (destination is memory or
1982 STRICT_LOW_PART). */
1983 XEXP (SET_DEST (x), 0) = replace_regs (XEXP (SET_DEST (x), 0),
1985 else if (GET_CODE (SET_DEST (x)) == ZERO_EXTRACT)
1986 /* Similarly, for ZERO_EXTRACT we replace all operands. */
1989 SET_SRC (x) = replace_regs (SET_SRC (x), reg_map, nregs, 0);
1996 fmt = GET_RTX_FORMAT (code);
1997 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
2000 XEXP (x, i) = replace_regs (XEXP (x, i), reg_map, nregs, replace_dest);
2001 else if (fmt[i] == 'E')
2004 for (j = 0; j < XVECLEN (x, i); j++)
2005 XVECEXP (x, i, j) = replace_regs (XVECEXP (x, i, j), reg_map,
2006 nregs, replace_dest);
2012 /* Return 1 if X, the SRC_SRC of SET of (pc) contain a REG or MEM that is
2013 not in the constant pool and not in the condition of an IF_THEN_ELSE. */
2016 jmp_uses_reg_or_mem (x)
2019 enum rtx_code code = GET_CODE (x);
2034 return ! (GET_CODE (XEXP (x, 0)) == SYMBOL_REF
2035 && CONSTANT_POOL_ADDRESS_P (XEXP (x, 0)));
2038 return (jmp_uses_reg_or_mem (XEXP (x, 1))
2039 || jmp_uses_reg_or_mem (XEXP (x, 2)));
2041 case PLUS: case MINUS: case MULT:
2042 return (jmp_uses_reg_or_mem (XEXP (x, 0))
2043 || jmp_uses_reg_or_mem (XEXP (x, 1)));
2049 fmt = GET_RTX_FORMAT (code);
2050 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
2053 && jmp_uses_reg_or_mem (XEXP (x, i)))
2056 else if (fmt[i] == 'E')
2057 for (j = 0; j < XVECLEN (x, i); j++)
2058 if (jmp_uses_reg_or_mem (XVECEXP (x, i, j)))
2065 /* Return nonzero if INSN is an indirect jump (aka computed jump).
2067 Tablejumps and casesi insns are not considered indirect jumps;
2068 we can recognize them by a (use (lael_ref)). */
2071 computed_jump_p (insn)
2075 if (GET_CODE (insn) == JUMP_INSN)
2077 rtx pat = PATTERN (insn);
2079 if (GET_CODE (pat) == PARALLEL)
2081 int len = XVECLEN (pat, 0);
2082 int has_use_labelref = 0;
2084 for (i = len - 1; i >= 0; i--)
2085 if (GET_CODE (XVECEXP (pat, 0, i)) == USE
2086 && (GET_CODE (XEXP (XVECEXP (pat, 0, i), 0))
2088 has_use_labelref = 1;
2090 if (! has_use_labelref)
2091 for (i = len - 1; i >= 0; i--)
2092 if (GET_CODE (XVECEXP (pat, 0, i)) == SET
2093 && SET_DEST (XVECEXP (pat, 0, i)) == pc_rtx
2094 && jmp_uses_reg_or_mem (SET_SRC (XVECEXP (pat, 0, i))))
2097 else if (GET_CODE (pat) == SET
2098 && SET_DEST (pat) == pc_rtx
2099 && jmp_uses_reg_or_mem (SET_SRC (pat)))
2105 /* Traverse X via depth-first search, calling F for each
2106 sub-expression (including X itself). F is also passed the DATA.
2107 If F returns -1, do not traverse sub-expressions, but continue
2108 traversing the rest of the tree. If F ever returns any other
2109 non-zero value, stop the traversal, and return the value returned
2110 by F. Otherwise, return 0. This function does not traverse inside
2111 tree structure that contains RTX_EXPRs, or into sub-expressions
2112 whose format code is `0' since it is not known whether or not those
2113 codes are actually RTL.
2115 This routine is very general, and could (should?) be used to
2116 implement many of the other routines in this file. */
2119 for_each_rtx (x, f, data)
2130 result = (*f)(x, data);
2132 /* Do not traverse sub-expressions. */
2134 else if (result != 0)
2135 /* Stop the traversal. */
2139 /* There are no sub-expressions. */
2142 length = GET_RTX_LENGTH (GET_CODE (*x));
2143 format = GET_RTX_FORMAT (GET_CODE (*x));
2145 for (i = 0; i < length; ++i)
2150 result = for_each_rtx (&XEXP (*x, i), f, data);
2157 if (XVEC (*x, i) != 0)
2160 for (j = 0; j < XVECLEN (*x, i); ++j)
2162 result = for_each_rtx (&XVECEXP (*x, i, j), f, data);
2170 /* Nothing to do. */
2179 /* Searches X for any reference to REGNO, returning the rtx of the
2180 reference found if any. Otherwise, returns NULL_RTX. */
2183 regno_use_in (regno, x)
2187 register const char *fmt;
2191 if (GET_CODE (x) == REG && REGNO (x) == regno)
2194 fmt = GET_RTX_FORMAT (GET_CODE (x));
2195 for (i = GET_RTX_LENGTH (GET_CODE (x)) - 1; i >= 0; i--)
2199 if ((tem = regno_use_in (regno, XEXP (x, i))))
2202 else if (fmt[i] == 'E')
2203 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
2204 if ((tem = regno_use_in (regno , XVECEXP (x, i, j))))
2212 /* Return 1 if X is an autoincrement side effect and the register is
2213 not the stack pointer. */
2218 switch (GET_CODE (x))
2226 /* There are no REG_INC notes for SP. */
2227 if (XEXP (x, 0) != stack_pointer_rtx)
2235 /* Return 1 if the sequence of instructions beginning with FROM and up
2236 to and including TO is safe to move. If NEW_TO is non-NULL, and
2237 the sequence is not already safe to move, but can be easily
2238 extended to a sequence which is safe, then NEW_TO will point to the
2239 end of the extended sequence.
2241 For now, this function only checks that the region contains whole
2242 exception regiongs, but it could be extended to check additional
2243 conditions as well. */
2246 insns_safe_to_move_p (from, to, new_to)
2251 int eh_region_count = 0;
2255 /* By default, assume the end of the region will be what was
2262 if (GET_CODE (r) == NOTE)
2264 switch (NOTE_LINE_NUMBER (r))
2266 case NOTE_INSN_EH_REGION_BEG:
2270 case NOTE_INSN_EH_REGION_END:
2271 if (eh_region_count == 0)
2272 /* This sequence of instructions contains the end of
2273 an exception region, but not he beginning. Moving
2274 it will cause chaos. */
2285 /* If we've passed TO, and we see a non-note instruction, we
2286 can't extend the sequence to a movable sequence. */
2292 /* It's OK to move the sequence if there were matched sets of
2293 exception region notes. */
2294 return eh_region_count == 0;
2299 /* It's OK to move the sequence if there were matched sets of
2300 exception region notes. */
2301 if (past_to_p && eh_region_count == 0)
2307 /* Go to the next instruction. */