1 /* Analyze RTL for C-Compiler
2 Copyright (C) 1987, 88, 91, 92, 93, 94, 1995 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. */
28 /* Bit flags that specify the machine subtype we are compiling for.
29 Bits are tested using macros TARGET_... defined in the tm.h file
30 and set by `-m...' switches. Must be defined in rtlanal.c. */
34 /* Return 1 if the value of X is unstable
35 (would be different at a different point in the program).
36 The frame pointer, arg pointer, etc. are considered stable
37 (within one function) and so is anything marked `unchanging'. */
43 register RTX_CODE code = GET_CODE (x);
48 return ! RTX_UNCHANGING_P (x);
53 if (code == CONST || code == CONST_INT)
57 return ! (REGNO (x) == FRAME_POINTER_REGNUM
58 || REGNO (x) == HARD_FRAME_POINTER_REGNUM
59 || REGNO (x) == ARG_POINTER_REGNUM
60 || RTX_UNCHANGING_P (x));
62 fmt = GET_RTX_FORMAT (code);
63 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
65 if (rtx_unstable_p (XEXP (x, i)))
70 /* Return 1 if X has a value that can vary even between two
71 executions of the program. 0 means X can be compared reliably
72 against certain constants or near-constants.
73 The frame pointer and the arg pointer are considered constant. */
79 register RTX_CODE code = GET_CODE (x);
97 /* Note that we have to test for the actual rtx used for the frame
98 and arg pointers and not just the register number in case we have
99 eliminated the frame and/or arg pointer and are using it
101 return ! (x == frame_pointer_rtx || x == hard_frame_pointer_rtx
102 || x == arg_pointer_rtx);
105 /* The operand 0 of a LO_SUM is considered constant
106 (in fact is it related specifically to operand 1). */
107 return rtx_varies_p (XEXP (x, 1));
110 fmt = GET_RTX_FORMAT (code);
111 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
113 if (rtx_varies_p (XEXP (x, i)))
118 /* Return 0 if the use of X as an address in a MEM can cause a trap. */
121 rtx_addr_can_trap_p (x)
124 register enum rtx_code code = GET_CODE (x);
130 /* SYMBOL_REF is problematic due to the possible presence of
131 a #pragma weak, but to say that loads from symbols can trap is
132 *very* costly. It's not at all clear what's best here. For
133 now, we ignore the impact of #pragma weak. */
137 /* As in rtx_varies_p, we have to use the actual rtx, not reg number. */
138 return ! (x == frame_pointer_rtx || x == hard_frame_pointer_rtx
139 || x == stack_pointer_rtx || x == arg_pointer_rtx);
142 return rtx_addr_can_trap_p (XEXP (x, 0));
145 /* An address is assumed not to trap if it is an address that can't
146 trap plus a constant integer. */
147 return (rtx_addr_can_trap_p (XEXP (x, 0))
148 || GET_CODE (XEXP (x, 1)) != CONST_INT);
151 return rtx_addr_can_trap_p (XEXP (x, 1));
154 /* If it isn't one of the case above, it can cause a trap. */
158 /* Return 1 if X refers to a memory location whose address
159 cannot be compared reliably with constant addresses,
160 or if X refers to a BLKmode memory object. */
163 rtx_addr_varies_p (x)
166 register enum rtx_code code;
175 return GET_MODE (x) == BLKmode || rtx_varies_p (XEXP (x, 0));
177 fmt = GET_RTX_FORMAT (code);
178 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
180 if (rtx_addr_varies_p (XEXP (x, i)))
185 /* Return the value of the integer term in X, if one is apparent;
187 Only obvious integer terms are detected.
188 This is used in cse.c with the `related_value' field.*/
194 if (GET_CODE (x) == CONST)
197 if (GET_CODE (x) == MINUS
198 && GET_CODE (XEXP (x, 1)) == CONST_INT)
199 return - INTVAL (XEXP (x, 1));
200 if (GET_CODE (x) == PLUS
201 && GET_CODE (XEXP (x, 1)) == CONST_INT)
202 return INTVAL (XEXP (x, 1));
206 /* If X is a constant, return the value sans apparent integer term;
208 Only obvious integer terms are detected. */
211 get_related_value (x)
214 if (GET_CODE (x) != CONST)
217 if (GET_CODE (x) == PLUS
218 && GET_CODE (XEXP (x, 1)) == CONST_INT)
220 else if (GET_CODE (x) == MINUS
221 && GET_CODE (XEXP (x, 1)) == CONST_INT)
226 /* Nonzero if register REG appears somewhere within IN.
227 Also works if REG is not a register; in this case it checks
228 for a subexpression of IN that is Lisp "equal" to REG. */
231 reg_mentioned_p (reg, in)
232 register rtx reg, in;
236 register enum rtx_code code;
244 if (GET_CODE (in) == LABEL_REF)
245 return reg == XEXP (in, 0);
247 code = GET_CODE (in);
251 /* Compare registers by number. */
253 return GET_CODE (reg) == REG && REGNO (in) == REGNO (reg);
255 /* These codes have no constituent expressions
263 return GET_CODE (reg) == CONST_INT && INTVAL (in) == INTVAL (reg);
266 /* These are kept unique for a given value. */
270 if (GET_CODE (reg) == code && rtx_equal_p (reg, in))
273 fmt = GET_RTX_FORMAT (code);
275 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
280 for (j = XVECLEN (in, i) - 1; j >= 0; j--)
281 if (reg_mentioned_p (reg, XVECEXP (in, i, j)))
284 else if (fmt[i] == 'e'
285 && reg_mentioned_p (reg, XEXP (in, i)))
291 /* Return 1 if in between BEG and END, exclusive of BEG and END, there is
292 no CODE_LABEL insn. */
295 no_labels_between_p (beg, end)
299 for (p = NEXT_INSN (beg); p != end; p = NEXT_INSN (p))
300 if (GET_CODE (p) == CODE_LABEL)
305 /* Nonzero if register REG is used in an insn between
306 FROM_INSN and TO_INSN (exclusive of those two). */
309 reg_used_between_p (reg, from_insn, to_insn)
310 rtx reg, from_insn, to_insn;
314 if (from_insn == to_insn)
317 for (insn = NEXT_INSN (from_insn); insn != to_insn; insn = NEXT_INSN (insn))
318 if (GET_RTX_CLASS (GET_CODE (insn)) == 'i'
319 && (reg_overlap_mentioned_p (reg, PATTERN (insn))
320 || (GET_CODE (insn) == CALL_INSN
321 && (find_reg_fusage (insn, USE, reg)
322 || find_reg_fusage (insn, CLOBBER, reg)))))
327 /* Nonzero if the old value of X, a register, is referenced in BODY. If X
328 is entirely replaced by a new value and the only use is as a SET_DEST,
329 we do not consider it a reference. */
332 reg_referenced_p (x, body)
338 switch (GET_CODE (body))
341 if (reg_overlap_mentioned_p (x, SET_SRC (body)))
344 /* If the destination is anything other than CC0, PC, a REG or a SUBREG
345 of a REG that occupies all of the REG, the insn references X if
346 it is mentioned in the destination. */
347 if (GET_CODE (SET_DEST (body)) != CC0
348 && GET_CODE (SET_DEST (body)) != PC
349 && GET_CODE (SET_DEST (body)) != REG
350 && ! (GET_CODE (SET_DEST (body)) == SUBREG
351 && GET_CODE (SUBREG_REG (SET_DEST (body))) == REG
352 && (((GET_MODE_SIZE (GET_MODE (SUBREG_REG (SET_DEST (body))))
353 + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD)
354 == ((GET_MODE_SIZE (GET_MODE (SET_DEST (body)))
355 + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD)))
356 && reg_overlap_mentioned_p (x, SET_DEST (body)))
361 for (i = ASM_OPERANDS_INPUT_LENGTH (body) - 1; i >= 0; i--)
362 if (reg_overlap_mentioned_p (x, ASM_OPERANDS_INPUT (body, i)))
368 return reg_overlap_mentioned_p (x, body);
371 return reg_overlap_mentioned_p (x, TRAP_CONDITION (body));
374 case UNSPEC_VOLATILE:
376 for (i = XVECLEN (body, 0) - 1; i >= 0; i--)
377 if (reg_referenced_p (x, XVECEXP (body, 0, i)))
385 /* Nonzero if register REG is referenced in an insn between
386 FROM_INSN and TO_INSN (exclusive of those two). Sets of REG do
390 reg_referenced_between_p (reg, from_insn, to_insn)
391 rtx reg, from_insn, to_insn;
395 if (from_insn == to_insn)
398 for (insn = NEXT_INSN (from_insn); insn != to_insn; insn = NEXT_INSN (insn))
399 if (GET_RTX_CLASS (GET_CODE (insn)) == 'i'
400 && (reg_referenced_p (reg, PATTERN (insn))
401 || (GET_CODE (insn) == CALL_INSN
402 && find_reg_fusage (insn, USE, reg))))
407 /* Nonzero if register REG is set or clobbered in an insn between
408 FROM_INSN and TO_INSN (exclusive of those two). */
411 reg_set_between_p (reg, from_insn, to_insn)
412 rtx reg, from_insn, to_insn;
416 if (from_insn == to_insn)
419 for (insn = NEXT_INSN (from_insn); insn != to_insn; insn = NEXT_INSN (insn))
420 if (GET_RTX_CLASS (GET_CODE (insn)) == 'i'
421 && reg_set_p (reg, insn))
426 /* Internals of reg_set_between_p. */
428 static rtx reg_set_reg;
429 static int reg_set_flag;
435 /* We don't want to return 1 if X is a MEM that contains a register
436 within REG_SET_REG. */
438 if ((GET_CODE (x) != MEM)
439 && reg_overlap_mentioned_p (reg_set_reg, x))
444 reg_set_p (reg, insn)
449 /* We can be passed an insn or part of one. If we are passed an insn,
450 check if a side-effect of the insn clobbers REG. */
451 if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
453 if (FIND_REG_INC_NOTE (insn, reg)
454 || (GET_CODE (insn) == CALL_INSN
455 /* We'd like to test call_used_regs here, but rtlanal.c can't
456 reference that variable due to its use in genattrtab. So
457 we'll just be more conservative.
459 ??? Unless we could ensure that the CALL_INSN_FUNCTION_USAGE
460 information holds all clobbered registers. */
461 && ((GET_CODE (reg) == REG
462 && REGNO (reg) < FIRST_PSEUDO_REGISTER)
463 || GET_CODE (reg) == MEM
464 || find_reg_fusage (insn, CLOBBER, reg))))
467 body = PATTERN (insn);
472 note_stores (body, reg_set_p_1);
476 /* Similar to reg_set_between_p, but check all registers in X. Return 0
477 only if none of them are modified between START and END. Return 1 if
478 X contains a MEM; this routine does not perform any memory aliasing. */
481 modified_between_p (x, start, end)
485 enum rtx_code code = GET_CODE (x);
503 /* If the memory is not constant, assume it is modified. If it is
504 constant, we still have to check the address. */
505 if (! RTX_UNCHANGING_P (x))
510 return reg_set_between_p (x, start, end);
513 fmt = GET_RTX_FORMAT (code);
514 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
516 if (fmt[i] == 'e' && modified_between_p (XEXP (x, i), start, end))
520 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
521 if (modified_between_p (XVECEXP (x, i, j), start, end))
528 /* Similar to reg_set_p, but check all registers in X. Return 0 only if none
529 of them are modified in INSN. Return 1 if X contains a MEM; this routine
530 does not perform any memory aliasing. */
533 modified_in_p (x, insn)
537 enum rtx_code code = GET_CODE (x);
555 /* If the memory is not constant, assume it is modified. If it is
556 constant, we still have to check the address. */
557 if (! RTX_UNCHANGING_P (x))
562 return reg_set_p (x, insn);
565 fmt = GET_RTX_FORMAT (code);
566 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
568 if (fmt[i] == 'e' && modified_in_p (XEXP (x, i), insn))
572 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
573 if (modified_in_p (XVECEXP (x, i, j), insn))
580 /* Given an INSN, return a SET expression if this insn has only a single SET.
581 It may also have CLOBBERs, USEs, or SET whose output
582 will not be used, which we ignore. */
591 if (GET_RTX_CLASS (GET_CODE (insn)) != 'i')
594 if (GET_CODE (PATTERN (insn)) == SET)
595 return PATTERN (insn);
597 else if (GET_CODE (PATTERN (insn)) == PARALLEL)
599 for (i = 0, set = 0; i < XVECLEN (PATTERN (insn), 0); i++)
600 if (GET_CODE (XVECEXP (PATTERN (insn), 0, i)) == SET
601 && (! find_reg_note (insn, REG_UNUSED,
602 SET_DEST (XVECEXP (PATTERN (insn), 0, i)))
603 || side_effects_p (XVECEXP (PATTERN (insn), 0, i))))
608 set = XVECEXP (PATTERN (insn), 0, i);
616 /* Return the last thing that X was assigned from before *PINSN. Verify that
617 the object is not modified up to VALID_TO. If it was, if we hit
618 a partial assignment to X, or hit a CODE_LABEL first, return X. If we
619 found an assignment, update *PINSN to point to it. */
622 find_last_value (x, pinsn, valid_to)
629 for (p = PREV_INSN (*pinsn); p && GET_CODE (p) != CODE_LABEL;
631 if (GET_RTX_CLASS (GET_CODE (p)) == 'i')
633 rtx set = single_set (p);
634 rtx note = find_reg_note (p, REG_EQUAL, NULL_RTX);
636 if (set && rtx_equal_p (x, SET_DEST (set)))
638 rtx src = SET_SRC (set);
640 if (note && GET_CODE (XEXP (note, 0)) != EXPR_LIST)
641 src = XEXP (note, 0);
643 if (! modified_between_p (src, PREV_INSN (p), valid_to)
644 /* Reject hard registers because we don't usually want
645 to use them; we'd rather use a pseudo. */
646 && ! (GET_CODE (src) == REG
647 && REGNO (src) < FIRST_PSEUDO_REGISTER))
654 /* If set in non-simple way, we don't have a value. */
655 if (reg_set_p (x, p))
662 /* Return nonzero if register in range [REGNO, ENDREGNO)
663 appears either explicitly or implicitly in X
664 other than being stored into.
666 References contained within the substructure at LOC do not count.
667 LOC may be zero, meaning don't ignore anything. */
670 refers_to_regno_p (regno, endregno, x, loc)
676 register RTX_CODE code;
680 /* The contents of a REG_NONNEG note is always zero, so we must come here
681 upon repeat in case the last REG_NOTE is a REG_NONNEG note. */
692 /* If we modifying the stack, frame, or argument pointer, it will
693 clobber a virtual register. In fact, we could be more precise,
694 but it isn't worth it. */
695 if ((i == STACK_POINTER_REGNUM
696 #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
697 || i == ARG_POINTER_REGNUM
699 || i == FRAME_POINTER_REGNUM)
700 && regno >= FIRST_VIRTUAL_REGISTER && regno <= LAST_VIRTUAL_REGISTER)
704 && regno < i + (i < FIRST_PSEUDO_REGISTER
705 ? HARD_REGNO_NREGS (i, GET_MODE (x))
709 /* If this is a SUBREG of a hard reg, we can see exactly which
710 registers are being modified. Otherwise, handle normally. */
711 if (GET_CODE (SUBREG_REG (x)) == REG
712 && REGNO (SUBREG_REG (x)) < FIRST_PSEUDO_REGISTER)
714 int inner_regno = REGNO (SUBREG_REG (x)) + SUBREG_WORD (x);
716 = inner_regno + (inner_regno < FIRST_PSEUDO_REGISTER
717 ? HARD_REGNO_NREGS (regno, GET_MODE (x)) : 1);
719 return endregno > inner_regno && regno < inner_endregno;
725 if (&SET_DEST (x) != loc
726 /* Note setting a SUBREG counts as referring to the REG it is in for
727 a pseudo but not for hard registers since we can
728 treat each word individually. */
729 && ((GET_CODE (SET_DEST (x)) == SUBREG
730 && loc != &SUBREG_REG (SET_DEST (x))
731 && GET_CODE (SUBREG_REG (SET_DEST (x))) == REG
732 && REGNO (SUBREG_REG (SET_DEST (x))) >= FIRST_PSEUDO_REGISTER
733 && refers_to_regno_p (regno, endregno,
734 SUBREG_REG (SET_DEST (x)), loc))
735 || (GET_CODE (SET_DEST (x)) != REG
736 && refers_to_regno_p (regno, endregno, SET_DEST (x), loc))))
739 if (code == CLOBBER || loc == &SET_SRC (x))
745 /* X does not match, so try its subexpressions. */
747 fmt = GET_RTX_FORMAT (code);
748 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
750 if (fmt[i] == 'e' && loc != &XEXP (x, i))
758 if (refers_to_regno_p (regno, endregno, XEXP (x, i), loc))
761 else if (fmt[i] == 'E')
764 for (j = XVECLEN (x, i) - 1; j >=0; j--)
765 if (loc != &XVECEXP (x, i, j)
766 && refers_to_regno_p (regno, endregno, XVECEXP (x, i, j), loc))
773 /* Nonzero if modifying X will affect IN. If X is a register or a SUBREG,
774 we check if any register number in X conflicts with the relevant register
775 numbers. If X is a constant, return 0. If X is a MEM, return 1 iff IN
776 contains a MEM (we don't bother checking for memory addresses that can't
777 conflict because we expect this to be a rare case. */
780 reg_overlap_mentioned_p (x, in)
785 if (GET_CODE (x) == SUBREG)
787 regno = REGNO (SUBREG_REG (x));
788 if (regno < FIRST_PSEUDO_REGISTER)
789 regno += SUBREG_WORD (x);
791 else if (GET_CODE (x) == REG)
793 else if (CONSTANT_P (x))
795 else if (GET_CODE (x) == MEM)
800 if (GET_CODE (in) == MEM)
803 fmt = GET_RTX_FORMAT (GET_CODE (in));
805 for (i = GET_RTX_LENGTH (GET_CODE (in)) - 1; i >= 0; i--)
806 if (fmt[i] == 'e' && reg_overlap_mentioned_p (x, XEXP (in, i)))
811 else if (GET_CODE (x) == SCRATCH || GET_CODE (x) == PC
812 || GET_CODE (x) == CC0)
813 return reg_mentioned_p (x, in);
817 endregno = regno + (regno < FIRST_PSEUDO_REGISTER
818 ? HARD_REGNO_NREGS (regno, GET_MODE (x)) : 1);
820 return refers_to_regno_p (regno, endregno, in, NULL_PTR);
823 /* Used for communications between the next few functions. */
825 static int reg_set_last_unknown;
826 static rtx reg_set_last_value;
827 static int reg_set_last_first_regno, reg_set_last_last_regno;
829 /* Called via note_stores from reg_set_last. */
832 reg_set_last_1 (x, pat)
838 /* If X is not a register, or is not one in the range we care
840 if (GET_CODE (x) != REG)
844 last = first + (first < FIRST_PSEUDO_REGISTER
845 ? HARD_REGNO_NREGS (first, GET_MODE (x)) : 1);
847 if (first >= reg_set_last_last_regno
848 || last <= reg_set_last_first_regno)
851 /* If this is a CLOBBER or is some complex LHS, or doesn't modify
852 exactly the registers we care about, show we don't know the value. */
853 if (GET_CODE (pat) == CLOBBER || SET_DEST (pat) != x
854 || first != reg_set_last_first_regno
855 || last != reg_set_last_last_regno)
856 reg_set_last_unknown = 1;
858 reg_set_last_value = SET_SRC (pat);
861 /* Return the last value to which REG was set prior to INSN. If we can't
862 find it easily, return 0.
864 We only return a REG, SUBREG, or constant because it is too hard to
865 check if a MEM remains unchanged. */
868 reg_set_last (x, insn)
872 rtx orig_insn = insn;
874 reg_set_last_first_regno = REGNO (x);
876 reg_set_last_last_regno
877 = reg_set_last_first_regno
878 + (reg_set_last_first_regno < FIRST_PSEUDO_REGISTER
879 ? HARD_REGNO_NREGS (reg_set_last_first_regno, GET_MODE (x)) : 1);
881 reg_set_last_unknown = 0;
882 reg_set_last_value = 0;
884 /* Scan backwards until reg_set_last_1 changed one of the above flags.
885 Stop when we reach a label or X is a hard reg and we reach a
886 CALL_INSN (if reg_set_last_last_regno is a hard reg).
888 If we find a set of X, ensure that its SET_SRC remains unchanged. */
890 /* We compare with <= here, because reg_set_last_last_regno
891 is actually the number of the first reg *not* in X. */
893 insn && GET_CODE (insn) != CODE_LABEL
894 && ! (GET_CODE (insn) == CALL_INSN
895 && reg_set_last_last_regno <= FIRST_PSEUDO_REGISTER);
896 insn = PREV_INSN (insn))
897 if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
899 note_stores (PATTERN (insn), reg_set_last_1);
900 if (reg_set_last_unknown)
902 else if (reg_set_last_value)
904 if (CONSTANT_P (reg_set_last_value)
905 || ((GET_CODE (reg_set_last_value) == REG
906 || GET_CODE (reg_set_last_value) == SUBREG)
907 && ! reg_set_between_p (reg_set_last_value,
909 return reg_set_last_value;
918 /* This is 1 until after reload pass. */
919 int rtx_equal_function_value_matters;
921 /* Return 1 if X and Y are identical-looking rtx's.
922 This is the Lisp function EQUAL for rtx arguments. */
930 register enum rtx_code code;
935 if (x == 0 || y == 0)
939 /* Rtx's of different codes cannot be equal. */
940 if (code != GET_CODE (y))
943 /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent.
944 (REG:SI x) and (REG:HI x) are NOT equivalent. */
946 if (GET_MODE (x) != GET_MODE (y))
949 /* REG, LABEL_REF, and SYMBOL_REF can be compared nonrecursively. */
952 /* Until rtl generation is complete, don't consider a reference to the
953 return register of the current function the same as the return from a
954 called function. This eases the job of function integration. Once the
955 distinction is no longer needed, they can be considered equivalent. */
956 return (REGNO (x) == REGNO (y)
957 && (! rtx_equal_function_value_matters
958 || REG_FUNCTION_VALUE_P (x) == REG_FUNCTION_VALUE_P (y)));
959 else if (code == LABEL_REF)
960 return XEXP (x, 0) == XEXP (y, 0);
961 else if (code == SYMBOL_REF)
962 return XSTR (x, 0) == XSTR (y, 0);
963 else if (code == SCRATCH || code == CONST_DOUBLE)
966 /* Compare the elements. If any pair of corresponding elements
967 fail to match, return 0 for the whole things. */
969 fmt = GET_RTX_FORMAT (code);
970 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
975 if (XWINT (x, i) != XWINT (y, i))
981 if (XINT (x, i) != XINT (y, i))
987 /* Two vectors must have the same length. */
988 if (XVECLEN (x, i) != XVECLEN (y, i))
991 /* And the corresponding elements must match. */
992 for (j = 0; j < XVECLEN (x, i); j++)
993 if (rtx_equal_p (XVECEXP (x, i, j), XVECEXP (y, i, j)) == 0)
998 if (rtx_equal_p (XEXP (x, i), XEXP (y, i)) == 0)
1004 if (strcmp (XSTR (x, i), XSTR (y, i)))
1009 /* These are just backpointers, so they don't matter. */
1015 /* It is believed that rtx's at this level will never
1016 contain anything but integers and other rtx's,
1017 except for within LABEL_REFs and SYMBOL_REFs. */
1025 /* Call FUN on each register or MEM that is stored into or clobbered by X.
1026 (X would be the pattern of an insn).
1027 FUN receives two arguments:
1028 the REG, MEM, CC0 or PC being stored in or clobbered,
1029 the SET or CLOBBER rtx that does the store.
1031 If the item being stored in or clobbered is a SUBREG of a hard register,
1032 the SUBREG will be passed. */
1035 note_stores (x, fun)
1039 if ((GET_CODE (x) == SET || GET_CODE (x) == CLOBBER))
1041 register rtx dest = SET_DEST (x);
1042 while ((GET_CODE (dest) == SUBREG
1043 && (GET_CODE (SUBREG_REG (dest)) != REG
1044 || REGNO (SUBREG_REG (dest)) >= FIRST_PSEUDO_REGISTER))
1045 || GET_CODE (dest) == ZERO_EXTRACT
1046 || GET_CODE (dest) == SIGN_EXTRACT
1047 || GET_CODE (dest) == STRICT_LOW_PART)
1048 dest = XEXP (dest, 0);
1051 else if (GET_CODE (x) == PARALLEL)
1054 for (i = XVECLEN (x, 0) - 1; i >= 0; i--)
1056 register rtx y = XVECEXP (x, 0, i);
1057 if (GET_CODE (y) == SET || GET_CODE (y) == CLOBBER)
1059 register rtx dest = SET_DEST (y);
1060 while ((GET_CODE (dest) == SUBREG
1061 && (GET_CODE (SUBREG_REG (dest)) != REG
1062 || (REGNO (SUBREG_REG (dest))
1063 >= FIRST_PSEUDO_REGISTER)))
1064 || GET_CODE (dest) == ZERO_EXTRACT
1065 || GET_CODE (dest) == SIGN_EXTRACT
1066 || GET_CODE (dest) == STRICT_LOW_PART)
1067 dest = XEXP (dest, 0);
1074 /* Return nonzero if X's old contents don't survive after INSN.
1075 This will be true if X is (cc0) or if X is a register and
1076 X dies in INSN or because INSN entirely sets X.
1078 "Entirely set" means set directly and not through a SUBREG,
1079 ZERO_EXTRACT or SIGN_EXTRACT, so no trace of the old contents remains.
1080 Likewise, REG_INC does not count.
1082 REG may be a hard or pseudo reg. Renumbering is not taken into account,
1083 but for this use that makes no difference, since regs don't overlap
1084 during their lifetimes. Therefore, this function may be used
1085 at any time after deaths have been computed (in flow.c).
1087 If REG is a hard reg that occupies multiple machine registers, this
1088 function will only return 1 if each of those registers will be replaced
1092 dead_or_set_p (insn, x)
1096 register int regno, last_regno;
1099 /* Can't use cc0_rtx below since this file is used by genattrtab.c. */
1100 if (GET_CODE (x) == CC0)
1103 if (GET_CODE (x) != REG)
1107 last_regno = (regno >= FIRST_PSEUDO_REGISTER ? regno
1108 : regno + HARD_REGNO_NREGS (regno, GET_MODE (x)) - 1);
1110 for (i = regno; i <= last_regno; i++)
1111 if (! dead_or_set_regno_p (insn, i))
1117 /* Utility function for dead_or_set_p to check an individual register. Also
1118 called from flow.c. */
1121 dead_or_set_regno_p (insn, test_regno)
1125 int regno, endregno;
1128 /* See if there is a death note for something that includes TEST_REGNO. */
1129 for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
1131 if (REG_NOTE_KIND (link) != REG_DEAD || GET_CODE (XEXP (link, 0)) != REG)
1134 regno = REGNO (XEXP (link, 0));
1135 endregno = (regno >= FIRST_PSEUDO_REGISTER ? regno + 1
1136 : regno + HARD_REGNO_NREGS (regno,
1137 GET_MODE (XEXP (link, 0))));
1139 if (test_regno >= regno && test_regno < endregno)
1143 if (GET_CODE (insn) == CALL_INSN
1144 && find_regno_fusage (insn, CLOBBER, test_regno))
1147 if (GET_CODE (PATTERN (insn)) == SET)
1149 rtx dest = SET_DEST (PATTERN (insn));
1151 /* A value is totally replaced if it is the destination or the
1152 destination is a SUBREG of REGNO that does not change the number of
1154 if (GET_CODE (dest) == SUBREG
1155 && (((GET_MODE_SIZE (GET_MODE (dest))
1156 + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
1157 == ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (dest)))
1158 + UNITS_PER_WORD - 1) / UNITS_PER_WORD)))
1159 dest = SUBREG_REG (dest);
1161 if (GET_CODE (dest) != REG)
1164 regno = REGNO (dest);
1165 endregno = (regno >= FIRST_PSEUDO_REGISTER ? regno + 1
1166 : regno + HARD_REGNO_NREGS (regno, GET_MODE (dest)));
1168 return (test_regno >= regno && test_regno < endregno);
1170 else if (GET_CODE (PATTERN (insn)) == PARALLEL)
1174 for (i = XVECLEN (PATTERN (insn), 0) - 1; i >= 0; i--)
1176 rtx body = XVECEXP (PATTERN (insn), 0, i);
1178 if (GET_CODE (body) == SET || GET_CODE (body) == CLOBBER)
1180 rtx dest = SET_DEST (body);
1182 if (GET_CODE (dest) == SUBREG
1183 && (((GET_MODE_SIZE (GET_MODE (dest))
1184 + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
1185 == ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (dest)))
1186 + UNITS_PER_WORD - 1) / UNITS_PER_WORD)))
1187 dest = SUBREG_REG (dest);
1189 if (GET_CODE (dest) != REG)
1192 regno = REGNO (dest);
1193 endregno = (regno >= FIRST_PSEUDO_REGISTER ? regno + 1
1194 : regno + HARD_REGNO_NREGS (regno, GET_MODE (dest)));
1196 if (test_regno >= regno && test_regno < endregno)
1205 /* Return the reg-note of kind KIND in insn INSN, if there is one.
1206 If DATUM is nonzero, look for one whose datum is DATUM. */
1209 find_reg_note (insn, kind, datum)
1216 for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
1217 if (REG_NOTE_KIND (link) == kind
1218 && (datum == 0 || datum == XEXP (link, 0)))
1223 /* Return the reg-note of kind KIND in insn INSN which applies to register
1224 number REGNO, if any. Return 0 if there is no such reg-note. Note that
1225 the REGNO of this NOTE need not be REGNO if REGNO is a hard register;
1226 it might be the case that the note overlaps REGNO. */
1229 find_regno_note (insn, kind, regno)
1236 for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
1237 if (REG_NOTE_KIND (link) == kind
1238 /* Verify that it is a register, so that scratch and MEM won't cause a
1240 && GET_CODE (XEXP (link, 0)) == REG
1241 && REGNO (XEXP (link, 0)) <= regno
1242 && ((REGNO (XEXP (link, 0))
1243 + (REGNO (XEXP (link, 0)) >= FIRST_PSEUDO_REGISTER ? 1
1244 : HARD_REGNO_NREGS (REGNO (XEXP (link, 0)),
1245 GET_MODE (XEXP (link, 0)))))
1251 /* Return true if DATUM, or any overlap of DATUM, of kind CODE is found
1252 in the CALL_INSN_FUNCTION_USAGE information of INSN. */
1255 find_reg_fusage (insn, code, datum)
1260 /* If it's not a CALL_INSN, it can't possibly have a
1261 CALL_INSN_FUNCTION_USAGE field, so don't bother checking. */
1262 if (GET_CODE (insn) != CALL_INSN)
1268 if (GET_CODE (datum) != REG)
1272 for (link = CALL_INSN_FUNCTION_USAGE (insn);
1274 link = XEXP (link, 1))
1275 if (GET_CODE (XEXP (link, 0)) == code
1276 && rtx_equal_p (datum, SET_DEST (XEXP (link, 0))))
1281 register int regno = REGNO (datum);
1283 /* CALL_INSN_FUNCTION_USAGE information cannot contain references
1284 to pseudo registers, so don't bother checking. */
1286 if (regno < FIRST_PSEUDO_REGISTER)
1288 int end_regno = regno + HARD_REGNO_NREGS (regno, GET_MODE (datum));
1291 for (i = regno; i < end_regno; i++)
1292 if (find_regno_fusage (insn, code, i))
1300 /* Return true if REGNO, or any overlap of REGNO, of kind CODE is found
1301 in the CALL_INSN_FUNCTION_USAGE information of INSN. */
1304 find_regno_fusage (insn, code, regno)
1311 /* CALL_INSN_FUNCTION_USAGE information cannot contain references
1312 to pseudo registers, so don't bother checking. */
1314 if (regno >= FIRST_PSEUDO_REGISTER
1315 || GET_CODE (insn) != CALL_INSN )
1318 for (link = CALL_INSN_FUNCTION_USAGE (insn); link; link = XEXP (link, 1))
1320 register int regnote;
1323 if (GET_CODE (op = XEXP (link, 0)) == code
1324 && GET_CODE (SET_DEST (op)) == REG
1325 && (regnote = REGNO (SET_DEST (op))) <= regno
1327 + HARD_REGNO_NREGS (regnote, GET_MODE (SET_DEST (op)))
1335 /* Remove register note NOTE from the REG_NOTES of INSN. */
1338 remove_note (insn, note)
1344 if (REG_NOTES (insn) == note)
1346 REG_NOTES (insn) = XEXP (note, 1);
1350 for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
1351 if (XEXP (link, 1) == note)
1353 XEXP (link, 1) = XEXP (note, 1);
1360 /* Nonzero if X contains any volatile instructions. These are instructions
1361 which may cause unpredictable machine state instructions, and thus no
1362 instructions should be moved or combined across them. This includes
1363 only volatile asms and UNSPEC_VOLATILE instructions. */
1369 register RTX_CODE code;
1371 code = GET_CODE (x);
1391 case UNSPEC_VOLATILE:
1392 /* case TRAP_IF: This isn't clear yet. */
1396 if (MEM_VOLATILE_P (x))
1400 /* Recursively scan the operands of this expression. */
1403 register char *fmt = GET_RTX_FORMAT (code);
1406 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
1410 if (volatile_insn_p (XEXP (x, i)))
1416 for (j = 0; j < XVECLEN (x, i); j++)
1417 if (volatile_insn_p (XVECEXP (x, i, j)))
1425 /* Nonzero if X contains any volatile memory references
1426 UNSPEC_VOLATILE operations or volatile ASM_OPERANDS expressions. */
1432 register RTX_CODE code;
1434 code = GET_CODE (x);
1453 case UNSPEC_VOLATILE:
1454 /* case TRAP_IF: This isn't clear yet. */
1459 if (MEM_VOLATILE_P (x))
1463 /* Recursively scan the operands of this expression. */
1466 register char *fmt = GET_RTX_FORMAT (code);
1469 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
1473 if (volatile_refs_p (XEXP (x, i)))
1479 for (j = 0; j < XVECLEN (x, i); j++)
1480 if (volatile_refs_p (XVECEXP (x, i, j)))
1488 /* Similar to above, except that it also rejects register pre- and post-
1495 register RTX_CODE code;
1497 code = GET_CODE (x);
1515 /* Reject CLOBBER with a non-VOID mode. These are made by combine.c
1516 when some combination can't be done. If we see one, don't think
1517 that we can simplify the expression. */
1518 return (GET_MODE (x) != VOIDmode);
1525 case UNSPEC_VOLATILE:
1526 /* case TRAP_IF: This isn't clear yet. */
1531 if (MEM_VOLATILE_P (x))
1535 /* Recursively scan the operands of this expression. */
1538 register char *fmt = GET_RTX_FORMAT (code);
1541 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
1545 if (side_effects_p (XEXP (x, i)))
1551 for (j = 0; j < XVECLEN (x, i); j++)
1552 if (side_effects_p (XVECEXP (x, i, j)))
1560 /* Return nonzero if evaluating rtx X might cause a trap. */
1572 code = GET_CODE (x);
1575 /* Handle these cases quickly. */
1587 /* Conditional trap can trap! */
1588 case UNSPEC_VOLATILE:
1592 /* Memory ref can trap unless it's a static var or a stack slot. */
1594 return rtx_addr_can_trap_p (XEXP (x, 0));
1596 /* Division by a non-constant might trap. */
1601 if (! CONSTANT_P (XEXP (x, 1)))
1603 /* This was const0_rtx, but by not using that,
1604 we can link this file into other programs. */
1605 if (GET_CODE (XEXP (x, 1)) == CONST_INT && INTVAL (XEXP (x, 1)) == 0)
1608 /* An EXPR_LIST is used to represent a function call. This
1609 certainly may trap. */
1612 /* Any floating arithmetic may trap. */
1613 if (GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT)
1617 fmt = GET_RTX_FORMAT (code);
1618 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
1622 if (may_trap_p (XEXP (x, i)))
1625 else if (fmt[i] == 'E')
1628 for (j = 0; j < XVECLEN (x, i); j++)
1629 if (may_trap_p (XVECEXP (x, i, j)))
1636 /* Return nonzero if X contains a comparison that is not either EQ or NE,
1637 i.e., an inequality. */
1640 inequality_comparisons_p (x)
1644 register int len, i;
1645 register enum rtx_code code = GET_CODE (x);
1671 len = GET_RTX_LENGTH (code);
1672 fmt = GET_RTX_FORMAT (code);
1674 for (i = 0; i < len; i++)
1678 if (inequality_comparisons_p (XEXP (x, i)))
1681 else if (fmt[i] == 'E')
1684 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
1685 if (inequality_comparisons_p (XVECEXP (x, i, j)))
1693 /* Replace any occurrence of FROM in X with TO.
1695 Note that copying is not done so X must not be shared unless all copies
1696 are to be modified. */
1699 replace_rtx (x, from, to)
1708 /* Allow this function to make replacements in EXPR_LISTs. */
1712 fmt = GET_RTX_FORMAT (GET_CODE (x));
1713 for (i = GET_RTX_LENGTH (GET_CODE (x)) - 1; i >= 0; i--)
1716 XEXP (x, i) = replace_rtx (XEXP (x, i), from, to);
1717 else if (fmt[i] == 'E')
1718 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
1719 XVECEXP (x, i, j) = replace_rtx (XVECEXP (x, i, j), from, to);
1725 /* Throughout the rtx X, replace many registers according to REG_MAP.
1726 Return the replacement for X (which may be X with altered contents).
1727 REG_MAP[R] is the replacement for register R, or 0 for don't replace.
1728 NREGS is the length of REG_MAP; regs >= NREGS are not mapped.
1730 We only support REG_MAP entries of REG or SUBREG. Also, hard registers
1731 should not be mapped to pseudos or vice versa since validate_change
1734 If REPLACE_DEST is 1, replacements are also done in destinations;
1735 otherwise, only sources are replaced. */
1738 replace_regs (x, reg_map, nregs, replace_dest)
1744 register enum rtx_code code;
1751 code = GET_CODE (x);
1765 /* Verify that the register has an entry before trying to access it. */
1766 if (REGNO (x) < nregs && reg_map[REGNO (x)] != 0)
1768 /* SUBREGs can't be shared. Always return a copy to ensure that if
1769 this replacement occurs more than once then each instance will
1770 get distinct rtx. */
1771 if (GET_CODE (reg_map[REGNO (x)]) == SUBREG)
1772 return copy_rtx (reg_map[REGNO (x)]);
1773 return reg_map[REGNO (x)];
1778 /* Prevent making nested SUBREGs. */
1779 if (GET_CODE (SUBREG_REG (x)) == REG && REGNO (SUBREG_REG (x)) < nregs
1780 && reg_map[REGNO (SUBREG_REG (x))] != 0
1781 && GET_CODE (reg_map[REGNO (SUBREG_REG (x))]) == SUBREG)
1783 rtx map_val = reg_map[REGNO (SUBREG_REG (x))];
1784 rtx map_inner = SUBREG_REG (map_val);
1786 if (GET_MODE (x) == GET_MODE (map_inner))
1790 /* We cannot call gen_rtx here since we may be linked with
1792 /* Let's try clobbering the incoming SUBREG and see
1793 if this is really safe. */
1794 SUBREG_REG (x) = map_inner;
1795 SUBREG_WORD (x) += SUBREG_WORD (map_val);
1798 rtx new = rtx_alloc (SUBREG);
1799 PUT_MODE (new, GET_MODE (x));
1800 SUBREG_REG (new) = map_inner;
1801 SUBREG_WORD (new) = SUBREG_WORD (x) + SUBREG_WORD (map_val);
1809 SET_DEST (x) = replace_regs (SET_DEST (x), reg_map, nregs, 0);
1811 else if (GET_CODE (SET_DEST (x)) == MEM
1812 || GET_CODE (SET_DEST (x)) == STRICT_LOW_PART)
1813 /* Even if we are not to replace destinations, replace register if it
1814 is CONTAINED in destination (destination is memory or
1815 STRICT_LOW_PART). */
1816 XEXP (SET_DEST (x), 0) = replace_regs (XEXP (SET_DEST (x), 0),
1818 else if (GET_CODE (SET_DEST (x)) == ZERO_EXTRACT)
1819 /* Similarly, for ZERO_EXTRACT we replace all operands. */
1822 SET_SRC (x) = replace_regs (SET_SRC (x), reg_map, nregs, 0);
1826 fmt = GET_RTX_FORMAT (code);
1827 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
1830 XEXP (x, i) = replace_regs (XEXP (x, i), reg_map, nregs, replace_dest);
1834 for (j = 0; j < XVECLEN (x, i); j++)
1835 XVECEXP (x, i, j) = replace_regs (XVECEXP (x, i, j), reg_map,
1836 nregs, replace_dest);