]>
gcc.gnu.org Git - gcc.git/blob - gcc/rtlanal.c
1 /* Analyze RTL for C-Compiler
2 Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000 Free Software Foundation, Inc.
5 This file is part of GNU CC.
7 GNU CC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU CC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU CC; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
27 static int rtx_addr_can_trap_p
PARAMS ((rtx
));
28 static void reg_set_p_1
PARAMS ((rtx
, rtx
, void *));
29 static void insn_dependent_p_1
PARAMS ((rtx
, rtx
, void *));
30 static void reg_set_last_1
PARAMS ((rtx
, rtx
, void *));
33 /* Forward declarations */
34 static int jmp_uses_reg_or_mem
PARAMS ((rtx
));
36 /* Bit flags that specify the machine subtype we are compiling for.
37 Bits are tested using macros TARGET_... defined in the tm.h file
38 and set by `-m...' switches. Must be defined in rtlanal.c. */
42 /* Return 1 if the value of X is unstable
43 (would be different at a different point in the program).
44 The frame pointer, arg pointer, etc. are considered stable
45 (within one function) and so is anything marked `unchanging'. */
51 register RTX_CODE code
= GET_CODE (x
);
53 register const char *fmt
;
58 return ! RTX_UNCHANGING_P (x
) || rtx_unstable_p (XEXP (x
, 0));
71 /* As in rtx_varies_p, we have to use the actual rtx, not reg number. */
72 return ! (x
== frame_pointer_rtx
|| x
== hard_frame_pointer_rtx
73 || x
== arg_pointer_rtx
|| x
== pic_offset_table_rtx
74 || RTX_UNCHANGING_P (x
));
77 if (MEM_VOLATILE_P (x
))
86 fmt
= GET_RTX_FORMAT (code
);
87 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
90 if (rtx_unstable_p (XEXP (x
, i
)))
93 else if (fmt
[i
] == 'E')
96 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
97 if (rtx_unstable_p (XVECEXP (x
, i
, j
)))
104 /* Return 1 if X has a value that can vary even between two
105 executions of the program. 0 means X can be compared reliably
106 against certain constants or near-constants.
107 The frame pointer and the arg pointer are considered constant. */
113 register RTX_CODE code
= GET_CODE (x
);
115 register const char *fmt
;
120 return ! RTX_UNCHANGING_P (x
) || rtx_varies_p (XEXP (x
, 0));
133 /* Note that we have to test for the actual rtx used for the frame
134 and arg pointers and not just the register number in case we have
135 eliminated the frame and/or arg pointer and are using it
137 return ! (x
== frame_pointer_rtx
|| x
== hard_frame_pointer_rtx
138 || x
== arg_pointer_rtx
|| x
== pic_offset_table_rtx
);
141 /* The operand 0 of a LO_SUM is considered constant
142 (in fact is it related specifically to operand 1). */
143 return rtx_varies_p (XEXP (x
, 1));
146 if (MEM_VOLATILE_P (x
))
155 fmt
= GET_RTX_FORMAT (code
);
156 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
159 if (rtx_varies_p (XEXP (x
, i
)))
162 else if (fmt
[i
] == 'E')
165 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
166 if (rtx_varies_p (XVECEXP (x
, i
, j
)))
173 /* Return 0 if the use of X as an address in a MEM can cause a trap. */
176 rtx_addr_can_trap_p (x
)
179 register enum rtx_code code
= GET_CODE (x
);
185 /* SYMBOL_REF is problematic due to the possible presence of
186 a #pragma weak, but to say that loads from symbols can trap is
187 *very* costly. It's not at all clear what's best here. For
188 now, we ignore the impact of #pragma weak. */
192 /* As in rtx_varies_p, we have to use the actual rtx, not reg number. */
193 return ! (x
== frame_pointer_rtx
|| x
== hard_frame_pointer_rtx
194 || x
== stack_pointer_rtx
|| x
== arg_pointer_rtx
);
197 return rtx_addr_can_trap_p (XEXP (x
, 0));
200 /* An address is assumed not to trap if it is an address that can't
201 trap plus a constant integer or it is the pic register plus a
203 return ! ((! rtx_addr_can_trap_p (XEXP (x
, 0))
204 && GET_CODE (XEXP (x
, 1)) == CONST_INT
)
205 || (XEXP (x
, 0) == pic_offset_table_rtx
206 && CONSTANT_P (XEXP (x
, 1))));
209 return rtx_addr_can_trap_p (XEXP (x
, 1));
215 /* If it isn't one of the case above, it can cause a trap. */
219 /* Return 1 if X refers to a memory location whose address
220 cannot be compared reliably with constant addresses,
221 or if X refers to a BLKmode memory object. */
224 rtx_addr_varies_p (x
)
227 register enum rtx_code code
;
229 register const char *fmt
;
236 return GET_MODE (x
) == BLKmode
|| rtx_varies_p (XEXP (x
, 0));
238 fmt
= GET_RTX_FORMAT (code
);
239 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
242 if (rtx_addr_varies_p (XEXP (x
, i
)))
245 else if (fmt
[i
] == 'E')
248 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
249 if (rtx_addr_varies_p (XVECEXP (x
, i
, j
)))
255 /* Return the value of the integer term in X, if one is apparent;
257 Only obvious integer terms are detected.
258 This is used in cse.c with the `related_value' field.*/
264 if (GET_CODE (x
) == CONST
)
267 if (GET_CODE (x
) == MINUS
268 && GET_CODE (XEXP (x
, 1)) == CONST_INT
)
269 return - INTVAL (XEXP (x
, 1));
270 if (GET_CODE (x
) == PLUS
271 && GET_CODE (XEXP (x
, 1)) == CONST_INT
)
272 return INTVAL (XEXP (x
, 1));
276 /* If X is a constant, return the value sans apparent integer term;
278 Only obvious integer terms are detected. */
281 get_related_value (x
)
284 if (GET_CODE (x
) != CONST
)
287 if (GET_CODE (x
) == PLUS
288 && GET_CODE (XEXP (x
, 1)) == CONST_INT
)
290 else if (GET_CODE (x
) == MINUS
291 && GET_CODE (XEXP (x
, 1)) == CONST_INT
)
296 /* Return the number of places FIND appears within X. If COUNT_DEST is
297 zero, we do not count occurrences inside the destination of a SET. */
300 count_occurrences (x
, find
, count_dest
)
306 const char *format_ptr
;
326 if (GET_CODE (find
) == MEM
&& rtx_equal_p (x
, find
))
331 if (SET_DEST (x
) == find
&& ! count_dest
)
332 return count_occurrences (SET_SRC (x
), find
, count_dest
);
339 format_ptr
= GET_RTX_FORMAT (code
);
342 for (i
= 0; i
< GET_RTX_LENGTH (code
); i
++)
344 switch (*format_ptr
++)
347 count
+= count_occurrences (XEXP (x
, i
), find
, count_dest
);
351 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
352 count
+= count_occurrences (XVECEXP (x
, i
, j
), find
, count_dest
);
359 /* Nonzero if register REG appears somewhere within IN.
360 Also works if REG is not a register; in this case it checks
361 for a subexpression of IN that is Lisp "equal" to REG. */
364 reg_mentioned_p (reg
, in
)
365 register rtx reg
, in
;
367 register const char *fmt
;
369 register enum rtx_code code
;
377 if (GET_CODE (in
) == LABEL_REF
)
378 return reg
== XEXP (in
, 0);
380 code
= GET_CODE (in
);
384 /* Compare registers by number. */
386 return GET_CODE (reg
) == REG
&& REGNO (in
) == REGNO (reg
);
388 /* These codes have no constituent expressions
396 return GET_CODE (reg
) == CONST_INT
&& INTVAL (in
) == INTVAL (reg
);
399 /* These are kept unique for a given value. */
406 if (GET_CODE (reg
) == code
&& rtx_equal_p (reg
, in
))
409 fmt
= GET_RTX_FORMAT (code
);
411 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
416 for (j
= XVECLEN (in
, i
) - 1; j
>= 0; j
--)
417 if (reg_mentioned_p (reg
, XVECEXP (in
, i
, j
)))
420 else if (fmt
[i
] == 'e'
421 && reg_mentioned_p (reg
, XEXP (in
, i
)))
427 /* Return 1 if in between BEG and END, exclusive of BEG and END, there is
428 no CODE_LABEL insn. */
431 no_labels_between_p (beg
, end
)
435 for (p
= NEXT_INSN (beg
); p
!= end
; p
= NEXT_INSN (p
))
436 if (GET_CODE (p
) == CODE_LABEL
)
441 /* Return 1 if in between BEG and END, exclusive of BEG and END, there is
442 no JUMP_INSN insn. */
445 no_jumps_between_p (beg
, end
)
449 for (p
= NEXT_INSN (beg
); p
!= end
; p
= NEXT_INSN (p
))
450 if (GET_CODE (p
) == JUMP_INSN
)
455 /* Nonzero if register REG is used in an insn between
456 FROM_INSN and TO_INSN (exclusive of those two). */
459 reg_used_between_p (reg
, from_insn
, to_insn
)
460 rtx reg
, from_insn
, to_insn
;
464 if (from_insn
== to_insn
)
467 for (insn
= NEXT_INSN (from_insn
); insn
!= to_insn
; insn
= NEXT_INSN (insn
))
469 && (reg_overlap_mentioned_p (reg
, PATTERN (insn
))
470 || (GET_CODE (insn
) == CALL_INSN
471 && (find_reg_fusage (insn
, USE
, reg
)
472 || find_reg_fusage (insn
, CLOBBER
, reg
)))))
477 /* Nonzero if the old value of X, a register, is referenced in BODY. If X
478 is entirely replaced by a new value and the only use is as a SET_DEST,
479 we do not consider it a reference. */
482 reg_referenced_p (x
, body
)
488 switch (GET_CODE (body
))
491 if (reg_overlap_mentioned_p (x
, SET_SRC (body
)))
494 /* If the destination is anything other than CC0, PC, a REG or a SUBREG
495 of a REG that occupies all of the REG, the insn references X if
496 it is mentioned in the destination. */
497 if (GET_CODE (SET_DEST (body
)) != CC0
498 && GET_CODE (SET_DEST (body
)) != PC
499 && GET_CODE (SET_DEST (body
)) != REG
500 && ! (GET_CODE (SET_DEST (body
)) == SUBREG
501 && GET_CODE (SUBREG_REG (SET_DEST (body
))) == REG
502 && (((GET_MODE_SIZE (GET_MODE (SUBREG_REG (SET_DEST (body
))))
503 + (UNITS_PER_WORD
- 1)) / UNITS_PER_WORD
)
504 == ((GET_MODE_SIZE (GET_MODE (SET_DEST (body
)))
505 + (UNITS_PER_WORD
- 1)) / UNITS_PER_WORD
)))
506 && reg_overlap_mentioned_p (x
, SET_DEST (body
)))
511 for (i
= ASM_OPERANDS_INPUT_LENGTH (body
) - 1; i
>= 0; i
--)
512 if (reg_overlap_mentioned_p (x
, ASM_OPERANDS_INPUT (body
, i
)))
519 return reg_overlap_mentioned_p (x
, body
);
522 return reg_overlap_mentioned_p (x
, TRAP_CONDITION (body
));
525 case UNSPEC_VOLATILE
:
526 for (i
= XVECLEN (body
, 0) - 1; i
>= 0; i
--)
527 if (reg_overlap_mentioned_p (x
, XVECEXP (body
, 0, i
)))
532 for (i
= XVECLEN (body
, 0) - 1; i
>= 0; i
--)
533 if (reg_referenced_p (x
, XVECEXP (body
, 0, i
)))
538 if (GET_CODE (XEXP (body
, 0)) == MEM
)
539 if (reg_overlap_mentioned_p (x
, XEXP (XEXP (body
, 0), 0)))
544 if (reg_overlap_mentioned_p (x
, COND_EXEC_TEST (body
)))
546 return reg_referenced_p (x
, COND_EXEC_CODE (body
));
553 /* Nonzero if register REG is referenced in an insn between
554 FROM_INSN and TO_INSN (exclusive of those two). Sets of REG do
558 reg_referenced_between_p (reg
, from_insn
, to_insn
)
559 rtx reg
, from_insn
, to_insn
;
563 if (from_insn
== to_insn
)
566 for (insn
= NEXT_INSN (from_insn
); insn
!= to_insn
; insn
= NEXT_INSN (insn
))
568 && (reg_referenced_p (reg
, PATTERN (insn
))
569 || (GET_CODE (insn
) == CALL_INSN
570 && find_reg_fusage (insn
, USE
, reg
))))
575 /* Nonzero if register REG is set or clobbered in an insn between
576 FROM_INSN and TO_INSN (exclusive of those two). */
579 reg_set_between_p (reg
, from_insn
, to_insn
)
580 rtx reg
, from_insn
, to_insn
;
584 if (from_insn
== to_insn
)
587 for (insn
= NEXT_INSN (from_insn
); insn
!= to_insn
; insn
= NEXT_INSN (insn
))
588 if (INSN_P (insn
) && reg_set_p (reg
, insn
))
593 /* Internals of reg_set_between_p. */
595 static rtx reg_set_reg
;
596 static int reg_set_flag
;
599 reg_set_p_1 (x
, pat
, data
)
601 rtx pat ATTRIBUTE_UNUSED
;
602 void *data ATTRIBUTE_UNUSED
;
604 /* We don't want to return 1 if X is a MEM that contains a register
605 within REG_SET_REG. */
607 if ((GET_CODE (x
) != MEM
)
608 && reg_overlap_mentioned_p (reg_set_reg
, x
))
613 reg_set_p (reg
, insn
)
618 /* We can be passed an insn or part of one. If we are passed an insn,
619 check if a side-effect of the insn clobbers REG. */
622 if (FIND_REG_INC_NOTE (insn
, reg
)
623 || (GET_CODE (insn
) == CALL_INSN
624 /* We'd like to test call_used_regs here, but rtlanal.c can't
625 reference that variable due to its use in genattrtab. So
626 we'll just be more conservative.
628 ??? Unless we could ensure that the CALL_INSN_FUNCTION_USAGE
629 information holds all clobbered registers. */
630 && ((GET_CODE (reg
) == REG
631 && REGNO (reg
) < FIRST_PSEUDO_REGISTER
)
632 || GET_CODE (reg
) == MEM
633 || find_reg_fusage (insn
, CLOBBER
, reg
))))
636 body
= PATTERN (insn
);
641 note_stores (body
, reg_set_p_1
, NULL
);
645 /* Similar to reg_set_between_p, but check all registers in X. Return 0
646 only if none of them are modified between START and END. Do not
647 consider non-registers one way or the other. */
650 regs_set_between_p (x
, start
, end
)
654 enum rtx_code code
= GET_CODE (x
);
670 return reg_set_between_p (x
, start
, end
);
676 fmt
= GET_RTX_FORMAT (code
);
677 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
679 if (fmt
[i
] == 'e' && regs_set_between_p (XEXP (x
, i
), start
, end
))
682 else if (fmt
[i
] == 'E')
683 for (j
= XVECLEN (x
, i
) - 1; j
>= 0; j
--)
684 if (regs_set_between_p (XVECEXP (x
, i
, j
), start
, end
))
691 /* Similar to reg_set_between_p, but check all registers in X. Return 0
692 only if none of them are modified between START and END. Return 1 if
693 X contains a MEM; this routine does not perform any memory aliasing. */
696 modified_between_p (x
, start
, end
)
700 enum rtx_code code
= GET_CODE (x
);
718 /* If the memory is not constant, assume it is modified. If it is
719 constant, we still have to check the address. */
720 if (! RTX_UNCHANGING_P (x
))
725 return reg_set_between_p (x
, start
, end
);
731 fmt
= GET_RTX_FORMAT (code
);
732 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
734 if (fmt
[i
] == 'e' && modified_between_p (XEXP (x
, i
), start
, end
))
737 else if (fmt
[i
] == 'E')
738 for (j
= XVECLEN (x
, i
) - 1; j
>= 0; j
--)
739 if (modified_between_p (XVECEXP (x
, i
, j
), start
, end
))
746 /* Similar to reg_set_p, but check all registers in X. Return 0 only if none
747 of them are modified in INSN. Return 1 if X contains a MEM; this routine
748 does not perform any memory aliasing. */
751 modified_in_p (x
, insn
)
755 enum rtx_code code
= GET_CODE (x
);
773 /* If the memory is not constant, assume it is modified. If it is
774 constant, we still have to check the address. */
775 if (! RTX_UNCHANGING_P (x
))
780 return reg_set_p (x
, insn
);
786 fmt
= GET_RTX_FORMAT (code
);
787 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
789 if (fmt
[i
] == 'e' && modified_in_p (XEXP (x
, i
), insn
))
792 else if (fmt
[i
] == 'E')
793 for (j
= XVECLEN (x
, i
) - 1; j
>= 0; j
--)
794 if (modified_in_p (XVECEXP (x
, i
, j
), insn
))
801 /* Return true if anything in insn X is (anti,output,true) dependent on
802 anything in insn Y. */
805 insn_dependent_p (x
, y
)
810 if (! INSN_P (x
) || ! INSN_P (y
))
814 note_stores (PATTERN (x
), insn_dependent_p_1
, &tmp
);
819 note_stores (PATTERN (y
), insn_dependent_p_1
, &tmp
);
826 /* A helper routine for insn_dependent_p called through note_stores. */
829 insn_dependent_p_1 (x
, pat
, data
)
831 rtx pat ATTRIBUTE_UNUSED
;
834 rtx
* pinsn
= (rtx
*) data
;
836 if (*pinsn
&& reg_mentioned_p (x
, *pinsn
))
840 /* Given an INSN, return a SET expression if this insn has only a single SET.
841 It may also have CLOBBERs, USEs, or SET whose output
842 will not be used, which we ignore. */
849 rtx pat
= PATTERN (insn
);
852 if (GET_CODE (pat
) == PARALLEL
)
855 /* This part is is performance critical for targets that use a lot of
856 parallels, such as i386. We want to accept as single set
857 instructions even an instructions with multiple sets where only
858 one has live result, but we attempt to delay this tests only for
859 multiple set instructions to reduce amount of calls to
860 find_reg_note and side_effects_p.
862 We expect the "common" instruction to be parallel with first SET
863 followed by the clobbers. So first we get the set, then look
864 if it is followed by USE or CLOBBER. If so, we just return expect
865 no SETs after these. When SET is followed by another SET, we
866 continue by the clomplex loop trought all members of PARALLEL.
868 #ifdef ENABLE_CHECKING
869 if (XVECLEN (pat
, 0) < 2)
872 set
= XVECEXP (pat
, 0, 0);
873 switch (GET_CODE (set
))
875 #ifdef ENABLE_CHECKING
878 /* Instruction should not consist only from USEs and CLOBBERS,
879 since then gcc is allowed to remove it entirely. In case
880 something else is present, it should be first in the pattern. */
888 x
= XVECEXP (pat
, 0, 1);
889 switch (GET_CODE (x
))
893 #ifdef ENABLE_CHECKING
894 /* The USEs and CLOBBERs should always come last in the pattern. */
895 for (i
= XVECLEN (pat
, 0) - 1; i
> 1; i
--)
896 if (GET_CODE (XVECEXP (pat
, 0, i
)) != USE
897 && GET_CODE (XVECEXP (pat
, 0, i
)) != CLOBBER
)
902 /* Multiple set insns - we are off the critical path now. */
903 for (i
= XVECLEN (pat
, 0) - 1; i
> 0; i
--)
905 sub
= XVECEXP (pat
, 0, i
);
906 switch GET_CODE (sub
)
914 || (find_reg_note (insn
, REG_UNUSED
, SET_DEST (set
))
915 && side_effects_p (set
)))
917 else if (! find_reg_note (insn
, REG_UNUSED
, SET_DEST (sub
))
918 || side_effects_p (sub
))
935 /* Given an INSN, return nonzero if it has more than one SET, else return
945 /* INSN must be an insn. */
949 /* Only a PARALLEL can have multiple SETs. */
950 if (GET_CODE (PATTERN (insn
)) == PARALLEL
)
952 for (i
= 0, found
= 0; i
< XVECLEN (PATTERN (insn
), 0); i
++)
953 if (GET_CODE (XVECEXP (PATTERN (insn
), 0, i
)) == SET
)
955 /* If we have already found a SET, then return now. */
963 /* Either zero or one SET. */
967 /* Return the last thing that X was assigned from before *PINSN. If VALID_TO
968 is not NULL_RTX then verify that the object is not modified up to VALID_TO.
969 If the object was modified, if we hit a partial assignment to X, or hit a
970 CODE_LABEL first, return X. If we found an assignment, update *PINSN to
971 point to it. ALLOW_HWREG is set to 1 if hardware registers are allowed to
975 find_last_value (x
, pinsn
, valid_to
, allow_hwreg
)
983 for (p
= PREV_INSN (*pinsn
); p
&& GET_CODE (p
) != CODE_LABEL
;
987 rtx set
= single_set (p
);
988 rtx note
= find_reg_note (p
, REG_EQUAL
, NULL_RTX
);
990 if (set
&& rtx_equal_p (x
, SET_DEST (set
)))
992 rtx src
= SET_SRC (set
);
994 if (note
&& GET_CODE (XEXP (note
, 0)) != EXPR_LIST
)
995 src
= XEXP (note
, 0);
997 if ((valid_to
== NULL_RTX
998 || ! modified_between_p (src
, PREV_INSN (p
), valid_to
))
999 /* Reject hard registers because we don't usually want
1000 to use them; we'd rather use a pseudo. */
1001 && (! (GET_CODE (src
) == REG
1002 && REGNO (src
) < FIRST_PSEUDO_REGISTER
) || allow_hwreg
))
1009 /* If set in non-simple way, we don't have a value. */
1010 if (reg_set_p (x
, p
))
1017 /* Return nonzero if register in range [REGNO, ENDREGNO)
1018 appears either explicitly or implicitly in X
1019 other than being stored into.
1021 References contained within the substructure at LOC do not count.
1022 LOC may be zero, meaning don't ignore anything. */
1025 refers_to_regno_p (regno
, endregno
, x
, loc
)
1026 unsigned int regno
, endregno
;
1031 unsigned int x_regno
;
1036 /* The contents of a REG_NONNEG note is always zero, so we must come here
1037 upon repeat in case the last REG_NOTE is a REG_NONNEG note. */
1041 code
= GET_CODE (x
);
1046 x_regno
= REGNO (x
);
1048 /* If we modifying the stack, frame, or argument pointer, it will
1049 clobber a virtual register. In fact, we could be more precise,
1050 but it isn't worth it. */
1051 if ((x_regno
== STACK_POINTER_REGNUM
1052 #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
1053 || x_regno
== ARG_POINTER_REGNUM
1055 || x_regno
== FRAME_POINTER_REGNUM
)
1056 && regno
>= FIRST_VIRTUAL_REGISTER
&& regno
<= LAST_VIRTUAL_REGISTER
)
1059 return (endregno
> x_regno
1060 && regno
< x_regno
+ (x_regno
< FIRST_PSEUDO_REGISTER
1061 ? HARD_REGNO_NREGS (x_regno
, GET_MODE (x
))
1065 /* If this is a SUBREG of a hard reg, we can see exactly which
1066 registers are being modified. Otherwise, handle normally. */
1067 if (GET_CODE (SUBREG_REG (x
)) == REG
1068 && REGNO (SUBREG_REG (x
)) < FIRST_PSEUDO_REGISTER
)
1070 unsigned int inner_regno
= REGNO (SUBREG_REG (x
)) + SUBREG_WORD (x
);
1071 unsigned int inner_endregno
1072 = inner_regno
+ (inner_regno
< FIRST_PSEUDO_REGISTER
1073 ? HARD_REGNO_NREGS (regno
, GET_MODE (x
)) : 1);
1075 return endregno
> inner_regno
&& regno
< inner_endregno
;
1081 if (&SET_DEST (x
) != loc
1082 /* Note setting a SUBREG counts as referring to the REG it is in for
1083 a pseudo but not for hard registers since we can
1084 treat each word individually. */
1085 && ((GET_CODE (SET_DEST (x
)) == SUBREG
1086 && loc
!= &SUBREG_REG (SET_DEST (x
))
1087 && GET_CODE (SUBREG_REG (SET_DEST (x
))) == REG
1088 && REGNO (SUBREG_REG (SET_DEST (x
))) >= FIRST_PSEUDO_REGISTER
1089 && refers_to_regno_p (regno
, endregno
,
1090 SUBREG_REG (SET_DEST (x
)), loc
))
1091 || (GET_CODE (SET_DEST (x
)) != REG
1092 && refers_to_regno_p (regno
, endregno
, SET_DEST (x
), loc
))))
1095 if (code
== CLOBBER
|| loc
== &SET_SRC (x
))
1104 /* X does not match, so try its subexpressions. */
1106 fmt
= GET_RTX_FORMAT (code
);
1107 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
1109 if (fmt
[i
] == 'e' && loc
!= &XEXP (x
, i
))
1117 if (refers_to_regno_p (regno
, endregno
, XEXP (x
, i
), loc
))
1120 else if (fmt
[i
] == 'E')
1123 for (j
= XVECLEN (x
, i
) - 1; j
>=0; j
--)
1124 if (loc
!= &XVECEXP (x
, i
, j
)
1125 && refers_to_regno_p (regno
, endregno
, XVECEXP (x
, i
, j
), loc
))
1132 /* Nonzero if modifying X will affect IN. If X is a register or a SUBREG,
1133 we check if any register number in X conflicts with the relevant register
1134 numbers. If X is a constant, return 0. If X is a MEM, return 1 iff IN
1135 contains a MEM (we don't bother checking for memory addresses that can't
1136 conflict because we expect this to be a rare case. */
1139 reg_overlap_mentioned_p (x
, in
)
1142 unsigned int regno
, endregno
;
1144 /* Overly conservative. */
1145 if (GET_CODE (x
) == STRICT_LOW_PART
)
1148 /* If either argument is a constant, then modifying X can not affect IN. */
1149 if (CONSTANT_P (x
) || CONSTANT_P (in
))
1152 switch (GET_CODE (x
))
1155 regno
= REGNO (SUBREG_REG (x
));
1156 if (regno
< FIRST_PSEUDO_REGISTER
)
1157 regno
+= SUBREG_WORD (x
);
1163 endregno
= regno
+ (regno
< FIRST_PSEUDO_REGISTER
1164 ? HARD_REGNO_NREGS (regno
, GET_MODE (x
)) : 1);
1165 return refers_to_regno_p (regno
, endregno
, in
, NULL_PTR
);
1172 if (GET_CODE (in
) == MEM
)
1175 fmt
= GET_RTX_FORMAT (GET_CODE (in
));
1176 for (i
= GET_RTX_LENGTH (GET_CODE (in
)) - 1; i
>= 0; i
--)
1177 if (fmt
[i
] == 'e' && reg_overlap_mentioned_p (x
, XEXP (in
, i
)))
1186 return reg_mentioned_p (x
, in
);
1192 /* Check for a NULL entry, used to indicate that the parameter goes
1193 both on the stack and in registers. */
1194 if (XEXP (XVECEXP (x
, 0, 0), 0))
1199 /* If any register in here refers to it we return true. */
1200 for (n
= XVECLEN (x
, 0); i
< n
; ++i
)
1201 if (reg_overlap_mentioned_p (XEXP (XVECEXP (x
, 0, i
), 0), in
))
1213 /* Used for communications between the next few functions. */
1215 static int reg_set_last_unknown
;
1216 static rtx reg_set_last_value
;
1217 static unsigned int reg_set_last_first_regno
, reg_set_last_last_regno
;
1219 /* Called via note_stores from reg_set_last. */
1222 reg_set_last_1 (x
, pat
, data
)
1225 void *data ATTRIBUTE_UNUSED
;
1227 unsigned int first
, last
;
1229 /* If X is not a register, or is not one in the range we care
1231 if (GET_CODE (x
) != REG
)
1235 last
= first
+ (first
< FIRST_PSEUDO_REGISTER
1236 ? HARD_REGNO_NREGS (first
, GET_MODE (x
)) : 1);
1238 if (first
>= reg_set_last_last_regno
1239 || last
<= reg_set_last_first_regno
)
1242 /* If this is a CLOBBER or is some complex LHS, or doesn't modify
1243 exactly the registers we care about, show we don't know the value. */
1244 if (GET_CODE (pat
) == CLOBBER
|| SET_DEST (pat
) != x
1245 || first
!= reg_set_last_first_regno
1246 || last
!= reg_set_last_last_regno
)
1247 reg_set_last_unknown
= 1;
1249 reg_set_last_value
= SET_SRC (pat
);
1252 /* Return the last value to which REG was set prior to INSN. If we can't
1253 find it easily, return 0.
1255 We only return a REG, SUBREG, or constant because it is too hard to
1256 check if a MEM remains unchanged. */
1259 reg_set_last (x
, insn
)
1263 rtx orig_insn
= insn
;
1265 reg_set_last_first_regno
= REGNO (x
);
1267 reg_set_last_last_regno
1268 = reg_set_last_first_regno
1269 + (reg_set_last_first_regno
< FIRST_PSEUDO_REGISTER
1270 ? HARD_REGNO_NREGS (reg_set_last_first_regno
, GET_MODE (x
)) : 1);
1272 reg_set_last_unknown
= 0;
1273 reg_set_last_value
= 0;
1275 /* Scan backwards until reg_set_last_1 changed one of the above flags.
1276 Stop when we reach a label or X is a hard reg and we reach a
1277 CALL_INSN (if reg_set_last_last_regno is a hard reg).
1279 If we find a set of X, ensure that its SET_SRC remains unchanged. */
1281 /* We compare with <= here, because reg_set_last_last_regno
1282 is actually the number of the first reg *not* in X. */
1284 insn
&& GET_CODE (insn
) != CODE_LABEL
1285 && ! (GET_CODE (insn
) == CALL_INSN
1286 && reg_set_last_last_regno
<= FIRST_PSEUDO_REGISTER
);
1287 insn
= PREV_INSN (insn
))
1290 note_stores (PATTERN (insn
), reg_set_last_1
, NULL
);
1291 if (reg_set_last_unknown
)
1293 else if (reg_set_last_value
)
1295 if (CONSTANT_P (reg_set_last_value
)
1296 || ((GET_CODE (reg_set_last_value
) == REG
1297 || GET_CODE (reg_set_last_value
) == SUBREG
)
1298 && ! reg_set_between_p (reg_set_last_value
,
1300 return reg_set_last_value
;
1309 /* Call FUN on each register or MEM that is stored into or clobbered by X.
1310 (X would be the pattern of an insn).
1311 FUN receives two arguments:
1312 the REG, MEM, CC0 or PC being stored in or clobbered,
1313 the SET or CLOBBER rtx that does the store.
1315 If the item being stored in or clobbered is a SUBREG of a hard register,
1316 the SUBREG will be passed. */
1319 note_stores (x
, fun
, data
)
1321 void (*fun
) PARAMS ((rtx
, rtx
, void *));
1324 if (GET_CODE (x
) == COND_EXEC
)
1325 x
= COND_EXEC_CODE (x
);
1326 if (GET_CODE (x
) == SET
|| GET_CODE (x
) == CLOBBER
)
1328 register rtx dest
= SET_DEST (x
);
1329 while ((GET_CODE (dest
) == SUBREG
1330 && (GET_CODE (SUBREG_REG (dest
)) != REG
1331 || REGNO (SUBREG_REG (dest
)) >= FIRST_PSEUDO_REGISTER
))
1332 || GET_CODE (dest
) == ZERO_EXTRACT
1333 || GET_CODE (dest
) == SIGN_EXTRACT
1334 || GET_CODE (dest
) == STRICT_LOW_PART
)
1335 dest
= XEXP (dest
, 0);
1337 if (GET_CODE (dest
) == PARALLEL
1338 && GET_MODE (dest
) == BLKmode
)
1341 for (i
= XVECLEN (dest
, 0) - 1; i
>= 0; i
--)
1342 (*fun
) (SET_DEST (XVECEXP (dest
, 0, i
)), x
, data
);
1345 (*fun
) (dest
, x
, data
);
1347 else if (GET_CODE (x
) == PARALLEL
)
1350 for (i
= XVECLEN (x
, 0) - 1; i
>= 0; i
--)
1352 register rtx y
= XVECEXP (x
, 0, i
);
1353 if (GET_CODE (y
) == COND_EXEC
)
1354 y
= COND_EXEC_CODE (y
);
1355 if (GET_CODE (y
) == SET
|| GET_CODE (y
) == CLOBBER
)
1357 register rtx dest
= SET_DEST (y
);
1358 while ((GET_CODE (dest
) == SUBREG
1359 && (GET_CODE (SUBREG_REG (dest
)) != REG
1360 || (REGNO (SUBREG_REG (dest
))
1361 >= FIRST_PSEUDO_REGISTER
)))
1362 || GET_CODE (dest
) == ZERO_EXTRACT
1363 || GET_CODE (dest
) == SIGN_EXTRACT
1364 || GET_CODE (dest
) == STRICT_LOW_PART
)
1365 dest
= XEXP (dest
, 0);
1366 if (GET_CODE (dest
) == PARALLEL
1367 && GET_MODE (dest
) == BLKmode
)
1371 for (i
= XVECLEN (dest
, 0) - 1; i
>= 0; i
--)
1372 (*fun
) (SET_DEST (XVECEXP (dest
, 0, i
)), y
, data
);
1375 (*fun
) (dest
, y
, data
);
1381 /* Return nonzero if X's old contents don't survive after INSN.
1382 This will be true if X is (cc0) or if X is a register and
1383 X dies in INSN or because INSN entirely sets X.
1385 "Entirely set" means set directly and not through a SUBREG,
1386 ZERO_EXTRACT or SIGN_EXTRACT, so no trace of the old contents remains.
1387 Likewise, REG_INC does not count.
1389 REG may be a hard or pseudo reg. Renumbering is not taken into account,
1390 but for this use that makes no difference, since regs don't overlap
1391 during their lifetimes. Therefore, this function may be used
1392 at any time after deaths have been computed (in flow.c).
1394 If REG is a hard reg that occupies multiple machine registers, this
1395 function will only return 1 if each of those registers will be replaced
1399 dead_or_set_p (insn
, x
)
1403 unsigned int regno
, last_regno
;
1406 /* Can't use cc0_rtx below since this file is used by genattrtab.c. */
1407 if (GET_CODE (x
) == CC0
)
1410 if (GET_CODE (x
) != REG
)
1414 last_regno
= (regno
>= FIRST_PSEUDO_REGISTER
? regno
1415 : regno
+ HARD_REGNO_NREGS (regno
, GET_MODE (x
)) - 1);
1417 for (i
= regno
; i
<= last_regno
; i
++)
1418 if (! dead_or_set_regno_p (insn
, i
))
1424 /* Utility function for dead_or_set_p to check an individual register. Also
1425 called from flow.c. */
1428 dead_or_set_regno_p (insn
, test_regno
)
1430 unsigned int test_regno
;
1432 unsigned int regno
, endregno
;
1435 /* See if there is a death note for something that includes TEST_REGNO. */
1436 if (find_regno_note (insn
, REG_DEAD
, test_regno
))
1439 if (GET_CODE (insn
) == CALL_INSN
1440 && find_regno_fusage (insn
, CLOBBER
, test_regno
))
1443 pattern
= PATTERN (insn
);
1445 if (GET_CODE (pattern
) == COND_EXEC
)
1446 pattern
= COND_EXEC_CODE (pattern
);
1448 if (GET_CODE (pattern
) == SET
)
1450 rtx dest
= SET_DEST (PATTERN (insn
));
1452 /* A value is totally replaced if it is the destination or the
1453 destination is a SUBREG of REGNO that does not change the number of
1455 if (GET_CODE (dest
) == SUBREG
1456 && (((GET_MODE_SIZE (GET_MODE (dest
))
1457 + UNITS_PER_WORD
- 1) / UNITS_PER_WORD
)
1458 == ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (dest
)))
1459 + UNITS_PER_WORD
- 1) / UNITS_PER_WORD
)))
1460 dest
= SUBREG_REG (dest
);
1462 if (GET_CODE (dest
) != REG
)
1465 regno
= REGNO (dest
);
1466 endregno
= (regno
>= FIRST_PSEUDO_REGISTER
? regno
+ 1
1467 : regno
+ HARD_REGNO_NREGS (regno
, GET_MODE (dest
)));
1469 return (test_regno
>= regno
&& test_regno
< endregno
);
1471 else if (GET_CODE (pattern
) == PARALLEL
)
1475 for (i
= XVECLEN (pattern
, 0) - 1; i
>= 0; i
--)
1477 rtx body
= XVECEXP (pattern
, 0, i
);
1479 if (GET_CODE (body
) == COND_EXEC
)
1480 body
= COND_EXEC_CODE (body
);
1482 if (GET_CODE (body
) == SET
|| GET_CODE (body
) == CLOBBER
)
1484 rtx dest
= SET_DEST (body
);
1486 if (GET_CODE (dest
) == SUBREG
1487 && (((GET_MODE_SIZE (GET_MODE (dest
))
1488 + UNITS_PER_WORD
- 1) / UNITS_PER_WORD
)
1489 == ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (dest
)))
1490 + UNITS_PER_WORD
- 1) / UNITS_PER_WORD
)))
1491 dest
= SUBREG_REG (dest
);
1493 if (GET_CODE (dest
) != REG
)
1496 regno
= REGNO (dest
);
1497 endregno
= (regno
>= FIRST_PSEUDO_REGISTER
? regno
+ 1
1498 : regno
+ HARD_REGNO_NREGS (regno
, GET_MODE (dest
)));
1500 if (test_regno
>= regno
&& test_regno
< endregno
)
1509 /* Return the reg-note of kind KIND in insn INSN, if there is one.
1510 If DATUM is nonzero, look for one whose datum is DATUM. */
1513 find_reg_note (insn
, kind
, datum
)
1520 /* Ignore anything that is not an INSN, JUMP_INSN or CALL_INSN. */
1521 if (! INSN_P (insn
))
1524 for (link
= REG_NOTES (insn
); link
; link
= XEXP (link
, 1))
1525 if (REG_NOTE_KIND (link
) == kind
1526 && (datum
== 0 || datum
== XEXP (link
, 0)))
1531 /* Return the reg-note of kind KIND in insn INSN which applies to register
1532 number REGNO, if any. Return 0 if there is no such reg-note. Note that
1533 the REGNO of this NOTE need not be REGNO if REGNO is a hard register;
1534 it might be the case that the note overlaps REGNO. */
1537 find_regno_note (insn
, kind
, regno
)
1544 /* Ignore anything that is not an INSN, JUMP_INSN or CALL_INSN. */
1545 if (! INSN_P (insn
))
1548 for (link
= REG_NOTES (insn
); link
; link
= XEXP (link
, 1))
1549 if (REG_NOTE_KIND (link
) == kind
1550 /* Verify that it is a register, so that scratch and MEM won't cause a
1552 && GET_CODE (XEXP (link
, 0)) == REG
1553 && REGNO (XEXP (link
, 0)) <= regno
1554 && ((REGNO (XEXP (link
, 0))
1555 + (REGNO (XEXP (link
, 0)) >= FIRST_PSEUDO_REGISTER
? 1
1556 : HARD_REGNO_NREGS (REGNO (XEXP (link
, 0)),
1557 GET_MODE (XEXP (link
, 0)))))
1563 /* Return true if DATUM, or any overlap of DATUM, of kind CODE is found
1564 in the CALL_INSN_FUNCTION_USAGE information of INSN. */
1567 find_reg_fusage (insn
, code
, datum
)
1572 /* If it's not a CALL_INSN, it can't possibly have a
1573 CALL_INSN_FUNCTION_USAGE field, so don't bother checking. */
1574 if (GET_CODE (insn
) != CALL_INSN
)
1580 if (GET_CODE (datum
) != REG
)
1584 for (link
= CALL_INSN_FUNCTION_USAGE (insn
);
1586 link
= XEXP (link
, 1))
1587 if (GET_CODE (XEXP (link
, 0)) == code
1588 && rtx_equal_p (datum
, SET_DEST (XEXP (link
, 0))))
1593 unsigned int regno
= REGNO (datum
);
1595 /* CALL_INSN_FUNCTION_USAGE information cannot contain references
1596 to pseudo registers, so don't bother checking. */
1598 if (regno
< FIRST_PSEUDO_REGISTER
)
1600 unsigned int end_regno
1601 = regno
+ HARD_REGNO_NREGS (regno
, GET_MODE (datum
));
1604 for (i
= regno
; i
< end_regno
; i
++)
1605 if (find_regno_fusage (insn
, code
, i
))
1613 /* Return true if REGNO, or any overlap of REGNO, of kind CODE is found
1614 in the CALL_INSN_FUNCTION_USAGE information of INSN. */
1617 find_regno_fusage (insn
, code
, regno
)
1624 /* CALL_INSN_FUNCTION_USAGE information cannot contain references
1625 to pseudo registers, so don't bother checking. */
1627 if (regno
>= FIRST_PSEUDO_REGISTER
1628 || GET_CODE (insn
) != CALL_INSN
)
1631 for (link
= CALL_INSN_FUNCTION_USAGE (insn
); link
; link
= XEXP (link
, 1))
1633 unsigned int regnote
;
1636 if (GET_CODE (op
= XEXP (link
, 0)) == code
1637 && GET_CODE (reg
= XEXP (op
, 0)) == REG
1638 && (regnote
= REGNO (reg
)) <= regno
1639 && regnote
+ HARD_REGNO_NREGS (regnote
, GET_MODE (reg
)) > regno
)
1646 /* Remove register note NOTE from the REG_NOTES of INSN. */
1649 remove_note (insn
, note
)
1655 if (note
== NULL_RTX
)
1658 if (REG_NOTES (insn
) == note
)
1660 REG_NOTES (insn
) = XEXP (note
, 1);
1664 for (link
= REG_NOTES (insn
); link
; link
= XEXP (link
, 1))
1665 if (XEXP (link
, 1) == note
)
1667 XEXP (link
, 1) = XEXP (note
, 1);
1674 /* Search LISTP (an EXPR_LIST) for NODE and remove NODE from the list
1677 A simple equality test is used to determine if NODE is on the
1681 remove_node_from_expr_list (node
, listp
)
1686 rtx prev
= NULL_RTX
;
1690 if (node
== XEXP (temp
, 0))
1692 /* Splice the node out of the list. */
1694 XEXP (prev
, 1) = XEXP (temp
, 1);
1696 *listp
= XEXP (temp
, 1);
1700 temp
= XEXP (temp
, 1);
1704 /* Nonzero if X contains any volatile instructions. These are instructions
1705 which may cause unpredictable machine state instructions, and thus no
1706 instructions should be moved or combined across them. This includes
1707 only volatile asms and UNSPEC_VOLATILE instructions. */
1713 register RTX_CODE code
;
1715 code
= GET_CODE (x
);
1735 case UNSPEC_VOLATILE
:
1736 /* case TRAP_IF: This isn't clear yet. */
1740 if (MEM_VOLATILE_P (x
))
1747 /* Recursively scan the operands of this expression. */
1750 register const char *fmt
= GET_RTX_FORMAT (code
);
1753 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
1757 if (volatile_insn_p (XEXP (x
, i
)))
1760 else if (fmt
[i
] == 'E')
1763 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
1764 if (volatile_insn_p (XVECEXP (x
, i
, j
)))
1772 /* Nonzero if X contains any volatile memory references
1773 UNSPEC_VOLATILE operations or volatile ASM_OPERANDS expressions. */
1779 register RTX_CODE code
;
1781 code
= GET_CODE (x
);
1800 case UNSPEC_VOLATILE
:
1801 /* case TRAP_IF: This isn't clear yet. */
1806 if (MEM_VOLATILE_P (x
))
1813 /* Recursively scan the operands of this expression. */
1816 register const char *fmt
= GET_RTX_FORMAT (code
);
1819 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
1823 if (volatile_refs_p (XEXP (x
, i
)))
1826 else if (fmt
[i
] == 'E')
1829 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
1830 if (volatile_refs_p (XVECEXP (x
, i
, j
)))
1838 /* Similar to above, except that it also rejects register pre- and post-
1845 register RTX_CODE code
;
1847 code
= GET_CODE (x
);
1865 /* Reject CLOBBER with a non-VOID mode. These are made by combine.c
1866 when some combination can't be done. If we see one, don't think
1867 that we can simplify the expression. */
1868 return (GET_MODE (x
) != VOIDmode
);
1875 case UNSPEC_VOLATILE
:
1876 /* case TRAP_IF: This isn't clear yet. */
1881 if (MEM_VOLATILE_P (x
))
1888 /* Recursively scan the operands of this expression. */
1891 register const char *fmt
= GET_RTX_FORMAT (code
);
1894 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
1898 if (side_effects_p (XEXP (x
, i
)))
1901 else if (fmt
[i
] == 'E')
1904 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
1905 if (side_effects_p (XVECEXP (x
, i
, j
)))
1913 /* Return nonzero if evaluating rtx X might cause a trap. */
1925 code
= GET_CODE (x
);
1928 /* Handle these cases quickly. */
1941 case UNSPEC_VOLATILE
:
1946 return MEM_VOLATILE_P (x
);
1948 /* Memory ref can trap unless it's a static var or a stack slot. */
1950 return rtx_addr_can_trap_p (XEXP (x
, 0));
1952 /* Division by a non-constant might trap. */
1957 if (! CONSTANT_P (XEXP (x
, 1))
1958 || GET_MODE_CLASS (GET_MODE (x
)) == MODE_FLOAT
)
1960 /* This was const0_rtx, but by not using that,
1961 we can link this file into other programs. */
1962 if (GET_CODE (XEXP (x
, 1)) == CONST_INT
&& INTVAL (XEXP (x
, 1)) == 0)
1967 /* An EXPR_LIST is used to represent a function call. This
1968 certainly may trap. */
1972 /* Any floating arithmetic may trap. */
1973 if (GET_MODE_CLASS (GET_MODE (x
)) == MODE_FLOAT
)
1977 fmt
= GET_RTX_FORMAT (code
);
1978 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
1982 if (may_trap_p (XEXP (x
, i
)))
1985 else if (fmt
[i
] == 'E')
1988 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
1989 if (may_trap_p (XVECEXP (x
, i
, j
)))
1996 /* Return nonzero if X contains a comparison that is not either EQ or NE,
1997 i.e., an inequality. */
2000 inequality_comparisons_p (x
)
2003 register const char *fmt
;
2004 register int len
, i
;
2005 register enum rtx_code code
= GET_CODE (x
);
2034 len
= GET_RTX_LENGTH (code
);
2035 fmt
= GET_RTX_FORMAT (code
);
2037 for (i
= 0; i
< len
; i
++)
2041 if (inequality_comparisons_p (XEXP (x
, i
)))
2044 else if (fmt
[i
] == 'E')
2047 for (j
= XVECLEN (x
, i
) - 1; j
>= 0; j
--)
2048 if (inequality_comparisons_p (XVECEXP (x
, i
, j
)))
2056 /* Replace any occurrence of FROM in X with TO. The function does
2057 not enter into CONST_DOUBLE for the replace.
2059 Note that copying is not done so X must not be shared unless all copies
2060 are to be modified. */
2063 replace_rtx (x
, from
, to
)
2067 register const char *fmt
;
2069 /* The following prevents loops occurrence when we change MEM in
2070 CONST_DOUBLE onto the same CONST_DOUBLE. */
2071 if (x
!= 0 && GET_CODE (x
) == CONST_DOUBLE
)
2077 /* Allow this function to make replacements in EXPR_LISTs. */
2081 fmt
= GET_RTX_FORMAT (GET_CODE (x
));
2082 for (i
= GET_RTX_LENGTH (GET_CODE (x
)) - 1; i
>= 0; i
--)
2085 XEXP (x
, i
) = replace_rtx (XEXP (x
, i
), from
, to
);
2086 else if (fmt
[i
] == 'E')
2087 for (j
= XVECLEN (x
, i
) - 1; j
>= 0; j
--)
2088 XVECEXP (x
, i
, j
) = replace_rtx (XVECEXP (x
, i
, j
), from
, to
);
2094 /* Throughout the rtx X, replace many registers according to REG_MAP.
2095 Return the replacement for X (which may be X with altered contents).
2096 REG_MAP[R] is the replacement for register R, or 0 for don't replace.
2097 NREGS is the length of REG_MAP; regs >= NREGS are not mapped.
2099 We only support REG_MAP entries of REG or SUBREG. Also, hard registers
2100 should not be mapped to pseudos or vice versa since validate_change
2103 If REPLACE_DEST is 1, replacements are also done in destinations;
2104 otherwise, only sources are replaced. */
2107 replace_regs (x
, reg_map
, nregs
, replace_dest
)
2113 register enum rtx_code code
;
2115 register const char *fmt
;
2120 code
= GET_CODE (x
);
2134 /* Verify that the register has an entry before trying to access it. */
2135 if (REGNO (x
) < nregs
&& reg_map
[REGNO (x
)] != 0)
2137 /* SUBREGs can't be shared. Always return a copy to ensure that if
2138 this replacement occurs more than once then each instance will
2139 get distinct rtx. */
2140 if (GET_CODE (reg_map
[REGNO (x
)]) == SUBREG
)
2141 return copy_rtx (reg_map
[REGNO (x
)]);
2142 return reg_map
[REGNO (x
)];
2147 /* Prevent making nested SUBREGs. */
2148 if (GET_CODE (SUBREG_REG (x
)) == REG
&& REGNO (SUBREG_REG (x
)) < nregs
2149 && reg_map
[REGNO (SUBREG_REG (x
))] != 0
2150 && GET_CODE (reg_map
[REGNO (SUBREG_REG (x
))]) == SUBREG
)
2152 rtx map_val
= reg_map
[REGNO (SUBREG_REG (x
))];
2153 rtx map_inner
= SUBREG_REG (map_val
);
2155 if (GET_MODE (x
) == GET_MODE (map_inner
))
2159 /* We cannot call gen_rtx here since we may be linked with
2161 /* Let's try clobbering the incoming SUBREG and see
2162 if this is really safe. */
2163 SUBREG_REG (x
) = map_inner
;
2164 SUBREG_WORD (x
) += SUBREG_WORD (map_val
);
2167 rtx
new = rtx_alloc (SUBREG
);
2168 PUT_MODE (new, GET_MODE (x
));
2169 SUBREG_REG (new) = map_inner
;
2170 SUBREG_WORD (new) = SUBREG_WORD (x
) + SUBREG_WORD (map_val
);
2178 SET_DEST (x
) = replace_regs (SET_DEST (x
), reg_map
, nregs
, 0);
2180 else if (GET_CODE (SET_DEST (x
)) == MEM
2181 || GET_CODE (SET_DEST (x
)) == STRICT_LOW_PART
)
2182 /* Even if we are not to replace destinations, replace register if it
2183 is CONTAINED in destination (destination is memory or
2184 STRICT_LOW_PART). */
2185 XEXP (SET_DEST (x
), 0) = replace_regs (XEXP (SET_DEST (x
), 0),
2187 else if (GET_CODE (SET_DEST (x
)) == ZERO_EXTRACT
)
2188 /* Similarly, for ZERO_EXTRACT we replace all operands. */
2191 SET_SRC (x
) = replace_regs (SET_SRC (x
), reg_map
, nregs
, 0);
2198 fmt
= GET_RTX_FORMAT (code
);
2199 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
2202 XEXP (x
, i
) = replace_regs (XEXP (x
, i
), reg_map
, nregs
, replace_dest
);
2203 else if (fmt
[i
] == 'E')
2206 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
2207 XVECEXP (x
, i
, j
) = replace_regs (XVECEXP (x
, i
, j
), reg_map
,
2208 nregs
, replace_dest
);
2214 /* Return 1 if X, the SRC_SRC of SET of (pc) contain a REG or MEM that is
2215 not in the constant pool and not in the condition of an IF_THEN_ELSE. */
2218 jmp_uses_reg_or_mem (x
)
2221 enum rtx_code code
= GET_CODE (x
);
2236 return ! (GET_CODE (XEXP (x
, 0)) == SYMBOL_REF
2237 && CONSTANT_POOL_ADDRESS_P (XEXP (x
, 0)));
2240 return (jmp_uses_reg_or_mem (XEXP (x
, 1))
2241 || jmp_uses_reg_or_mem (XEXP (x
, 2)));
2243 case PLUS
: case MINUS
: case MULT
:
2244 return (jmp_uses_reg_or_mem (XEXP (x
, 0))
2245 || jmp_uses_reg_or_mem (XEXP (x
, 1)));
2251 fmt
= GET_RTX_FORMAT (code
);
2252 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
2255 && jmp_uses_reg_or_mem (XEXP (x
, i
)))
2258 else if (fmt
[i
] == 'E')
2259 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
2260 if (jmp_uses_reg_or_mem (XVECEXP (x
, i
, j
)))
2267 /* Return nonzero if INSN is an indirect jump (aka computed jump).
2269 Tablejumps and casesi insns are not considered indirect jumps;
2270 we can recognize them by a (use (label_ref)). */
2273 computed_jump_p (insn
)
2277 if (GET_CODE (insn
) == JUMP_INSN
)
2279 rtx pat
= PATTERN (insn
);
2281 if (GET_CODE (pat
) == PARALLEL
)
2283 int len
= XVECLEN (pat
, 0);
2284 int has_use_labelref
= 0;
2286 for (i
= len
- 1; i
>= 0; i
--)
2287 if (GET_CODE (XVECEXP (pat
, 0, i
)) == USE
2288 && (GET_CODE (XEXP (XVECEXP (pat
, 0, i
), 0))
2290 has_use_labelref
= 1;
2292 if (! has_use_labelref
)
2293 for (i
= len
- 1; i
>= 0; i
--)
2294 if (GET_CODE (XVECEXP (pat
, 0, i
)) == SET
2295 && SET_DEST (XVECEXP (pat
, 0, i
)) == pc_rtx
2296 && jmp_uses_reg_or_mem (SET_SRC (XVECEXP (pat
, 0, i
))))
2299 else if (GET_CODE (pat
) == SET
2300 && SET_DEST (pat
) == pc_rtx
2301 && jmp_uses_reg_or_mem (SET_SRC (pat
)))
2307 /* Traverse X via depth-first search, calling F for each
2308 sub-expression (including X itself). F is also passed the DATA.
2309 If F returns -1, do not traverse sub-expressions, but continue
2310 traversing the rest of the tree. If F ever returns any other
2311 non-zero value, stop the traversal, and return the value returned
2312 by F. Otherwise, return 0. This function does not traverse inside
2313 tree structure that contains RTX_EXPRs, or into sub-expressions
2314 whose format code is `0' since it is not known whether or not those
2315 codes are actually RTL.
2317 This routine is very general, and could (should?) be used to
2318 implement many of the other routines in this file. */
2321 for_each_rtx (x
, f
, data
)
2332 result
= (*f
)(x
, data
);
2334 /* Do not traverse sub-expressions. */
2336 else if (result
!= 0)
2337 /* Stop the traversal. */
2341 /* There are no sub-expressions. */
2344 length
= GET_RTX_LENGTH (GET_CODE (*x
));
2345 format
= GET_RTX_FORMAT (GET_CODE (*x
));
2347 for (i
= 0; i
< length
; ++i
)
2352 result
= for_each_rtx (&XEXP (*x
, i
), f
, data
);
2359 if (XVEC (*x
, i
) != 0)
2362 for (j
= 0; j
< XVECLEN (*x
, i
); ++j
)
2364 result
= for_each_rtx (&XVECEXP (*x
, i
, j
), f
, data
);
2372 /* Nothing to do. */
2381 /* Searches X for any reference to REGNO, returning the rtx of the
2382 reference found if any. Otherwise, returns NULL_RTX. */
2385 regno_use_in (regno
, x
)
2389 register const char *fmt
;
2393 if (GET_CODE (x
) == REG
&& REGNO (x
) == regno
)
2396 fmt
= GET_RTX_FORMAT (GET_CODE (x
));
2397 for (i
= GET_RTX_LENGTH (GET_CODE (x
)) - 1; i
>= 0; i
--)
2401 if ((tem
= regno_use_in (regno
, XEXP (x
, i
))))
2404 else if (fmt
[i
] == 'E')
2405 for (j
= XVECLEN (x
, i
) - 1; j
>= 0; j
--)
2406 if ((tem
= regno_use_in (regno
, XVECEXP (x
, i
, j
))))
2414 /* Return 1 if X is an autoincrement side effect and the register is
2415 not the stack pointer. */
2420 switch (GET_CODE (x
))
2428 /* There are no REG_INC notes for SP. */
2429 if (XEXP (x
, 0) != stack_pointer_rtx
)
2437 /* Return 1 if the sequence of instructions beginning with FROM and up
2438 to and including TO is safe to move. If NEW_TO is non-NULL, and
2439 the sequence is not already safe to move, but can be easily
2440 extended to a sequence which is safe, then NEW_TO will point to the
2441 end of the extended sequence.
2443 For now, this function only checks that the region contains whole
2444 exception regiongs, but it could be extended to check additional
2445 conditions as well. */
2448 insns_safe_to_move_p (from
, to
, new_to
)
2453 int eh_region_count
= 0;
2457 /* By default, assume the end of the region will be what was
2464 if (GET_CODE (r
) == NOTE
)
2466 switch (NOTE_LINE_NUMBER (r
))
2468 case NOTE_INSN_EH_REGION_BEG
:
2472 case NOTE_INSN_EH_REGION_END
:
2473 if (eh_region_count
== 0)
2474 /* This sequence of instructions contains the end of
2475 an exception region, but not he beginning. Moving
2476 it will cause chaos. */
2487 /* If we've passed TO, and we see a non-note instruction, we
2488 can't extend the sequence to a movable sequence. */
2494 /* It's OK to move the sequence if there were matched sets of
2495 exception region notes. */
2496 return eh_region_count
== 0;
2501 /* It's OK to move the sequence if there were matched sets of
2502 exception region notes. */
2503 if (past_to_p
&& eh_region_count
== 0)
2509 /* Go to the next instruction. */
2516 /* Return non-zero if IN contains a piece of rtl that has the address LOC */
2518 loc_mentioned_in_p (loc
, in
)
2521 enum rtx_code code
= GET_CODE (in
);
2522 const char *fmt
= GET_RTX_FORMAT (code
);
2525 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
2527 if (loc
== &in
->fld
[i
].rtx
)
2531 if (loc_mentioned_in_p (loc
, XEXP (in
, i
)))
2534 else if (fmt
[i
] == 'E')
2535 for (j
= XVECLEN (in
, i
) - 1; j
>= 0; j
--)
2536 if (loc_mentioned_in_p (loc
, XVECEXP (in
, i
, j
)))
This page took 0.213109 seconds and 6 git commands to generate.