1 /* Analyze RTL for C-Compiler
2 Copyright (C) 1987, 1988, 1991, 1992, 1993 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, 675 Mass Ave, Cambridge, MA 02139, USA. */
27 /* Bit flags that specify the machine subtype we are compiling for.
28 Bits are tested using macros TARGET_... defined in the tm.h file
29 and set by `-m...' switches. Must be defined in rtlanal.c. */
33 /* Return 1 if the value of X is unstable
34 (would be different at a different point in the program).
35 The frame pointer, arg pointer, etc. are considered stable
36 (within one function) and so is anything marked `unchanging'. */
42 register RTX_CODE code = GET_CODE (x);
47 return ! RTX_UNCHANGING_P (x);
52 if (code == CONST || code == CONST_INT)
56 return ! (REGNO (x) == FRAME_POINTER_REGNUM
57 || REGNO (x) == HARD_FRAME_POINTER_REGNUM
58 || REGNO (x) == ARG_POINTER_REGNUM
59 || RTX_UNCHANGING_P (x));
61 fmt = GET_RTX_FORMAT (code);
62 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
64 if (rtx_unstable_p (XEXP (x, i)))
69 /* Return 1 if X has a value that can vary even between two
70 executions of the program. 0 means X can be compared reliably
71 against certain constants or near-constants.
72 The frame pointer and the arg pointer are considered constant. */
78 register RTX_CODE code = GET_CODE (x);
96 /* Note that we have to test for the actual rtx used for the frame
97 and arg pointers and not just the register number in case we have
98 eliminated the frame and/or arg pointer and are using it
100 return ! (x == frame_pointer_rtx || x == hard_frame_pointer_rtx
101 || x == arg_pointer_rtx);
104 /* The operand 0 of a LO_SUM is considered constant
105 (in fact is it related specifically to operand 1). */
106 return rtx_varies_p (XEXP (x, 1));
109 fmt = GET_RTX_FORMAT (code);
110 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
112 if (rtx_varies_p (XEXP (x, i)))
117 /* Return 0 if the use of X as an address in a MEM can cause a trap. */
120 rtx_addr_can_trap_p (x)
123 register enum rtx_code code = GET_CODE (x);
129 /* SYMBOL_REF is problematic due to the possible presence of
130 a #pragma weak, but to say that loads from symbols can trap is
131 *very* costly. It's not at all clear what's best here. For
132 now, we ignore the impact of #pragma weak. */
136 /* As in rtx_varies_p, we have to use the actual rtx, not reg number. */
137 return ! (x == frame_pointer_rtx || x == hard_frame_pointer_rtx
138 || x == stack_pointer_rtx || x == arg_pointer_rtx);
141 return rtx_addr_can_trap_p (XEXP (x, 0));
144 /* An address is assumed not to trap if it is an address that can't
145 trap plus a constant integer. */
146 return (rtx_addr_can_trap_p (XEXP (x, 0))
147 || GET_CODE (XEXP (x, 1)) != CONST_INT);
150 return rtx_addr_can_trap_p (XEXP (x, 1));
153 /* If it isn't one of the case above, it can cause a trap. */
157 /* Return 1 if X refers to a memory location whose address
158 cannot be compared reliably with constant addresses,
159 or if X refers to a BLKmode memory object. */
162 rtx_addr_varies_p (x)
165 register enum rtx_code code;
174 return GET_MODE (x) == BLKmode || rtx_varies_p (XEXP (x, 0));
176 fmt = GET_RTX_FORMAT (code);
177 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
179 if (rtx_addr_varies_p (XEXP (x, i)))
184 /* Return the value of the integer term in X, if one is apparent;
186 Only obvious integer terms are detected.
187 This is used in cse.c with the `related_value' field.*/
193 if (GET_CODE (x) == CONST)
196 if (GET_CODE (x) == MINUS
197 && GET_CODE (XEXP (x, 1)) == CONST_INT)
198 return - INTVAL (XEXP (x, 1));
199 if (GET_CODE (x) == PLUS
200 && GET_CODE (XEXP (x, 1)) == CONST_INT)
201 return INTVAL (XEXP (x, 1));
205 /* If X is a constant, return the value sans apparent integer term;
207 Only obvious integer terms are detected. */
210 get_related_value (x)
213 if (GET_CODE (x) != CONST)
216 if (GET_CODE (x) == PLUS
217 && GET_CODE (XEXP (x, 1)) == CONST_INT)
219 else if (GET_CODE (x) == MINUS
220 && GET_CODE (XEXP (x, 1)) == CONST_INT)
225 /* Nonzero if register REG appears somewhere within IN.
226 Also works if REG is not a register; in this case it checks
227 for a subexpression of IN that is Lisp "equal" to REG. */
230 reg_mentioned_p (reg, in)
231 register rtx reg, in;
235 register enum rtx_code code;
243 if (GET_CODE (in) == LABEL_REF)
244 return reg == XEXP (in, 0);
246 code = GET_CODE (in);
250 /* Compare registers by number. */
252 return GET_CODE (reg) == REG && REGNO (in) == REGNO (reg);
254 /* These codes have no constituent expressions
262 return GET_CODE (reg) == CONST_INT && INTVAL (in) == INTVAL (reg);
265 /* These are kept unique for a given value. */
269 if (GET_CODE (reg) == code && rtx_equal_p (reg, in))
272 fmt = GET_RTX_FORMAT (code);
274 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
279 for (j = XVECLEN (in, i) - 1; j >= 0; j--)
280 if (reg_mentioned_p (reg, XVECEXP (in, i, j)))
283 else if (fmt[i] == 'e'
284 && reg_mentioned_p (reg, XEXP (in, i)))
290 /* Return 1 if in between BEG and END, exclusive of BEG and END, there is
291 no CODE_LABEL insn. */
294 no_labels_between_p (beg, end)
298 for (p = NEXT_INSN (beg); p != end; p = NEXT_INSN (p))
299 if (GET_CODE (p) == CODE_LABEL)
304 /* Nonzero if register REG is used in an insn between
305 FROM_INSN and TO_INSN (exclusive of those two). */
308 reg_used_between_p (reg, from_insn, to_insn)
309 rtx reg, from_insn, to_insn;
313 if (from_insn == to_insn)
316 for (insn = NEXT_INSN (from_insn); insn != to_insn; insn = NEXT_INSN (insn))
317 if (GET_RTX_CLASS (GET_CODE (insn)) == 'i'
318 && reg_overlap_mentioned_p (reg, PATTERN (insn)))
323 /* Nonzero if the old value of X, a register, is referenced in BODY. If X
324 is entirely replaced by a new value and the only use is as a SET_DEST,
325 we do not consider it a reference. */
328 reg_referenced_p (x, body)
334 switch (GET_CODE (body))
337 if (reg_overlap_mentioned_p (x, SET_SRC (body)))
340 /* If the destination is anything other than CC0, PC, a REG or a SUBREG
341 of a REG that occupies all of the REG, the insn references X if
342 it is mentioned in the destination. */
343 if (GET_CODE (SET_DEST (body)) != CC0
344 && GET_CODE (SET_DEST (body)) != PC
345 && GET_CODE (SET_DEST (body)) != REG
346 && ! (GET_CODE (SET_DEST (body)) == SUBREG
347 && GET_CODE (SUBREG_REG (SET_DEST (body))) == REG
348 && (((GET_MODE_SIZE (GET_MODE (SUBREG_REG (SET_DEST (body))))
349 + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD)
350 == ((GET_MODE_SIZE (GET_MODE (SET_DEST (body)))
351 + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD)))
352 && reg_overlap_mentioned_p (x, SET_DEST (body)))
357 for (i = ASM_OPERANDS_INPUT_LENGTH (body) - 1; i >= 0; i--)
358 if (reg_overlap_mentioned_p (x, ASM_OPERANDS_INPUT (body, i)))
364 return reg_overlap_mentioned_p (x, body);
367 return reg_overlap_mentioned_p (x, TRAP_CONDITION (body));
370 case UNSPEC_VOLATILE:
372 for (i = XVECLEN (body, 0) - 1; i >= 0; i--)
373 if (reg_referenced_p (x, XVECEXP (body, 0, i)))
381 /* Nonzero if register REG is referenced in an insn between
382 FROM_INSN and TO_INSN (exclusive of those two). Sets of REG do
386 reg_referenced_between_p (reg, from_insn, to_insn)
387 rtx reg, from_insn, to_insn;
391 if (from_insn == to_insn)
394 for (insn = NEXT_INSN (from_insn); insn != to_insn; insn = NEXT_INSN (insn))
395 if (GET_RTX_CLASS (GET_CODE (insn)) == 'i'
396 && reg_referenced_p (reg, PATTERN (insn)))
401 /* Nonzero if register REG is set or clobbered in an insn between
402 FROM_INSN and TO_INSN (exclusive of those two). */
405 reg_set_between_p (reg, from_insn, to_insn)
406 rtx reg, from_insn, to_insn;
410 if (from_insn == to_insn)
413 for (insn = NEXT_INSN (from_insn); insn != to_insn; insn = NEXT_INSN (insn))
414 if (GET_RTX_CLASS (GET_CODE (insn)) == 'i'
415 && reg_set_p (reg, insn))
420 /* Internals of reg_set_between_p. */
422 static rtx reg_set_reg;
423 static int reg_set_flag;
429 /* We don't want to return 1 if X is a MEM that contains a register
430 within REG_SET_REG. */
432 if ((GET_CODE (x) != MEM)
433 && reg_overlap_mentioned_p (reg_set_reg, x))
438 reg_set_p (reg, insn)
443 /* We can be passed an insn or part of one. If we are passed an insn,
444 check if a side-effect of the insn clobbers REG. */
445 if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
447 if (FIND_REG_INC_NOTE (insn, reg)
448 || (GET_CODE (insn) == CALL_INSN
449 /* We'd like to test call_used_regs here, but rtlanal.c can't
450 reference that variable due to its use in genattrtab. So
451 we'll just be more conservative. */
452 && ((GET_CODE (reg) == REG
453 && REGNO (reg) < FIRST_PSEUDO_REGISTER)
454 || GET_CODE (reg) == MEM)))
457 body = PATTERN (insn);
462 note_stores (body, reg_set_p_1);
466 /* Similar to reg_set_between_p, but check all registers in X. Return 0
467 only if none of them are modified between START and END. Return 1 if
468 X contains a MEM; this routine does not perform any memory aliasing. */
471 modified_between_p (x, start, end)
475 enum rtx_code code = GET_CODE (x);
493 /* If the memory is not constant, assume it is modified. If it is
494 constant, we still have to check the address. */
495 if (! RTX_UNCHANGING_P (x))
500 return reg_set_between_p (x, start, end);
503 fmt = GET_RTX_FORMAT (code);
504 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
506 if (fmt[i] == 'e' && modified_between_p (XEXP (x, i), start, end))
510 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
511 if (modified_between_p (XVECEXP (x, i, j), start, end))
518 /* Similar to reg_set_p, but check all registers in X. Return 0 only if none
519 of them are modified in INSN. Return 1 if X contains a MEM; this routine
520 does not perform any memory aliasing. */
523 modified_in_p (x, insn)
527 enum rtx_code code = GET_CODE (x);
545 /* If the memory is not constant, assume it is modified. If it is
546 constant, we still have to check the address. */
547 if (! RTX_UNCHANGING_P (x))
552 return reg_set_p (x, insn);
555 fmt = GET_RTX_FORMAT (code);
556 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
558 if (fmt[i] == 'e' && modified_in_p (XEXP (x, i), insn))
562 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
563 if (modified_in_p (XVECEXP (x, i, j), insn))
570 /* Given an INSN, return a SET expression if this insn has only a single SET.
571 It may also have CLOBBERs, USEs, or SET whose output
572 will not be used, which we ignore. */
581 if (GET_RTX_CLASS (GET_CODE (insn)) != 'i')
584 if (GET_CODE (PATTERN (insn)) == SET)
585 return PATTERN (insn);
587 else if (GET_CODE (PATTERN (insn)) == PARALLEL)
589 for (i = 0, set = 0; i < XVECLEN (PATTERN (insn), 0); i++)
590 if (GET_CODE (XVECEXP (PATTERN (insn), 0, i)) == SET
591 && (! find_reg_note (insn, REG_UNUSED,
592 SET_DEST (XVECEXP (PATTERN (insn), 0, i)))
593 || side_effects_p (XVECEXP (PATTERN (insn), 0, i))))
598 set = XVECEXP (PATTERN (insn), 0, i);
606 /* Return the last thing that X was assigned from before *PINSN. Verify that
607 the object is not modified up to VALID_TO. If it was, if we hit
608 a partial assignment to X, or hit a CODE_LABEL first, return X. If we
609 found an assignment, update *PINSN to point to it. */
612 find_last_value (x, pinsn, valid_to)
619 for (p = PREV_INSN (*pinsn); p && GET_CODE (p) != CODE_LABEL;
621 if (GET_RTX_CLASS (GET_CODE (p)) == 'i')
623 rtx set = single_set (p);
624 rtx note = find_reg_note (p, REG_EQUAL, NULL_RTX);
626 if (set && rtx_equal_p (x, SET_DEST (set)))
628 rtx src = SET_SRC (set);
630 if (note && GET_CODE (XEXP (note, 0)) != EXPR_LIST)
631 src = XEXP (note, 0);
633 if (! modified_between_p (src, PREV_INSN (p), valid_to)
634 /* Reject hard registers because we don't usually want
635 to use them; we'd rather use a pseudo. */
636 && ! (GET_CODE (src) == REG
637 && REGNO (src) < FIRST_PSEUDO_REGISTER))
644 /* If set in non-simple way, we don't have a value. */
645 if (reg_set_p (x, p))
652 /* Return nonzero if register in range [REGNO, ENDREGNO)
653 appears either explicitly or implicitly in X
654 other than being stored into.
656 References contained within the substructure at LOC do not count.
657 LOC may be zero, meaning don't ignore anything. */
660 refers_to_regno_p (regno, endregno, x, loc)
666 register RTX_CODE code;
670 /* The contents of a REG_NONNEG note is always zero, so we must come here
671 upon repeat in case the last REG_NOTE is a REG_NONNEG note. */
682 /* If we modifying the stack, frame, or argument pointer, it will
683 clobber a virtual register. In fact, we could be more precise,
684 but it isn't worth it. */
685 if ((i == STACK_POINTER_REGNUM
686 #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
687 || i == ARG_POINTER_REGNUM
689 || i == FRAME_POINTER_REGNUM)
690 && regno >= FIRST_VIRTUAL_REGISTER && regno <= LAST_VIRTUAL_REGISTER)
694 && regno < i + (i < FIRST_PSEUDO_REGISTER
695 ? HARD_REGNO_NREGS (i, GET_MODE (x))
699 /* If this is a SUBREG of a hard reg, we can see exactly which
700 registers are being modified. Otherwise, handle normally. */
701 if (GET_CODE (SUBREG_REG (x)) == REG
702 && REGNO (SUBREG_REG (x)) < FIRST_PSEUDO_REGISTER)
704 int inner_regno = REGNO (SUBREG_REG (x)) + SUBREG_WORD (x);
706 = inner_regno + (inner_regno < FIRST_PSEUDO_REGISTER
707 ? HARD_REGNO_NREGS (regno, GET_MODE (x)) : 1);
709 return endregno > inner_regno && regno < inner_endregno;
715 if (&SET_DEST (x) != loc
716 /* Note setting a SUBREG counts as referring to the REG it is in for
717 a pseudo but not for hard registers since we can
718 treat each word individually. */
719 && ((GET_CODE (SET_DEST (x)) == SUBREG
720 && loc != &SUBREG_REG (SET_DEST (x))
721 && GET_CODE (SUBREG_REG (SET_DEST (x))) == REG
722 && REGNO (SUBREG_REG (SET_DEST (x))) >= FIRST_PSEUDO_REGISTER
723 && refers_to_regno_p (regno, endregno,
724 SUBREG_REG (SET_DEST (x)), loc))
725 || (GET_CODE (SET_DEST (x)) != REG
726 && refers_to_regno_p (regno, endregno, SET_DEST (x), loc))))
729 if (code == CLOBBER || loc == &SET_SRC (x))
735 /* X does not match, so try its subexpressions. */
737 fmt = GET_RTX_FORMAT (code);
738 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
740 if (fmt[i] == 'e' && loc != &XEXP (x, i))
748 if (refers_to_regno_p (regno, endregno, XEXP (x, i), loc))
751 else if (fmt[i] == 'E')
754 for (j = XVECLEN (x, i) - 1; j >=0; j--)
755 if (loc != &XVECEXP (x, i, j)
756 && refers_to_regno_p (regno, endregno, XVECEXP (x, i, j), loc))
763 /* Nonzero if modifying X will affect IN. If X is a register or a SUBREG,
764 we check if any register number in X conflicts with the relevant register
765 numbers. If X is a constant, return 0. If X is a MEM, return 1 iff IN
766 contains a MEM (we don't bother checking for memory addresses that can't
767 conflict because we expect this to be a rare case. */
770 reg_overlap_mentioned_p (x, in)
775 if (GET_CODE (x) == SUBREG)
777 regno = REGNO (SUBREG_REG (x));
778 if (regno < FIRST_PSEUDO_REGISTER)
779 regno += SUBREG_WORD (x);
781 else if (GET_CODE (x) == REG)
783 else if (CONSTANT_P (x))
785 else if (GET_CODE (x) == MEM)
790 if (GET_CODE (in) == MEM)
793 fmt = GET_RTX_FORMAT (GET_CODE (in));
795 for (i = GET_RTX_LENGTH (GET_CODE (in)) - 1; i >= 0; i--)
796 if (fmt[i] == 'e' && reg_overlap_mentioned_p (x, XEXP (in, i)))
801 else if (GET_CODE (x) == SCRATCH || GET_CODE (x) == PC
802 || GET_CODE (x) == CC0)
803 return reg_mentioned_p (x, in);
807 endregno = regno + (regno < FIRST_PSEUDO_REGISTER
808 ? HARD_REGNO_NREGS (regno, GET_MODE (x)) : 1);
810 return refers_to_regno_p (regno, endregno, in, NULL_PTR);
813 /* Used for communications between the next few functions. */
815 static int reg_set_last_unknown;
816 static rtx reg_set_last_value;
817 static int reg_set_last_first_regno, reg_set_last_last_regno;
819 /* Called via note_stores from reg_set_last. */
822 reg_set_last_1 (x, pat)
828 /* If X is not a register, or is not one in the range we care
830 if (GET_CODE (x) != REG)
834 last = first + (first < FIRST_PSEUDO_REGISTER
835 ? HARD_REGNO_NREGS (first, GET_MODE (x)) : 1);
837 if (first >= reg_set_last_last_regno
838 || last <= reg_set_last_first_regno)
841 /* If this is a CLOBBER or is some complex LHS, or doesn't modify
842 exactly the registers we care about, show we don't know the value. */
843 if (GET_CODE (pat) == CLOBBER || SET_DEST (pat) != x
844 || first != reg_set_last_first_regno
845 || last != reg_set_last_last_regno)
846 reg_set_last_unknown = 1;
848 reg_set_last_value = SET_SRC (pat);
851 /* Return the last value to which REG was set prior to INSN. If we can't
852 find it easily, return 0.
854 We only return a REG, SUBREG, or constant because it is too hard to
855 check if a MEM remains unchanged. */
858 reg_set_last (x, insn)
862 rtx orig_insn = insn;
864 reg_set_last_first_regno = REGNO (x);
866 reg_set_last_last_regno
867 = reg_set_last_first_regno
868 + (reg_set_last_first_regno < FIRST_PSEUDO_REGISTER
869 ? HARD_REGNO_NREGS (reg_set_last_first_regno, GET_MODE (x)) : 1);
871 reg_set_last_unknown = 0;
872 reg_set_last_value = 0;
874 /* Scan backwards until reg_set_last_1 changed one of the above flags.
875 Stop when we reach a label or X is a hard reg and we reach a
876 CALL_INSN (if reg_set_last_last_regno is a hard reg).
878 If we find a set of X, ensure that its SET_SRC remains unchanged. */
880 /* We compare with <= here, because reg_set_last_last_regno
881 is actually the number of the first reg *not* in X. */
883 insn && GET_CODE (insn) != CODE_LABEL
884 && ! (GET_CODE (insn) == CALL_INSN
885 && reg_set_last_last_regno <= FIRST_PSEUDO_REGISTER);
886 insn = PREV_INSN (insn))
887 if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
889 note_stores (PATTERN (insn), reg_set_last_1);
890 if (reg_set_last_unknown)
892 else if (reg_set_last_value)
894 if (CONSTANT_P (reg_set_last_value)
895 || ((GET_CODE (reg_set_last_value) == REG
896 || GET_CODE (reg_set_last_value) == SUBREG)
897 && ! reg_set_between_p (reg_set_last_value,
898 NEXT_INSN (insn), orig_insn)))
899 return reg_set_last_value;
908 /* This is 1 until after reload pass. */
909 int rtx_equal_function_value_matters;
911 /* Return 1 if X and Y are identical-looking rtx's.
912 This is the Lisp function EQUAL for rtx arguments. */
920 register enum rtx_code code;
925 if (x == 0 || y == 0)
929 /* Rtx's of different codes cannot be equal. */
930 if (code != GET_CODE (y))
933 /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent.
934 (REG:SI x) and (REG:HI x) are NOT equivalent. */
936 if (GET_MODE (x) != GET_MODE (y))
939 /* REG, LABEL_REF, and SYMBOL_REF can be compared nonrecursively. */
942 /* Until rtl generation is complete, don't consider a reference to the
943 return register of the current function the same as the return from a
944 called function. This eases the job of function integration. Once the
945 distinction is no longer needed, they can be considered equivalent. */
946 return (REGNO (x) == REGNO (y)
947 && (! rtx_equal_function_value_matters
948 || REG_FUNCTION_VALUE_P (x) == REG_FUNCTION_VALUE_P (y)));
949 else if (code == LABEL_REF)
950 return XEXP (x, 0) == XEXP (y, 0);
951 else if (code == SYMBOL_REF)
952 return XSTR (x, 0) == XSTR (y, 0);
953 else if (code == SCRATCH || code == CONST_DOUBLE)
956 /* Compare the elements. If any pair of corresponding elements
957 fail to match, return 0 for the whole things. */
959 fmt = GET_RTX_FORMAT (code);
960 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
965 if (XWINT (x, i) != XWINT (y, i))
971 if (XINT (x, i) != XINT (y, i))
977 /* Two vectors must have the same length. */
978 if (XVECLEN (x, i) != XVECLEN (y, i))
981 /* And the corresponding elements must match. */
982 for (j = 0; j < XVECLEN (x, i); j++)
983 if (rtx_equal_p (XVECEXP (x, i, j), XVECEXP (y, i, j)) == 0)
988 if (rtx_equal_p (XEXP (x, i), XEXP (y, i)) == 0)
994 if (strcmp (XSTR (x, i), XSTR (y, i)))
999 /* These are just backpointers, so they don't matter. */
1005 /* It is believed that rtx's at this level will never
1006 contain anything but integers and other rtx's,
1007 except for within LABEL_REFs and SYMBOL_REFs. */
1015 /* Call FUN on each register or MEM that is stored into or clobbered by X.
1016 (X would be the pattern of an insn).
1017 FUN receives two arguments:
1018 the REG, MEM, CC0 or PC being stored in or clobbered,
1019 the SET or CLOBBER rtx that does the store.
1021 If the item being stored in or clobbered is a SUBREG of a hard register,
1022 the SUBREG will be passed. */
1025 note_stores (x, fun)
1029 if ((GET_CODE (x) == SET || GET_CODE (x) == CLOBBER))
1031 register rtx dest = SET_DEST (x);
1032 while ((GET_CODE (dest) == SUBREG
1033 && (GET_CODE (SUBREG_REG (dest)) != REG
1034 || REGNO (SUBREG_REG (dest)) >= FIRST_PSEUDO_REGISTER))
1035 || GET_CODE (dest) == ZERO_EXTRACT
1036 || GET_CODE (dest) == SIGN_EXTRACT
1037 || GET_CODE (dest) == STRICT_LOW_PART)
1038 dest = XEXP (dest, 0);
1041 else if (GET_CODE (x) == PARALLEL)
1044 for (i = XVECLEN (x, 0) - 1; i >= 0; i--)
1046 register rtx y = XVECEXP (x, 0, i);
1047 if (GET_CODE (y) == SET || GET_CODE (y) == CLOBBER)
1049 register rtx dest = SET_DEST (y);
1050 while ((GET_CODE (dest) == SUBREG
1051 && (GET_CODE (SUBREG_REG (dest)) != REG
1052 || (REGNO (SUBREG_REG (dest))
1053 >= FIRST_PSEUDO_REGISTER)))
1054 || GET_CODE (dest) == ZERO_EXTRACT
1055 || GET_CODE (dest) == SIGN_EXTRACT
1056 || GET_CODE (dest) == STRICT_LOW_PART)
1057 dest = XEXP (dest, 0);
1064 /* Return nonzero if X's old contents don't survive after INSN.
1065 This will be true if X is (cc0) or if X is a register and
1066 X dies in INSN or because INSN entirely sets X.
1068 "Entirely set" means set directly and not through a SUBREG,
1069 ZERO_EXTRACT or SIGN_EXTRACT, so no trace of the old contents remains.
1070 Likewise, REG_INC does not count.
1072 REG may be a hard or pseudo reg. Renumbering is not taken into account,
1073 but for this use that makes no difference, since regs don't overlap
1074 during their lifetimes. Therefore, this function may be used
1075 at any time after deaths have been computed (in flow.c).
1077 If REG is a hard reg that occupies multiple machine registers, this
1078 function will only return 1 if each of those registers will be replaced
1082 dead_or_set_p (insn, x)
1086 register int regno, last_regno;
1089 /* Can't use cc0_rtx below since this file is used by genattrtab.c. */
1090 if (GET_CODE (x) == CC0)
1093 if (GET_CODE (x) != REG)
1097 last_regno = (regno >= FIRST_PSEUDO_REGISTER ? regno
1098 : regno + HARD_REGNO_NREGS (regno, GET_MODE (x)) - 1);
1100 for (i = regno; i <= last_regno; i++)
1101 if (! dead_or_set_regno_p (insn, i))
1107 /* Utility function for dead_or_set_p to check an individual register. Also
1108 called from flow.c. */
1111 dead_or_set_regno_p (insn, test_regno)
1115 int regno, endregno;
1118 /* See if there is a death note for something that includes TEST_REGNO. */
1119 for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
1121 if (REG_NOTE_KIND (link) != REG_DEAD || GET_CODE (XEXP (link, 0)) != REG)
1124 regno = REGNO (XEXP (link, 0));
1125 endregno = (regno >= FIRST_PSEUDO_REGISTER ? regno + 1
1126 : regno + HARD_REGNO_NREGS (regno,
1127 GET_MODE (XEXP (link, 0))));
1129 if (test_regno >= regno && test_regno < endregno)
1133 if (GET_CODE (PATTERN (insn)) == SET)
1135 rtx dest = SET_DEST (PATTERN (insn));
1137 /* A value is totally replaced if it is the destination or the
1138 destination is a SUBREG of REGNO that does not change the number of
1140 if (GET_CODE (dest) == SUBREG
1141 && (((GET_MODE_SIZE (GET_MODE (dest))
1142 + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
1143 == ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (dest)))
1144 + UNITS_PER_WORD - 1) / UNITS_PER_WORD)))
1145 dest = SUBREG_REG (dest);
1147 if (GET_CODE (dest) != REG)
1150 regno = REGNO (dest);
1151 endregno = (regno >= FIRST_PSEUDO_REGISTER ? regno + 1
1152 : regno + HARD_REGNO_NREGS (regno, GET_MODE (dest)));
1154 return (test_regno >= regno && test_regno < endregno);
1156 else if (GET_CODE (PATTERN (insn)) == PARALLEL)
1160 for (i = XVECLEN (PATTERN (insn), 0) - 1; i >= 0; i--)
1162 rtx body = XVECEXP (PATTERN (insn), 0, i);
1164 if (GET_CODE (body) == SET || GET_CODE (body) == CLOBBER)
1166 rtx dest = SET_DEST (body);
1168 if (GET_CODE (dest) == SUBREG
1169 && (((GET_MODE_SIZE (GET_MODE (dest))
1170 + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
1171 == ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (dest)))
1172 + UNITS_PER_WORD - 1) / UNITS_PER_WORD)))
1173 dest = SUBREG_REG (dest);
1175 if (GET_CODE (dest) != REG)
1178 regno = REGNO (dest);
1179 endregno = (regno >= FIRST_PSEUDO_REGISTER ? regno + 1
1180 : regno + HARD_REGNO_NREGS (regno, GET_MODE (dest)));
1182 if (test_regno >= regno && test_regno < endregno)
1191 /* Return the reg-note of kind KIND in insn INSN, if there is one.
1192 If DATUM is nonzero, look for one whose datum is DATUM. */
1195 find_reg_note (insn, kind, datum)
1202 for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
1203 if (REG_NOTE_KIND (link) == kind
1204 && (datum == 0 || datum == XEXP (link, 0)))
1209 /* Return the reg-note of kind KIND in insn INSN which applies to register
1210 number REGNO, if any. Return 0 if there is no such reg-note. Note that
1211 the REGNO of this NOTE need not be REGNO if REGNO is a hard register;
1212 it might be the case that the note overlaps REGNO. */
1215 find_regno_note (insn, kind, regno)
1222 for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
1223 if (REG_NOTE_KIND (link) == kind
1224 /* Verify that it is a register, so that scratch and MEM won't cause a
1226 && GET_CODE (XEXP (link, 0)) == REG
1227 && REGNO (XEXP (link, 0)) <= regno
1228 && ((REGNO (XEXP (link, 0))
1229 + (REGNO (XEXP (link, 0)) >= FIRST_PSEUDO_REGISTER ? 1
1230 : HARD_REGNO_NREGS (REGNO (XEXP (link, 0)),
1231 GET_MODE (XEXP (link, 0)))))
1237 /* Remove register note NOTE from the REG_NOTES of INSN. */
1240 remove_note (insn, note)
1246 if (REG_NOTES (insn) == note)
1248 REG_NOTES (insn) = XEXP (note, 1);
1252 for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
1253 if (XEXP (link, 1) == note)
1255 XEXP (link, 1) = XEXP (note, 1);
1262 /* Nonzero if X contains any volatile instructions. These are instructions
1263 which may cause unpredictable machine state instructions, and thus no
1264 instructions should be moved or combined across them. This includes
1265 only volatile asms and UNSPEC_VOLATILE instructions. */
1271 register RTX_CODE code;
1273 code = GET_CODE (x);
1293 case UNSPEC_VOLATILE:
1294 /* case TRAP_IF: This isn't clear yet. */
1298 if (MEM_VOLATILE_P (x))
1302 /* Recursively scan the operands of this expression. */
1305 register char *fmt = GET_RTX_FORMAT (code);
1308 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
1312 if (volatile_refs_p (XEXP (x, i)))
1318 for (j = 0; j < XVECLEN (x, i); j++)
1319 if (volatile_refs_p (XVECEXP (x, i, j)))
1327 /* Nonzero if X contains any volatile memory references
1328 UNSPEC_VOLATILE operations or volatile ASM_OPERANDS expressions. */
1334 register RTX_CODE code;
1336 code = GET_CODE (x);
1355 case UNSPEC_VOLATILE:
1356 /* case TRAP_IF: This isn't clear yet. */
1361 if (MEM_VOLATILE_P (x))
1365 /* Recursively scan the operands of this expression. */
1368 register char *fmt = GET_RTX_FORMAT (code);
1371 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
1375 if (volatile_refs_p (XEXP (x, i)))
1381 for (j = 0; j < XVECLEN (x, i); j++)
1382 if (volatile_refs_p (XVECEXP (x, i, j)))
1390 /* Similar to above, except that it also rejects register pre- and post-
1397 register RTX_CODE code;
1399 code = GET_CODE (x);
1417 /* Reject CLOBBER with a non-VOID mode. These are made by combine.c
1418 when some combination can't be done. If we see one, don't think
1419 that we can simplify the expression. */
1420 return (GET_MODE (x) != VOIDmode);
1427 case UNSPEC_VOLATILE:
1428 /* case TRAP_IF: This isn't clear yet. */
1433 if (MEM_VOLATILE_P (x))
1437 /* Recursively scan the operands of this expression. */
1440 register char *fmt = GET_RTX_FORMAT (code);
1443 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
1447 if (side_effects_p (XEXP (x, i)))
1453 for (j = 0; j < XVECLEN (x, i); j++)
1454 if (side_effects_p (XVECEXP (x, i, j)))
1462 /* Return nonzero if evaluating rtx X might cause a trap. */
1474 code = GET_CODE (x);
1477 /* Handle these cases quickly. */
1489 /* Conditional trap can trap! */
1490 case UNSPEC_VOLATILE:
1494 /* Memory ref can trap unless it's a static var or a stack slot. */
1496 return rtx_addr_can_trap_p (XEXP (x, 0));
1498 /* Division by a non-constant might trap. */
1503 if (! CONSTANT_P (XEXP (x, 1)))
1505 /* This was const0_rtx, but by not using that,
1506 we can link this file into other programs. */
1507 if (GET_CODE (XEXP (x, 1)) == CONST_INT && INTVAL (XEXP (x, 1)) == 0)
1510 /* Any floating arithmetic may trap. */
1511 if (GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT)
1515 fmt = GET_RTX_FORMAT (code);
1516 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
1520 if (may_trap_p (XEXP (x, i)))
1523 else if (fmt[i] == 'E')
1526 for (j = 0; j < XVECLEN (x, i); j++)
1527 if (may_trap_p (XVECEXP (x, i, j)))
1534 /* Return nonzero if X contains a comparison that is not either EQ or NE,
1535 i.e., an inequality. */
1538 inequality_comparisons_p (x)
1542 register int len, i;
1543 register enum rtx_code code = GET_CODE (x);
1569 len = GET_RTX_LENGTH (code);
1570 fmt = GET_RTX_FORMAT (code);
1572 for (i = 0; i < len; i++)
1576 if (inequality_comparisons_p (XEXP (x, i)))
1579 else if (fmt[i] == 'E')
1582 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
1583 if (inequality_comparisons_p (XVECEXP (x, i, j)))
1591 /* Replace any occurrence of FROM in X with TO.
1593 Note that copying is not done so X must not be shared unless all copies
1594 are to be modified. */
1597 replace_rtx (x, from, to)
1606 /* Allow this function to make replacements in EXPR_LISTs. */
1610 fmt = GET_RTX_FORMAT (GET_CODE (x));
1611 for (i = GET_RTX_LENGTH (GET_CODE (x)) - 1; i >= 0; i--)
1614 XEXP (x, i) = replace_rtx (XEXP (x, i), from, to);
1615 else if (fmt[i] == 'E')
1616 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
1617 XVECEXP (x, i, j) = replace_rtx (XVECEXP (x, i, j), from, to);
1623 /* Throughout the rtx X, replace many registers according to REG_MAP.
1624 Return the replacement for X (which may be X with altered contents).
1625 REG_MAP[R] is the replacement for register R, or 0 for don't replace.
1626 NREGS is the length of REG_MAP; regs >= NREGS are not mapped.
1628 We only support REG_MAP entries of REG or SUBREG. Also, hard registers
1629 should not be mapped to pseudos or vice versa since validate_change
1632 If REPLACE_DEST is 1, replacements are also done in destinations;
1633 otherwise, only sources are replaced. */
1636 replace_regs (x, reg_map, nregs, replace_dest)
1642 register enum rtx_code code;
1649 code = GET_CODE (x);
1663 /* Verify that the register has an entry before trying to access it. */
1664 if (REGNO (x) < nregs && reg_map[REGNO (x)] != 0)
1666 /* SUBREGs can't be shared. Always return a copy to ensure that if
1667 this replacement occurs more than once then each instance will
1668 get distinct rtx. */
1669 if (GET_CODE (reg_map[REGNO (x)]) == SUBREG)
1670 return copy_rtx (reg_map[REGNO (x)]);
1671 return reg_map[REGNO (x)];
1676 /* Prevent making nested SUBREGs. */
1677 if (GET_CODE (SUBREG_REG (x)) == REG && REGNO (SUBREG_REG (x)) < nregs
1678 && reg_map[REGNO (SUBREG_REG (x))] != 0
1679 && GET_CODE (reg_map[REGNO (SUBREG_REG (x))]) == SUBREG)
1681 rtx map_val = reg_map[REGNO (SUBREG_REG (x))];
1682 rtx map_inner = SUBREG_REG (map_val);
1684 if (GET_MODE (x) == GET_MODE (map_inner))
1688 /* We cannot call gen_rtx here since we may be linked with
1690 /* Let's try clobbering the incoming SUBREG and see
1691 if this is really safe. */
1692 SUBREG_REG (x) = map_inner;
1693 SUBREG_WORD (x) += SUBREG_WORD (map_val);
1696 rtx new = rtx_alloc (SUBREG);
1697 PUT_MODE (new, GET_MODE (x));
1698 SUBREG_REG (new) = map_inner;
1699 SUBREG_WORD (new) = SUBREG_WORD (x) + SUBREG_WORD (map_val);
1707 SET_DEST (x) = replace_regs (SET_DEST (x), reg_map, nregs, 0);
1709 else if (GET_CODE (SET_DEST (x)) == MEM
1710 || GET_CODE (SET_DEST (x)) == STRICT_LOW_PART)
1711 /* Even if we are not to replace destinations, replace register if it
1712 is CONTAINED in destination (destination is memory or
1713 STRICT_LOW_PART). */
1714 XEXP (SET_DEST (x), 0) = replace_regs (XEXP (SET_DEST (x), 0),
1716 else if (GET_CODE (SET_DEST (x)) == ZERO_EXTRACT)
1717 /* Similarly, for ZERO_EXTRACT we replace all operands. */
1720 SET_SRC (x) = replace_regs (SET_SRC (x), reg_map, nregs, 0);
1724 fmt = GET_RTX_FORMAT (code);
1725 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
1728 XEXP (x, i) = replace_regs (XEXP (x, i), reg_map, nregs, replace_dest);
1732 for (j = 0; j < XVECLEN (x, i); j++)
1733 XVECEXP (x, i, j) = replace_regs (XVECEXP (x, i, j), reg_map,
1734 nregs, replace_dest);