1 /* Analyze RTL for C-Compiler
2 Copyright (C) 1987, 88, 92-98, 1999 Free Software Foundation, Inc.
4 This file is part of GNU CC.
6 GNU CC is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GNU CC is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU CC; see the file COPYING. If not, write to
18 the Free Software Foundation, 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
26 static int rtx_addr_can_trap_p PROTO((rtx));
27 static void reg_set_p_1 PROTO((rtx, rtx, void *));
28 static void reg_set_last_1 PROTO((rtx, rtx, void *));
31 /* Forward declarations */
32 static int jmp_uses_reg_or_mem PROTO((rtx));
34 /* Bit flags that specify the machine subtype we are compiling for.
35 Bits are tested using macros TARGET_... defined in the tm.h file
36 and set by `-m...' switches. Must be defined in rtlanal.c. */
40 /* Return 1 if the value of X is unstable
41 (would be different at a different point in the program).
42 The frame pointer, arg pointer, etc. are considered stable
43 (within one function) and so is anything marked `unchanging'. */
49 register RTX_CODE code = GET_CODE (x);
51 register const char *fmt;
54 return ! RTX_UNCHANGING_P (x);
59 if (code == CONST || code == CONST_INT)
63 return ! (REGNO (x) == FRAME_POINTER_REGNUM
64 || REGNO (x) == HARD_FRAME_POINTER_REGNUM
65 || REGNO (x) == ARG_POINTER_REGNUM
66 || RTX_UNCHANGING_P (x));
68 fmt = GET_RTX_FORMAT (code);
69 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
71 if (rtx_unstable_p (XEXP (x, i)))
76 /* Return 1 if X has a value that can vary even between two
77 executions of the program. 0 means X can be compared reliably
78 against certain constants or near-constants.
79 The frame pointer and the arg pointer are considered constant. */
85 register RTX_CODE code = GET_CODE (x);
87 register const char *fmt;
103 /* Note that we have to test for the actual rtx used for the frame
104 and arg pointers and not just the register number in case we have
105 eliminated the frame and/or arg pointer and are using it
107 return ! (x == frame_pointer_rtx || x == hard_frame_pointer_rtx
108 || x == arg_pointer_rtx || x == pic_offset_table_rtx);
111 /* The operand 0 of a LO_SUM is considered constant
112 (in fact is it related specifically to operand 1). */
113 return rtx_varies_p (XEXP (x, 1));
119 fmt = GET_RTX_FORMAT (code);
120 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
122 if (rtx_varies_p (XEXP (x, i)))
127 /* Return 0 if the use of X as an address in a MEM can cause a trap. */
130 rtx_addr_can_trap_p (x)
133 register enum rtx_code code = GET_CODE (x);
139 /* SYMBOL_REF is problematic due to the possible presence of
140 a #pragma weak, but to say that loads from symbols can trap is
141 *very* costly. It's not at all clear what's best here. For
142 now, we ignore the impact of #pragma weak. */
146 /* As in rtx_varies_p, we have to use the actual rtx, not reg number. */
147 return ! (x == frame_pointer_rtx || x == hard_frame_pointer_rtx
148 || x == stack_pointer_rtx || x == arg_pointer_rtx);
151 return rtx_addr_can_trap_p (XEXP (x, 0));
154 /* An address is assumed not to trap if it is an address that can't
155 trap plus a constant integer. */
156 return (rtx_addr_can_trap_p (XEXP (x, 0))
157 || GET_CODE (XEXP (x, 1)) != CONST_INT);
160 return rtx_addr_can_trap_p (XEXP (x, 1));
166 /* If it isn't one of the case above, it can cause a trap. */
170 /* Return 1 if X refers to a memory location whose address
171 cannot be compared reliably with constant addresses,
172 or if X refers to a BLKmode memory object. */
175 rtx_addr_varies_p (x)
178 register enum rtx_code code;
180 register const char *fmt;
187 return GET_MODE (x) == BLKmode || rtx_varies_p (XEXP (x, 0));
189 fmt = GET_RTX_FORMAT (code);
190 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
193 if (rtx_addr_varies_p (XEXP (x, i)))
196 else if (fmt[i] == 'E')
199 for (j = 0; j < XVECLEN (x, i); j++)
200 if (rtx_addr_varies_p (XVECEXP (x, i, j)))
206 /* Return the value of the integer term in X, if one is apparent;
208 Only obvious integer terms are detected.
209 This is used in cse.c with the `related_value' field.*/
215 if (GET_CODE (x) == CONST)
218 if (GET_CODE (x) == MINUS
219 && GET_CODE (XEXP (x, 1)) == CONST_INT)
220 return - INTVAL (XEXP (x, 1));
221 if (GET_CODE (x) == PLUS
222 && GET_CODE (XEXP (x, 1)) == CONST_INT)
223 return INTVAL (XEXP (x, 1));
227 /* If X is a constant, return the value sans apparent integer term;
229 Only obvious integer terms are detected. */
232 get_related_value (x)
235 if (GET_CODE (x) != CONST)
238 if (GET_CODE (x) == PLUS
239 && GET_CODE (XEXP (x, 1)) == CONST_INT)
241 else if (GET_CODE (x) == MINUS
242 && GET_CODE (XEXP (x, 1)) == CONST_INT)
247 /* Nonzero if register REG appears somewhere within IN.
248 Also works if REG is not a register; in this case it checks
249 for a subexpression of IN that is Lisp "equal" to REG. */
252 reg_mentioned_p (reg, in)
253 register rtx reg, in;
255 register const char *fmt;
257 register enum rtx_code code;
265 if (GET_CODE (in) == LABEL_REF)
266 return reg == XEXP (in, 0);
268 code = GET_CODE (in);
272 /* Compare registers by number. */
274 return GET_CODE (reg) == REG && REGNO (in) == REGNO (reg);
276 /* These codes have no constituent expressions
284 return GET_CODE (reg) == CONST_INT && INTVAL (in) == INTVAL (reg);
287 /* These are kept unique for a given value. */
294 if (GET_CODE (reg) == code && rtx_equal_p (reg, in))
297 fmt = GET_RTX_FORMAT (code);
299 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
304 for (j = XVECLEN (in, i) - 1; j >= 0; j--)
305 if (reg_mentioned_p (reg, XVECEXP (in, i, j)))
308 else if (fmt[i] == 'e'
309 && reg_mentioned_p (reg, XEXP (in, i)))
315 /* Return 1 if in between BEG and END, exclusive of BEG and END, there is
316 no CODE_LABEL insn. */
319 no_labels_between_p (beg, end)
323 for (p = NEXT_INSN (beg); p != end; p = NEXT_INSN (p))
324 if (GET_CODE (p) == CODE_LABEL)
329 /* Return 1 if in between BEG and END, exclusive of BEG and END, there is
330 no JUMP_INSN insn. */
333 no_jumps_between_p (beg, end)
337 for (p = NEXT_INSN (beg); p != end; p = NEXT_INSN (p))
338 if (GET_CODE (p) == JUMP_INSN)
343 /* Nonzero if register REG is used in an insn between
344 FROM_INSN and TO_INSN (exclusive of those two). */
347 reg_used_between_p (reg, from_insn, to_insn)
348 rtx reg, from_insn, to_insn;
352 if (from_insn == to_insn)
355 for (insn = NEXT_INSN (from_insn); insn != to_insn; insn = NEXT_INSN (insn))
356 if (GET_RTX_CLASS (GET_CODE (insn)) == 'i'
357 && (reg_overlap_mentioned_p (reg, PATTERN (insn))
358 || (GET_CODE (insn) == CALL_INSN
359 && (find_reg_fusage (insn, USE, reg)
360 || find_reg_fusage (insn, CLOBBER, reg)))))
365 /* Nonzero if the old value of X, a register, is referenced in BODY. If X
366 is entirely replaced by a new value and the only use is as a SET_DEST,
367 we do not consider it a reference. */
370 reg_referenced_p (x, body)
376 switch (GET_CODE (body))
379 if (reg_overlap_mentioned_p (x, SET_SRC (body)))
382 /* If the destination is anything other than CC0, PC, a REG or a SUBREG
383 of a REG that occupies all of the REG, the insn references X if
384 it is mentioned in the destination. */
385 if (GET_CODE (SET_DEST (body)) != CC0
386 && GET_CODE (SET_DEST (body)) != PC
387 && GET_CODE (SET_DEST (body)) != REG
388 && ! (GET_CODE (SET_DEST (body)) == SUBREG
389 && GET_CODE (SUBREG_REG (SET_DEST (body))) == REG
390 && (((GET_MODE_SIZE (GET_MODE (SUBREG_REG (SET_DEST (body))))
391 + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD)
392 == ((GET_MODE_SIZE (GET_MODE (SET_DEST (body)))
393 + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD)))
394 && reg_overlap_mentioned_p (x, SET_DEST (body)))
399 for (i = ASM_OPERANDS_INPUT_LENGTH (body) - 1; i >= 0; i--)
400 if (reg_overlap_mentioned_p (x, ASM_OPERANDS_INPUT (body, i)))
406 return reg_overlap_mentioned_p (x, body);
409 return reg_overlap_mentioned_p (x, TRAP_CONDITION (body));
412 case UNSPEC_VOLATILE:
413 for (i = XVECLEN (body, 0) - 1; i >= 0; i--)
414 if (reg_overlap_mentioned_p (x, XVECEXP (body, 0, i)))
419 for (i = XVECLEN (body, 0) - 1; i >= 0; i--)
420 if (reg_referenced_p (x, XVECEXP (body, 0, i)))
429 /* Nonzero if register REG is referenced in an insn between
430 FROM_INSN and TO_INSN (exclusive of those two). Sets of REG do
434 reg_referenced_between_p (reg, from_insn, to_insn)
435 rtx reg, from_insn, to_insn;
439 if (from_insn == to_insn)
442 for (insn = NEXT_INSN (from_insn); insn != to_insn; insn = NEXT_INSN (insn))
443 if (GET_RTX_CLASS (GET_CODE (insn)) == 'i'
444 && (reg_referenced_p (reg, PATTERN (insn))
445 || (GET_CODE (insn) == CALL_INSN
446 && find_reg_fusage (insn, USE, reg))))
451 /* Nonzero if register REG is set or clobbered in an insn between
452 FROM_INSN and TO_INSN (exclusive of those two). */
455 reg_set_between_p (reg, from_insn, to_insn)
456 rtx reg, from_insn, to_insn;
460 if (from_insn == to_insn)
463 for (insn = NEXT_INSN (from_insn); insn != to_insn; insn = NEXT_INSN (insn))
464 if (GET_RTX_CLASS (GET_CODE (insn)) == 'i'
465 && reg_set_p (reg, insn))
470 /* Internals of reg_set_between_p. */
472 static rtx reg_set_reg;
473 static int reg_set_flag;
476 reg_set_p_1 (x, pat, data)
478 rtx pat ATTRIBUTE_UNUSED;
479 void *data ATTRIBUTE_UNUSED;
481 /* We don't want to return 1 if X is a MEM that contains a register
482 within REG_SET_REG. */
484 if ((GET_CODE (x) != MEM)
485 && reg_overlap_mentioned_p (reg_set_reg, x))
490 reg_set_p (reg, insn)
495 /* We can be passed an insn or part of one. If we are passed an insn,
496 check if a side-effect of the insn clobbers REG. */
497 if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
499 if (FIND_REG_INC_NOTE (insn, reg)
500 || (GET_CODE (insn) == CALL_INSN
501 /* We'd like to test call_used_regs here, but rtlanal.c can't
502 reference that variable due to its use in genattrtab. So
503 we'll just be more conservative.
505 ??? Unless we could ensure that the CALL_INSN_FUNCTION_USAGE
506 information holds all clobbered registers. */
507 && ((GET_CODE (reg) == REG
508 && REGNO (reg) < FIRST_PSEUDO_REGISTER)
509 || GET_CODE (reg) == MEM
510 || find_reg_fusage (insn, CLOBBER, reg))))
513 body = PATTERN (insn);
518 note_stores (body, reg_set_p_1, NULL);
522 /* Similar to reg_set_between_p, but check all registers in X. Return 0
523 only if none of them are modified between START and END. Do not
524 consider non-registers one way or the other. */
527 regs_set_between_p (x, start, end)
531 enum rtx_code code = GET_CODE (x);
547 return reg_set_between_p (x, start, end);
553 fmt = GET_RTX_FORMAT (code);
554 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
556 if (fmt[i] == 'e' && regs_set_between_p (XEXP (x, i), start, end))
559 else if (fmt[i] == 'E')
560 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
561 if (regs_set_between_p (XVECEXP (x, i, j), start, end))
568 /* Similar to reg_set_between_p, but check all registers in X. Return 0
569 only if none of them are modified between START and END. Return 1 if
570 X contains a MEM; this routine does not perform any memory aliasing. */
573 modified_between_p (x, start, end)
577 enum rtx_code code = GET_CODE (x);
595 /* If the memory is not constant, assume it is modified. If it is
596 constant, we still have to check the address. */
597 if (! RTX_UNCHANGING_P (x))
602 return reg_set_between_p (x, start, end);
608 fmt = GET_RTX_FORMAT (code);
609 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
611 if (fmt[i] == 'e' && modified_between_p (XEXP (x, i), start, end))
615 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
616 if (modified_between_p (XVECEXP (x, i, j), start, end))
623 /* Similar to reg_set_p, but check all registers in X. Return 0 only if none
624 of them are modified in INSN. Return 1 if X contains a MEM; this routine
625 does not perform any memory aliasing. */
628 modified_in_p (x, insn)
632 enum rtx_code code = GET_CODE (x);
650 /* If the memory is not constant, assume it is modified. If it is
651 constant, we still have to check the address. */
652 if (! RTX_UNCHANGING_P (x))
657 return reg_set_p (x, insn);
663 fmt = GET_RTX_FORMAT (code);
664 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
666 if (fmt[i] == 'e' && modified_in_p (XEXP (x, i), insn))
670 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
671 if (modified_in_p (XVECEXP (x, i, j), insn))
678 /* Given an INSN, return a SET expression if this insn has only a single SET.
679 It may also have CLOBBERs, USEs, or SET whose output
680 will not be used, which we ignore. */
689 if (GET_RTX_CLASS (GET_CODE (insn)) != 'i')
692 if (GET_CODE (PATTERN (insn)) == SET)
693 return PATTERN (insn);
695 else if (GET_CODE (PATTERN (insn)) == PARALLEL)
697 for (i = 0, set = 0; i < XVECLEN (PATTERN (insn), 0); i++)
698 if (GET_CODE (XVECEXP (PATTERN (insn), 0, i)) == SET
699 && (! find_reg_note (insn, REG_UNUSED,
700 SET_DEST (XVECEXP (PATTERN (insn), 0, i)))
701 || side_effects_p (XVECEXP (PATTERN (insn), 0, i))))
706 set = XVECEXP (PATTERN (insn), 0, i);
714 /* Given an INSN, return nonzero if it has more than one SET, else return
724 /* INSN must be an insn. */
725 if (GET_RTX_CLASS (GET_CODE (insn)) != 'i')
728 /* Only a PARALLEL can have multiple SETs. */
729 if (GET_CODE (PATTERN (insn)) == PARALLEL)
731 for (i = 0, found = 0; i < XVECLEN (PATTERN (insn), 0); i++)
732 if (GET_CODE (XVECEXP (PATTERN (insn), 0, i)) == SET)
734 /* If we have already found a SET, then return now. */
742 /* Either zero or one SET. */
746 /* Return the last thing that X was assigned from before *PINSN. Verify that
747 the object is not modified up to VALID_TO. If it was, if we hit
748 a partial assignment to X, or hit a CODE_LABEL first, return X. If we
749 found an assignment, update *PINSN to point to it.
750 ALLOW_HWREG is set to 1 if hardware registers are allowed to be the src. */
753 find_last_value (x, pinsn, valid_to, allow_hwreg)
761 for (p = PREV_INSN (*pinsn); p && GET_CODE (p) != CODE_LABEL;
763 if (GET_RTX_CLASS (GET_CODE (p)) == 'i')
765 rtx set = single_set (p);
766 rtx note = find_reg_note (p, REG_EQUAL, NULL_RTX);
768 if (set && rtx_equal_p (x, SET_DEST (set)))
770 rtx src = SET_SRC (set);
772 if (note && GET_CODE (XEXP (note, 0)) != EXPR_LIST)
773 src = XEXP (note, 0);
775 if (! modified_between_p (src, PREV_INSN (p), valid_to)
776 /* Reject hard registers because we don't usually want
777 to use them; we'd rather use a pseudo. */
778 && (! (GET_CODE (src) == REG
779 && REGNO (src) < FIRST_PSEUDO_REGISTER) || allow_hwreg))
786 /* If set in non-simple way, we don't have a value. */
787 if (reg_set_p (x, p))
794 /* Return nonzero if register in range [REGNO, ENDREGNO)
795 appears either explicitly or implicitly in X
796 other than being stored into.
798 References contained within the substructure at LOC do not count.
799 LOC may be zero, meaning don't ignore anything. */
802 refers_to_regno_p (regno, endregno, x, loc)
808 register RTX_CODE code;
809 register const char *fmt;
812 /* The contents of a REG_NONNEG note is always zero, so we must come here
813 upon repeat in case the last REG_NOTE is a REG_NONNEG note. */
824 /* If we modifying the stack, frame, or argument pointer, it will
825 clobber a virtual register. In fact, we could be more precise,
826 but it isn't worth it. */
827 if ((i == STACK_POINTER_REGNUM
828 #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
829 || i == ARG_POINTER_REGNUM
831 || i == FRAME_POINTER_REGNUM)
832 && regno >= FIRST_VIRTUAL_REGISTER && regno <= LAST_VIRTUAL_REGISTER)
836 && regno < i + (i < FIRST_PSEUDO_REGISTER
837 ? HARD_REGNO_NREGS (i, GET_MODE (x))
841 /* If this is a SUBREG of a hard reg, we can see exactly which
842 registers are being modified. Otherwise, handle normally. */
843 if (GET_CODE (SUBREG_REG (x)) == REG
844 && REGNO (SUBREG_REG (x)) < FIRST_PSEUDO_REGISTER)
846 int inner_regno = REGNO (SUBREG_REG (x)) + SUBREG_WORD (x);
848 = inner_regno + (inner_regno < FIRST_PSEUDO_REGISTER
849 ? HARD_REGNO_NREGS (regno, GET_MODE (x)) : 1);
851 return endregno > inner_regno && regno < inner_endregno;
857 if (&SET_DEST (x) != loc
858 /* Note setting a SUBREG counts as referring to the REG it is in for
859 a pseudo but not for hard registers since we can
860 treat each word individually. */
861 && ((GET_CODE (SET_DEST (x)) == SUBREG
862 && loc != &SUBREG_REG (SET_DEST (x))
863 && GET_CODE (SUBREG_REG (SET_DEST (x))) == REG
864 && REGNO (SUBREG_REG (SET_DEST (x))) >= FIRST_PSEUDO_REGISTER
865 && refers_to_regno_p (regno, endregno,
866 SUBREG_REG (SET_DEST (x)), loc))
867 || (GET_CODE (SET_DEST (x)) != REG
868 && refers_to_regno_p (regno, endregno, SET_DEST (x), loc))))
871 if (code == CLOBBER || loc == &SET_SRC (x))
880 /* X does not match, so try its subexpressions. */
882 fmt = GET_RTX_FORMAT (code);
883 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
885 if (fmt[i] == 'e' && loc != &XEXP (x, i))
893 if (refers_to_regno_p (regno, endregno, XEXP (x, i), loc))
896 else if (fmt[i] == 'E')
899 for (j = XVECLEN (x, i) - 1; j >=0; j--)
900 if (loc != &XVECEXP (x, i, j)
901 && refers_to_regno_p (regno, endregno, XVECEXP (x, i, j), loc))
908 /* Nonzero if modifying X will affect IN. If X is a register or a SUBREG,
909 we check if any register number in X conflicts with the relevant register
910 numbers. If X is a constant, return 0. If X is a MEM, return 1 iff IN
911 contains a MEM (we don't bother checking for memory addresses that can't
912 conflict because we expect this to be a rare case. */
915 reg_overlap_mentioned_p (x, in)
920 /* Overly conservative. */
921 if (GET_CODE (x) == STRICT_LOW_PART)
924 /* If either argument is a constant, then modifying X can not affect IN. */
925 if (CONSTANT_P (x) || CONSTANT_P (in))
927 else if (GET_CODE (x) == SUBREG)
929 regno = REGNO (SUBREG_REG (x));
930 if (regno < FIRST_PSEUDO_REGISTER)
931 regno += SUBREG_WORD (x);
933 else if (GET_CODE (x) == REG)
935 else if (GET_CODE (x) == MEM)
940 if (GET_CODE (in) == MEM)
943 fmt = GET_RTX_FORMAT (GET_CODE (in));
945 for (i = GET_RTX_LENGTH (GET_CODE (in)) - 1; i >= 0; i--)
946 if (fmt[i] == 'e' && reg_overlap_mentioned_p (x, XEXP (in, i)))
951 else if (GET_CODE (x) == SCRATCH || GET_CODE (x) == PC
952 || GET_CODE (x) == CC0)
953 return reg_mentioned_p (x, in);
954 else if (GET_CODE (x) == PARALLEL
955 && GET_MODE (x) == BLKmode)
959 /* If any register in here refers to it
961 for (i = XVECLEN (x, 0) - 1; i >= 0; i--)
962 if (reg_overlap_mentioned_p (SET_DEST (XVECEXP (x, 0, i)), in))
969 endregno = regno + (regno < FIRST_PSEUDO_REGISTER
970 ? HARD_REGNO_NREGS (regno, GET_MODE (x)) : 1);
972 return refers_to_regno_p (regno, endregno, in, NULL_PTR);
975 /* Used for communications between the next few functions. */
977 static int reg_set_last_unknown;
978 static rtx reg_set_last_value;
979 static int reg_set_last_first_regno, reg_set_last_last_regno;
981 /* Called via note_stores from reg_set_last. */
984 reg_set_last_1 (x, pat, data)
987 void *data ATTRIBUTE_UNUSED;
991 /* If X is not a register, or is not one in the range we care
993 if (GET_CODE (x) != REG)
997 last = first + (first < FIRST_PSEUDO_REGISTER
998 ? HARD_REGNO_NREGS (first, GET_MODE (x)) : 1);
1000 if (first >= reg_set_last_last_regno
1001 || last <= reg_set_last_first_regno)
1004 /* If this is a CLOBBER or is some complex LHS, or doesn't modify
1005 exactly the registers we care about, show we don't know the value. */
1006 if (GET_CODE (pat) == CLOBBER || SET_DEST (pat) != x
1007 || first != reg_set_last_first_regno
1008 || last != reg_set_last_last_regno)
1009 reg_set_last_unknown = 1;
1011 reg_set_last_value = SET_SRC (pat);
1014 /* Return the last value to which REG was set prior to INSN. If we can't
1015 find it easily, return 0.
1017 We only return a REG, SUBREG, or constant because it is too hard to
1018 check if a MEM remains unchanged. */
1021 reg_set_last (x, insn)
1025 rtx orig_insn = insn;
1027 reg_set_last_first_regno = REGNO (x);
1029 reg_set_last_last_regno
1030 = reg_set_last_first_regno
1031 + (reg_set_last_first_regno < FIRST_PSEUDO_REGISTER
1032 ? HARD_REGNO_NREGS (reg_set_last_first_regno, GET_MODE (x)) : 1);
1034 reg_set_last_unknown = 0;
1035 reg_set_last_value = 0;
1037 /* Scan backwards until reg_set_last_1 changed one of the above flags.
1038 Stop when we reach a label or X is a hard reg and we reach a
1039 CALL_INSN (if reg_set_last_last_regno is a hard reg).
1041 If we find a set of X, ensure that its SET_SRC remains unchanged. */
1043 /* We compare with <= here, because reg_set_last_last_regno
1044 is actually the number of the first reg *not* in X. */
1046 insn && GET_CODE (insn) != CODE_LABEL
1047 && ! (GET_CODE (insn) == CALL_INSN
1048 && reg_set_last_last_regno <= FIRST_PSEUDO_REGISTER);
1049 insn = PREV_INSN (insn))
1050 if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
1052 note_stores (PATTERN (insn), reg_set_last_1, NULL);
1053 if (reg_set_last_unknown)
1055 else if (reg_set_last_value)
1057 if (CONSTANT_P (reg_set_last_value)
1058 || ((GET_CODE (reg_set_last_value) == REG
1059 || GET_CODE (reg_set_last_value) == SUBREG)
1060 && ! reg_set_between_p (reg_set_last_value,
1062 return reg_set_last_value;
1071 /* This is 1 until after the rtl generation pass. */
1072 int rtx_equal_function_value_matters;
1074 /* Return 1 if X and Y are identical-looking rtx's.
1075 This is the Lisp function EQUAL for rtx arguments. */
1083 register enum rtx_code code;
1084 register const char *fmt;
1088 if (x == 0 || y == 0)
1091 code = GET_CODE (x);
1092 /* Rtx's of different codes cannot be equal. */
1093 if (code != GET_CODE (y))
1096 /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent.
1097 (REG:SI x) and (REG:HI x) are NOT equivalent. */
1099 if (GET_MODE (x) != GET_MODE (y))
1102 /* REG, LABEL_REF, and SYMBOL_REF can be compared nonrecursively. */
1105 /* Until rtl generation is complete, don't consider a reference to the
1106 return register of the current function the same as the return from a
1107 called function. This eases the job of function integration. Once the
1108 distinction is no longer needed, they can be considered equivalent. */
1109 return (REGNO (x) == REGNO (y)
1110 && (! rtx_equal_function_value_matters
1111 || REG_FUNCTION_VALUE_P (x) == REG_FUNCTION_VALUE_P (y)));
1112 else if (code == LABEL_REF)
1113 return XEXP (x, 0) == XEXP (y, 0);
1114 else if (code == SYMBOL_REF)
1115 return XSTR (x, 0) == XSTR (y, 0);
1116 else if (code == SCRATCH || code == CONST_DOUBLE)
1119 /* Compare the elements. If any pair of corresponding elements
1120 fail to match, return 0 for the whole things. */
1122 fmt = GET_RTX_FORMAT (code);
1123 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
1128 if (XWINT (x, i) != XWINT (y, i))
1134 if (XINT (x, i) != XINT (y, i))
1140 /* Two vectors must have the same length. */
1141 if (XVECLEN (x, i) != XVECLEN (y, i))
1144 /* And the corresponding elements must match. */
1145 for (j = 0; j < XVECLEN (x, i); j++)
1146 if (rtx_equal_p (XVECEXP (x, i, j), XVECEXP (y, i, j)) == 0)
1151 if (rtx_equal_p (XEXP (x, i), XEXP (y, i)) == 0)
1157 if (strcmp (XSTR (x, i), XSTR (y, i)))
1162 /* These are just backpointers, so they don't matter. */
1169 /* It is believed that rtx's at this level will never
1170 contain anything but integers and other rtx's,
1171 except for within LABEL_REFs and SYMBOL_REFs. */
1179 /* Call FUN on each register or MEM that is stored into or clobbered by X.
1180 (X would be the pattern of an insn).
1181 FUN receives two arguments:
1182 the REG, MEM, CC0 or PC being stored in or clobbered,
1183 the SET or CLOBBER rtx that does the store.
1185 If the item being stored in or clobbered is a SUBREG of a hard register,
1186 the SUBREG will be passed. */
1189 note_stores (x, fun, data)
1191 void (*fun) PROTO ((rtx, rtx, void *));
1194 if ((GET_CODE (x) == SET || GET_CODE (x) == CLOBBER))
1196 register rtx dest = SET_DEST (x);
1197 while ((GET_CODE (dest) == SUBREG
1198 && (GET_CODE (SUBREG_REG (dest)) != REG
1199 || REGNO (SUBREG_REG (dest)) >= FIRST_PSEUDO_REGISTER))
1200 || GET_CODE (dest) == ZERO_EXTRACT
1201 || GET_CODE (dest) == SIGN_EXTRACT
1202 || GET_CODE (dest) == STRICT_LOW_PART)
1203 dest = XEXP (dest, 0);
1205 if (GET_CODE (dest) == PARALLEL
1206 && GET_MODE (dest) == BLKmode)
1209 for (i = XVECLEN (dest, 0) - 1; i >= 0; i--)
1210 (*fun) (SET_DEST (XVECEXP (dest, 0, i)), x, data);
1213 (*fun) (dest, x, data);
1215 else if (GET_CODE (x) == PARALLEL)
1218 for (i = XVECLEN (x, 0) - 1; i >= 0; i--)
1220 register rtx y = XVECEXP (x, 0, i);
1221 if (GET_CODE (y) == SET || GET_CODE (y) == CLOBBER)
1223 register rtx dest = SET_DEST (y);
1224 while ((GET_CODE (dest) == SUBREG
1225 && (GET_CODE (SUBREG_REG (dest)) != REG
1226 || (REGNO (SUBREG_REG (dest))
1227 >= FIRST_PSEUDO_REGISTER)))
1228 || GET_CODE (dest) == ZERO_EXTRACT
1229 || GET_CODE (dest) == SIGN_EXTRACT
1230 || GET_CODE (dest) == STRICT_LOW_PART)
1231 dest = XEXP (dest, 0);
1232 if (GET_CODE (dest) == PARALLEL
1233 && GET_MODE (dest) == BLKmode)
1236 for (i = XVECLEN (dest, 0) - 1; i >= 0; i--)
1237 (*fun) (SET_DEST (XVECEXP (dest, 0, i)), y, data);
1240 (*fun) (dest, y, data);
1246 /* Return nonzero if X's old contents don't survive after INSN.
1247 This will be true if X is (cc0) or if X is a register and
1248 X dies in INSN or because INSN entirely sets X.
1250 "Entirely set" means set directly and not through a SUBREG,
1251 ZERO_EXTRACT or SIGN_EXTRACT, so no trace of the old contents remains.
1252 Likewise, REG_INC does not count.
1254 REG may be a hard or pseudo reg. Renumbering is not taken into account,
1255 but for this use that makes no difference, since regs don't overlap
1256 during their lifetimes. Therefore, this function may be used
1257 at any time after deaths have been computed (in flow.c).
1259 If REG is a hard reg that occupies multiple machine registers, this
1260 function will only return 1 if each of those registers will be replaced
1264 dead_or_set_p (insn, x)
1268 register int regno, last_regno;
1271 /* Can't use cc0_rtx below since this file is used by genattrtab.c. */
1272 if (GET_CODE (x) == CC0)
1275 if (GET_CODE (x) != REG)
1279 last_regno = (regno >= FIRST_PSEUDO_REGISTER ? regno
1280 : regno + HARD_REGNO_NREGS (regno, GET_MODE (x)) - 1);
1282 for (i = regno; i <= last_regno; i++)
1283 if (! dead_or_set_regno_p (insn, i))
1289 /* Utility function for dead_or_set_p to check an individual register. Also
1290 called from flow.c. */
1293 dead_or_set_regno_p (insn, test_regno)
1297 int regno, endregno;
1300 /* See if there is a death note for something that includes
1302 for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
1304 if (REG_NOTE_KIND (link) != REG_DEAD
1305 || GET_CODE (XEXP (link, 0)) != REG)
1308 regno = REGNO (XEXP (link, 0));
1309 endregno = (regno >= FIRST_PSEUDO_REGISTER ? regno + 1
1310 : regno + HARD_REGNO_NREGS (regno,
1311 GET_MODE (XEXP (link, 0))));
1313 if (test_regno >= regno && test_regno < endregno)
1317 if (GET_CODE (insn) == CALL_INSN
1318 && find_regno_fusage (insn, CLOBBER, test_regno))
1321 if (GET_CODE (PATTERN (insn)) == SET)
1323 rtx dest = SET_DEST (PATTERN (insn));
1325 /* A value is totally replaced if it is the destination or the
1326 destination is a SUBREG of REGNO that does not change the number of
1328 if (GET_CODE (dest) == SUBREG
1329 && (((GET_MODE_SIZE (GET_MODE (dest))
1330 + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
1331 == ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (dest)))
1332 + UNITS_PER_WORD - 1) / UNITS_PER_WORD)))
1333 dest = SUBREG_REG (dest);
1335 if (GET_CODE (dest) != REG)
1338 regno = REGNO (dest);
1339 endregno = (regno >= FIRST_PSEUDO_REGISTER ? regno + 1
1340 : regno + HARD_REGNO_NREGS (regno, GET_MODE (dest)));
1342 return (test_regno >= regno && test_regno < endregno);
1344 else if (GET_CODE (PATTERN (insn)) == PARALLEL)
1348 for (i = XVECLEN (PATTERN (insn), 0) - 1; i >= 0; i--)
1350 rtx body = XVECEXP (PATTERN (insn), 0, i);
1352 if (GET_CODE (body) == SET || GET_CODE (body) == CLOBBER)
1354 rtx dest = SET_DEST (body);
1356 if (GET_CODE (dest) == SUBREG
1357 && (((GET_MODE_SIZE (GET_MODE (dest))
1358 + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
1359 == ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (dest)))
1360 + UNITS_PER_WORD - 1) / UNITS_PER_WORD)))
1361 dest = SUBREG_REG (dest);
1363 if (GET_CODE (dest) != REG)
1366 regno = REGNO (dest);
1367 endregno = (regno >= FIRST_PSEUDO_REGISTER ? regno + 1
1368 : regno + HARD_REGNO_NREGS (regno, GET_MODE (dest)));
1370 if (test_regno >= regno && test_regno < endregno)
1379 /* Return the reg-note of kind KIND in insn INSN, if there is one.
1380 If DATUM is nonzero, look for one whose datum is DATUM. */
1383 find_reg_note (insn, kind, datum)
1390 /* Ignore anything that is not an INSN, JUMP_INSN or CALL_INSN. */
1391 if (GET_RTX_CLASS (GET_CODE (insn)) != 'i')
1394 for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
1395 if (REG_NOTE_KIND (link) == kind
1396 && (datum == 0 || datum == XEXP (link, 0)))
1401 /* Return the reg-note of kind KIND in insn INSN which applies to register
1402 number REGNO, if any. Return 0 if there is no such reg-note. Note that
1403 the REGNO of this NOTE need not be REGNO if REGNO is a hard register;
1404 it might be the case that the note overlaps REGNO. */
1407 find_regno_note (insn, kind, regno)
1414 /* Ignore anything that is not an INSN, JUMP_INSN or CALL_INSN. */
1415 if (GET_RTX_CLASS (GET_CODE (insn)) != 'i')
1418 for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
1419 if (REG_NOTE_KIND (link) == kind
1420 /* Verify that it is a register, so that scratch and MEM won't cause a
1422 && GET_CODE (XEXP (link, 0)) == REG
1423 && REGNO (XEXP (link, 0)) <= regno
1424 && ((REGNO (XEXP (link, 0))
1425 + (REGNO (XEXP (link, 0)) >= FIRST_PSEUDO_REGISTER ? 1
1426 : HARD_REGNO_NREGS (REGNO (XEXP (link, 0)),
1427 GET_MODE (XEXP (link, 0)))))
1433 /* Return true if DATUM, or any overlap of DATUM, of kind CODE is found
1434 in the CALL_INSN_FUNCTION_USAGE information of INSN. */
1437 find_reg_fusage (insn, code, datum)
1442 /* If it's not a CALL_INSN, it can't possibly have a
1443 CALL_INSN_FUNCTION_USAGE field, so don't bother checking. */
1444 if (GET_CODE (insn) != CALL_INSN)
1450 if (GET_CODE (datum) != REG)
1454 for (link = CALL_INSN_FUNCTION_USAGE (insn);
1456 link = XEXP (link, 1))
1457 if (GET_CODE (XEXP (link, 0)) == code
1458 && rtx_equal_p (datum, SET_DEST (XEXP (link, 0))))
1463 register int regno = REGNO (datum);
1465 /* CALL_INSN_FUNCTION_USAGE information cannot contain references
1466 to pseudo registers, so don't bother checking. */
1468 if (regno < FIRST_PSEUDO_REGISTER)
1470 int end_regno = regno + HARD_REGNO_NREGS (regno, GET_MODE (datum));
1473 for (i = regno; i < end_regno; i++)
1474 if (find_regno_fusage (insn, code, i))
1482 /* Return true if REGNO, or any overlap of REGNO, of kind CODE is found
1483 in the CALL_INSN_FUNCTION_USAGE information of INSN. */
1486 find_regno_fusage (insn, code, regno)
1493 /* CALL_INSN_FUNCTION_USAGE information cannot contain references
1494 to pseudo registers, so don't bother checking. */
1496 if (regno >= FIRST_PSEUDO_REGISTER
1497 || GET_CODE (insn) != CALL_INSN )
1500 for (link = CALL_INSN_FUNCTION_USAGE (insn); link; link = XEXP (link, 1))
1502 register int regnote;
1503 register rtx op, reg;
1505 if (GET_CODE (op = XEXP (link, 0)) == code
1506 && GET_CODE (reg = XEXP (op, 0)) == REG
1507 && (regnote = REGNO (reg)) <= regno
1508 && regnote + HARD_REGNO_NREGS (regnote, GET_MODE (reg)) > regno)
1515 /* Remove register note NOTE from the REG_NOTES of INSN. */
1518 remove_note (insn, note)
1524 if (note == NULL_RTX)
1527 if (REG_NOTES (insn) == note)
1529 REG_NOTES (insn) = XEXP (note, 1);
1533 for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
1534 if (XEXP (link, 1) == note)
1536 XEXP (link, 1) = XEXP (note, 1);
1543 /* Search LISTP (an EXPR_LIST) for NODE and remove NODE from the list
1546 A simple equality test is used to determine if NODE is on the
1550 remove_node_from_expr_list (node, listp)
1555 rtx prev = NULL_RTX;
1559 if (node == XEXP (temp, 0))
1561 /* Splice the node out of the list. */
1563 XEXP (prev, 1) = XEXP (temp, 1);
1565 *listp = XEXP (temp, 1);
1569 temp = XEXP (temp, 1);
1573 /* Nonzero if X contains any volatile instructions. These are instructions
1574 which may cause unpredictable machine state instructions, and thus no
1575 instructions should be moved or combined across them. This includes
1576 only volatile asms and UNSPEC_VOLATILE instructions. */
1582 register RTX_CODE code;
1584 code = GET_CODE (x);
1604 case UNSPEC_VOLATILE:
1605 /* case TRAP_IF: This isn't clear yet. */
1609 if (MEM_VOLATILE_P (x))
1616 /* Recursively scan the operands of this expression. */
1619 register const char *fmt = GET_RTX_FORMAT (code);
1622 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
1626 if (volatile_insn_p (XEXP (x, i)))
1632 for (j = 0; j < XVECLEN (x, i); j++)
1633 if (volatile_insn_p (XVECEXP (x, i, j)))
1641 /* Nonzero if X contains any volatile memory references
1642 UNSPEC_VOLATILE operations or volatile ASM_OPERANDS expressions. */
1648 register RTX_CODE code;
1650 code = GET_CODE (x);
1669 case UNSPEC_VOLATILE:
1670 /* case TRAP_IF: This isn't clear yet. */
1675 if (MEM_VOLATILE_P (x))
1682 /* Recursively scan the operands of this expression. */
1685 register const char *fmt = GET_RTX_FORMAT (code);
1688 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
1692 if (volatile_refs_p (XEXP (x, i)))
1698 for (j = 0; j < XVECLEN (x, i); j++)
1699 if (volatile_refs_p (XVECEXP (x, i, j)))
1707 /* Similar to above, except that it also rejects register pre- and post-
1714 register RTX_CODE code;
1716 code = GET_CODE (x);
1734 /* Reject CLOBBER with a non-VOID mode. These are made by combine.c
1735 when some combination can't be done. If we see one, don't think
1736 that we can simplify the expression. */
1737 return (GET_MODE (x) != VOIDmode);
1744 case UNSPEC_VOLATILE:
1745 /* case TRAP_IF: This isn't clear yet. */
1750 if (MEM_VOLATILE_P (x))
1757 /* Recursively scan the operands of this expression. */
1760 register const char *fmt = GET_RTX_FORMAT (code);
1763 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
1767 if (side_effects_p (XEXP (x, i)))
1773 for (j = 0; j < XVECLEN (x, i); j++)
1774 if (side_effects_p (XVECEXP (x, i, j)))
1782 /* Return nonzero if evaluating rtx X might cause a trap. */
1794 code = GET_CODE (x);
1797 /* Handle these cases quickly. */
1809 /* Conditional trap can trap! */
1810 case UNSPEC_VOLATILE:
1814 /* Memory ref can trap unless it's a static var or a stack slot. */
1816 return rtx_addr_can_trap_p (XEXP (x, 0));
1818 /* Division by a non-constant might trap. */
1823 if (! CONSTANT_P (XEXP (x, 1))
1824 || GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT)
1826 /* This was const0_rtx, but by not using that,
1827 we can link this file into other programs. */
1828 if (GET_CODE (XEXP (x, 1)) == CONST_INT && INTVAL (XEXP (x, 1)) == 0)
1833 /* An EXPR_LIST is used to represent a function call. This
1834 certainly may trap. */
1838 /* Any floating arithmetic may trap. */
1839 if (GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT)
1843 fmt = GET_RTX_FORMAT (code);
1844 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
1848 if (may_trap_p (XEXP (x, i)))
1851 else if (fmt[i] == 'E')
1854 for (j = 0; j < XVECLEN (x, i); j++)
1855 if (may_trap_p (XVECEXP (x, i, j)))
1862 /* Return nonzero if X contains a comparison that is not either EQ or NE,
1863 i.e., an inequality. */
1866 inequality_comparisons_p (x)
1869 register const char *fmt;
1870 register int len, i;
1871 register enum rtx_code code = GET_CODE (x);
1900 len = GET_RTX_LENGTH (code);
1901 fmt = GET_RTX_FORMAT (code);
1903 for (i = 0; i < len; i++)
1907 if (inequality_comparisons_p (XEXP (x, i)))
1910 else if (fmt[i] == 'E')
1913 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
1914 if (inequality_comparisons_p (XVECEXP (x, i, j)))
1922 /* Replace any occurrence of FROM in X with TO. The function does
1923 not enter into CONST_DOUBLE for the replace.
1925 Note that copying is not done so X must not be shared unless all copies
1926 are to be modified. */
1929 replace_rtx (x, from, to)
1933 register const char *fmt;
1935 /* The following prevents loops occurrence when we change MEM in
1936 CONST_DOUBLE onto the same CONST_DOUBLE. */
1937 if (x != 0 && GET_CODE (x) == CONST_DOUBLE)
1943 /* Allow this function to make replacements in EXPR_LISTs. */
1947 fmt = GET_RTX_FORMAT (GET_CODE (x));
1948 for (i = GET_RTX_LENGTH (GET_CODE (x)) - 1; i >= 0; i--)
1951 XEXP (x, i) = replace_rtx (XEXP (x, i), from, to);
1952 else if (fmt[i] == 'E')
1953 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
1954 XVECEXP (x, i, j) = replace_rtx (XVECEXP (x, i, j), from, to);
1960 /* Throughout the rtx X, replace many registers according to REG_MAP.
1961 Return the replacement for X (which may be X with altered contents).
1962 REG_MAP[R] is the replacement for register R, or 0 for don't replace.
1963 NREGS is the length of REG_MAP; regs >= NREGS are not mapped.
1965 We only support REG_MAP entries of REG or SUBREG. Also, hard registers
1966 should not be mapped to pseudos or vice versa since validate_change
1969 If REPLACE_DEST is 1, replacements are also done in destinations;
1970 otherwise, only sources are replaced. */
1973 replace_regs (x, reg_map, nregs, replace_dest)
1979 register enum rtx_code code;
1981 register const char *fmt;
1986 code = GET_CODE (x);
2000 /* Verify that the register has an entry before trying to access it. */
2001 if (REGNO (x) < nregs && reg_map[REGNO (x)] != 0)
2003 /* SUBREGs can't be shared. Always return a copy to ensure that if
2004 this replacement occurs more than once then each instance will
2005 get distinct rtx. */
2006 if (GET_CODE (reg_map[REGNO (x)]) == SUBREG)
2007 return copy_rtx (reg_map[REGNO (x)]);
2008 return reg_map[REGNO (x)];
2013 /* Prevent making nested SUBREGs. */
2014 if (GET_CODE (SUBREG_REG (x)) == REG && REGNO (SUBREG_REG (x)) < nregs
2015 && reg_map[REGNO (SUBREG_REG (x))] != 0
2016 && GET_CODE (reg_map[REGNO (SUBREG_REG (x))]) == SUBREG)
2018 rtx map_val = reg_map[REGNO (SUBREG_REG (x))];
2019 rtx map_inner = SUBREG_REG (map_val);
2021 if (GET_MODE (x) == GET_MODE (map_inner))
2025 /* We cannot call gen_rtx here since we may be linked with
2027 /* Let's try clobbering the incoming SUBREG and see
2028 if this is really safe. */
2029 SUBREG_REG (x) = map_inner;
2030 SUBREG_WORD (x) += SUBREG_WORD (map_val);
2033 rtx new = rtx_alloc (SUBREG);
2034 PUT_MODE (new, GET_MODE (x));
2035 SUBREG_REG (new) = map_inner;
2036 SUBREG_WORD (new) = SUBREG_WORD (x) + SUBREG_WORD (map_val);
2044 SET_DEST (x) = replace_regs (SET_DEST (x), reg_map, nregs, 0);
2046 else if (GET_CODE (SET_DEST (x)) == MEM
2047 || GET_CODE (SET_DEST (x)) == STRICT_LOW_PART)
2048 /* Even if we are not to replace destinations, replace register if it
2049 is CONTAINED in destination (destination is memory or
2050 STRICT_LOW_PART). */
2051 XEXP (SET_DEST (x), 0) = replace_regs (XEXP (SET_DEST (x), 0),
2053 else if (GET_CODE (SET_DEST (x)) == ZERO_EXTRACT)
2054 /* Similarly, for ZERO_EXTRACT we replace all operands. */
2057 SET_SRC (x) = replace_regs (SET_SRC (x), reg_map, nregs, 0);
2064 fmt = GET_RTX_FORMAT (code);
2065 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
2068 XEXP (x, i) = replace_regs (XEXP (x, i), reg_map, nregs, replace_dest);
2072 for (j = 0; j < XVECLEN (x, i); j++)
2073 XVECEXP (x, i, j) = replace_regs (XVECEXP (x, i, j), reg_map,
2074 nregs, replace_dest);
2080 /* Return 1 if X, the SRC_SRC of SET of (pc) contain a REG or MEM that is
2081 not in the constant pool and not in the condition of an IF_THEN_ELSE. */
2084 jmp_uses_reg_or_mem (x)
2087 enum rtx_code code = GET_CODE (x);
2102 return ! (GET_CODE (XEXP (x, 0)) == SYMBOL_REF
2103 && CONSTANT_POOL_ADDRESS_P (XEXP (x, 0)));
2106 return (jmp_uses_reg_or_mem (XEXP (x, 1))
2107 || jmp_uses_reg_or_mem (XEXP (x, 2)));
2109 case PLUS: case MINUS: case MULT:
2110 return (jmp_uses_reg_or_mem (XEXP (x, 0))
2111 || jmp_uses_reg_or_mem (XEXP (x, 1)));
2117 fmt = GET_RTX_FORMAT (code);
2118 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
2121 && jmp_uses_reg_or_mem (XEXP (x, i)))
2125 for (j = 0; j < XVECLEN (x, i); j++)
2126 if (jmp_uses_reg_or_mem (XVECEXP (x, i, j)))
2133 /* Return nonzero if INSN is an indirect jump (aka computed jump).
2135 Tablejumps and casesi insns are not considered indirect jumps;
2136 we can recognize them by a (use (lael_ref)). */
2139 computed_jump_p (insn)
2143 if (GET_CODE (insn) == JUMP_INSN)
2145 rtx pat = PATTERN (insn);
2147 if (GET_CODE (pat) == PARALLEL)
2149 int len = XVECLEN (pat, 0);
2150 int has_use_labelref = 0;
2152 for (i = len - 1; i >= 0; i--)
2153 if (GET_CODE (XVECEXP (pat, 0, i)) == USE
2154 && (GET_CODE (XEXP (XVECEXP (pat, 0, i), 0))
2156 has_use_labelref = 1;
2158 if (! has_use_labelref)
2159 for (i = len - 1; i >= 0; i--)
2160 if (GET_CODE (XVECEXP (pat, 0, i)) == SET
2161 && SET_DEST (XVECEXP (pat, 0, i)) == pc_rtx
2162 && jmp_uses_reg_or_mem (SET_SRC (XVECEXP (pat, 0, i))))
2165 else if (GET_CODE (pat) == SET
2166 && SET_DEST (pat) == pc_rtx
2167 && jmp_uses_reg_or_mem (SET_SRC (pat)))
2173 /* Traverse X via depth-first search, calling F for each
2174 sub-expression (including X itself). F is also passed the DATA.
2175 If F returns -1, do not traverse sub-expressions, but continue
2176 traversing the rest of the tree. If F ever returns any other
2177 non-zero value, stop the traversal, and return the value returned
2178 by F. Otherwise, return 0. This function does not traverse inside
2179 tree structure that contains RTX_EXPRs, or into sub-expressions
2180 whose format code is `0' since it is not known whether or not those
2181 codes are actually RTL.
2183 This routine is very general, and could (should?) be used to
2184 implement many of the other routines in this file. */
2187 for_each_rtx (x, f, data)
2198 result = (*f)(x, data);
2200 /* Do not traverse sub-expressions. */
2202 else if (result != 0)
2203 /* Stop the traversal. */
2207 /* There are no sub-expressions. */
2210 length = GET_RTX_LENGTH (GET_CODE (*x));
2211 format = GET_RTX_FORMAT (GET_CODE (*x));
2213 for (i = 0; i < length; ++i)
2218 result = for_each_rtx (&XEXP (*x, i), f, data);
2225 if (XVEC (*x, i) != 0)
2228 for (j = 0; j < XVECLEN (*x, i); ++j)
2230 result = for_each_rtx (&XVECEXP (*x, i, j), f, data);
2238 /* Nothing to do. */
2247 /* Searches X for any reference to REGNO, returning the rtx of the
2248 reference found if any. Otherwise, returns NULL_RTX. */
2251 regno_use_in (regno, x)
2255 register const char *fmt;
2259 if (GET_CODE (x) == REG && REGNO (x) == regno)
2262 fmt = GET_RTX_FORMAT (GET_CODE (x));
2263 for (i = GET_RTX_LENGTH (GET_CODE (x)) - 1; i >= 0; i--)
2267 if ((tem = regno_use_in (regno, XEXP (x, i))))
2270 else if (fmt[i] == 'E')
2271 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
2272 if ((tem = regno_use_in (regno , XVECEXP (x, i, j))))
2280 /* Return 1 if X is an autoincrement side effect and the register is
2281 not the stack pointer. */
2286 switch (GET_CODE (x))
2294 /* There are no REG_INC notes for SP. */
2295 if (XEXP (x, 0) != stack_pointer_rtx)
2303 /* Return 1 if the sequence of instructions beginning with FROM and up
2304 to and including TO is safe to move. If NEW_TO is non-NULL, and
2305 the sequence is not already safe to move, but can be easily
2306 extended to a sequence which is safe, then NEW_TO will point to the
2307 end of the extended sequence.
2309 For now, this function only checks that the region contains whole
2310 exception regiongs, but it could be extended to check additional
2311 conditions as well. */
2314 insns_safe_to_move_p (from, to, new_to)
2319 int eh_region_count = 0;
2323 /* By default, assume the end of the region will be what was
2330 if (GET_CODE (r) == NOTE)
2332 switch (NOTE_LINE_NUMBER (r))
2334 case NOTE_INSN_EH_REGION_BEG:
2338 case NOTE_INSN_EH_REGION_END:
2339 if (eh_region_count == 0)
2340 /* This sequence of instructions contains the end of
2341 an exception region, but not he beginning. Moving
2342 it will cause chaos. */
2353 /* If we've passed TO, and we see a non-note instruction, we
2354 can't extend the sequence to a movable sequence. */
2360 /* It's OK to move the sequence if there were matched sets of
2361 exception region notes. */
2362 return eh_region_count == 0;
2367 /* It's OK to move the sequence if there were matched sets of
2368 exception region notes. */
2369 if (past_to_p && eh_region_count == 0)
2375 /* Go to the next instruction. */