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 insn_dependent_p_1 PARAMS ((rtx, rtx, void *));
30 static void reg_set_last_1 PARAMS ((rtx, rtx, void *));
33 /* Forward declarations */
34 static int jmp_uses_reg_or_mem PARAMS ((rtx));
36 /* Bit flags that specify the machine subtype we are compiling for.
37 Bits are tested using macros TARGET_... defined in the tm.h file
38 and set by `-m...' switches. Must be defined in rtlanal.c. */
42 /* Return 1 if the value of X is unstable
43 (would be different at a different point in the program).
44 The frame pointer, arg pointer, etc. are considered stable
45 (within one function) and so is anything marked `unchanging'. */
51 register RTX_CODE code = GET_CODE (x);
53 register const char *fmt;
58 return ! RTX_UNCHANGING_P (x) || rtx_unstable_p (XEXP (x, 0));
71 /* As in rtx_varies_p, we have to use the actual rtx, not reg number. */
72 return ! (x == frame_pointer_rtx || x == hard_frame_pointer_rtx
73 || x == arg_pointer_rtx || x == pic_offset_table_rtx
74 || RTX_UNCHANGING_P (x));
77 if (MEM_VOLATILE_P (x))
86 fmt = GET_RTX_FORMAT (code);
87 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
90 if (rtx_unstable_p (XEXP (x, i)))
93 else if (fmt[i] == 'E')
96 for (j = 0; j < XVECLEN (x, i); j++)
97 if (rtx_unstable_p (XVECEXP (x, i, j)))
104 /* Return 1 if X has a value that can vary even between two
105 executions of the program. 0 means X can be compared reliably
106 against certain constants or near-constants.
107 The frame pointer and the arg pointer are considered constant. */
113 register RTX_CODE code = GET_CODE (x);
115 register const char *fmt;
120 return ! RTX_UNCHANGING_P (x) || rtx_varies_p (XEXP (x, 0));
133 /* Note that we have to test for the actual rtx used for the frame
134 and arg pointers and not just the register number in case we have
135 eliminated the frame and/or arg pointer and are using it
137 return ! (x == frame_pointer_rtx || x == hard_frame_pointer_rtx
138 || x == arg_pointer_rtx || x == pic_offset_table_rtx);
141 /* The operand 0 of a LO_SUM is considered constant
142 (in fact is it related specifically to operand 1). */
143 return rtx_varies_p (XEXP (x, 1));
146 if (MEM_VOLATILE_P (x))
155 fmt = GET_RTX_FORMAT (code);
156 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
159 if (rtx_varies_p (XEXP (x, i)))
162 else if (fmt[i] == 'E')
165 for (j = 0; j < XVECLEN (x, i); j++)
166 if (rtx_varies_p (XVECEXP (x, i, j)))
173 /* Return 0 if the use of X as an address in a MEM can cause a trap. */
176 rtx_addr_can_trap_p (x)
179 register enum rtx_code code = GET_CODE (x);
185 /* SYMBOL_REF is problematic due to the possible presence of
186 a #pragma weak, but to say that loads from symbols can trap is
187 *very* costly. It's not at all clear what's best here. For
188 now, we ignore the impact of #pragma weak. */
192 /* As in rtx_varies_p, we have to use the actual rtx, not reg number. */
193 return ! (x == frame_pointer_rtx || x == hard_frame_pointer_rtx
194 || x == stack_pointer_rtx || x == arg_pointer_rtx);
197 return rtx_addr_can_trap_p (XEXP (x, 0));
200 /* An address is assumed not to trap if it is an address that can't
201 trap plus a constant integer or it is the pic register plus a
203 return ! ((! rtx_addr_can_trap_p (XEXP (x, 0))
204 && GET_CODE (XEXP (x, 1)) == CONST_INT)
205 || (XEXP (x, 0) == pic_offset_table_rtx
206 && CONSTANT_P (XEXP (x, 1))));
209 return rtx_addr_can_trap_p (XEXP (x, 1));
215 /* If it isn't one of the case above, it can cause a trap. */
219 /* Return 1 if X refers to a memory location whose address
220 cannot be compared reliably with constant addresses,
221 or if X refers to a BLKmode memory object. */
224 rtx_addr_varies_p (x)
227 register enum rtx_code code;
229 register const char *fmt;
236 return GET_MODE (x) == BLKmode || rtx_varies_p (XEXP (x, 0));
238 fmt = GET_RTX_FORMAT (code);
239 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
242 if (rtx_addr_varies_p (XEXP (x, i)))
245 else if (fmt[i] == 'E')
248 for (j = 0; j < XVECLEN (x, i); j++)
249 if (rtx_addr_varies_p (XVECEXP (x, i, j)))
255 /* Return the value of the integer term in X, if one is apparent;
257 Only obvious integer terms are detected.
258 This is used in cse.c with the `related_value' field.*/
264 if (GET_CODE (x) == CONST)
267 if (GET_CODE (x) == MINUS
268 && GET_CODE (XEXP (x, 1)) == CONST_INT)
269 return - INTVAL (XEXP (x, 1));
270 if (GET_CODE (x) == PLUS
271 && GET_CODE (XEXP (x, 1)) == CONST_INT)
272 return INTVAL (XEXP (x, 1));
276 /* If X is a constant, return the value sans apparent integer term;
278 Only obvious integer terms are detected. */
281 get_related_value (x)
284 if (GET_CODE (x) != CONST)
287 if (GET_CODE (x) == PLUS
288 && GET_CODE (XEXP (x, 1)) == CONST_INT)
290 else if (GET_CODE (x) == MINUS
291 && GET_CODE (XEXP (x, 1)) == CONST_INT)
296 /* Return the number of places FIND appears within X. If COUNT_DEST is
297 zero, we do not count occurrences inside the destination of a SET. */
300 count_occurrences (x, find, count_dest)
306 const char *format_ptr;
326 if (GET_CODE (find) == MEM && rtx_equal_p (x, find))
331 if (SET_DEST (x) == find && ! count_dest)
332 return count_occurrences (SET_SRC (x), find, count_dest);
339 format_ptr = GET_RTX_FORMAT (code);
342 for (i = 0; i < GET_RTX_LENGTH (code); i++)
344 switch (*format_ptr++)
347 count += count_occurrences (XEXP (x, i), find, count_dest);
351 for (j = 0; j < XVECLEN (x, i); j++)
352 count += count_occurrences (XVECEXP (x, i, j), find, count_dest);
359 /* Nonzero if register REG appears somewhere within IN.
360 Also works if REG is not a register; in this case it checks
361 for a subexpression of IN that is Lisp "equal" to REG. */
364 reg_mentioned_p (reg, in)
365 register rtx reg, in;
367 register const char *fmt;
369 register enum rtx_code code;
377 if (GET_CODE (in) == LABEL_REF)
378 return reg == XEXP (in, 0);
380 code = GET_CODE (in);
384 /* Compare registers by number. */
386 return GET_CODE (reg) == REG && REGNO (in) == REGNO (reg);
388 /* These codes have no constituent expressions
396 return GET_CODE (reg) == CONST_INT && INTVAL (in) == INTVAL (reg);
399 /* These are kept unique for a given value. */
406 if (GET_CODE (reg) == code && rtx_equal_p (reg, in))
409 fmt = GET_RTX_FORMAT (code);
411 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
416 for (j = XVECLEN (in, i) - 1; j >= 0; j--)
417 if (reg_mentioned_p (reg, XVECEXP (in, i, j)))
420 else if (fmt[i] == 'e'
421 && reg_mentioned_p (reg, XEXP (in, i)))
427 /* Return 1 if in between BEG and END, exclusive of BEG and END, there is
428 no CODE_LABEL insn. */
431 no_labels_between_p (beg, end)
435 for (p = NEXT_INSN (beg); p != end; p = NEXT_INSN (p))
436 if (GET_CODE (p) == CODE_LABEL)
441 /* Return 1 if in between BEG and END, exclusive of BEG and END, there is
442 no JUMP_INSN insn. */
445 no_jumps_between_p (beg, end)
449 for (p = NEXT_INSN (beg); p != end; p = NEXT_INSN (p))
450 if (GET_CODE (p) == JUMP_INSN)
455 /* Nonzero if register REG is used in an insn between
456 FROM_INSN and TO_INSN (exclusive of those two). */
459 reg_used_between_p (reg, from_insn, to_insn)
460 rtx reg, from_insn, to_insn;
464 if (from_insn == to_insn)
467 for (insn = NEXT_INSN (from_insn); insn != to_insn; insn = NEXT_INSN (insn))
469 && (reg_overlap_mentioned_p (reg, PATTERN (insn))
470 || (GET_CODE (insn) == CALL_INSN
471 && (find_reg_fusage (insn, USE, reg)
472 || find_reg_fusage (insn, CLOBBER, reg)))))
477 /* Nonzero if the old value of X, a register, is referenced in BODY. If X
478 is entirely replaced by a new value and the only use is as a SET_DEST,
479 we do not consider it a reference. */
482 reg_referenced_p (x, body)
488 switch (GET_CODE (body))
491 if (reg_overlap_mentioned_p (x, SET_SRC (body)))
494 /* If the destination is anything other than CC0, PC, a REG or a SUBREG
495 of a REG that occupies all of the REG, the insn references X if
496 it is mentioned in the destination. */
497 if (GET_CODE (SET_DEST (body)) != CC0
498 && GET_CODE (SET_DEST (body)) != PC
499 && GET_CODE (SET_DEST (body)) != REG
500 && ! (GET_CODE (SET_DEST (body)) == SUBREG
501 && GET_CODE (SUBREG_REG (SET_DEST (body))) == REG
502 && (((GET_MODE_SIZE (GET_MODE (SUBREG_REG (SET_DEST (body))))
503 + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD)
504 == ((GET_MODE_SIZE (GET_MODE (SET_DEST (body)))
505 + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD)))
506 && reg_overlap_mentioned_p (x, SET_DEST (body)))
511 for (i = ASM_OPERANDS_INPUT_LENGTH (body) - 1; i >= 0; i--)
512 if (reg_overlap_mentioned_p (x, ASM_OPERANDS_INPUT (body, i)))
519 return reg_overlap_mentioned_p (x, body);
522 return reg_overlap_mentioned_p (x, TRAP_CONDITION (body));
525 case UNSPEC_VOLATILE:
526 for (i = XVECLEN (body, 0) - 1; i >= 0; i--)
527 if (reg_overlap_mentioned_p (x, XVECEXP (body, 0, i)))
532 for (i = XVECLEN (body, 0) - 1; i >= 0; i--)
533 if (reg_referenced_p (x, XVECEXP (body, 0, i)))
538 if (GET_CODE (XEXP (body, 0)) == MEM)
539 if (reg_overlap_mentioned_p (x, XEXP (XEXP (body, 0), 0)))
544 if (reg_overlap_mentioned_p (x, COND_EXEC_TEST (body)))
546 return reg_referenced_p (x, COND_EXEC_CODE (body));
553 /* Nonzero if register REG is referenced in an insn between
554 FROM_INSN and TO_INSN (exclusive of those two). Sets of REG do
558 reg_referenced_between_p (reg, from_insn, to_insn)
559 rtx reg, from_insn, to_insn;
563 if (from_insn == to_insn)
566 for (insn = NEXT_INSN (from_insn); insn != to_insn; insn = NEXT_INSN (insn))
568 && (reg_referenced_p (reg, PATTERN (insn))
569 || (GET_CODE (insn) == CALL_INSN
570 && find_reg_fusage (insn, USE, reg))))
575 /* Nonzero if register REG is set or clobbered in an insn between
576 FROM_INSN and TO_INSN (exclusive of those two). */
579 reg_set_between_p (reg, from_insn, to_insn)
580 rtx reg, from_insn, to_insn;
584 if (from_insn == to_insn)
587 for (insn = NEXT_INSN (from_insn); insn != to_insn; insn = NEXT_INSN (insn))
588 if (INSN_P (insn) && reg_set_p (reg, insn))
593 /* Internals of reg_set_between_p. */
595 static rtx reg_set_reg;
596 static int reg_set_flag;
599 reg_set_p_1 (x, pat, data)
601 rtx pat ATTRIBUTE_UNUSED;
602 void *data ATTRIBUTE_UNUSED;
604 /* We don't want to return 1 if X is a MEM that contains a register
605 within REG_SET_REG. */
607 if ((GET_CODE (x) != MEM)
608 && reg_overlap_mentioned_p (reg_set_reg, x))
613 reg_set_p (reg, insn)
618 /* We can be passed an insn or part of one. If we are passed an insn,
619 check if a side-effect of the insn clobbers REG. */
622 if (FIND_REG_INC_NOTE (insn, reg)
623 || (GET_CODE (insn) == CALL_INSN
624 /* We'd like to test call_used_regs here, but rtlanal.c can't
625 reference that variable due to its use in genattrtab. So
626 we'll just be more conservative.
628 ??? Unless we could ensure that the CALL_INSN_FUNCTION_USAGE
629 information holds all clobbered registers. */
630 && ((GET_CODE (reg) == REG
631 && REGNO (reg) < FIRST_PSEUDO_REGISTER)
632 || GET_CODE (reg) == MEM
633 || find_reg_fusage (insn, CLOBBER, reg))))
636 body = PATTERN (insn);
641 note_stores (body, reg_set_p_1, NULL);
645 /* Similar to reg_set_between_p, but check all registers in X. Return 0
646 only if none of them are modified between START and END. Do not
647 consider non-registers one way or the other. */
650 regs_set_between_p (x, start, end)
654 enum rtx_code code = GET_CODE (x);
670 return reg_set_between_p (x, start, end);
676 fmt = GET_RTX_FORMAT (code);
677 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
679 if (fmt[i] == 'e' && regs_set_between_p (XEXP (x, i), start, end))
682 else if (fmt[i] == 'E')
683 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
684 if (regs_set_between_p (XVECEXP (x, i, j), start, end))
691 /* Similar to reg_set_between_p, but check all registers in X. Return 0
692 only if none of them are modified between START and END. Return 1 if
693 X contains a MEM; this routine does not perform any memory aliasing. */
696 modified_between_p (x, start, end)
700 enum rtx_code code = GET_CODE (x);
718 /* If the memory is not constant, assume it is modified. If it is
719 constant, we still have to check the address. */
720 if (! RTX_UNCHANGING_P (x))
725 return reg_set_between_p (x, start, end);
731 fmt = GET_RTX_FORMAT (code);
732 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
734 if (fmt[i] == 'e' && modified_between_p (XEXP (x, i), start, end))
737 else if (fmt[i] == 'E')
738 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
739 if (modified_between_p (XVECEXP (x, i, j), start, end))
746 /* Similar to reg_set_p, but check all registers in X. Return 0 only if none
747 of them are modified in INSN. Return 1 if X contains a MEM; this routine
748 does not perform any memory aliasing. */
751 modified_in_p (x, insn)
755 enum rtx_code code = GET_CODE (x);
773 /* If the memory is not constant, assume it is modified. If it is
774 constant, we still have to check the address. */
775 if (! RTX_UNCHANGING_P (x))
780 return reg_set_p (x, insn);
786 fmt = GET_RTX_FORMAT (code);
787 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
789 if (fmt[i] == 'e' && modified_in_p (XEXP (x, i), insn))
792 else if (fmt[i] == 'E')
793 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
794 if (modified_in_p (XVECEXP (x, i, j), insn))
801 /* Return true if anything in insn X is (anti,output,true) dependent on
802 anything in insn Y. */
805 insn_dependent_p (x, y)
810 if (! INSN_P (x) || ! INSN_P (y))
814 note_stores (PATTERN (x), insn_dependent_p_1, &tmp);
819 note_stores (PATTERN (y), insn_dependent_p_1, &tmp);
826 /* A helper routine for insn_dependent_p called through note_stores. */
829 insn_dependent_p_1 (x, pat, data)
831 rtx pat ATTRIBUTE_UNUSED;
834 rtx * pinsn = (rtx *) data;
836 if (*pinsn && reg_mentioned_p (x, *pinsn))
840 /* Given an INSN, return a SET expression if this insn has only a single SET.
841 It may also have CLOBBERs, USEs, or SET whose output
842 will not be used, which we ignore. */
854 if (GET_CODE (PATTERN (insn)) == SET)
855 return PATTERN (insn);
857 else if (GET_CODE (PATTERN (insn)) == PARALLEL)
859 for (i = 0, set = 0; i < XVECLEN (PATTERN (insn), 0); i++)
861 rtx sub = XVECEXP (PATTERN (insn), 0, i);
863 switch (GET_CODE (sub))
870 if (! find_reg_note (insn, REG_UNUSED, SET_DEST (sub))
871 || side_effects_p (sub))
890 /* Given an INSN, return nonzero if it has more than one SET, else return
900 /* INSN must be an insn. */
904 /* Only a PARALLEL can have multiple SETs. */
905 if (GET_CODE (PATTERN (insn)) == PARALLEL)
907 for (i = 0, found = 0; i < XVECLEN (PATTERN (insn), 0); i++)
908 if (GET_CODE (XVECEXP (PATTERN (insn), 0, i)) == SET)
910 /* If we have already found a SET, then return now. */
918 /* Either zero or one SET. */
922 /* Return the last thing that X was assigned from before *PINSN. If VALID_TO
923 is not NULL_RTX then verify that the object is not modified up to VALID_TO.
924 If the object was modified, if we hit a partial assignment to X, or hit a
925 CODE_LABEL first, return X. If we found an assignment, update *PINSN to
926 point to it. ALLOW_HWREG is set to 1 if hardware registers are allowed to
930 find_last_value (x, pinsn, valid_to, allow_hwreg)
938 for (p = PREV_INSN (*pinsn); p && GET_CODE (p) != CODE_LABEL;
942 rtx set = single_set (p);
943 rtx note = find_reg_note (p, REG_EQUAL, NULL_RTX);
945 if (set && rtx_equal_p (x, SET_DEST (set)))
947 rtx src = SET_SRC (set);
949 if (note && GET_CODE (XEXP (note, 0)) != EXPR_LIST)
950 src = XEXP (note, 0);
952 if ((valid_to == NULL_RTX
953 || ! modified_between_p (src, PREV_INSN (p), valid_to))
954 /* Reject hard registers because we don't usually want
955 to use them; we'd rather use a pseudo. */
956 && (! (GET_CODE (src) == REG
957 && REGNO (src) < FIRST_PSEUDO_REGISTER) || allow_hwreg))
964 /* If set in non-simple way, we don't have a value. */
965 if (reg_set_p (x, p))
972 /* Return nonzero if register in range [REGNO, ENDREGNO)
973 appears either explicitly or implicitly in X
974 other than being stored into.
976 References contained within the substructure at LOC do not count.
977 LOC may be zero, meaning don't ignore anything. */
980 refers_to_regno_p (regno, endregno, x, loc)
981 unsigned int regno, endregno;
986 unsigned int x_regno;
991 /* The contents of a REG_NONNEG note is always zero, so we must come here
992 upon repeat in case the last REG_NOTE is a REG_NONNEG note. */
1001 x_regno = REGNO (x);
1003 /* If we modifying the stack, frame, or argument pointer, it will
1004 clobber a virtual register. In fact, we could be more precise,
1005 but it isn't worth it. */
1006 if ((x_regno == STACK_POINTER_REGNUM
1007 #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
1008 || x_regno == ARG_POINTER_REGNUM
1010 || x_regno == FRAME_POINTER_REGNUM)
1011 && regno >= FIRST_VIRTUAL_REGISTER && regno <= LAST_VIRTUAL_REGISTER)
1014 return (endregno > x_regno
1015 && regno < x_regno + (x_regno < FIRST_PSEUDO_REGISTER
1016 ? HARD_REGNO_NREGS (x_regno, GET_MODE (x))
1020 /* If this is a SUBREG of a hard reg, we can see exactly which
1021 registers are being modified. Otherwise, handle normally. */
1022 if (GET_CODE (SUBREG_REG (x)) == REG
1023 && REGNO (SUBREG_REG (x)) < FIRST_PSEUDO_REGISTER)
1025 unsigned int inner_regno = REGNO (SUBREG_REG (x)) + SUBREG_WORD (x);
1026 unsigned int inner_endregno
1027 = inner_regno + (inner_regno < FIRST_PSEUDO_REGISTER
1028 ? HARD_REGNO_NREGS (regno, GET_MODE (x)) : 1);
1030 return endregno > inner_regno && regno < inner_endregno;
1036 if (&SET_DEST (x) != loc
1037 /* Note setting a SUBREG counts as referring to the REG it is in for
1038 a pseudo but not for hard registers since we can
1039 treat each word individually. */
1040 && ((GET_CODE (SET_DEST (x)) == SUBREG
1041 && loc != &SUBREG_REG (SET_DEST (x))
1042 && GET_CODE (SUBREG_REG (SET_DEST (x))) == REG
1043 && REGNO (SUBREG_REG (SET_DEST (x))) >= FIRST_PSEUDO_REGISTER
1044 && refers_to_regno_p (regno, endregno,
1045 SUBREG_REG (SET_DEST (x)), loc))
1046 || (GET_CODE (SET_DEST (x)) != REG
1047 && refers_to_regno_p (regno, endregno, SET_DEST (x), loc))))
1050 if (code == CLOBBER || loc == &SET_SRC (x))
1059 /* X does not match, so try its subexpressions. */
1061 fmt = GET_RTX_FORMAT (code);
1062 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
1064 if (fmt[i] == 'e' && loc != &XEXP (x, i))
1072 if (refers_to_regno_p (regno, endregno, XEXP (x, i), loc))
1075 else if (fmt[i] == 'E')
1078 for (j = XVECLEN (x, i) - 1; j >=0; j--)
1079 if (loc != &XVECEXP (x, i, j)
1080 && refers_to_regno_p (regno, endregno, XVECEXP (x, i, j), loc))
1087 /* Nonzero if modifying X will affect IN. If X is a register or a SUBREG,
1088 we check if any register number in X conflicts with the relevant register
1089 numbers. If X is a constant, return 0. If X is a MEM, return 1 iff IN
1090 contains a MEM (we don't bother checking for memory addresses that can't
1091 conflict because we expect this to be a rare case. */
1094 reg_overlap_mentioned_p (x, in)
1097 unsigned int regno, endregno;
1099 /* Overly conservative. */
1100 if (GET_CODE (x) == STRICT_LOW_PART)
1103 /* If either argument is a constant, then modifying X can not affect IN. */
1104 if (CONSTANT_P (x) || CONSTANT_P (in))
1107 switch (GET_CODE (x))
1110 regno = REGNO (SUBREG_REG (x));
1111 if (regno < FIRST_PSEUDO_REGISTER)
1112 regno += SUBREG_WORD (x);
1118 endregno = regno + (regno < FIRST_PSEUDO_REGISTER
1119 ? HARD_REGNO_NREGS (regno, GET_MODE (x)) : 1);
1120 return refers_to_regno_p (regno, endregno, in, NULL_PTR);
1127 if (GET_CODE (in) == MEM)
1130 fmt = GET_RTX_FORMAT (GET_CODE (in));
1131 for (i = GET_RTX_LENGTH (GET_CODE (in)) - 1; i >= 0; i--)
1132 if (fmt[i] == 'e' && reg_overlap_mentioned_p (x, XEXP (in, i)))
1141 return reg_mentioned_p (x, in);
1147 /* Check for a NULL entry, used to indicate that the parameter goes
1148 both on the stack and in registers. */
1149 if (XEXP (XVECEXP (x, 0, 0), 0))
1154 /* If any register in here refers to it we return true. */
1155 for (n = XVECLEN (x, 0); i < n; ++i)
1156 if (reg_overlap_mentioned_p (XEXP (XVECEXP (x, 0, i), 0), in))
1168 /* Used for communications between the next few functions. */
1170 static int reg_set_last_unknown;
1171 static rtx reg_set_last_value;
1172 static unsigned int reg_set_last_first_regno, reg_set_last_last_regno;
1174 /* Called via note_stores from reg_set_last. */
1177 reg_set_last_1 (x, pat, data)
1180 void *data ATTRIBUTE_UNUSED;
1182 unsigned int first, last;
1184 /* If X is not a register, or is not one in the range we care
1186 if (GET_CODE (x) != REG)
1190 last = first + (first < FIRST_PSEUDO_REGISTER
1191 ? HARD_REGNO_NREGS (first, GET_MODE (x)) : 1);
1193 if (first >= reg_set_last_last_regno
1194 || last <= reg_set_last_first_regno)
1197 /* If this is a CLOBBER or is some complex LHS, or doesn't modify
1198 exactly the registers we care about, show we don't know the value. */
1199 if (GET_CODE (pat) == CLOBBER || SET_DEST (pat) != x
1200 || first != reg_set_last_first_regno
1201 || last != reg_set_last_last_regno)
1202 reg_set_last_unknown = 1;
1204 reg_set_last_value = SET_SRC (pat);
1207 /* Return the last value to which REG was set prior to INSN. If we can't
1208 find it easily, return 0.
1210 We only return a REG, SUBREG, or constant because it is too hard to
1211 check if a MEM remains unchanged. */
1214 reg_set_last (x, insn)
1218 rtx orig_insn = insn;
1220 reg_set_last_first_regno = REGNO (x);
1222 reg_set_last_last_regno
1223 = reg_set_last_first_regno
1224 + (reg_set_last_first_regno < FIRST_PSEUDO_REGISTER
1225 ? HARD_REGNO_NREGS (reg_set_last_first_regno, GET_MODE (x)) : 1);
1227 reg_set_last_unknown = 0;
1228 reg_set_last_value = 0;
1230 /* Scan backwards until reg_set_last_1 changed one of the above flags.
1231 Stop when we reach a label or X is a hard reg and we reach a
1232 CALL_INSN (if reg_set_last_last_regno is a hard reg).
1234 If we find a set of X, ensure that its SET_SRC remains unchanged. */
1236 /* We compare with <= here, because reg_set_last_last_regno
1237 is actually the number of the first reg *not* in X. */
1239 insn && GET_CODE (insn) != CODE_LABEL
1240 && ! (GET_CODE (insn) == CALL_INSN
1241 && reg_set_last_last_regno <= FIRST_PSEUDO_REGISTER);
1242 insn = PREV_INSN (insn))
1245 note_stores (PATTERN (insn), reg_set_last_1, NULL);
1246 if (reg_set_last_unknown)
1248 else if (reg_set_last_value)
1250 if (CONSTANT_P (reg_set_last_value)
1251 || ((GET_CODE (reg_set_last_value) == REG
1252 || GET_CODE (reg_set_last_value) == SUBREG)
1253 && ! reg_set_between_p (reg_set_last_value,
1255 return reg_set_last_value;
1264 /* Call FUN on each register or MEM that is stored into or clobbered by X.
1265 (X would be the pattern of an insn).
1266 FUN receives two arguments:
1267 the REG, MEM, CC0 or PC being stored in or clobbered,
1268 the SET or CLOBBER rtx that does the store.
1270 If the item being stored in or clobbered is a SUBREG of a hard register,
1271 the SUBREG will be passed. */
1274 note_stores (x, fun, data)
1276 void (*fun) PARAMS ((rtx, rtx, void *));
1279 if (GET_CODE (x) == COND_EXEC)
1280 x = COND_EXEC_CODE (x);
1281 if (GET_CODE (x) == SET || GET_CODE (x) == CLOBBER)
1283 register rtx dest = SET_DEST (x);
1284 while ((GET_CODE (dest) == SUBREG
1285 && (GET_CODE (SUBREG_REG (dest)) != REG
1286 || REGNO (SUBREG_REG (dest)) >= FIRST_PSEUDO_REGISTER))
1287 || GET_CODE (dest) == ZERO_EXTRACT
1288 || GET_CODE (dest) == SIGN_EXTRACT
1289 || GET_CODE (dest) == STRICT_LOW_PART)
1290 dest = XEXP (dest, 0);
1292 if (GET_CODE (dest) == PARALLEL
1293 && GET_MODE (dest) == BLKmode)
1296 for (i = XVECLEN (dest, 0) - 1; i >= 0; i--)
1297 (*fun) (SET_DEST (XVECEXP (dest, 0, i)), x, data);
1300 (*fun) (dest, x, data);
1302 else if (GET_CODE (x) == PARALLEL)
1305 for (i = XVECLEN (x, 0) - 1; i >= 0; i--)
1307 register rtx y = XVECEXP (x, 0, i);
1308 if (GET_CODE (y) == COND_EXEC)
1309 y = COND_EXEC_CODE (y);
1310 if (GET_CODE (y) == SET || GET_CODE (y) == CLOBBER)
1312 register rtx dest = SET_DEST (y);
1313 while ((GET_CODE (dest) == SUBREG
1314 && (GET_CODE (SUBREG_REG (dest)) != REG
1315 || (REGNO (SUBREG_REG (dest))
1316 >= FIRST_PSEUDO_REGISTER)))
1317 || GET_CODE (dest) == ZERO_EXTRACT
1318 || GET_CODE (dest) == SIGN_EXTRACT
1319 || GET_CODE (dest) == STRICT_LOW_PART)
1320 dest = XEXP (dest, 0);
1321 if (GET_CODE (dest) == PARALLEL
1322 && GET_MODE (dest) == BLKmode)
1326 for (i = XVECLEN (dest, 0) - 1; i >= 0; i--)
1327 (*fun) (SET_DEST (XVECEXP (dest, 0, i)), y, data);
1330 (*fun) (dest, y, data);
1336 /* Return nonzero if X's old contents don't survive after INSN.
1337 This will be true if X is (cc0) or if X is a register and
1338 X dies in INSN or because INSN entirely sets X.
1340 "Entirely set" means set directly and not through a SUBREG,
1341 ZERO_EXTRACT or SIGN_EXTRACT, so no trace of the old contents remains.
1342 Likewise, REG_INC does not count.
1344 REG may be a hard or pseudo reg. Renumbering is not taken into account,
1345 but for this use that makes no difference, since regs don't overlap
1346 during their lifetimes. Therefore, this function may be used
1347 at any time after deaths have been computed (in flow.c).
1349 If REG is a hard reg that occupies multiple machine registers, this
1350 function will only return 1 if each of those registers will be replaced
1354 dead_or_set_p (insn, x)
1358 unsigned int regno, last_regno;
1361 /* Can't use cc0_rtx below since this file is used by genattrtab.c. */
1362 if (GET_CODE (x) == CC0)
1365 if (GET_CODE (x) != REG)
1369 last_regno = (regno >= FIRST_PSEUDO_REGISTER ? regno
1370 : regno + HARD_REGNO_NREGS (regno, GET_MODE (x)) - 1);
1372 for (i = regno; i <= last_regno; i++)
1373 if (! dead_or_set_regno_p (insn, i))
1379 /* Utility function for dead_or_set_p to check an individual register. Also
1380 called from flow.c. */
1383 dead_or_set_regno_p (insn, test_regno)
1385 unsigned int test_regno;
1387 unsigned int regno, endregno;
1390 /* See if there is a death note for something that includes TEST_REGNO. */
1391 if (find_regno_note (insn, REG_DEAD, test_regno))
1394 if (GET_CODE (insn) == CALL_INSN
1395 && find_regno_fusage (insn, CLOBBER, test_regno))
1398 pattern = PATTERN (insn);
1400 if (GET_CODE (pattern) == COND_EXEC)
1401 pattern = COND_EXEC_CODE (pattern);
1403 if (GET_CODE (pattern) == SET)
1405 rtx dest = SET_DEST (PATTERN (insn));
1407 /* A value is totally replaced if it is the destination or the
1408 destination is a SUBREG of REGNO that does not change the number of
1410 if (GET_CODE (dest) == SUBREG
1411 && (((GET_MODE_SIZE (GET_MODE (dest))
1412 + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
1413 == ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (dest)))
1414 + UNITS_PER_WORD - 1) / UNITS_PER_WORD)))
1415 dest = SUBREG_REG (dest);
1417 if (GET_CODE (dest) != REG)
1420 regno = REGNO (dest);
1421 endregno = (regno >= FIRST_PSEUDO_REGISTER ? regno + 1
1422 : regno + HARD_REGNO_NREGS (regno, GET_MODE (dest)));
1424 return (test_regno >= regno && test_regno < endregno);
1426 else if (GET_CODE (pattern) == PARALLEL)
1430 for (i = XVECLEN (pattern, 0) - 1; i >= 0; i--)
1432 rtx body = XVECEXP (pattern, 0, i);
1434 if (GET_CODE (body) == COND_EXEC)
1435 body = COND_EXEC_CODE (body);
1437 if (GET_CODE (body) == SET || GET_CODE (body) == CLOBBER)
1439 rtx dest = SET_DEST (body);
1441 if (GET_CODE (dest) == SUBREG
1442 && (((GET_MODE_SIZE (GET_MODE (dest))
1443 + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
1444 == ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (dest)))
1445 + UNITS_PER_WORD - 1) / UNITS_PER_WORD)))
1446 dest = SUBREG_REG (dest);
1448 if (GET_CODE (dest) != REG)
1451 regno = REGNO (dest);
1452 endregno = (regno >= FIRST_PSEUDO_REGISTER ? regno + 1
1453 : regno + HARD_REGNO_NREGS (regno, GET_MODE (dest)));
1455 if (test_regno >= regno && test_regno < endregno)
1464 /* Return the reg-note of kind KIND in insn INSN, if there is one.
1465 If DATUM is nonzero, look for one whose datum is DATUM. */
1468 find_reg_note (insn, kind, datum)
1475 /* Ignore anything that is not an INSN, JUMP_INSN or CALL_INSN. */
1476 if (! INSN_P (insn))
1479 for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
1480 if (REG_NOTE_KIND (link) == kind
1481 && (datum == 0 || datum == XEXP (link, 0)))
1486 /* Return the reg-note of kind KIND in insn INSN which applies to register
1487 number REGNO, if any. Return 0 if there is no such reg-note. Note that
1488 the REGNO of this NOTE need not be REGNO if REGNO is a hard register;
1489 it might be the case that the note overlaps REGNO. */
1492 find_regno_note (insn, kind, regno)
1499 /* Ignore anything that is not an INSN, JUMP_INSN or CALL_INSN. */
1500 if (! INSN_P (insn))
1503 for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
1504 if (REG_NOTE_KIND (link) == kind
1505 /* Verify that it is a register, so that scratch and MEM won't cause a
1507 && GET_CODE (XEXP (link, 0)) == REG
1508 && REGNO (XEXP (link, 0)) <= regno
1509 && ((REGNO (XEXP (link, 0))
1510 + (REGNO (XEXP (link, 0)) >= FIRST_PSEUDO_REGISTER ? 1
1511 : HARD_REGNO_NREGS (REGNO (XEXP (link, 0)),
1512 GET_MODE (XEXP (link, 0)))))
1518 /* Return true if DATUM, or any overlap of DATUM, of kind CODE is found
1519 in the CALL_INSN_FUNCTION_USAGE information of INSN. */
1522 find_reg_fusage (insn, code, datum)
1527 /* If it's not a CALL_INSN, it can't possibly have a
1528 CALL_INSN_FUNCTION_USAGE field, so don't bother checking. */
1529 if (GET_CODE (insn) != CALL_INSN)
1535 if (GET_CODE (datum) != REG)
1539 for (link = CALL_INSN_FUNCTION_USAGE (insn);
1541 link = XEXP (link, 1))
1542 if (GET_CODE (XEXP (link, 0)) == code
1543 && rtx_equal_p (datum, SET_DEST (XEXP (link, 0))))
1548 unsigned int regno = REGNO (datum);
1550 /* CALL_INSN_FUNCTION_USAGE information cannot contain references
1551 to pseudo registers, so don't bother checking. */
1553 if (regno < FIRST_PSEUDO_REGISTER)
1555 unsigned int end_regno
1556 = regno + HARD_REGNO_NREGS (regno, GET_MODE (datum));
1559 for (i = regno; i < end_regno; i++)
1560 if (find_regno_fusage (insn, code, i))
1568 /* Return true if REGNO, or any overlap of REGNO, of kind CODE is found
1569 in the CALL_INSN_FUNCTION_USAGE information of INSN. */
1572 find_regno_fusage (insn, code, regno)
1579 /* CALL_INSN_FUNCTION_USAGE information cannot contain references
1580 to pseudo registers, so don't bother checking. */
1582 if (regno >= FIRST_PSEUDO_REGISTER
1583 || GET_CODE (insn) != CALL_INSN )
1586 for (link = CALL_INSN_FUNCTION_USAGE (insn); link; link = XEXP (link, 1))
1588 unsigned int regnote;
1591 if (GET_CODE (op = XEXP (link, 0)) == code
1592 && GET_CODE (reg = XEXP (op, 0)) == REG
1593 && (regnote = REGNO (reg)) <= regno
1594 && regnote + HARD_REGNO_NREGS (regnote, GET_MODE (reg)) > regno)
1601 /* Remove register note NOTE from the REG_NOTES of INSN. */
1604 remove_note (insn, note)
1610 if (note == NULL_RTX)
1613 if (REG_NOTES (insn) == note)
1615 REG_NOTES (insn) = XEXP (note, 1);
1619 for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
1620 if (XEXP (link, 1) == note)
1622 XEXP (link, 1) = XEXP (note, 1);
1629 /* Search LISTP (an EXPR_LIST) for NODE and remove NODE from the list
1632 A simple equality test is used to determine if NODE is on the
1636 remove_node_from_expr_list (node, listp)
1641 rtx prev = NULL_RTX;
1645 if (node == XEXP (temp, 0))
1647 /* Splice the node out of the list. */
1649 XEXP (prev, 1) = XEXP (temp, 1);
1651 *listp = XEXP (temp, 1);
1655 temp = XEXP (temp, 1);
1659 /* Nonzero if X contains any volatile instructions. These are instructions
1660 which may cause unpredictable machine state instructions, and thus no
1661 instructions should be moved or combined across them. This includes
1662 only volatile asms and UNSPEC_VOLATILE instructions. */
1668 register RTX_CODE code;
1670 code = GET_CODE (x);
1690 case UNSPEC_VOLATILE:
1691 /* case TRAP_IF: This isn't clear yet. */
1695 if (MEM_VOLATILE_P (x))
1702 /* Recursively scan the operands of this expression. */
1705 register const char *fmt = GET_RTX_FORMAT (code);
1708 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
1712 if (volatile_insn_p (XEXP (x, i)))
1715 else if (fmt[i] == 'E')
1718 for (j = 0; j < XVECLEN (x, i); j++)
1719 if (volatile_insn_p (XVECEXP (x, i, j)))
1727 /* Nonzero if X contains any volatile memory references
1728 UNSPEC_VOLATILE operations or volatile ASM_OPERANDS expressions. */
1734 register RTX_CODE code;
1736 code = GET_CODE (x);
1755 case UNSPEC_VOLATILE:
1756 /* case TRAP_IF: This isn't clear yet. */
1761 if (MEM_VOLATILE_P (x))
1768 /* Recursively scan the operands of this expression. */
1771 register const char *fmt = GET_RTX_FORMAT (code);
1774 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
1778 if (volatile_refs_p (XEXP (x, i)))
1781 else if (fmt[i] == 'E')
1784 for (j = 0; j < XVECLEN (x, i); j++)
1785 if (volatile_refs_p (XVECEXP (x, i, j)))
1793 /* Similar to above, except that it also rejects register pre- and post-
1800 register RTX_CODE code;
1802 code = GET_CODE (x);
1820 /* Reject CLOBBER with a non-VOID mode. These are made by combine.c
1821 when some combination can't be done. If we see one, don't think
1822 that we can simplify the expression. */
1823 return (GET_MODE (x) != VOIDmode);
1830 case UNSPEC_VOLATILE:
1831 /* case TRAP_IF: This isn't clear yet. */
1836 if (MEM_VOLATILE_P (x))
1843 /* Recursively scan the operands of this expression. */
1846 register const char *fmt = GET_RTX_FORMAT (code);
1849 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
1853 if (side_effects_p (XEXP (x, i)))
1856 else if (fmt[i] == 'E')
1859 for (j = 0; j < XVECLEN (x, i); j++)
1860 if (side_effects_p (XVECEXP (x, i, j)))
1868 /* Return nonzero if evaluating rtx X might cause a trap. */
1880 code = GET_CODE (x);
1883 /* Handle these cases quickly. */
1896 case UNSPEC_VOLATILE:
1901 return MEM_VOLATILE_P (x);
1903 /* Memory ref can trap unless it's a static var or a stack slot. */
1905 return rtx_addr_can_trap_p (XEXP (x, 0));
1907 /* Division by a non-constant might trap. */
1912 if (! CONSTANT_P (XEXP (x, 1))
1913 || GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT)
1915 /* This was const0_rtx, but by not using that,
1916 we can link this file into other programs. */
1917 if (GET_CODE (XEXP (x, 1)) == CONST_INT && INTVAL (XEXP (x, 1)) == 0)
1922 /* An EXPR_LIST is used to represent a function call. This
1923 certainly may trap. */
1927 /* Any floating arithmetic may trap. */
1928 if (GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT)
1932 fmt = GET_RTX_FORMAT (code);
1933 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
1937 if (may_trap_p (XEXP (x, i)))
1940 else if (fmt[i] == 'E')
1943 for (j = 0; j < XVECLEN (x, i); j++)
1944 if (may_trap_p (XVECEXP (x, i, j)))
1951 /* Return nonzero if X contains a comparison that is not either EQ or NE,
1952 i.e., an inequality. */
1955 inequality_comparisons_p (x)
1958 register const char *fmt;
1959 register int len, i;
1960 register enum rtx_code code = GET_CODE (x);
1989 len = GET_RTX_LENGTH (code);
1990 fmt = GET_RTX_FORMAT (code);
1992 for (i = 0; i < len; i++)
1996 if (inequality_comparisons_p (XEXP (x, i)))
1999 else if (fmt[i] == 'E')
2002 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
2003 if (inequality_comparisons_p (XVECEXP (x, i, j)))
2011 /* Replace any occurrence of FROM in X with TO. The function does
2012 not enter into CONST_DOUBLE for the replace.
2014 Note that copying is not done so X must not be shared unless all copies
2015 are to be modified. */
2018 replace_rtx (x, from, to)
2022 register const char *fmt;
2024 /* The following prevents loops occurrence when we change MEM in
2025 CONST_DOUBLE onto the same CONST_DOUBLE. */
2026 if (x != 0 && GET_CODE (x) == CONST_DOUBLE)
2032 /* Allow this function to make replacements in EXPR_LISTs. */
2036 fmt = GET_RTX_FORMAT (GET_CODE (x));
2037 for (i = GET_RTX_LENGTH (GET_CODE (x)) - 1; i >= 0; i--)
2040 XEXP (x, i) = replace_rtx (XEXP (x, i), from, to);
2041 else if (fmt[i] == 'E')
2042 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
2043 XVECEXP (x, i, j) = replace_rtx (XVECEXP (x, i, j), from, to);
2049 /* Throughout the rtx X, replace many registers according to REG_MAP.
2050 Return the replacement for X (which may be X with altered contents).
2051 REG_MAP[R] is the replacement for register R, or 0 for don't replace.
2052 NREGS is the length of REG_MAP; regs >= NREGS are not mapped.
2054 We only support REG_MAP entries of REG or SUBREG. Also, hard registers
2055 should not be mapped to pseudos or vice versa since validate_change
2058 If REPLACE_DEST is 1, replacements are also done in destinations;
2059 otherwise, only sources are replaced. */
2062 replace_regs (x, reg_map, nregs, replace_dest)
2068 register enum rtx_code code;
2070 register const char *fmt;
2075 code = GET_CODE (x);
2089 /* Verify that the register has an entry before trying to access it. */
2090 if (REGNO (x) < nregs && reg_map[REGNO (x)] != 0)
2092 /* SUBREGs can't be shared. Always return a copy to ensure that if
2093 this replacement occurs more than once then each instance will
2094 get distinct rtx. */
2095 if (GET_CODE (reg_map[REGNO (x)]) == SUBREG)
2096 return copy_rtx (reg_map[REGNO (x)]);
2097 return reg_map[REGNO (x)];
2102 /* Prevent making nested SUBREGs. */
2103 if (GET_CODE (SUBREG_REG (x)) == REG && REGNO (SUBREG_REG (x)) < nregs
2104 && reg_map[REGNO (SUBREG_REG (x))] != 0
2105 && GET_CODE (reg_map[REGNO (SUBREG_REG (x))]) == SUBREG)
2107 rtx map_val = reg_map[REGNO (SUBREG_REG (x))];
2108 rtx map_inner = SUBREG_REG (map_val);
2110 if (GET_MODE (x) == GET_MODE (map_inner))
2114 /* We cannot call gen_rtx here since we may be linked with
2116 /* Let's try clobbering the incoming SUBREG and see
2117 if this is really safe. */
2118 SUBREG_REG (x) = map_inner;
2119 SUBREG_WORD (x) += SUBREG_WORD (map_val);
2122 rtx new = rtx_alloc (SUBREG);
2123 PUT_MODE (new, GET_MODE (x));
2124 SUBREG_REG (new) = map_inner;
2125 SUBREG_WORD (new) = SUBREG_WORD (x) + SUBREG_WORD (map_val);
2133 SET_DEST (x) = replace_regs (SET_DEST (x), reg_map, nregs, 0);
2135 else if (GET_CODE (SET_DEST (x)) == MEM
2136 || GET_CODE (SET_DEST (x)) == STRICT_LOW_PART)
2137 /* Even if we are not to replace destinations, replace register if it
2138 is CONTAINED in destination (destination is memory or
2139 STRICT_LOW_PART). */
2140 XEXP (SET_DEST (x), 0) = replace_regs (XEXP (SET_DEST (x), 0),
2142 else if (GET_CODE (SET_DEST (x)) == ZERO_EXTRACT)
2143 /* Similarly, for ZERO_EXTRACT we replace all operands. */
2146 SET_SRC (x) = replace_regs (SET_SRC (x), reg_map, nregs, 0);
2153 fmt = GET_RTX_FORMAT (code);
2154 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
2157 XEXP (x, i) = replace_regs (XEXP (x, i), reg_map, nregs, replace_dest);
2158 else if (fmt[i] == 'E')
2161 for (j = 0; j < XVECLEN (x, i); j++)
2162 XVECEXP (x, i, j) = replace_regs (XVECEXP (x, i, j), reg_map,
2163 nregs, replace_dest);
2169 /* Return 1 if X, the SRC_SRC of SET of (pc) contain a REG or MEM that is
2170 not in the constant pool and not in the condition of an IF_THEN_ELSE. */
2173 jmp_uses_reg_or_mem (x)
2176 enum rtx_code code = GET_CODE (x);
2191 return ! (GET_CODE (XEXP (x, 0)) == SYMBOL_REF
2192 && CONSTANT_POOL_ADDRESS_P (XEXP (x, 0)));
2195 return (jmp_uses_reg_or_mem (XEXP (x, 1))
2196 || jmp_uses_reg_or_mem (XEXP (x, 2)));
2198 case PLUS: case MINUS: case MULT:
2199 return (jmp_uses_reg_or_mem (XEXP (x, 0))
2200 || jmp_uses_reg_or_mem (XEXP (x, 1)));
2206 fmt = GET_RTX_FORMAT (code);
2207 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
2210 && jmp_uses_reg_or_mem (XEXP (x, i)))
2213 else if (fmt[i] == 'E')
2214 for (j = 0; j < XVECLEN (x, i); j++)
2215 if (jmp_uses_reg_or_mem (XVECEXP (x, i, j)))
2222 /* Return nonzero if INSN is an indirect jump (aka computed jump).
2224 Tablejumps and casesi insns are not considered indirect jumps;
2225 we can recognize them by a (use (label_ref)). */
2228 computed_jump_p (insn)
2232 if (GET_CODE (insn) == JUMP_INSN)
2234 rtx pat = PATTERN (insn);
2236 if (GET_CODE (pat) == PARALLEL)
2238 int len = XVECLEN (pat, 0);
2239 int has_use_labelref = 0;
2241 for (i = len - 1; i >= 0; i--)
2242 if (GET_CODE (XVECEXP (pat, 0, i)) == USE
2243 && (GET_CODE (XEXP (XVECEXP (pat, 0, i), 0))
2245 has_use_labelref = 1;
2247 if (! has_use_labelref)
2248 for (i = len - 1; i >= 0; i--)
2249 if (GET_CODE (XVECEXP (pat, 0, i)) == SET
2250 && SET_DEST (XVECEXP (pat, 0, i)) == pc_rtx
2251 && jmp_uses_reg_or_mem (SET_SRC (XVECEXP (pat, 0, i))))
2254 else if (GET_CODE (pat) == SET
2255 && SET_DEST (pat) == pc_rtx
2256 && jmp_uses_reg_or_mem (SET_SRC (pat)))
2262 /* Traverse X via depth-first search, calling F for each
2263 sub-expression (including X itself). F is also passed the DATA.
2264 If F returns -1, do not traverse sub-expressions, but continue
2265 traversing the rest of the tree. If F ever returns any other
2266 non-zero value, stop the traversal, and return the value returned
2267 by F. Otherwise, return 0. This function does not traverse inside
2268 tree structure that contains RTX_EXPRs, or into sub-expressions
2269 whose format code is `0' since it is not known whether or not those
2270 codes are actually RTL.
2272 This routine is very general, and could (should?) be used to
2273 implement many of the other routines in this file. */
2276 for_each_rtx (x, f, data)
2287 result = (*f)(x, data);
2289 /* Do not traverse sub-expressions. */
2291 else if (result != 0)
2292 /* Stop the traversal. */
2296 /* There are no sub-expressions. */
2299 length = GET_RTX_LENGTH (GET_CODE (*x));
2300 format = GET_RTX_FORMAT (GET_CODE (*x));
2302 for (i = 0; i < length; ++i)
2307 result = for_each_rtx (&XEXP (*x, i), f, data);
2314 if (XVEC (*x, i) != 0)
2317 for (j = 0; j < XVECLEN (*x, i); ++j)
2319 result = for_each_rtx (&XVECEXP (*x, i, j), f, data);
2327 /* Nothing to do. */
2336 /* Searches X for any reference to REGNO, returning the rtx of the
2337 reference found if any. Otherwise, returns NULL_RTX. */
2340 regno_use_in (regno, x)
2344 register const char *fmt;
2348 if (GET_CODE (x) == REG && REGNO (x) == regno)
2351 fmt = GET_RTX_FORMAT (GET_CODE (x));
2352 for (i = GET_RTX_LENGTH (GET_CODE (x)) - 1; i >= 0; i--)
2356 if ((tem = regno_use_in (regno, XEXP (x, i))))
2359 else if (fmt[i] == 'E')
2360 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
2361 if ((tem = regno_use_in (regno , XVECEXP (x, i, j))))
2369 /* Return 1 if X is an autoincrement side effect and the register is
2370 not the stack pointer. */
2375 switch (GET_CODE (x))
2383 /* There are no REG_INC notes for SP. */
2384 if (XEXP (x, 0) != stack_pointer_rtx)
2392 /* Return 1 if the sequence of instructions beginning with FROM and up
2393 to and including TO is safe to move. If NEW_TO is non-NULL, and
2394 the sequence is not already safe to move, but can be easily
2395 extended to a sequence which is safe, then NEW_TO will point to the
2396 end of the extended sequence.
2398 For now, this function only checks that the region contains whole
2399 exception regiongs, but it could be extended to check additional
2400 conditions as well. */
2403 insns_safe_to_move_p (from, to, new_to)
2408 int eh_region_count = 0;
2412 /* By default, assume the end of the region will be what was
2419 if (GET_CODE (r) == NOTE)
2421 switch (NOTE_LINE_NUMBER (r))
2423 case NOTE_INSN_EH_REGION_BEG:
2427 case NOTE_INSN_EH_REGION_END:
2428 if (eh_region_count == 0)
2429 /* This sequence of instructions contains the end of
2430 an exception region, but not he beginning. Moving
2431 it will cause chaos. */
2442 /* If we've passed TO, and we see a non-note instruction, we
2443 can't extend the sequence to a movable sequence. */
2449 /* It's OK to move the sequence if there were matched sets of
2450 exception region notes. */
2451 return eh_region_count == 0;
2456 /* It's OK to move the sequence if there were matched sets of
2457 exception region notes. */
2458 if (past_to_p && eh_region_count == 0)
2464 /* Go to the next instruction. */
2471 /* Return non-zero if IN contains a piece of rtl that has the address LOC */
2473 loc_mentioned_in_p (loc, in)
2476 enum rtx_code code = GET_CODE (in);
2477 const char *fmt = GET_RTX_FORMAT (code);
2480 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
2482 if (loc == &in->fld[i].rtx)
2486 if (loc_mentioned_in_p (loc, XEXP (in, i)))
2489 else if (fmt[i] == 'E')
2490 for (j = XVECLEN (in, i) - 1; j >= 0; j--)
2491 if (loc_mentioned_in_p (loc, XVECEXP (in, i, j)))