1 /* Analyze RTL for C-Compiler
2 Copyright (C) 1987, 88, 91, 92, 93, 1994 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
))
319 || (GET_CODE (insn
) == CALL_INSN
320 && (find_reg_fusage (insn
, USE
, reg
)
321 || find_reg_fusage (insn
, CLOBBER
, reg
)))))
326 /* Nonzero if the old value of X, a register, is referenced in BODY. If X
327 is entirely replaced by a new value and the only use is as a SET_DEST,
328 we do not consider it a reference. */
331 reg_referenced_p (x
, body
)
337 switch (GET_CODE (body
))
340 if (reg_overlap_mentioned_p (x
, SET_SRC (body
)))
343 /* If the destination is anything other than CC0, PC, a REG or a SUBREG
344 of a REG that occupies all of the REG, the insn references X if
345 it is mentioned in the destination. */
346 if (GET_CODE (SET_DEST (body
)) != CC0
347 && GET_CODE (SET_DEST (body
)) != PC
348 && GET_CODE (SET_DEST (body
)) != REG
349 && ! (GET_CODE (SET_DEST (body
)) == SUBREG
350 && GET_CODE (SUBREG_REG (SET_DEST (body
))) == REG
351 && (((GET_MODE_SIZE (GET_MODE (SUBREG_REG (SET_DEST (body
))))
352 + (UNITS_PER_WORD
- 1)) / UNITS_PER_WORD
)
353 == ((GET_MODE_SIZE (GET_MODE (SET_DEST (body
)))
354 + (UNITS_PER_WORD
- 1)) / UNITS_PER_WORD
)))
355 && reg_overlap_mentioned_p (x
, SET_DEST (body
)))
360 for (i
= ASM_OPERANDS_INPUT_LENGTH (body
) - 1; i
>= 0; i
--)
361 if (reg_overlap_mentioned_p (x
, ASM_OPERANDS_INPUT (body
, i
)))
367 return reg_overlap_mentioned_p (x
, body
);
370 return reg_overlap_mentioned_p (x
, TRAP_CONDITION (body
));
373 case UNSPEC_VOLATILE
:
375 for (i
= XVECLEN (body
, 0) - 1; i
>= 0; i
--)
376 if (reg_referenced_p (x
, XVECEXP (body
, 0, i
)))
384 /* Nonzero if register REG is referenced in an insn between
385 FROM_INSN and TO_INSN (exclusive of those two). Sets of REG do
389 reg_referenced_between_p (reg
, from_insn
, to_insn
)
390 rtx reg
, from_insn
, to_insn
;
394 if (from_insn
== to_insn
)
397 for (insn
= NEXT_INSN (from_insn
); insn
!= to_insn
; insn
= NEXT_INSN (insn
))
398 if (GET_RTX_CLASS (GET_CODE (insn
)) == 'i'
399 && (reg_referenced_p (reg
, PATTERN (insn
))
400 || (GET_CODE (insn
) == CALL_INSN
401 && find_reg_fusage (insn
, USE
, reg
))))
406 /* Nonzero if register REG is set or clobbered in an insn between
407 FROM_INSN and TO_INSN (exclusive of those two). */
410 reg_set_between_p (reg
, from_insn
, to_insn
)
411 rtx reg
, from_insn
, to_insn
;
415 if (from_insn
== to_insn
)
418 for (insn
= NEXT_INSN (from_insn
); insn
!= to_insn
; insn
= NEXT_INSN (insn
))
419 if (GET_RTX_CLASS (GET_CODE (insn
)) == 'i'
420 && reg_set_p (reg
, insn
))
425 /* Internals of reg_set_between_p. */
427 static rtx reg_set_reg
;
428 static int reg_set_flag
;
434 /* We don't want to return 1 if X is a MEM that contains a register
435 within REG_SET_REG. */
437 if ((GET_CODE (x
) != MEM
)
438 && reg_overlap_mentioned_p (reg_set_reg
, x
))
443 reg_set_p (reg
, insn
)
448 /* We can be passed an insn or part of one. If we are passed an insn,
449 check if a side-effect of the insn clobbers REG. */
450 if (GET_RTX_CLASS (GET_CODE (insn
)) == 'i')
452 if (FIND_REG_INC_NOTE (insn
, reg
)
453 || (GET_CODE (insn
) == CALL_INSN
454 /* We'd like to test call_used_regs here, but rtlanal.c can't
455 reference that variable due to its use in genattrtab. So
456 we'll just be more conservative.
458 ??? Unless we could ensure that the CALL_INSN_FUNCTION_USAGE
459 information holds all clobbered registers. */
460 && ((GET_CODE (reg
) == REG
461 && REGNO (reg
) < FIRST_PSEUDO_REGISTER
)
462 || GET_CODE (reg
) == MEM
463 || find_reg_fusage (insn
, CLOBBER
, reg
))))
466 body
= PATTERN (insn
);
471 note_stores (body
, reg_set_p_1
);
475 /* Similar to reg_set_between_p, but check all registers in X. Return 0
476 only if none of them are modified between START and END. Return 1 if
477 X contains a MEM; this routine does not perform any memory aliasing. */
480 modified_between_p (x
, start
, end
)
484 enum rtx_code code
= GET_CODE (x
);
502 /* If the memory is not constant, assume it is modified. If it is
503 constant, we still have to check the address. */
504 if (! RTX_UNCHANGING_P (x
))
509 return reg_set_between_p (x
, start
, end
);
512 fmt
= GET_RTX_FORMAT (code
);
513 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
515 if (fmt
[i
] == 'e' && modified_between_p (XEXP (x
, i
), start
, end
))
519 for (j
= XVECLEN (x
, i
) - 1; j
>= 0; j
--)
520 if (modified_between_p (XVECEXP (x
, i
, j
), start
, end
))
527 /* Similar to reg_set_p, but check all registers in X. Return 0 only if none
528 of them are modified in INSN. Return 1 if X contains a MEM; this routine
529 does not perform any memory aliasing. */
532 modified_in_p (x
, insn
)
536 enum rtx_code code
= GET_CODE (x
);
554 /* If the memory is not constant, assume it is modified. If it is
555 constant, we still have to check the address. */
556 if (! RTX_UNCHANGING_P (x
))
561 return reg_set_p (x
, insn
);
564 fmt
= GET_RTX_FORMAT (code
);
565 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
567 if (fmt
[i
] == 'e' && modified_in_p (XEXP (x
, i
), insn
))
571 for (j
= XVECLEN (x
, i
) - 1; j
>= 0; j
--)
572 if (modified_in_p (XVECEXP (x
, i
, j
), insn
))
579 /* Given an INSN, return a SET expression if this insn has only a single SET.
580 It may also have CLOBBERs, USEs, or SET whose output
581 will not be used, which we ignore. */
590 if (GET_RTX_CLASS (GET_CODE (insn
)) != 'i')
593 if (GET_CODE (PATTERN (insn
)) == SET
)
594 return PATTERN (insn
);
596 else if (GET_CODE (PATTERN (insn
)) == PARALLEL
)
598 for (i
= 0, set
= 0; i
< XVECLEN (PATTERN (insn
), 0); i
++)
599 if (GET_CODE (XVECEXP (PATTERN (insn
), 0, i
)) == SET
600 && (! find_reg_note (insn
, REG_UNUSED
,
601 SET_DEST (XVECEXP (PATTERN (insn
), 0, i
)))
602 || side_effects_p (XVECEXP (PATTERN (insn
), 0, i
))))
607 set
= XVECEXP (PATTERN (insn
), 0, i
);
615 /* Return the last thing that X was assigned from before *PINSN. Verify that
616 the object is not modified up to VALID_TO. If it was, if we hit
617 a partial assignment to X, or hit a CODE_LABEL first, return X. If we
618 found an assignment, update *PINSN to point to it. */
621 find_last_value (x
, pinsn
, valid_to
)
628 for (p
= PREV_INSN (*pinsn
); p
&& GET_CODE (p
) != CODE_LABEL
;
630 if (GET_RTX_CLASS (GET_CODE (p
)) == 'i')
632 rtx set
= single_set (p
);
633 rtx note
= find_reg_note (p
, REG_EQUAL
, NULL_RTX
);
635 if (set
&& rtx_equal_p (x
, SET_DEST (set
)))
637 rtx src
= SET_SRC (set
);
639 if (note
&& GET_CODE (XEXP (note
, 0)) != EXPR_LIST
)
640 src
= XEXP (note
, 0);
642 if (! modified_between_p (src
, PREV_INSN (p
), valid_to
)
643 /* Reject hard registers because we don't usually want
644 to use them; we'd rather use a pseudo. */
645 && ! (GET_CODE (src
) == REG
646 && REGNO (src
) < FIRST_PSEUDO_REGISTER
))
653 /* If set in non-simple way, we don't have a value. */
654 if (reg_set_p (x
, p
))
661 /* Return nonzero if register in range [REGNO, ENDREGNO)
662 appears either explicitly or implicitly in X
663 other than being stored into.
665 References contained within the substructure at LOC do not count.
666 LOC may be zero, meaning don't ignore anything. */
669 refers_to_regno_p (regno
, endregno
, x
, loc
)
675 register RTX_CODE code
;
679 /* The contents of a REG_NONNEG note is always zero, so we must come here
680 upon repeat in case the last REG_NOTE is a REG_NONNEG note. */
691 /* If we modifying the stack, frame, or argument pointer, it will
692 clobber a virtual register. In fact, we could be more precise,
693 but it isn't worth it. */
694 if ((i
== STACK_POINTER_REGNUM
695 #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
696 || i
== ARG_POINTER_REGNUM
698 || i
== FRAME_POINTER_REGNUM
)
699 && regno
>= FIRST_VIRTUAL_REGISTER
&& regno
<= LAST_VIRTUAL_REGISTER
)
703 && regno
< i
+ (i
< FIRST_PSEUDO_REGISTER
704 ? HARD_REGNO_NREGS (i
, GET_MODE (x
))
708 /* If this is a SUBREG of a hard reg, we can see exactly which
709 registers are being modified. Otherwise, handle normally. */
710 if (GET_CODE (SUBREG_REG (x
)) == REG
711 && REGNO (SUBREG_REG (x
)) < FIRST_PSEUDO_REGISTER
)
713 int inner_regno
= REGNO (SUBREG_REG (x
)) + SUBREG_WORD (x
);
715 = inner_regno
+ (inner_regno
< FIRST_PSEUDO_REGISTER
716 ? HARD_REGNO_NREGS (regno
, GET_MODE (x
)) : 1);
718 return endregno
> inner_regno
&& regno
< inner_endregno
;
724 if (&SET_DEST (x
) != loc
725 /* Note setting a SUBREG counts as referring to the REG it is in for
726 a pseudo but not for hard registers since we can
727 treat each word individually. */
728 && ((GET_CODE (SET_DEST (x
)) == SUBREG
729 && loc
!= &SUBREG_REG (SET_DEST (x
))
730 && GET_CODE (SUBREG_REG (SET_DEST (x
))) == REG
731 && REGNO (SUBREG_REG (SET_DEST (x
))) >= FIRST_PSEUDO_REGISTER
732 && refers_to_regno_p (regno
, endregno
,
733 SUBREG_REG (SET_DEST (x
)), loc
))
734 || (GET_CODE (SET_DEST (x
)) != REG
735 && refers_to_regno_p (regno
, endregno
, SET_DEST (x
), loc
))))
738 if (code
== CLOBBER
|| loc
== &SET_SRC (x
))
744 /* X does not match, so try its subexpressions. */
746 fmt
= GET_RTX_FORMAT (code
);
747 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
749 if (fmt
[i
] == 'e' && loc
!= &XEXP (x
, i
))
757 if (refers_to_regno_p (regno
, endregno
, XEXP (x
, i
), loc
))
760 else if (fmt
[i
] == 'E')
763 for (j
= XVECLEN (x
, i
) - 1; j
>=0; j
--)
764 if (loc
!= &XVECEXP (x
, i
, j
)
765 && refers_to_regno_p (regno
, endregno
, XVECEXP (x
, i
, j
), loc
))
772 /* Nonzero if modifying X will affect IN. If X is a register or a SUBREG,
773 we check if any register number in X conflicts with the relevant register
774 numbers. If X is a constant, return 0. If X is a MEM, return 1 iff IN
775 contains a MEM (we don't bother checking for memory addresses that can't
776 conflict because we expect this to be a rare case. */
779 reg_overlap_mentioned_p (x
, in
)
784 if (GET_CODE (x
) == SUBREG
)
786 regno
= REGNO (SUBREG_REG (x
));
787 if (regno
< FIRST_PSEUDO_REGISTER
)
788 regno
+= SUBREG_WORD (x
);
790 else if (GET_CODE (x
) == REG
)
792 else if (CONSTANT_P (x
))
794 else if (GET_CODE (x
) == MEM
)
799 if (GET_CODE (in
) == MEM
)
802 fmt
= GET_RTX_FORMAT (GET_CODE (in
));
804 for (i
= GET_RTX_LENGTH (GET_CODE (in
)) - 1; i
>= 0; i
--)
805 if (fmt
[i
] == 'e' && reg_overlap_mentioned_p (x
, XEXP (in
, i
)))
810 else if (GET_CODE (x
) == SCRATCH
|| GET_CODE (x
) == PC
811 || GET_CODE (x
) == CC0
)
812 return reg_mentioned_p (x
, in
);
816 endregno
= regno
+ (regno
< FIRST_PSEUDO_REGISTER
817 ? HARD_REGNO_NREGS (regno
, GET_MODE (x
)) : 1);
819 return refers_to_regno_p (regno
, endregno
, in
, NULL_PTR
);
822 /* Used for communications between the next few functions. */
824 static int reg_set_last_unknown
;
825 static rtx reg_set_last_value
;
826 static int reg_set_last_first_regno
, reg_set_last_last_regno
;
828 /* Called via note_stores from reg_set_last. */
831 reg_set_last_1 (x
, pat
)
837 /* If X is not a register, or is not one in the range we care
839 if (GET_CODE (x
) != REG
)
843 last
= first
+ (first
< FIRST_PSEUDO_REGISTER
844 ? HARD_REGNO_NREGS (first
, GET_MODE (x
)) : 1);
846 if (first
>= reg_set_last_last_regno
847 || last
<= reg_set_last_first_regno
)
850 /* If this is a CLOBBER or is some complex LHS, or doesn't modify
851 exactly the registers we care about, show we don't know the value. */
852 if (GET_CODE (pat
) == CLOBBER
|| SET_DEST (pat
) != x
853 || first
!= reg_set_last_first_regno
854 || last
!= reg_set_last_last_regno
)
855 reg_set_last_unknown
= 1;
857 reg_set_last_value
= SET_SRC (pat
);
860 /* Return the last value to which REG was set prior to INSN. If we can't
861 find it easily, return 0.
863 We only return a REG, SUBREG, or constant because it is too hard to
864 check if a MEM remains unchanged. */
867 reg_set_last (x
, insn
)
871 rtx orig_insn
= insn
;
873 reg_set_last_first_regno
= REGNO (x
);
875 reg_set_last_last_regno
876 = reg_set_last_first_regno
877 + (reg_set_last_first_regno
< FIRST_PSEUDO_REGISTER
878 ? HARD_REGNO_NREGS (reg_set_last_first_regno
, GET_MODE (x
)) : 1);
880 reg_set_last_unknown
= 0;
881 reg_set_last_value
= 0;
883 /* Scan backwards until reg_set_last_1 changed one of the above flags.
884 Stop when we reach a label or X is a hard reg and we reach a
885 CALL_INSN (if reg_set_last_last_regno is a hard reg).
887 If we find a set of X, ensure that its SET_SRC remains unchanged. */
889 /* We compare with <= here, because reg_set_last_last_regno
890 is actually the number of the first reg *not* in X. */
892 insn
&& GET_CODE (insn
) != CODE_LABEL
893 && ! (GET_CODE (insn
) == CALL_INSN
894 && reg_set_last_last_regno
<= FIRST_PSEUDO_REGISTER
);
895 insn
= PREV_INSN (insn
))
896 if (GET_RTX_CLASS (GET_CODE (insn
)) == 'i')
898 note_stores (PATTERN (insn
), reg_set_last_1
);
899 if (reg_set_last_unknown
)
901 else if (reg_set_last_value
)
903 if (CONSTANT_P (reg_set_last_value
)
904 || ((GET_CODE (reg_set_last_value
) == REG
905 || GET_CODE (reg_set_last_value
) == SUBREG
)
906 && ! reg_set_between_p (reg_set_last_value
,
907 NEXT_INSN (insn
), orig_insn
)))
908 return reg_set_last_value
;
917 /* This is 1 until after reload pass. */
918 int rtx_equal_function_value_matters
;
920 /* Return 1 if X and Y are identical-looking rtx's.
921 This is the Lisp function EQUAL for rtx arguments. */
929 register enum rtx_code code
;
934 if (x
== 0 || y
== 0)
938 /* Rtx's of different codes cannot be equal. */
939 if (code
!= GET_CODE (y
))
942 /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent.
943 (REG:SI x) and (REG:HI x) are NOT equivalent. */
945 if (GET_MODE (x
) != GET_MODE (y
))
948 /* REG, LABEL_REF, and SYMBOL_REF can be compared nonrecursively. */
951 /* Until rtl generation is complete, don't consider a reference to the
952 return register of the current function the same as the return from a
953 called function. This eases the job of function integration. Once the
954 distinction is no longer needed, they can be considered equivalent. */
955 return (REGNO (x
) == REGNO (y
)
956 && (! rtx_equal_function_value_matters
957 || REG_FUNCTION_VALUE_P (x
) == REG_FUNCTION_VALUE_P (y
)));
958 else if (code
== LABEL_REF
)
959 return XEXP (x
, 0) == XEXP (y
, 0);
960 else if (code
== SYMBOL_REF
)
961 return XSTR (x
, 0) == XSTR (y
, 0);
962 else if (code
== SCRATCH
|| code
== CONST_DOUBLE
)
965 /* Compare the elements. If any pair of corresponding elements
966 fail to match, return 0 for the whole things. */
968 fmt
= GET_RTX_FORMAT (code
);
969 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
974 if (XWINT (x
, i
) != XWINT (y
, i
))
980 if (XINT (x
, i
) != XINT (y
, i
))
986 /* Two vectors must have the same length. */
987 if (XVECLEN (x
, i
) != XVECLEN (y
, i
))
990 /* And the corresponding elements must match. */
991 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
992 if (rtx_equal_p (XVECEXP (x
, i
, j
), XVECEXP (y
, i
, j
)) == 0)
997 if (rtx_equal_p (XEXP (x
, i
), XEXP (y
, i
)) == 0)
1003 if (strcmp (XSTR (x
, i
), XSTR (y
, i
)))
1008 /* These are just backpointers, so they don't matter. */
1014 /* It is believed that rtx's at this level will never
1015 contain anything but integers and other rtx's,
1016 except for within LABEL_REFs and SYMBOL_REFs. */
1024 /* Call FUN on each register or MEM that is stored into or clobbered by X.
1025 (X would be the pattern of an insn).
1026 FUN receives two arguments:
1027 the REG, MEM, CC0 or PC being stored in or clobbered,
1028 the SET or CLOBBER rtx that does the store.
1030 If the item being stored in or clobbered is a SUBREG of a hard register,
1031 the SUBREG will be passed. */
1034 note_stores (x
, fun
)
1038 if ((GET_CODE (x
) == SET
|| GET_CODE (x
) == CLOBBER
))
1040 register rtx dest
= SET_DEST (x
);
1041 while ((GET_CODE (dest
) == SUBREG
1042 && (GET_CODE (SUBREG_REG (dest
)) != REG
1043 || REGNO (SUBREG_REG (dest
)) >= FIRST_PSEUDO_REGISTER
))
1044 || GET_CODE (dest
) == ZERO_EXTRACT
1045 || GET_CODE (dest
) == SIGN_EXTRACT
1046 || GET_CODE (dest
) == STRICT_LOW_PART
)
1047 dest
= XEXP (dest
, 0);
1050 else if (GET_CODE (x
) == PARALLEL
)
1053 for (i
= XVECLEN (x
, 0) - 1; i
>= 0; i
--)
1055 register rtx y
= XVECEXP (x
, 0, i
);
1056 if (GET_CODE (y
) == SET
|| GET_CODE (y
) == CLOBBER
)
1058 register rtx dest
= SET_DEST (y
);
1059 while ((GET_CODE (dest
) == SUBREG
1060 && (GET_CODE (SUBREG_REG (dest
)) != REG
1061 || (REGNO (SUBREG_REG (dest
))
1062 >= FIRST_PSEUDO_REGISTER
)))
1063 || GET_CODE (dest
) == ZERO_EXTRACT
1064 || GET_CODE (dest
) == SIGN_EXTRACT
1065 || GET_CODE (dest
) == STRICT_LOW_PART
)
1066 dest
= XEXP (dest
, 0);
1073 /* Return nonzero if X's old contents don't survive after INSN.
1074 This will be true if X is (cc0) or if X is a register and
1075 X dies in INSN or because INSN entirely sets X.
1077 "Entirely set" means set directly and not through a SUBREG,
1078 ZERO_EXTRACT or SIGN_EXTRACT, so no trace of the old contents remains.
1079 Likewise, REG_INC does not count.
1081 REG may be a hard or pseudo reg. Renumbering is not taken into account,
1082 but for this use that makes no difference, since regs don't overlap
1083 during their lifetimes. Therefore, this function may be used
1084 at any time after deaths have been computed (in flow.c).
1086 If REG is a hard reg that occupies multiple machine registers, this
1087 function will only return 1 if each of those registers will be replaced
1091 dead_or_set_p (insn
, x
)
1095 register int regno
, last_regno
;
1098 /* Can't use cc0_rtx below since this file is used by genattrtab.c. */
1099 if (GET_CODE (x
) == CC0
)
1102 if (GET_CODE (x
) != REG
)
1106 last_regno
= (regno
>= FIRST_PSEUDO_REGISTER
? regno
1107 : regno
+ HARD_REGNO_NREGS (regno
, GET_MODE (x
)) - 1);
1109 for (i
= regno
; i
<= last_regno
; i
++)
1110 if (! dead_or_set_regno_p (insn
, i
))
1116 /* Utility function for dead_or_set_p to check an individual register. Also
1117 called from flow.c. */
1120 dead_or_set_regno_p (insn
, test_regno
)
1124 int regno
, endregno
;
1127 /* See if there is a death note for something that includes TEST_REGNO. */
1128 for (link
= REG_NOTES (insn
); link
; link
= XEXP (link
, 1))
1130 if (REG_NOTE_KIND (link
) != REG_DEAD
|| GET_CODE (XEXP (link
, 0)) != REG
)
1133 regno
= REGNO (XEXP (link
, 0));
1134 endregno
= (regno
>= FIRST_PSEUDO_REGISTER
? regno
+ 1
1135 : regno
+ HARD_REGNO_NREGS (regno
,
1136 GET_MODE (XEXP (link
, 0))));
1138 if (test_regno
>= regno
&& test_regno
< endregno
)
1142 if (GET_CODE (insn
) == CALL_INSN
1143 && find_regno_fusage (insn
, CLOBBER
, test_regno
))
1146 if (GET_CODE (PATTERN (insn
)) == SET
)
1148 rtx dest
= SET_DEST (PATTERN (insn
));
1150 /* A value is totally replaced if it is the destination or the
1151 destination is a SUBREG of REGNO that does not change the number of
1153 if (GET_CODE (dest
) == SUBREG
1154 && (((GET_MODE_SIZE (GET_MODE (dest
))
1155 + UNITS_PER_WORD
- 1) / UNITS_PER_WORD
)
1156 == ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (dest
)))
1157 + UNITS_PER_WORD
- 1) / UNITS_PER_WORD
)))
1158 dest
= SUBREG_REG (dest
);
1160 if (GET_CODE (dest
) != REG
)
1163 regno
= REGNO (dest
);
1164 endregno
= (regno
>= FIRST_PSEUDO_REGISTER
? regno
+ 1
1165 : regno
+ HARD_REGNO_NREGS (regno
, GET_MODE (dest
)));
1167 return (test_regno
>= regno
&& test_regno
< endregno
);
1169 else if (GET_CODE (PATTERN (insn
)) == PARALLEL
)
1173 for (i
= XVECLEN (PATTERN (insn
), 0) - 1; i
>= 0; i
--)
1175 rtx body
= XVECEXP (PATTERN (insn
), 0, i
);
1177 if (GET_CODE (body
) == SET
|| GET_CODE (body
) == CLOBBER
)
1179 rtx dest
= SET_DEST (body
);
1181 if (GET_CODE (dest
) == SUBREG
1182 && (((GET_MODE_SIZE (GET_MODE (dest
))
1183 + UNITS_PER_WORD
- 1) / UNITS_PER_WORD
)
1184 == ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (dest
)))
1185 + UNITS_PER_WORD
- 1) / UNITS_PER_WORD
)))
1186 dest
= SUBREG_REG (dest
);
1188 if (GET_CODE (dest
) != REG
)
1191 regno
= REGNO (dest
);
1192 endregno
= (regno
>= FIRST_PSEUDO_REGISTER
? regno
+ 1
1193 : regno
+ HARD_REGNO_NREGS (regno
, GET_MODE (dest
)));
1195 if (test_regno
>= regno
&& test_regno
< endregno
)
1204 /* Return the reg-note of kind KIND in insn INSN, if there is one.
1205 If DATUM is nonzero, look for one whose datum is DATUM. */
1208 find_reg_note (insn
, kind
, datum
)
1215 for (link
= REG_NOTES (insn
); link
; link
= XEXP (link
, 1))
1216 if (REG_NOTE_KIND (link
) == kind
1217 && (datum
== 0 || datum
== XEXP (link
, 0)))
1222 /* Return the reg-note of kind KIND in insn INSN which applies to register
1223 number REGNO, if any. Return 0 if there is no such reg-note. Note that
1224 the REGNO of this NOTE need not be REGNO if REGNO is a hard register;
1225 it might be the case that the note overlaps REGNO. */
1228 find_regno_note (insn
, kind
, regno
)
1235 for (link
= REG_NOTES (insn
); link
; link
= XEXP (link
, 1))
1236 if (REG_NOTE_KIND (link
) == kind
1237 /* Verify that it is a register, so that scratch and MEM won't cause a
1239 && GET_CODE (XEXP (link
, 0)) == REG
1240 && REGNO (XEXP (link
, 0)) <= regno
1241 && ((REGNO (XEXP (link
, 0))
1242 + (REGNO (XEXP (link
, 0)) >= FIRST_PSEUDO_REGISTER
? 1
1243 : HARD_REGNO_NREGS (REGNO (XEXP (link
, 0)),
1244 GET_MODE (XEXP (link
, 0)))))
1250 /* Return true if DATUM, or any overlap of DATUM, of kind CODE is found
1251 in the CALL_INSN_FUNCTION_USAGE information of INSN. */
1254 find_reg_fusage (insn
, code
, datum
)
1259 /* If it's not a CALL_INSN, it can't possibly have a
1260 CALL_INSN_FUNCTION_USAGE field, so don't bother checking. */
1261 if (GET_CODE (insn
) != CALL_INSN
)
1267 if (GET_CODE (datum
) != REG
)
1271 for (link
= CALL_INSN_FUNCTION_USAGE (insn
);
1273 link
= XEXP (link
, 1))
1274 if (GET_CODE (XEXP (link
, 0)) == code
1275 && rtx_equal_p (datum
, SET_DEST (XEXP (link
, 0))))
1280 register int regno
= REGNO (datum
);
1282 /* CALL_INSN_FUNCTION_USAGE information cannot contain references
1283 to pseudo registers, so don't bother checking. */
1285 if (regno
< FIRST_PSEUDO_REGISTER
)
1287 int end_regno
= regno
+ HARD_REGNO_NREGS (regno
, GET_MODE (datum
));
1290 for (i
= regno
; i
< end_regno
; i
++)
1291 if (find_regno_fusage (insn
, code
, i
))
1299 /* Return true if REGNO, or any overlap of REGNO, of kind CODE is found
1300 in the CALL_INSN_FUNCTION_USAGE information of INSN. */
1303 find_regno_fusage (insn
, code
, regno
)
1310 /* CALL_INSN_FUNCTION_USAGE information cannot contain references
1311 to pseudo registers, so don't bother checking. */
1313 if (regno
>= FIRST_PSEUDO_REGISTER
1314 || GET_CODE (insn
) != CALL_INSN
)
1317 for (link
= CALL_INSN_FUNCTION_USAGE (insn
); link
; link
= XEXP (link
, 1))
1319 register int regnote
;
1322 if (GET_CODE (op
= XEXP (link
, 0)) == code
1323 && GET_CODE (SET_DEST (op
)) == REG
1324 && (regnote
= REGNO (SET_DEST (op
))) <= regno
1326 + HARD_REGNO_NREGS (regnote
, GET_MODE (SET_DEST (op
)))
1334 /* Remove register note NOTE from the REG_NOTES of INSN. */
1337 remove_note (insn
, note
)
1343 if (REG_NOTES (insn
) == note
)
1345 REG_NOTES (insn
) = XEXP (note
, 1);
1349 for (link
= REG_NOTES (insn
); link
; link
= XEXP (link
, 1))
1350 if (XEXP (link
, 1) == note
)
1352 XEXP (link
, 1) = XEXP (note
, 1);
1359 /* Nonzero if X contains any volatile instructions. These are instructions
1360 which may cause unpredictable machine state instructions, and thus no
1361 instructions should be moved or combined across them. This includes
1362 only volatile asms and UNSPEC_VOLATILE instructions. */
1368 register RTX_CODE code
;
1370 code
= GET_CODE (x
);
1390 case UNSPEC_VOLATILE
:
1391 /* case TRAP_IF: This isn't clear yet. */
1395 if (MEM_VOLATILE_P (x
))
1399 /* Recursively scan the operands of this expression. */
1402 register char *fmt
= GET_RTX_FORMAT (code
);
1405 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
1409 if (volatile_insn_p (XEXP (x
, i
)))
1415 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
1416 if (volatile_insn_p (XVECEXP (x
, i
, j
)))
1424 /* Nonzero if X contains any volatile memory references
1425 UNSPEC_VOLATILE operations or volatile ASM_OPERANDS expressions. */
1431 register RTX_CODE code
;
1433 code
= GET_CODE (x
);
1452 case UNSPEC_VOLATILE
:
1453 /* case TRAP_IF: This isn't clear yet. */
1458 if (MEM_VOLATILE_P (x
))
1462 /* Recursively scan the operands of this expression. */
1465 register char *fmt
= GET_RTX_FORMAT (code
);
1468 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
1472 if (volatile_refs_p (XEXP (x
, i
)))
1478 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
1479 if (volatile_refs_p (XVECEXP (x
, i
, j
)))
1487 /* Similar to above, except that it also rejects register pre- and post-
1494 register RTX_CODE code
;
1496 code
= GET_CODE (x
);
1514 /* Reject CLOBBER with a non-VOID mode. These are made by combine.c
1515 when some combination can't be done. If we see one, don't think
1516 that we can simplify the expression. */
1517 return (GET_MODE (x
) != VOIDmode
);
1524 case UNSPEC_VOLATILE
:
1525 /* case TRAP_IF: This isn't clear yet. */
1530 if (MEM_VOLATILE_P (x
))
1534 /* Recursively scan the operands of this expression. */
1537 register char *fmt
= GET_RTX_FORMAT (code
);
1540 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
1544 if (side_effects_p (XEXP (x
, i
)))
1550 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
1551 if (side_effects_p (XVECEXP (x
, i
, j
)))
1559 /* Return nonzero if evaluating rtx X might cause a trap. */
1571 code
= GET_CODE (x
);
1574 /* Handle these cases quickly. */
1586 /* Conditional trap can trap! */
1587 case UNSPEC_VOLATILE
:
1591 /* Memory ref can trap unless it's a static var or a stack slot. */
1593 return rtx_addr_can_trap_p (XEXP (x
, 0));
1595 /* Division by a non-constant might trap. */
1600 if (! CONSTANT_P (XEXP (x
, 1)))
1602 /* This was const0_rtx, but by not using that,
1603 we can link this file into other programs. */
1604 if (GET_CODE (XEXP (x
, 1)) == CONST_INT
&& INTVAL (XEXP (x
, 1)) == 0)
1607 /* Any floating arithmetic may trap. */
1608 if (GET_MODE_CLASS (GET_MODE (x
)) == MODE_FLOAT
)
1612 fmt
= GET_RTX_FORMAT (code
);
1613 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
1617 if (may_trap_p (XEXP (x
, i
)))
1620 else if (fmt
[i
] == 'E')
1623 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
1624 if (may_trap_p (XVECEXP (x
, i
, j
)))
1631 /* Return nonzero if X contains a comparison that is not either EQ or NE,
1632 i.e., an inequality. */
1635 inequality_comparisons_p (x
)
1639 register int len
, i
;
1640 register enum rtx_code code
= GET_CODE (x
);
1666 len
= GET_RTX_LENGTH (code
);
1667 fmt
= GET_RTX_FORMAT (code
);
1669 for (i
= 0; i
< len
; i
++)
1673 if (inequality_comparisons_p (XEXP (x
, i
)))
1676 else if (fmt
[i
] == 'E')
1679 for (j
= XVECLEN (x
, i
) - 1; j
>= 0; j
--)
1680 if (inequality_comparisons_p (XVECEXP (x
, i
, j
)))
1688 /* Replace any occurrence of FROM in X with TO.
1690 Note that copying is not done so X must not be shared unless all copies
1691 are to be modified. */
1694 replace_rtx (x
, from
, to
)
1703 /* Allow this function to make replacements in EXPR_LISTs. */
1707 fmt
= GET_RTX_FORMAT (GET_CODE (x
));
1708 for (i
= GET_RTX_LENGTH (GET_CODE (x
)) - 1; i
>= 0; i
--)
1711 XEXP (x
, i
) = replace_rtx (XEXP (x
, i
), from
, to
);
1712 else if (fmt
[i
] == 'E')
1713 for (j
= XVECLEN (x
, i
) - 1; j
>= 0; j
--)
1714 XVECEXP (x
, i
, j
) = replace_rtx (XVECEXP (x
, i
, j
), from
, to
);
1720 /* Throughout the rtx X, replace many registers according to REG_MAP.
1721 Return the replacement for X (which may be X with altered contents).
1722 REG_MAP[R] is the replacement for register R, or 0 for don't replace.
1723 NREGS is the length of REG_MAP; regs >= NREGS are not mapped.
1725 We only support REG_MAP entries of REG or SUBREG. Also, hard registers
1726 should not be mapped to pseudos or vice versa since validate_change
1729 If REPLACE_DEST is 1, replacements are also done in destinations;
1730 otherwise, only sources are replaced. */
1733 replace_regs (x
, reg_map
, nregs
, replace_dest
)
1739 register enum rtx_code code
;
1746 code
= GET_CODE (x
);
1760 /* Verify that the register has an entry before trying to access it. */
1761 if (REGNO (x
) < nregs
&& reg_map
[REGNO (x
)] != 0)
1763 /* SUBREGs can't be shared. Always return a copy to ensure that if
1764 this replacement occurs more than once then each instance will
1765 get distinct rtx. */
1766 if (GET_CODE (reg_map
[REGNO (x
)]) == SUBREG
)
1767 return copy_rtx (reg_map
[REGNO (x
)]);
1768 return reg_map
[REGNO (x
)];
1773 /* Prevent making nested SUBREGs. */
1774 if (GET_CODE (SUBREG_REG (x
)) == REG
&& REGNO (SUBREG_REG (x
)) < nregs
1775 && reg_map
[REGNO (SUBREG_REG (x
))] != 0
1776 && GET_CODE (reg_map
[REGNO (SUBREG_REG (x
))]) == SUBREG
)
1778 rtx map_val
= reg_map
[REGNO (SUBREG_REG (x
))];
1779 rtx map_inner
= SUBREG_REG (map_val
);
1781 if (GET_MODE (x
) == GET_MODE (map_inner
))
1785 /* We cannot call gen_rtx here since we may be linked with
1787 /* Let's try clobbering the incoming SUBREG and see
1788 if this is really safe. */
1789 SUBREG_REG (x
) = map_inner
;
1790 SUBREG_WORD (x
) += SUBREG_WORD (map_val
);
1793 rtx
new = rtx_alloc (SUBREG
);
1794 PUT_MODE (new, GET_MODE (x
));
1795 SUBREG_REG (new) = map_inner
;
1796 SUBREG_WORD (new) = SUBREG_WORD (x
) + SUBREG_WORD (map_val
);
1804 SET_DEST (x
) = replace_regs (SET_DEST (x
), reg_map
, nregs
, 0);
1806 else if (GET_CODE (SET_DEST (x
)) == MEM
1807 || GET_CODE (SET_DEST (x
)) == STRICT_LOW_PART
)
1808 /* Even if we are not to replace destinations, replace register if it
1809 is CONTAINED in destination (destination is memory or
1810 STRICT_LOW_PART). */
1811 XEXP (SET_DEST (x
), 0) = replace_regs (XEXP (SET_DEST (x
), 0),
1813 else if (GET_CODE (SET_DEST (x
)) == ZERO_EXTRACT
)
1814 /* Similarly, for ZERO_EXTRACT we replace all operands. */
1817 SET_SRC (x
) = replace_regs (SET_SRC (x
), reg_map
, nregs
, 0);
1821 fmt
= GET_RTX_FORMAT (code
);
1822 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
1825 XEXP (x
, i
) = replace_regs (XEXP (x
, i
), reg_map
, nregs
, replace_dest
);
1829 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
1830 XVECEXP (x
, i
, j
) = replace_regs (XVECEXP (x
, i
, j
), reg_map
,
1831 nregs
, replace_dest
);