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);
998 /* Check for a NULL entry, used to indicate that the parameter goes
999 both on the stack and in registers. */
1000 if (XEXP (XVECEXP (x, 0, 0), 0))
1005 /* If any register in here refers to it we return true. */
1006 for (n = XVECLEN (x, 0); i < n; ++i)
1007 if (reg_overlap_mentioned_p (XEXP (XVECEXP (x, 0, i), 0), in))
1019 /* Used for communications between the next few functions. */
1021 static int reg_set_last_unknown;
1022 static rtx reg_set_last_value;
1023 static unsigned int reg_set_last_first_regno, reg_set_last_last_regno;
1025 /* Called via note_stores from reg_set_last. */
1028 reg_set_last_1 (x, pat, data)
1031 void *data ATTRIBUTE_UNUSED;
1033 unsigned int first, last;
1035 /* If X is not a register, or is not one in the range we care
1037 if (GET_CODE (x) != REG)
1041 last = first + (first < FIRST_PSEUDO_REGISTER
1042 ? HARD_REGNO_NREGS (first, GET_MODE (x)) : 1);
1044 if (first >= reg_set_last_last_regno
1045 || last <= reg_set_last_first_regno)
1048 /* If this is a CLOBBER or is some complex LHS, or doesn't modify
1049 exactly the registers we care about, show we don't know the value. */
1050 if (GET_CODE (pat) == CLOBBER || SET_DEST (pat) != x
1051 || first != reg_set_last_first_regno
1052 || last != reg_set_last_last_regno)
1053 reg_set_last_unknown = 1;
1055 reg_set_last_value = SET_SRC (pat);
1058 /* Return the last value to which REG was set prior to INSN. If we can't
1059 find it easily, return 0.
1061 We only return a REG, SUBREG, or constant because it is too hard to
1062 check if a MEM remains unchanged. */
1065 reg_set_last (x, insn)
1069 rtx orig_insn = insn;
1071 reg_set_last_first_regno = REGNO (x);
1073 reg_set_last_last_regno
1074 = reg_set_last_first_regno
1075 + (reg_set_last_first_regno < FIRST_PSEUDO_REGISTER
1076 ? HARD_REGNO_NREGS (reg_set_last_first_regno, GET_MODE (x)) : 1);
1078 reg_set_last_unknown = 0;
1079 reg_set_last_value = 0;
1081 /* Scan backwards until reg_set_last_1 changed one of the above flags.
1082 Stop when we reach a label or X is a hard reg and we reach a
1083 CALL_INSN (if reg_set_last_last_regno is a hard reg).
1085 If we find a set of X, ensure that its SET_SRC remains unchanged. */
1087 /* We compare with <= here, because reg_set_last_last_regno
1088 is actually the number of the first reg *not* in X. */
1090 insn && GET_CODE (insn) != CODE_LABEL
1091 && ! (GET_CODE (insn) == CALL_INSN
1092 && reg_set_last_last_regno <= FIRST_PSEUDO_REGISTER);
1093 insn = PREV_INSN (insn))
1094 if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
1096 note_stores (PATTERN (insn), reg_set_last_1, NULL);
1097 if (reg_set_last_unknown)
1099 else if (reg_set_last_value)
1101 if (CONSTANT_P (reg_set_last_value)
1102 || ((GET_CODE (reg_set_last_value) == REG
1103 || GET_CODE (reg_set_last_value) == SUBREG)
1104 && ! reg_set_between_p (reg_set_last_value,
1106 return reg_set_last_value;
1115 /* Call FUN on each register or MEM that is stored into or clobbered by X.
1116 (X would be the pattern of an insn).
1117 FUN receives two arguments:
1118 the REG, MEM, CC0 or PC being stored in or clobbered,
1119 the SET or CLOBBER rtx that does the store.
1121 If the item being stored in or clobbered is a SUBREG of a hard register,
1122 the SUBREG will be passed. */
1125 note_stores (x, fun, data)
1127 void (*fun) PARAMS ((rtx, rtx, void *));
1130 if (GET_CODE (x) == COND_EXEC)
1131 x = COND_EXEC_CODE (x);
1132 if (GET_CODE (x) == SET || GET_CODE (x) == CLOBBER)
1134 register rtx dest = SET_DEST (x);
1135 while ((GET_CODE (dest) == SUBREG
1136 && (GET_CODE (SUBREG_REG (dest)) != REG
1137 || REGNO (SUBREG_REG (dest)) >= FIRST_PSEUDO_REGISTER))
1138 || GET_CODE (dest) == ZERO_EXTRACT
1139 || GET_CODE (dest) == SIGN_EXTRACT
1140 || GET_CODE (dest) == STRICT_LOW_PART)
1141 dest = XEXP (dest, 0);
1143 if (GET_CODE (dest) == PARALLEL
1144 && GET_MODE (dest) == BLKmode)
1147 for (i = XVECLEN (dest, 0) - 1; i >= 0; i--)
1148 (*fun) (SET_DEST (XVECEXP (dest, 0, i)), x, data);
1151 (*fun) (dest, x, data);
1153 else if (GET_CODE (x) == PARALLEL)
1156 for (i = XVECLEN (x, 0) - 1; i >= 0; i--)
1158 register rtx y = XVECEXP (x, 0, i);
1159 if (GET_CODE (y) == COND_EXEC)
1160 y = COND_EXEC_CODE (y);
1161 if (GET_CODE (y) == SET || GET_CODE (y) == CLOBBER)
1163 register rtx dest = SET_DEST (y);
1164 while ((GET_CODE (dest) == SUBREG
1165 && (GET_CODE (SUBREG_REG (dest)) != REG
1166 || (REGNO (SUBREG_REG (dest))
1167 >= FIRST_PSEUDO_REGISTER)))
1168 || GET_CODE (dest) == ZERO_EXTRACT
1169 || GET_CODE (dest) == SIGN_EXTRACT
1170 || GET_CODE (dest) == STRICT_LOW_PART)
1171 dest = XEXP (dest, 0);
1172 if (GET_CODE (dest) == PARALLEL
1173 && GET_MODE (dest) == BLKmode)
1177 for (i = XVECLEN (dest, 0) - 1; i >= 0; i--)
1178 (*fun) (SET_DEST (XVECEXP (dest, 0, i)), y, data);
1181 (*fun) (dest, y, data);
1187 /* Return nonzero if X's old contents don't survive after INSN.
1188 This will be true if X is (cc0) or if X is a register and
1189 X dies in INSN or because INSN entirely sets X.
1191 "Entirely set" means set directly and not through a SUBREG,
1192 ZERO_EXTRACT or SIGN_EXTRACT, so no trace of the old contents remains.
1193 Likewise, REG_INC does not count.
1195 REG may be a hard or pseudo reg. Renumbering is not taken into account,
1196 but for this use that makes no difference, since regs don't overlap
1197 during their lifetimes. Therefore, this function may be used
1198 at any time after deaths have been computed (in flow.c).
1200 If REG is a hard reg that occupies multiple machine registers, this
1201 function will only return 1 if each of those registers will be replaced
1205 dead_or_set_p (insn, x)
1209 unsigned int regno, last_regno;
1212 /* Can't use cc0_rtx below since this file is used by genattrtab.c. */
1213 if (GET_CODE (x) == CC0)
1216 if (GET_CODE (x) != REG)
1220 last_regno = (regno >= FIRST_PSEUDO_REGISTER ? regno
1221 : regno + HARD_REGNO_NREGS (regno, GET_MODE (x)) - 1);
1223 for (i = regno; i <= last_regno; i++)
1224 if (! dead_or_set_regno_p (insn, i))
1230 /* Utility function for dead_or_set_p to check an individual register. Also
1231 called from flow.c. */
1234 dead_or_set_regno_p (insn, test_regno)
1236 unsigned int test_regno;
1238 unsigned int regno, endregno;
1241 /* See if there is a death note for something that includes TEST_REGNO. */
1242 if (find_regno_note (insn, REG_DEAD, test_regno))
1245 if (GET_CODE (insn) == CALL_INSN
1246 && find_regno_fusage (insn, CLOBBER, test_regno))
1249 pattern = PATTERN (insn);
1251 if (GET_CODE (pattern) == COND_EXEC)
1252 pattern = COND_EXEC_CODE (pattern);
1254 if (GET_CODE (pattern) == SET)
1256 rtx dest = SET_DEST (PATTERN (insn));
1258 /* A value is totally replaced if it is the destination or the
1259 destination is a SUBREG of REGNO that does not change the number of
1261 if (GET_CODE (dest) == SUBREG
1262 && (((GET_MODE_SIZE (GET_MODE (dest))
1263 + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
1264 == ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (dest)))
1265 + UNITS_PER_WORD - 1) / UNITS_PER_WORD)))
1266 dest = SUBREG_REG (dest);
1268 if (GET_CODE (dest) != REG)
1271 regno = REGNO (dest);
1272 endregno = (regno >= FIRST_PSEUDO_REGISTER ? regno + 1
1273 : regno + HARD_REGNO_NREGS (regno, GET_MODE (dest)));
1275 return (test_regno >= regno && test_regno < endregno);
1277 else if (GET_CODE (pattern) == PARALLEL)
1281 for (i = XVECLEN (pattern, 0) - 1; i >= 0; i--)
1283 rtx body = XVECEXP (pattern, 0, i);
1285 if (GET_CODE (body) == COND_EXEC)
1286 body = COND_EXEC_CODE (body);
1288 if (GET_CODE (body) == SET || GET_CODE (body) == CLOBBER)
1290 rtx dest = SET_DEST (body);
1292 if (GET_CODE (dest) == SUBREG
1293 && (((GET_MODE_SIZE (GET_MODE (dest))
1294 + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
1295 == ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (dest)))
1296 + UNITS_PER_WORD - 1) / UNITS_PER_WORD)))
1297 dest = SUBREG_REG (dest);
1299 if (GET_CODE (dest) != REG)
1302 regno = REGNO (dest);
1303 endregno = (regno >= FIRST_PSEUDO_REGISTER ? regno + 1
1304 : regno + HARD_REGNO_NREGS (regno, GET_MODE (dest)));
1306 if (test_regno >= regno && test_regno < endregno)
1315 /* Return the reg-note of kind KIND in insn INSN, if there is one.
1316 If DATUM is nonzero, look for one whose datum is DATUM. */
1319 find_reg_note (insn, kind, datum)
1326 /* Ignore anything that is not an INSN, JUMP_INSN or CALL_INSN. */
1327 if (GET_RTX_CLASS (GET_CODE (insn)) != 'i')
1330 for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
1331 if (REG_NOTE_KIND (link) == kind
1332 && (datum == 0 || datum == XEXP (link, 0)))
1337 /* Return the reg-note of kind KIND in insn INSN which applies to register
1338 number REGNO, if any. Return 0 if there is no such reg-note. Note that
1339 the REGNO of this NOTE need not be REGNO if REGNO is a hard register;
1340 it might be the case that the note overlaps REGNO. */
1343 find_regno_note (insn, kind, regno)
1350 /* Ignore anything that is not an INSN, JUMP_INSN or CALL_INSN. */
1351 if (GET_RTX_CLASS (GET_CODE (insn)) != 'i')
1354 for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
1355 if (REG_NOTE_KIND (link) == kind
1356 /* Verify that it is a register, so that scratch and MEM won't cause a
1358 && GET_CODE (XEXP (link, 0)) == REG
1359 && REGNO (XEXP (link, 0)) <= regno
1360 && ((REGNO (XEXP (link, 0))
1361 + (REGNO (XEXP (link, 0)) >= FIRST_PSEUDO_REGISTER ? 1
1362 : HARD_REGNO_NREGS (REGNO (XEXP (link, 0)),
1363 GET_MODE (XEXP (link, 0)))))
1369 /* Return true if DATUM, or any overlap of DATUM, of kind CODE is found
1370 in the CALL_INSN_FUNCTION_USAGE information of INSN. */
1373 find_reg_fusage (insn, code, datum)
1378 /* If it's not a CALL_INSN, it can't possibly have a
1379 CALL_INSN_FUNCTION_USAGE field, so don't bother checking. */
1380 if (GET_CODE (insn) != CALL_INSN)
1386 if (GET_CODE (datum) != REG)
1390 for (link = CALL_INSN_FUNCTION_USAGE (insn);
1392 link = XEXP (link, 1))
1393 if (GET_CODE (XEXP (link, 0)) == code
1394 && rtx_equal_p (datum, SET_DEST (XEXP (link, 0))))
1399 unsigned int regno = REGNO (datum);
1401 /* CALL_INSN_FUNCTION_USAGE information cannot contain references
1402 to pseudo registers, so don't bother checking. */
1404 if (regno < FIRST_PSEUDO_REGISTER)
1406 unsigned int end_regno
1407 = regno + HARD_REGNO_NREGS (regno, GET_MODE (datum));
1410 for (i = regno; i < end_regno; i++)
1411 if (find_regno_fusage (insn, code, i))
1419 /* Return true if REGNO, or any overlap of REGNO, of kind CODE is found
1420 in the CALL_INSN_FUNCTION_USAGE information of INSN. */
1423 find_regno_fusage (insn, code, regno)
1430 /* CALL_INSN_FUNCTION_USAGE information cannot contain references
1431 to pseudo registers, so don't bother checking. */
1433 if (regno >= FIRST_PSEUDO_REGISTER
1434 || GET_CODE (insn) != CALL_INSN )
1437 for (link = CALL_INSN_FUNCTION_USAGE (insn); link; link = XEXP (link, 1))
1439 unsigned int regnote;
1442 if (GET_CODE (op = XEXP (link, 0)) == code
1443 && GET_CODE (reg = XEXP (op, 0)) == REG
1444 && (regnote = REGNO (reg)) <= regno
1445 && regnote + HARD_REGNO_NREGS (regnote, GET_MODE (reg)) > regno)
1452 /* Remove register note NOTE from the REG_NOTES of INSN. */
1455 remove_note (insn, note)
1461 if (note == NULL_RTX)
1464 if (REG_NOTES (insn) == note)
1466 REG_NOTES (insn) = XEXP (note, 1);
1470 for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
1471 if (XEXP (link, 1) == note)
1473 XEXP (link, 1) = XEXP (note, 1);
1480 /* Search LISTP (an EXPR_LIST) for NODE and remove NODE from the list
1483 A simple equality test is used to determine if NODE is on the
1487 remove_node_from_expr_list (node, listp)
1492 rtx prev = NULL_RTX;
1496 if (node == XEXP (temp, 0))
1498 /* Splice the node out of the list. */
1500 XEXP (prev, 1) = XEXP (temp, 1);
1502 *listp = XEXP (temp, 1);
1506 temp = XEXP (temp, 1);
1510 /* Nonzero if X contains any volatile instructions. These are instructions
1511 which may cause unpredictable machine state instructions, and thus no
1512 instructions should be moved or combined across them. This includes
1513 only volatile asms and UNSPEC_VOLATILE instructions. */
1519 register RTX_CODE code;
1521 code = GET_CODE (x);
1541 case UNSPEC_VOLATILE:
1542 /* case TRAP_IF: This isn't clear yet. */
1546 if (MEM_VOLATILE_P (x))
1553 /* Recursively scan the operands of this expression. */
1556 register const char *fmt = GET_RTX_FORMAT (code);
1559 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
1563 if (volatile_insn_p (XEXP (x, i)))
1566 else if (fmt[i] == 'E')
1569 for (j = 0; j < XVECLEN (x, i); j++)
1570 if (volatile_insn_p (XVECEXP (x, i, j)))
1578 /* Nonzero if X contains any volatile memory references
1579 UNSPEC_VOLATILE operations or volatile ASM_OPERANDS expressions. */
1585 register RTX_CODE code;
1587 code = GET_CODE (x);
1606 case UNSPEC_VOLATILE:
1607 /* case TRAP_IF: This isn't clear yet. */
1612 if (MEM_VOLATILE_P (x))
1619 /* Recursively scan the operands of this expression. */
1622 register const char *fmt = GET_RTX_FORMAT (code);
1625 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
1629 if (volatile_refs_p (XEXP (x, i)))
1632 else if (fmt[i] == 'E')
1635 for (j = 0; j < XVECLEN (x, i); j++)
1636 if (volatile_refs_p (XVECEXP (x, i, j)))
1644 /* Similar to above, except that it also rejects register pre- and post-
1651 register RTX_CODE code;
1653 code = GET_CODE (x);
1671 /* Reject CLOBBER with a non-VOID mode. These are made by combine.c
1672 when some combination can't be done. If we see one, don't think
1673 that we can simplify the expression. */
1674 return (GET_MODE (x) != VOIDmode);
1681 case UNSPEC_VOLATILE:
1682 /* case TRAP_IF: This isn't clear yet. */
1687 if (MEM_VOLATILE_P (x))
1694 /* Recursively scan the operands of this expression. */
1697 register const char *fmt = GET_RTX_FORMAT (code);
1700 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
1704 if (side_effects_p (XEXP (x, i)))
1707 else if (fmt[i] == 'E')
1710 for (j = 0; j < XVECLEN (x, i); j++)
1711 if (side_effects_p (XVECEXP (x, i, j)))
1719 /* Return nonzero if evaluating rtx X might cause a trap. */
1731 code = GET_CODE (x);
1734 /* Handle these cases quickly. */
1746 /* Conditional trap can trap! */
1747 case UNSPEC_VOLATILE:
1751 /* Memory ref can trap unless it's a static var or a stack slot. */
1753 return rtx_addr_can_trap_p (XEXP (x, 0));
1755 /* Division by a non-constant might trap. */
1760 if (! CONSTANT_P (XEXP (x, 1))
1761 || GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT)
1763 /* This was const0_rtx, but by not using that,
1764 we can link this file into other programs. */
1765 if (GET_CODE (XEXP (x, 1)) == CONST_INT && INTVAL (XEXP (x, 1)) == 0)
1770 /* An EXPR_LIST is used to represent a function call. This
1771 certainly may trap. */
1775 /* Any floating arithmetic may trap. */
1776 if (GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT)
1780 fmt = GET_RTX_FORMAT (code);
1781 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
1785 if (may_trap_p (XEXP (x, i)))
1788 else if (fmt[i] == 'E')
1791 for (j = 0; j < XVECLEN (x, i); j++)
1792 if (may_trap_p (XVECEXP (x, i, j)))
1799 /* Return nonzero if X contains a comparison that is not either EQ or NE,
1800 i.e., an inequality. */
1803 inequality_comparisons_p (x)
1806 register const char *fmt;
1807 register int len, i;
1808 register enum rtx_code code = GET_CODE (x);
1837 len = GET_RTX_LENGTH (code);
1838 fmt = GET_RTX_FORMAT (code);
1840 for (i = 0; i < len; i++)
1844 if (inequality_comparisons_p (XEXP (x, i)))
1847 else if (fmt[i] == 'E')
1850 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
1851 if (inequality_comparisons_p (XVECEXP (x, i, j)))
1859 /* Replace any occurrence of FROM in X with TO. The function does
1860 not enter into CONST_DOUBLE for the replace.
1862 Note that copying is not done so X must not be shared unless all copies
1863 are to be modified. */
1866 replace_rtx (x, from, to)
1870 register const char *fmt;
1872 /* The following prevents loops occurrence when we change MEM in
1873 CONST_DOUBLE onto the same CONST_DOUBLE. */
1874 if (x != 0 && GET_CODE (x) == CONST_DOUBLE)
1880 /* Allow this function to make replacements in EXPR_LISTs. */
1884 fmt = GET_RTX_FORMAT (GET_CODE (x));
1885 for (i = GET_RTX_LENGTH (GET_CODE (x)) - 1; i >= 0; i--)
1888 XEXP (x, i) = replace_rtx (XEXP (x, i), from, to);
1889 else if (fmt[i] == 'E')
1890 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
1891 XVECEXP (x, i, j) = replace_rtx (XVECEXP (x, i, j), from, to);
1897 /* Throughout the rtx X, replace many registers according to REG_MAP.
1898 Return the replacement for X (which may be X with altered contents).
1899 REG_MAP[R] is the replacement for register R, or 0 for don't replace.
1900 NREGS is the length of REG_MAP; regs >= NREGS are not mapped.
1902 We only support REG_MAP entries of REG or SUBREG. Also, hard registers
1903 should not be mapped to pseudos or vice versa since validate_change
1906 If REPLACE_DEST is 1, replacements are also done in destinations;
1907 otherwise, only sources are replaced. */
1910 replace_regs (x, reg_map, nregs, replace_dest)
1916 register enum rtx_code code;
1918 register const char *fmt;
1923 code = GET_CODE (x);
1937 /* Verify that the register has an entry before trying to access it. */
1938 if (REGNO (x) < nregs && reg_map[REGNO (x)] != 0)
1940 /* SUBREGs can't be shared. Always return a copy to ensure that if
1941 this replacement occurs more than once then each instance will
1942 get distinct rtx. */
1943 if (GET_CODE (reg_map[REGNO (x)]) == SUBREG)
1944 return copy_rtx (reg_map[REGNO (x)]);
1945 return reg_map[REGNO (x)];
1950 /* Prevent making nested SUBREGs. */
1951 if (GET_CODE (SUBREG_REG (x)) == REG && REGNO (SUBREG_REG (x)) < nregs
1952 && reg_map[REGNO (SUBREG_REG (x))] != 0
1953 && GET_CODE (reg_map[REGNO (SUBREG_REG (x))]) == SUBREG)
1955 rtx map_val = reg_map[REGNO (SUBREG_REG (x))];
1956 rtx map_inner = SUBREG_REG (map_val);
1958 if (GET_MODE (x) == GET_MODE (map_inner))
1962 /* We cannot call gen_rtx here since we may be linked with
1964 /* Let's try clobbering the incoming SUBREG and see
1965 if this is really safe. */
1966 SUBREG_REG (x) = map_inner;
1967 SUBREG_WORD (x) += SUBREG_WORD (map_val);
1970 rtx new = rtx_alloc (SUBREG);
1971 PUT_MODE (new, GET_MODE (x));
1972 SUBREG_REG (new) = map_inner;
1973 SUBREG_WORD (new) = SUBREG_WORD (x) + SUBREG_WORD (map_val);
1981 SET_DEST (x) = replace_regs (SET_DEST (x), reg_map, nregs, 0);
1983 else if (GET_CODE (SET_DEST (x)) == MEM
1984 || GET_CODE (SET_DEST (x)) == STRICT_LOW_PART)
1985 /* Even if we are not to replace destinations, replace register if it
1986 is CONTAINED in destination (destination is memory or
1987 STRICT_LOW_PART). */
1988 XEXP (SET_DEST (x), 0) = replace_regs (XEXP (SET_DEST (x), 0),
1990 else if (GET_CODE (SET_DEST (x)) == ZERO_EXTRACT)
1991 /* Similarly, for ZERO_EXTRACT we replace all operands. */
1994 SET_SRC (x) = replace_regs (SET_SRC (x), reg_map, nregs, 0);
2001 fmt = GET_RTX_FORMAT (code);
2002 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
2005 XEXP (x, i) = replace_regs (XEXP (x, i), reg_map, nregs, replace_dest);
2006 else if (fmt[i] == 'E')
2009 for (j = 0; j < XVECLEN (x, i); j++)
2010 XVECEXP (x, i, j) = replace_regs (XVECEXP (x, i, j), reg_map,
2011 nregs, replace_dest);
2017 /* Return 1 if X, the SRC_SRC of SET of (pc) contain a REG or MEM that is
2018 not in the constant pool and not in the condition of an IF_THEN_ELSE. */
2021 jmp_uses_reg_or_mem (x)
2024 enum rtx_code code = GET_CODE (x);
2039 return ! (GET_CODE (XEXP (x, 0)) == SYMBOL_REF
2040 && CONSTANT_POOL_ADDRESS_P (XEXP (x, 0)));
2043 return (jmp_uses_reg_or_mem (XEXP (x, 1))
2044 || jmp_uses_reg_or_mem (XEXP (x, 2)));
2046 case PLUS: case MINUS: case MULT:
2047 return (jmp_uses_reg_or_mem (XEXP (x, 0))
2048 || jmp_uses_reg_or_mem (XEXP (x, 1)));
2054 fmt = GET_RTX_FORMAT (code);
2055 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
2058 && jmp_uses_reg_or_mem (XEXP (x, i)))
2061 else if (fmt[i] == 'E')
2062 for (j = 0; j < XVECLEN (x, i); j++)
2063 if (jmp_uses_reg_or_mem (XVECEXP (x, i, j)))
2070 /* Return nonzero if INSN is an indirect jump (aka computed jump).
2072 Tablejumps and casesi insns are not considered indirect jumps;
2073 we can recognize them by a (use (lael_ref)). */
2076 computed_jump_p (insn)
2080 if (GET_CODE (insn) == JUMP_INSN)
2082 rtx pat = PATTERN (insn);
2084 if (GET_CODE (pat) == PARALLEL)
2086 int len = XVECLEN (pat, 0);
2087 int has_use_labelref = 0;
2089 for (i = len - 1; i >= 0; i--)
2090 if (GET_CODE (XVECEXP (pat, 0, i)) == USE
2091 && (GET_CODE (XEXP (XVECEXP (pat, 0, i), 0))
2093 has_use_labelref = 1;
2095 if (! has_use_labelref)
2096 for (i = len - 1; i >= 0; i--)
2097 if (GET_CODE (XVECEXP (pat, 0, i)) == SET
2098 && SET_DEST (XVECEXP (pat, 0, i)) == pc_rtx
2099 && jmp_uses_reg_or_mem (SET_SRC (XVECEXP (pat, 0, i))))
2102 else if (GET_CODE (pat) == SET
2103 && SET_DEST (pat) == pc_rtx
2104 && jmp_uses_reg_or_mem (SET_SRC (pat)))
2110 /* Traverse X via depth-first search, calling F for each
2111 sub-expression (including X itself). F is also passed the DATA.
2112 If F returns -1, do not traverse sub-expressions, but continue
2113 traversing the rest of the tree. If F ever returns any other
2114 non-zero value, stop the traversal, and return the value returned
2115 by F. Otherwise, return 0. This function does not traverse inside
2116 tree structure that contains RTX_EXPRs, or into sub-expressions
2117 whose format code is `0' since it is not known whether or not those
2118 codes are actually RTL.
2120 This routine is very general, and could (should?) be used to
2121 implement many of the other routines in this file. */
2124 for_each_rtx (x, f, data)
2135 result = (*f)(x, data);
2137 /* Do not traverse sub-expressions. */
2139 else if (result != 0)
2140 /* Stop the traversal. */
2144 /* There are no sub-expressions. */
2147 length = GET_RTX_LENGTH (GET_CODE (*x));
2148 format = GET_RTX_FORMAT (GET_CODE (*x));
2150 for (i = 0; i < length; ++i)
2155 result = for_each_rtx (&XEXP (*x, i), f, data);
2162 if (XVEC (*x, i) != 0)
2165 for (j = 0; j < XVECLEN (*x, i); ++j)
2167 result = for_each_rtx (&XVECEXP (*x, i, j), f, data);
2175 /* Nothing to do. */
2184 /* Searches X for any reference to REGNO, returning the rtx of the
2185 reference found if any. Otherwise, returns NULL_RTX. */
2188 regno_use_in (regno, x)
2192 register const char *fmt;
2196 if (GET_CODE (x) == REG && REGNO (x) == regno)
2199 fmt = GET_RTX_FORMAT (GET_CODE (x));
2200 for (i = GET_RTX_LENGTH (GET_CODE (x)) - 1; i >= 0; i--)
2204 if ((tem = regno_use_in (regno, XEXP (x, i))))
2207 else if (fmt[i] == 'E')
2208 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
2209 if ((tem = regno_use_in (regno , XVECEXP (x, i, j))))
2217 /* Return 1 if X is an autoincrement side effect and the register is
2218 not the stack pointer. */
2223 switch (GET_CODE (x))
2231 /* There are no REG_INC notes for SP. */
2232 if (XEXP (x, 0) != stack_pointer_rtx)
2240 /* Return 1 if the sequence of instructions beginning with FROM and up
2241 to and including TO is safe to move. If NEW_TO is non-NULL, and
2242 the sequence is not already safe to move, but can be easily
2243 extended to a sequence which is safe, then NEW_TO will point to the
2244 end of the extended sequence.
2246 For now, this function only checks that the region contains whole
2247 exception regiongs, but it could be extended to check additional
2248 conditions as well. */
2251 insns_safe_to_move_p (from, to, new_to)
2256 int eh_region_count = 0;
2260 /* By default, assume the end of the region will be what was
2267 if (GET_CODE (r) == NOTE)
2269 switch (NOTE_LINE_NUMBER (r))
2271 case NOTE_INSN_EH_REGION_BEG:
2275 case NOTE_INSN_EH_REGION_END:
2276 if (eh_region_count == 0)
2277 /* This sequence of instructions contains the end of
2278 an exception region, but not he beginning. Moving
2279 it will cause chaos. */
2290 /* If we've passed TO, and we see a non-note instruction, we
2291 can't extend the sequence to a movable sequence. */
2297 /* It's OK to move the sequence if there were matched sets of
2298 exception region notes. */
2299 return eh_region_count == 0;
2304 /* It's OK to move the sequence if there were matched sets of
2305 exception region notes. */
2306 if (past_to_p && eh_region_count == 0)
2312 /* Go to the next instruction. */