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
;
56 return ! RTX_UNCHANGING_P (x
) || rtx_unstable_p (XEXP (x
, 0));
65 /* As in rtx_varies_p, we have to use the actual rtx, not reg number. */
66 return ! (x
== frame_pointer_rtx
|| x
== hard_frame_pointer_rtx
67 || x
== arg_pointer_rtx
|| x
== pic_offset_table_rtx
68 || RTX_UNCHANGING_P (x
));
70 fmt
= GET_RTX_FORMAT (code
);
71 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
74 if (rtx_unstable_p (XEXP (x
, i
)))
77 else if (fmt
[i
] == 'E')
80 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
81 if (rtx_unstable_p (XVECEXP (x
, i
, j
)))
88 /* Return 1 if X has a value that can vary even between two
89 executions of the program. 0 means X can be compared reliably
90 against certain constants or near-constants.
91 The frame pointer and the arg pointer are considered constant. */
97 register RTX_CODE code
= GET_CODE (x
);
99 register const char *fmt
;
104 return ! RTX_UNCHANGING_P (x
) || rtx_varies_p (XEXP (x
, 0));
117 /* Note that we have to test for the actual rtx used for the frame
118 and arg pointers and not just the register number in case we have
119 eliminated the frame and/or arg pointer and are using it
121 return ! (x
== frame_pointer_rtx
|| x
== hard_frame_pointer_rtx
122 || x
== arg_pointer_rtx
|| x
== pic_offset_table_rtx
);
125 /* The operand 0 of a LO_SUM is considered constant
126 (in fact is it related specifically to operand 1). */
127 return rtx_varies_p (XEXP (x
, 1));
133 fmt
= GET_RTX_FORMAT (code
);
134 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
137 if (rtx_varies_p (XEXP (x
, i
)))
140 else if (fmt
[i
] == 'E')
143 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
144 if (rtx_varies_p (XVECEXP (x
, i
, j
)))
151 /* Return 0 if the use of X as an address in a MEM can cause a trap. */
154 rtx_addr_can_trap_p (x
)
157 register enum rtx_code code
= GET_CODE (x
);
163 /* SYMBOL_REF is problematic due to the possible presence of
164 a #pragma weak, but to say that loads from symbols can trap is
165 *very* costly. It's not at all clear what's best here. For
166 now, we ignore the impact of #pragma weak. */
170 /* As in rtx_varies_p, we have to use the actual rtx, not reg number. */
171 return ! (x
== frame_pointer_rtx
|| x
== hard_frame_pointer_rtx
172 || x
== stack_pointer_rtx
|| x
== arg_pointer_rtx
);
175 return rtx_addr_can_trap_p (XEXP (x
, 0));
178 /* An address is assumed not to trap if it is an address that can't
179 trap plus a constant integer or it is the pic register plus a
181 return ! ((! rtx_addr_can_trap_p (XEXP (x
, 0))
182 && GET_CODE (XEXP (x
, 1)) == CONST_INT
)
183 || (XEXP (x
, 0) == pic_offset_table_rtx
184 && CONSTANT_P (XEXP (x
, 1))));
187 return rtx_addr_can_trap_p (XEXP (x
, 1));
193 /* If it isn't one of the case above, it can cause a trap. */
197 /* Return 1 if X refers to a memory location whose address
198 cannot be compared reliably with constant addresses,
199 or if X refers to a BLKmode memory object. */
202 rtx_addr_varies_p (x
)
205 register enum rtx_code code
;
207 register const char *fmt
;
214 return GET_MODE (x
) == BLKmode
|| rtx_varies_p (XEXP (x
, 0));
216 fmt
= GET_RTX_FORMAT (code
);
217 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
220 if (rtx_addr_varies_p (XEXP (x
, i
)))
223 else if (fmt
[i
] == 'E')
226 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
227 if (rtx_addr_varies_p (XVECEXP (x
, i
, j
)))
233 /* Return the value of the integer term in X, if one is apparent;
235 Only obvious integer terms are detected.
236 This is used in cse.c with the `related_value' field.*/
242 if (GET_CODE (x
) == CONST
)
245 if (GET_CODE (x
) == MINUS
246 && GET_CODE (XEXP (x
, 1)) == CONST_INT
)
247 return - INTVAL (XEXP (x
, 1));
248 if (GET_CODE (x
) == PLUS
249 && GET_CODE (XEXP (x
, 1)) == CONST_INT
)
250 return INTVAL (XEXP (x
, 1));
254 /* If X is a constant, return the value sans apparent integer term;
256 Only obvious integer terms are detected. */
259 get_related_value (x
)
262 if (GET_CODE (x
) != CONST
)
265 if (GET_CODE (x
) == PLUS
266 && GET_CODE (XEXP (x
, 1)) == CONST_INT
)
268 else if (GET_CODE (x
) == MINUS
269 && GET_CODE (XEXP (x
, 1)) == CONST_INT
)
274 /* Return the number of places FIND appears within X. If COUNT_DEST is
275 zero, we do not count occurrences inside the destination of a SET. */
278 count_occurrences (x
, find
, count_dest
)
284 const char *format_ptr
;
304 if (GET_CODE (find
) == MEM
&& rtx_equal_p (x
, find
))
309 if (SET_DEST (x
) == find
&& ! count_dest
)
310 return count_occurrences (SET_SRC (x
), find
, count_dest
);
317 format_ptr
= GET_RTX_FORMAT (code
);
320 for (i
= 0; i
< GET_RTX_LENGTH (code
); i
++)
322 switch (*format_ptr
++)
325 count
+= count_occurrences (XEXP (x
, i
), find
, count_dest
);
329 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
330 count
+= count_occurrences (XVECEXP (x
, i
, j
), find
, count_dest
);
337 /* Nonzero if register REG appears somewhere within IN.
338 Also works if REG is not a register; in this case it checks
339 for a subexpression of IN that is Lisp "equal" to REG. */
342 reg_mentioned_p (reg
, in
)
343 register rtx reg
, in
;
345 register const char *fmt
;
347 register enum rtx_code code
;
355 if (GET_CODE (in
) == LABEL_REF
)
356 return reg
== XEXP (in
, 0);
358 code
= GET_CODE (in
);
362 /* Compare registers by number. */
364 return GET_CODE (reg
) == REG
&& REGNO (in
) == REGNO (reg
);
366 /* These codes have no constituent expressions
374 return GET_CODE (reg
) == CONST_INT
&& INTVAL (in
) == INTVAL (reg
);
377 /* These are kept unique for a given value. */
384 if (GET_CODE (reg
) == code
&& rtx_equal_p (reg
, in
))
387 fmt
= GET_RTX_FORMAT (code
);
389 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
394 for (j
= XVECLEN (in
, i
) - 1; j
>= 0; j
--)
395 if (reg_mentioned_p (reg
, XVECEXP (in
, i
, j
)))
398 else if (fmt
[i
] == 'e'
399 && reg_mentioned_p (reg
, XEXP (in
, i
)))
405 /* Return 1 if in between BEG and END, exclusive of BEG and END, there is
406 no CODE_LABEL insn. */
409 no_labels_between_p (beg
, end
)
413 for (p
= NEXT_INSN (beg
); p
!= end
; p
= NEXT_INSN (p
))
414 if (GET_CODE (p
) == CODE_LABEL
)
419 /* Return 1 if in between BEG and END, exclusive of BEG and END, there is
420 no JUMP_INSN insn. */
423 no_jumps_between_p (beg
, end
)
427 for (p
= NEXT_INSN (beg
); p
!= end
; p
= NEXT_INSN (p
))
428 if (GET_CODE (p
) == JUMP_INSN
)
433 /* Nonzero if register REG is used in an insn between
434 FROM_INSN and TO_INSN (exclusive of those two). */
437 reg_used_between_p (reg
, from_insn
, to_insn
)
438 rtx reg
, from_insn
, to_insn
;
442 if (from_insn
== to_insn
)
445 for (insn
= NEXT_INSN (from_insn
); insn
!= to_insn
; insn
= NEXT_INSN (insn
))
447 && (reg_overlap_mentioned_p (reg
, PATTERN (insn
))
448 || (GET_CODE (insn
) == CALL_INSN
449 && (find_reg_fusage (insn
, USE
, reg
)
450 || find_reg_fusage (insn
, CLOBBER
, reg
)))))
455 /* Nonzero if the old value of X, a register, is referenced in BODY. If X
456 is entirely replaced by a new value and the only use is as a SET_DEST,
457 we do not consider it a reference. */
460 reg_referenced_p (x
, body
)
466 switch (GET_CODE (body
))
469 if (reg_overlap_mentioned_p (x
, SET_SRC (body
)))
472 /* If the destination is anything other than CC0, PC, a REG or a SUBREG
473 of a REG that occupies all of the REG, the insn references X if
474 it is mentioned in the destination. */
475 if (GET_CODE (SET_DEST (body
)) != CC0
476 && GET_CODE (SET_DEST (body
)) != PC
477 && GET_CODE (SET_DEST (body
)) != REG
478 && ! (GET_CODE (SET_DEST (body
)) == SUBREG
479 && GET_CODE (SUBREG_REG (SET_DEST (body
))) == REG
480 && (((GET_MODE_SIZE (GET_MODE (SUBREG_REG (SET_DEST (body
))))
481 + (UNITS_PER_WORD
- 1)) / UNITS_PER_WORD
)
482 == ((GET_MODE_SIZE (GET_MODE (SET_DEST (body
)))
483 + (UNITS_PER_WORD
- 1)) / UNITS_PER_WORD
)))
484 && reg_overlap_mentioned_p (x
, SET_DEST (body
)))
489 for (i
= ASM_OPERANDS_INPUT_LENGTH (body
) - 1; i
>= 0; i
--)
490 if (reg_overlap_mentioned_p (x
, ASM_OPERANDS_INPUT (body
, i
)))
497 return reg_overlap_mentioned_p (x
, body
);
500 return reg_overlap_mentioned_p (x
, TRAP_CONDITION (body
));
503 case UNSPEC_VOLATILE
:
504 for (i
= XVECLEN (body
, 0) - 1; i
>= 0; i
--)
505 if (reg_overlap_mentioned_p (x
, XVECEXP (body
, 0, i
)))
510 for (i
= XVECLEN (body
, 0) - 1; i
>= 0; i
--)
511 if (reg_referenced_p (x
, XVECEXP (body
, 0, i
)))
516 if (GET_CODE (XEXP (body
, 0)) == MEM
)
517 if (reg_overlap_mentioned_p (x
, XEXP (XEXP (body
, 0), 0)))
522 if (reg_overlap_mentioned_p (x
, COND_EXEC_TEST (body
)))
524 return reg_referenced_p (x
, COND_EXEC_CODE (body
));
531 /* Nonzero if register REG is referenced in an insn between
532 FROM_INSN and TO_INSN (exclusive of those two). Sets of REG do
536 reg_referenced_between_p (reg
, from_insn
, to_insn
)
537 rtx reg
, from_insn
, to_insn
;
541 if (from_insn
== to_insn
)
544 for (insn
= NEXT_INSN (from_insn
); insn
!= to_insn
; insn
= NEXT_INSN (insn
))
546 && (reg_referenced_p (reg
, PATTERN (insn
))
547 || (GET_CODE (insn
) == CALL_INSN
548 && find_reg_fusage (insn
, USE
, reg
))))
553 /* Nonzero if register REG is set or clobbered in an insn between
554 FROM_INSN and TO_INSN (exclusive of those two). */
557 reg_set_between_p (reg
, from_insn
, to_insn
)
558 rtx reg
, from_insn
, to_insn
;
562 if (from_insn
== to_insn
)
565 for (insn
= NEXT_INSN (from_insn
); insn
!= to_insn
; insn
= NEXT_INSN (insn
))
566 if (INSN_P (insn
) && reg_set_p (reg
, insn
))
571 /* Internals of reg_set_between_p. */
573 static rtx reg_set_reg
;
574 static int reg_set_flag
;
577 reg_set_p_1 (x
, pat
, data
)
579 rtx pat ATTRIBUTE_UNUSED
;
580 void *data ATTRIBUTE_UNUSED
;
582 /* We don't want to return 1 if X is a MEM that contains a register
583 within REG_SET_REG. */
585 if ((GET_CODE (x
) != MEM
)
586 && reg_overlap_mentioned_p (reg_set_reg
, x
))
591 reg_set_p (reg
, insn
)
596 /* We can be passed an insn or part of one. If we are passed an insn,
597 check if a side-effect of the insn clobbers REG. */
600 if (FIND_REG_INC_NOTE (insn
, reg
)
601 || (GET_CODE (insn
) == CALL_INSN
602 /* We'd like to test call_used_regs here, but rtlanal.c can't
603 reference that variable due to its use in genattrtab. So
604 we'll just be more conservative.
606 ??? Unless we could ensure that the CALL_INSN_FUNCTION_USAGE
607 information holds all clobbered registers. */
608 && ((GET_CODE (reg
) == REG
609 && REGNO (reg
) < FIRST_PSEUDO_REGISTER
)
610 || GET_CODE (reg
) == MEM
611 || find_reg_fusage (insn
, CLOBBER
, reg
))))
614 body
= PATTERN (insn
);
619 note_stores (body
, reg_set_p_1
, NULL
);
623 /* Similar to reg_set_between_p, but check all registers in X. Return 0
624 only if none of them are modified between START and END. Do not
625 consider non-registers one way or the other. */
628 regs_set_between_p (x
, start
, end
)
632 enum rtx_code code
= GET_CODE (x
);
648 return reg_set_between_p (x
, start
, end
);
654 fmt
= GET_RTX_FORMAT (code
);
655 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
657 if (fmt
[i
] == 'e' && regs_set_between_p (XEXP (x
, i
), start
, end
))
660 else if (fmt
[i
] == 'E')
661 for (j
= XVECLEN (x
, i
) - 1; j
>= 0; j
--)
662 if (regs_set_between_p (XVECEXP (x
, i
, j
), start
, end
))
669 /* Similar to reg_set_between_p, but check all registers in X. Return 0
670 only if none of them are modified between START and END. Return 1 if
671 X contains a MEM; this routine does not perform any memory aliasing. */
674 modified_between_p (x
, start
, end
)
678 enum rtx_code code
= GET_CODE (x
);
696 /* If the memory is not constant, assume it is modified. If it is
697 constant, we still have to check the address. */
698 if (! RTX_UNCHANGING_P (x
))
703 return reg_set_between_p (x
, start
, end
);
709 fmt
= GET_RTX_FORMAT (code
);
710 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
712 if (fmt
[i
] == 'e' && modified_between_p (XEXP (x
, i
), start
, end
))
715 else if (fmt
[i
] == 'E')
716 for (j
= XVECLEN (x
, i
) - 1; j
>= 0; j
--)
717 if (modified_between_p (XVECEXP (x
, i
, j
), start
, end
))
724 /* Similar to reg_set_p, but check all registers in X. Return 0 only if none
725 of them are modified in INSN. Return 1 if X contains a MEM; this routine
726 does not perform any memory aliasing. */
729 modified_in_p (x
, insn
)
733 enum rtx_code code
= GET_CODE (x
);
751 /* If the memory is not constant, assume it is modified. If it is
752 constant, we still have to check the address. */
753 if (! RTX_UNCHANGING_P (x
))
758 return reg_set_p (x
, insn
);
764 fmt
= GET_RTX_FORMAT (code
);
765 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
767 if (fmt
[i
] == 'e' && modified_in_p (XEXP (x
, i
), insn
))
770 else if (fmt
[i
] == 'E')
771 for (j
= XVECLEN (x
, i
) - 1; j
>= 0; j
--)
772 if (modified_in_p (XVECEXP (x
, i
, j
), insn
))
779 /* Return true if anything in insn X is (anti,output,true) dependent on
780 anything in insn Y. */
783 insn_dependent_p (x
, y
)
788 if (! INSN_P (x
) || ! INSN_P (y
))
792 note_stores (PATTERN (x
), insn_dependent_p_1
, &tmp
);
797 note_stores (PATTERN (y
), insn_dependent_p_1
, &tmp
);
804 /* A helper routine for insn_dependent_p called through note_stores. */
807 insn_dependent_p_1 (x
, pat
, data
)
809 rtx pat ATTRIBUTE_UNUSED
;
812 rtx
* pinsn
= (rtx
*) data
;
814 if (*pinsn
&& reg_mentioned_p (x
, *pinsn
))
818 /* Given an INSN, return a SET expression if this insn has only a single SET.
819 It may also have CLOBBERs, USEs, or SET whose output
820 will not be used, which we ignore. */
832 if (GET_CODE (PATTERN (insn
)) == SET
)
833 return PATTERN (insn
);
835 else if (GET_CODE (PATTERN (insn
)) == PARALLEL
)
837 for (i
= 0, set
= 0; i
< XVECLEN (PATTERN (insn
), 0); i
++)
839 rtx sub
= XVECEXP (PATTERN (insn
), 0, i
);
841 switch (GET_CODE (sub
))
848 if (! find_reg_note (insn
, REG_UNUSED
, SET_DEST (sub
))
849 || side_effects_p (sub
))
868 /* Given an INSN, return nonzero if it has more than one SET, else return
878 /* INSN must be an insn. */
882 /* Only a PARALLEL can have multiple SETs. */
883 if (GET_CODE (PATTERN (insn
)) == PARALLEL
)
885 for (i
= 0, found
= 0; i
< XVECLEN (PATTERN (insn
), 0); i
++)
886 if (GET_CODE (XVECEXP (PATTERN (insn
), 0, i
)) == SET
)
888 /* If we have already found a SET, then return now. */
896 /* Either zero or one SET. */
900 /* Return the last thing that X was assigned from before *PINSN. If VALID_TO
901 is not NULL_RTX then verify that the object is not modified up to VALID_TO.
902 If the object was modified, if we hit a partial assignment to X, or hit a
903 CODE_LABEL first, return X. If we found an assignment, update *PINSN to
904 point to it. ALLOW_HWREG is set to 1 if hardware registers are allowed to
908 find_last_value (x
, pinsn
, valid_to
, allow_hwreg
)
916 for (p
= PREV_INSN (*pinsn
); p
&& GET_CODE (p
) != CODE_LABEL
;
920 rtx set
= single_set (p
);
921 rtx note
= find_reg_note (p
, REG_EQUAL
, NULL_RTX
);
923 if (set
&& rtx_equal_p (x
, SET_DEST (set
)))
925 rtx src
= SET_SRC (set
);
927 if (note
&& GET_CODE (XEXP (note
, 0)) != EXPR_LIST
)
928 src
= XEXP (note
, 0);
930 if ((valid_to
== NULL_RTX
931 || ! modified_between_p (src
, PREV_INSN (p
), valid_to
))
932 /* Reject hard registers because we don't usually want
933 to use them; we'd rather use a pseudo. */
934 && (! (GET_CODE (src
) == REG
935 && REGNO (src
) < FIRST_PSEUDO_REGISTER
) || allow_hwreg
))
942 /* If set in non-simple way, we don't have a value. */
943 if (reg_set_p (x
, p
))
950 /* Return nonzero if register in range [REGNO, ENDREGNO)
951 appears either explicitly or implicitly in X
952 other than being stored into.
954 References contained within the substructure at LOC do not count.
955 LOC may be zero, meaning don't ignore anything. */
958 refers_to_regno_p (regno
, endregno
, x
, loc
)
959 unsigned int regno
, endregno
;
964 unsigned int x_regno
;
969 /* The contents of a REG_NONNEG note is always zero, so we must come here
970 upon repeat in case the last REG_NOTE is a REG_NONNEG note. */
981 /* If we modifying the stack, frame, or argument pointer, it will
982 clobber a virtual register. In fact, we could be more precise,
983 but it isn't worth it. */
984 if ((x_regno
== STACK_POINTER_REGNUM
985 #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
986 || x_regno
== ARG_POINTER_REGNUM
988 || x_regno
== FRAME_POINTER_REGNUM
)
989 && regno
>= FIRST_VIRTUAL_REGISTER
&& regno
<= LAST_VIRTUAL_REGISTER
)
992 return (endregno
> x_regno
993 && regno
< x_regno
+ (x_regno
< FIRST_PSEUDO_REGISTER
994 ? HARD_REGNO_NREGS (x_regno
, GET_MODE (x
))
998 /* If this is a SUBREG of a hard reg, we can see exactly which
999 registers are being modified. Otherwise, handle normally. */
1000 if (GET_CODE (SUBREG_REG (x
)) == REG
1001 && REGNO (SUBREG_REG (x
)) < FIRST_PSEUDO_REGISTER
)
1003 unsigned int inner_regno
= REGNO (SUBREG_REG (x
)) + SUBREG_WORD (x
);
1004 unsigned int inner_endregno
1005 = inner_regno
+ (inner_regno
< FIRST_PSEUDO_REGISTER
1006 ? HARD_REGNO_NREGS (regno
, GET_MODE (x
)) : 1);
1008 return endregno
> inner_regno
&& regno
< inner_endregno
;
1014 if (&SET_DEST (x
) != loc
1015 /* Note setting a SUBREG counts as referring to the REG it is in for
1016 a pseudo but not for hard registers since we can
1017 treat each word individually. */
1018 && ((GET_CODE (SET_DEST (x
)) == SUBREG
1019 && loc
!= &SUBREG_REG (SET_DEST (x
))
1020 && GET_CODE (SUBREG_REG (SET_DEST (x
))) == REG
1021 && REGNO (SUBREG_REG (SET_DEST (x
))) >= FIRST_PSEUDO_REGISTER
1022 && refers_to_regno_p (regno
, endregno
,
1023 SUBREG_REG (SET_DEST (x
)), loc
))
1024 || (GET_CODE (SET_DEST (x
)) != REG
1025 && refers_to_regno_p (regno
, endregno
, SET_DEST (x
), loc
))))
1028 if (code
== CLOBBER
|| loc
== &SET_SRC (x
))
1037 /* X does not match, so try its subexpressions. */
1039 fmt
= GET_RTX_FORMAT (code
);
1040 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
1042 if (fmt
[i
] == 'e' && loc
!= &XEXP (x
, i
))
1050 if (refers_to_regno_p (regno
, endregno
, XEXP (x
, i
), loc
))
1053 else if (fmt
[i
] == 'E')
1056 for (j
= XVECLEN (x
, i
) - 1; j
>=0; j
--)
1057 if (loc
!= &XVECEXP (x
, i
, j
)
1058 && refers_to_regno_p (regno
, endregno
, XVECEXP (x
, i
, j
), loc
))
1065 /* Nonzero if modifying X will affect IN. If X is a register or a SUBREG,
1066 we check if any register number in X conflicts with the relevant register
1067 numbers. If X is a constant, return 0. If X is a MEM, return 1 iff IN
1068 contains a MEM (we don't bother checking for memory addresses that can't
1069 conflict because we expect this to be a rare case. */
1072 reg_overlap_mentioned_p (x
, in
)
1075 unsigned int regno
, endregno
;
1077 /* Overly conservative. */
1078 if (GET_CODE (x
) == STRICT_LOW_PART
)
1081 /* If either argument is a constant, then modifying X can not affect IN. */
1082 if (CONSTANT_P (x
) || CONSTANT_P (in
))
1085 switch (GET_CODE (x
))
1088 regno
= REGNO (SUBREG_REG (x
));
1089 if (regno
< FIRST_PSEUDO_REGISTER
)
1090 regno
+= SUBREG_WORD (x
);
1096 endregno
= regno
+ (regno
< FIRST_PSEUDO_REGISTER
1097 ? HARD_REGNO_NREGS (regno
, GET_MODE (x
)) : 1);
1098 return refers_to_regno_p (regno
, endregno
, in
, NULL_PTR
);
1105 if (GET_CODE (in
) == MEM
)
1108 fmt
= GET_RTX_FORMAT (GET_CODE (in
));
1109 for (i
= GET_RTX_LENGTH (GET_CODE (in
)) - 1; i
>= 0; i
--)
1110 if (fmt
[i
] == 'e' && reg_overlap_mentioned_p (x
, XEXP (in
, i
)))
1119 return reg_mentioned_p (x
, in
);
1125 /* Check for a NULL entry, used to indicate that the parameter goes
1126 both on the stack and in registers. */
1127 if (XEXP (XVECEXP (x
, 0, 0), 0))
1132 /* If any register in here refers to it we return true. */
1133 for (n
= XVECLEN (x
, 0); i
< n
; ++i
)
1134 if (reg_overlap_mentioned_p (XEXP (XVECEXP (x
, 0, i
), 0), in
))
1146 /* Used for communications between the next few functions. */
1148 static int reg_set_last_unknown
;
1149 static rtx reg_set_last_value
;
1150 static unsigned int reg_set_last_first_regno
, reg_set_last_last_regno
;
1152 /* Called via note_stores from reg_set_last. */
1155 reg_set_last_1 (x
, pat
, data
)
1158 void *data ATTRIBUTE_UNUSED
;
1160 unsigned int first
, last
;
1162 /* If X is not a register, or is not one in the range we care
1164 if (GET_CODE (x
) != REG
)
1168 last
= first
+ (first
< FIRST_PSEUDO_REGISTER
1169 ? HARD_REGNO_NREGS (first
, GET_MODE (x
)) : 1);
1171 if (first
>= reg_set_last_last_regno
1172 || last
<= reg_set_last_first_regno
)
1175 /* If this is a CLOBBER or is some complex LHS, or doesn't modify
1176 exactly the registers we care about, show we don't know the value. */
1177 if (GET_CODE (pat
) == CLOBBER
|| SET_DEST (pat
) != x
1178 || first
!= reg_set_last_first_regno
1179 || last
!= reg_set_last_last_regno
)
1180 reg_set_last_unknown
= 1;
1182 reg_set_last_value
= SET_SRC (pat
);
1185 /* Return the last value to which REG was set prior to INSN. If we can't
1186 find it easily, return 0.
1188 We only return a REG, SUBREG, or constant because it is too hard to
1189 check if a MEM remains unchanged. */
1192 reg_set_last (x
, insn
)
1196 rtx orig_insn
= insn
;
1198 reg_set_last_first_regno
= REGNO (x
);
1200 reg_set_last_last_regno
1201 = reg_set_last_first_regno
1202 + (reg_set_last_first_regno
< FIRST_PSEUDO_REGISTER
1203 ? HARD_REGNO_NREGS (reg_set_last_first_regno
, GET_MODE (x
)) : 1);
1205 reg_set_last_unknown
= 0;
1206 reg_set_last_value
= 0;
1208 /* Scan backwards until reg_set_last_1 changed one of the above flags.
1209 Stop when we reach a label or X is a hard reg and we reach a
1210 CALL_INSN (if reg_set_last_last_regno is a hard reg).
1212 If we find a set of X, ensure that its SET_SRC remains unchanged. */
1214 /* We compare with <= here, because reg_set_last_last_regno
1215 is actually the number of the first reg *not* in X. */
1217 insn
&& GET_CODE (insn
) != CODE_LABEL
1218 && ! (GET_CODE (insn
) == CALL_INSN
1219 && reg_set_last_last_regno
<= FIRST_PSEUDO_REGISTER
);
1220 insn
= PREV_INSN (insn
))
1223 note_stores (PATTERN (insn
), reg_set_last_1
, NULL
);
1224 if (reg_set_last_unknown
)
1226 else if (reg_set_last_value
)
1228 if (CONSTANT_P (reg_set_last_value
)
1229 || ((GET_CODE (reg_set_last_value
) == REG
1230 || GET_CODE (reg_set_last_value
) == SUBREG
)
1231 && ! reg_set_between_p (reg_set_last_value
,
1233 return reg_set_last_value
;
1242 /* Call FUN on each register or MEM that is stored into or clobbered by X.
1243 (X would be the pattern of an insn).
1244 FUN receives two arguments:
1245 the REG, MEM, CC0 or PC being stored in or clobbered,
1246 the SET or CLOBBER rtx that does the store.
1248 If the item being stored in or clobbered is a SUBREG of a hard register,
1249 the SUBREG will be passed. */
1252 note_stores (x
, fun
, data
)
1254 void (*fun
) PARAMS ((rtx
, rtx
, void *));
1257 if (GET_CODE (x
) == COND_EXEC
)
1258 x
= COND_EXEC_CODE (x
);
1259 if (GET_CODE (x
) == SET
|| GET_CODE (x
) == CLOBBER
)
1261 register rtx dest
= SET_DEST (x
);
1262 while ((GET_CODE (dest
) == SUBREG
1263 && (GET_CODE (SUBREG_REG (dest
)) != REG
1264 || REGNO (SUBREG_REG (dest
)) >= FIRST_PSEUDO_REGISTER
))
1265 || GET_CODE (dest
) == ZERO_EXTRACT
1266 || GET_CODE (dest
) == SIGN_EXTRACT
1267 || GET_CODE (dest
) == STRICT_LOW_PART
)
1268 dest
= XEXP (dest
, 0);
1270 if (GET_CODE (dest
) == PARALLEL
1271 && GET_MODE (dest
) == BLKmode
)
1274 for (i
= XVECLEN (dest
, 0) - 1; i
>= 0; i
--)
1275 (*fun
) (SET_DEST (XVECEXP (dest
, 0, i
)), x
, data
);
1278 (*fun
) (dest
, x
, data
);
1280 else if (GET_CODE (x
) == PARALLEL
)
1283 for (i
= XVECLEN (x
, 0) - 1; i
>= 0; i
--)
1285 register rtx y
= XVECEXP (x
, 0, i
);
1286 if (GET_CODE (y
) == COND_EXEC
)
1287 y
= COND_EXEC_CODE (y
);
1288 if (GET_CODE (y
) == SET
|| GET_CODE (y
) == CLOBBER
)
1290 register rtx dest
= SET_DEST (y
);
1291 while ((GET_CODE (dest
) == SUBREG
1292 && (GET_CODE (SUBREG_REG (dest
)) != REG
1293 || (REGNO (SUBREG_REG (dest
))
1294 >= FIRST_PSEUDO_REGISTER
)))
1295 || GET_CODE (dest
) == ZERO_EXTRACT
1296 || GET_CODE (dest
) == SIGN_EXTRACT
1297 || GET_CODE (dest
) == STRICT_LOW_PART
)
1298 dest
= XEXP (dest
, 0);
1299 if (GET_CODE (dest
) == PARALLEL
1300 && GET_MODE (dest
) == BLKmode
)
1304 for (i
= XVECLEN (dest
, 0) - 1; i
>= 0; i
--)
1305 (*fun
) (SET_DEST (XVECEXP (dest
, 0, i
)), y
, data
);
1308 (*fun
) (dest
, y
, data
);
1314 /* Return nonzero if X's old contents don't survive after INSN.
1315 This will be true if X is (cc0) or if X is a register and
1316 X dies in INSN or because INSN entirely sets X.
1318 "Entirely set" means set directly and not through a SUBREG,
1319 ZERO_EXTRACT or SIGN_EXTRACT, so no trace of the old contents remains.
1320 Likewise, REG_INC does not count.
1322 REG may be a hard or pseudo reg. Renumbering is not taken into account,
1323 but for this use that makes no difference, since regs don't overlap
1324 during their lifetimes. Therefore, this function may be used
1325 at any time after deaths have been computed (in flow.c).
1327 If REG is a hard reg that occupies multiple machine registers, this
1328 function will only return 1 if each of those registers will be replaced
1332 dead_or_set_p (insn
, x
)
1336 unsigned int regno
, last_regno
;
1339 /* Can't use cc0_rtx below since this file is used by genattrtab.c. */
1340 if (GET_CODE (x
) == CC0
)
1343 if (GET_CODE (x
) != REG
)
1347 last_regno
= (regno
>= FIRST_PSEUDO_REGISTER
? regno
1348 : regno
+ HARD_REGNO_NREGS (regno
, GET_MODE (x
)) - 1);
1350 for (i
= regno
; i
<= last_regno
; i
++)
1351 if (! dead_or_set_regno_p (insn
, i
))
1357 /* Utility function for dead_or_set_p to check an individual register. Also
1358 called from flow.c. */
1361 dead_or_set_regno_p (insn
, test_regno
)
1363 unsigned int test_regno
;
1365 unsigned int regno
, endregno
;
1368 /* See if there is a death note for something that includes TEST_REGNO. */
1369 if (find_regno_note (insn
, REG_DEAD
, test_regno
))
1372 if (GET_CODE (insn
) == CALL_INSN
1373 && find_regno_fusage (insn
, CLOBBER
, test_regno
))
1376 pattern
= PATTERN (insn
);
1378 if (GET_CODE (pattern
) == COND_EXEC
)
1379 pattern
= COND_EXEC_CODE (pattern
);
1381 if (GET_CODE (pattern
) == SET
)
1383 rtx dest
= SET_DEST (PATTERN (insn
));
1385 /* A value is totally replaced if it is the destination or the
1386 destination is a SUBREG of REGNO that does not change the number of
1388 if (GET_CODE (dest
) == SUBREG
1389 && (((GET_MODE_SIZE (GET_MODE (dest
))
1390 + UNITS_PER_WORD
- 1) / UNITS_PER_WORD
)
1391 == ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (dest
)))
1392 + UNITS_PER_WORD
- 1) / UNITS_PER_WORD
)))
1393 dest
= SUBREG_REG (dest
);
1395 if (GET_CODE (dest
) != REG
)
1398 regno
= REGNO (dest
);
1399 endregno
= (regno
>= FIRST_PSEUDO_REGISTER
? regno
+ 1
1400 : regno
+ HARD_REGNO_NREGS (regno
, GET_MODE (dest
)));
1402 return (test_regno
>= regno
&& test_regno
< endregno
);
1404 else if (GET_CODE (pattern
) == PARALLEL
)
1408 for (i
= XVECLEN (pattern
, 0) - 1; i
>= 0; i
--)
1410 rtx body
= XVECEXP (pattern
, 0, i
);
1412 if (GET_CODE (body
) == COND_EXEC
)
1413 body
= COND_EXEC_CODE (body
);
1415 if (GET_CODE (body
) == SET
|| GET_CODE (body
) == CLOBBER
)
1417 rtx dest
= SET_DEST (body
);
1419 if (GET_CODE (dest
) == SUBREG
1420 && (((GET_MODE_SIZE (GET_MODE (dest
))
1421 + UNITS_PER_WORD
- 1) / UNITS_PER_WORD
)
1422 == ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (dest
)))
1423 + UNITS_PER_WORD
- 1) / UNITS_PER_WORD
)))
1424 dest
= SUBREG_REG (dest
);
1426 if (GET_CODE (dest
) != REG
)
1429 regno
= REGNO (dest
);
1430 endregno
= (regno
>= FIRST_PSEUDO_REGISTER
? regno
+ 1
1431 : regno
+ HARD_REGNO_NREGS (regno
, GET_MODE (dest
)));
1433 if (test_regno
>= regno
&& test_regno
< endregno
)
1442 /* Return the reg-note of kind KIND in insn INSN, if there is one.
1443 If DATUM is nonzero, look for one whose datum is DATUM. */
1446 find_reg_note (insn
, kind
, datum
)
1453 /* Ignore anything that is not an INSN, JUMP_INSN or CALL_INSN. */
1454 if (! INSN_P (insn
))
1457 for (link
= REG_NOTES (insn
); link
; link
= XEXP (link
, 1))
1458 if (REG_NOTE_KIND (link
) == kind
1459 && (datum
== 0 || datum
== XEXP (link
, 0)))
1464 /* Return the reg-note of kind KIND in insn INSN which applies to register
1465 number REGNO, if any. Return 0 if there is no such reg-note. Note that
1466 the REGNO of this NOTE need not be REGNO if REGNO is a hard register;
1467 it might be the case that the note overlaps REGNO. */
1470 find_regno_note (insn
, kind
, regno
)
1477 /* Ignore anything that is not an INSN, JUMP_INSN or CALL_INSN. */
1478 if (! INSN_P (insn
))
1481 for (link
= REG_NOTES (insn
); link
; link
= XEXP (link
, 1))
1482 if (REG_NOTE_KIND (link
) == kind
1483 /* Verify that it is a register, so that scratch and MEM won't cause a
1485 && GET_CODE (XEXP (link
, 0)) == REG
1486 && REGNO (XEXP (link
, 0)) <= regno
1487 && ((REGNO (XEXP (link
, 0))
1488 + (REGNO (XEXP (link
, 0)) >= FIRST_PSEUDO_REGISTER
? 1
1489 : HARD_REGNO_NREGS (REGNO (XEXP (link
, 0)),
1490 GET_MODE (XEXP (link
, 0)))))
1496 /* Return true if DATUM, or any overlap of DATUM, of kind CODE is found
1497 in the CALL_INSN_FUNCTION_USAGE information of INSN. */
1500 find_reg_fusage (insn
, code
, datum
)
1505 /* If it's not a CALL_INSN, it can't possibly have a
1506 CALL_INSN_FUNCTION_USAGE field, so don't bother checking. */
1507 if (GET_CODE (insn
) != CALL_INSN
)
1513 if (GET_CODE (datum
) != REG
)
1517 for (link
= CALL_INSN_FUNCTION_USAGE (insn
);
1519 link
= XEXP (link
, 1))
1520 if (GET_CODE (XEXP (link
, 0)) == code
1521 && rtx_equal_p (datum
, SET_DEST (XEXP (link
, 0))))
1526 unsigned int regno
= REGNO (datum
);
1528 /* CALL_INSN_FUNCTION_USAGE information cannot contain references
1529 to pseudo registers, so don't bother checking. */
1531 if (regno
< FIRST_PSEUDO_REGISTER
)
1533 unsigned int end_regno
1534 = regno
+ HARD_REGNO_NREGS (regno
, GET_MODE (datum
));
1537 for (i
= regno
; i
< end_regno
; i
++)
1538 if (find_regno_fusage (insn
, code
, i
))
1546 /* Return true if REGNO, or any overlap of REGNO, of kind CODE is found
1547 in the CALL_INSN_FUNCTION_USAGE information of INSN. */
1550 find_regno_fusage (insn
, code
, regno
)
1557 /* CALL_INSN_FUNCTION_USAGE information cannot contain references
1558 to pseudo registers, so don't bother checking. */
1560 if (regno
>= FIRST_PSEUDO_REGISTER
1561 || GET_CODE (insn
) != CALL_INSN
)
1564 for (link
= CALL_INSN_FUNCTION_USAGE (insn
); link
; link
= XEXP (link
, 1))
1566 unsigned int regnote
;
1569 if (GET_CODE (op
= XEXP (link
, 0)) == code
1570 && GET_CODE (reg
= XEXP (op
, 0)) == REG
1571 && (regnote
= REGNO (reg
)) <= regno
1572 && regnote
+ HARD_REGNO_NREGS (regnote
, GET_MODE (reg
)) > regno
)
1579 /* Remove register note NOTE from the REG_NOTES of INSN. */
1582 remove_note (insn
, note
)
1588 if (note
== NULL_RTX
)
1591 if (REG_NOTES (insn
) == note
)
1593 REG_NOTES (insn
) = XEXP (note
, 1);
1597 for (link
= REG_NOTES (insn
); link
; link
= XEXP (link
, 1))
1598 if (XEXP (link
, 1) == note
)
1600 XEXP (link
, 1) = XEXP (note
, 1);
1607 /* Search LISTP (an EXPR_LIST) for NODE and remove NODE from the list
1610 A simple equality test is used to determine if NODE is on the
1614 remove_node_from_expr_list (node
, listp
)
1619 rtx prev
= NULL_RTX
;
1623 if (node
== XEXP (temp
, 0))
1625 /* Splice the node out of the list. */
1627 XEXP (prev
, 1) = XEXP (temp
, 1);
1629 *listp
= XEXP (temp
, 1);
1633 temp
= XEXP (temp
, 1);
1637 /* Nonzero if X contains any volatile instructions. These are instructions
1638 which may cause unpredictable machine state instructions, and thus no
1639 instructions should be moved or combined across them. This includes
1640 only volatile asms and UNSPEC_VOLATILE instructions. */
1646 register RTX_CODE code
;
1648 code
= GET_CODE (x
);
1668 case UNSPEC_VOLATILE
:
1669 /* case TRAP_IF: This isn't clear yet. */
1673 if (MEM_VOLATILE_P (x
))
1680 /* Recursively scan the operands of this expression. */
1683 register const char *fmt
= GET_RTX_FORMAT (code
);
1686 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
1690 if (volatile_insn_p (XEXP (x
, i
)))
1693 else if (fmt
[i
] == 'E')
1696 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
1697 if (volatile_insn_p (XVECEXP (x
, i
, j
)))
1705 /* Nonzero if X contains any volatile memory references
1706 UNSPEC_VOLATILE operations or volatile ASM_OPERANDS expressions. */
1712 register RTX_CODE code
;
1714 code
= GET_CODE (x
);
1733 case UNSPEC_VOLATILE
:
1734 /* case TRAP_IF: This isn't clear yet. */
1739 if (MEM_VOLATILE_P (x
))
1746 /* Recursively scan the operands of this expression. */
1749 register const char *fmt
= GET_RTX_FORMAT (code
);
1752 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
1756 if (volatile_refs_p (XEXP (x
, i
)))
1759 else if (fmt
[i
] == 'E')
1762 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
1763 if (volatile_refs_p (XVECEXP (x
, i
, j
)))
1771 /* Similar to above, except that it also rejects register pre- and post-
1778 register RTX_CODE code
;
1780 code
= GET_CODE (x
);
1798 /* Reject CLOBBER with a non-VOID mode. These are made by combine.c
1799 when some combination can't be done. If we see one, don't think
1800 that we can simplify the expression. */
1801 return (GET_MODE (x
) != VOIDmode
);
1808 case UNSPEC_VOLATILE
:
1809 /* case TRAP_IF: This isn't clear yet. */
1814 if (MEM_VOLATILE_P (x
))
1821 /* Recursively scan the operands of this expression. */
1824 register const char *fmt
= GET_RTX_FORMAT (code
);
1827 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
1831 if (side_effects_p (XEXP (x
, i
)))
1834 else if (fmt
[i
] == 'E')
1837 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
1838 if (side_effects_p (XVECEXP (x
, i
, j
)))
1846 /* Return nonzero if evaluating rtx X might cause a trap. */
1858 code
= GET_CODE (x
);
1861 /* Handle these cases quickly. */
1874 case UNSPEC_VOLATILE
:
1879 return MEM_VOLATILE_P (x
);
1881 /* Memory ref can trap unless it's a static var or a stack slot. */
1883 return rtx_addr_can_trap_p (XEXP (x
, 0));
1885 /* Division by a non-constant might trap. */
1890 if (! CONSTANT_P (XEXP (x
, 1))
1891 || GET_MODE_CLASS (GET_MODE (x
)) == MODE_FLOAT
)
1893 /* This was const0_rtx, but by not using that,
1894 we can link this file into other programs. */
1895 if (GET_CODE (XEXP (x
, 1)) == CONST_INT
&& INTVAL (XEXP (x
, 1)) == 0)
1900 /* An EXPR_LIST is used to represent a function call. This
1901 certainly may trap. */
1905 /* Any floating arithmetic may trap. */
1906 if (GET_MODE_CLASS (GET_MODE (x
)) == MODE_FLOAT
)
1910 fmt
= GET_RTX_FORMAT (code
);
1911 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
1915 if (may_trap_p (XEXP (x
, i
)))
1918 else if (fmt
[i
] == 'E')
1921 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
1922 if (may_trap_p (XVECEXP (x
, i
, j
)))
1929 /* Return nonzero if X contains a comparison that is not either EQ or NE,
1930 i.e., an inequality. */
1933 inequality_comparisons_p (x
)
1936 register const char *fmt
;
1937 register int len
, i
;
1938 register enum rtx_code code
= GET_CODE (x
);
1967 len
= GET_RTX_LENGTH (code
);
1968 fmt
= GET_RTX_FORMAT (code
);
1970 for (i
= 0; i
< len
; i
++)
1974 if (inequality_comparisons_p (XEXP (x
, i
)))
1977 else if (fmt
[i
] == 'E')
1980 for (j
= XVECLEN (x
, i
) - 1; j
>= 0; j
--)
1981 if (inequality_comparisons_p (XVECEXP (x
, i
, j
)))
1989 /* Replace any occurrence of FROM in X with TO. The function does
1990 not enter into CONST_DOUBLE for the replace.
1992 Note that copying is not done so X must not be shared unless all copies
1993 are to be modified. */
1996 replace_rtx (x
, from
, to
)
2000 register const char *fmt
;
2002 /* The following prevents loops occurrence when we change MEM in
2003 CONST_DOUBLE onto the same CONST_DOUBLE. */
2004 if (x
!= 0 && GET_CODE (x
) == CONST_DOUBLE
)
2010 /* Allow this function to make replacements in EXPR_LISTs. */
2014 fmt
= GET_RTX_FORMAT (GET_CODE (x
));
2015 for (i
= GET_RTX_LENGTH (GET_CODE (x
)) - 1; i
>= 0; i
--)
2018 XEXP (x
, i
) = replace_rtx (XEXP (x
, i
), from
, to
);
2019 else if (fmt
[i
] == 'E')
2020 for (j
= XVECLEN (x
, i
) - 1; j
>= 0; j
--)
2021 XVECEXP (x
, i
, j
) = replace_rtx (XVECEXP (x
, i
, j
), from
, to
);
2027 /* Throughout the rtx X, replace many registers according to REG_MAP.
2028 Return the replacement for X (which may be X with altered contents).
2029 REG_MAP[R] is the replacement for register R, or 0 for don't replace.
2030 NREGS is the length of REG_MAP; regs >= NREGS are not mapped.
2032 We only support REG_MAP entries of REG or SUBREG. Also, hard registers
2033 should not be mapped to pseudos or vice versa since validate_change
2036 If REPLACE_DEST is 1, replacements are also done in destinations;
2037 otherwise, only sources are replaced. */
2040 replace_regs (x
, reg_map
, nregs
, replace_dest
)
2046 register enum rtx_code code
;
2048 register const char *fmt
;
2053 code
= GET_CODE (x
);
2067 /* Verify that the register has an entry before trying to access it. */
2068 if (REGNO (x
) < nregs
&& reg_map
[REGNO (x
)] != 0)
2070 /* SUBREGs can't be shared. Always return a copy to ensure that if
2071 this replacement occurs more than once then each instance will
2072 get distinct rtx. */
2073 if (GET_CODE (reg_map
[REGNO (x
)]) == SUBREG
)
2074 return copy_rtx (reg_map
[REGNO (x
)]);
2075 return reg_map
[REGNO (x
)];
2080 /* Prevent making nested SUBREGs. */
2081 if (GET_CODE (SUBREG_REG (x
)) == REG
&& REGNO (SUBREG_REG (x
)) < nregs
2082 && reg_map
[REGNO (SUBREG_REG (x
))] != 0
2083 && GET_CODE (reg_map
[REGNO (SUBREG_REG (x
))]) == SUBREG
)
2085 rtx map_val
= reg_map
[REGNO (SUBREG_REG (x
))];
2086 rtx map_inner
= SUBREG_REG (map_val
);
2088 if (GET_MODE (x
) == GET_MODE (map_inner
))
2092 /* We cannot call gen_rtx here since we may be linked with
2094 /* Let's try clobbering the incoming SUBREG and see
2095 if this is really safe. */
2096 SUBREG_REG (x
) = map_inner
;
2097 SUBREG_WORD (x
) += SUBREG_WORD (map_val
);
2100 rtx
new = rtx_alloc (SUBREG
);
2101 PUT_MODE (new, GET_MODE (x
));
2102 SUBREG_REG (new) = map_inner
;
2103 SUBREG_WORD (new) = SUBREG_WORD (x
) + SUBREG_WORD (map_val
);
2111 SET_DEST (x
) = replace_regs (SET_DEST (x
), reg_map
, nregs
, 0);
2113 else if (GET_CODE (SET_DEST (x
)) == MEM
2114 || GET_CODE (SET_DEST (x
)) == STRICT_LOW_PART
)
2115 /* Even if we are not to replace destinations, replace register if it
2116 is CONTAINED in destination (destination is memory or
2117 STRICT_LOW_PART). */
2118 XEXP (SET_DEST (x
), 0) = replace_regs (XEXP (SET_DEST (x
), 0),
2120 else if (GET_CODE (SET_DEST (x
)) == ZERO_EXTRACT
)
2121 /* Similarly, for ZERO_EXTRACT we replace all operands. */
2124 SET_SRC (x
) = replace_regs (SET_SRC (x
), reg_map
, nregs
, 0);
2131 fmt
= GET_RTX_FORMAT (code
);
2132 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
2135 XEXP (x
, i
) = replace_regs (XEXP (x
, i
), reg_map
, nregs
, replace_dest
);
2136 else if (fmt
[i
] == 'E')
2139 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
2140 XVECEXP (x
, i
, j
) = replace_regs (XVECEXP (x
, i
, j
), reg_map
,
2141 nregs
, replace_dest
);
2147 /* Return 1 if X, the SRC_SRC of SET of (pc) contain a REG or MEM that is
2148 not in the constant pool and not in the condition of an IF_THEN_ELSE. */
2151 jmp_uses_reg_or_mem (x
)
2154 enum rtx_code code
= GET_CODE (x
);
2169 return ! (GET_CODE (XEXP (x
, 0)) == SYMBOL_REF
2170 && CONSTANT_POOL_ADDRESS_P (XEXP (x
, 0)));
2173 return (jmp_uses_reg_or_mem (XEXP (x
, 1))
2174 || jmp_uses_reg_or_mem (XEXP (x
, 2)));
2176 case PLUS
: case MINUS
: case MULT
:
2177 return (jmp_uses_reg_or_mem (XEXP (x
, 0))
2178 || jmp_uses_reg_or_mem (XEXP (x
, 1)));
2184 fmt
= GET_RTX_FORMAT (code
);
2185 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
2188 && jmp_uses_reg_or_mem (XEXP (x
, i
)))
2191 else if (fmt
[i
] == 'E')
2192 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
2193 if (jmp_uses_reg_or_mem (XVECEXP (x
, i
, j
)))
2200 /* Return nonzero if INSN is an indirect jump (aka computed jump).
2202 Tablejumps and casesi insns are not considered indirect jumps;
2203 we can recognize them by a (use (label_ref)). */
2206 computed_jump_p (insn
)
2210 if (GET_CODE (insn
) == JUMP_INSN
)
2212 rtx pat
= PATTERN (insn
);
2214 if (GET_CODE (pat
) == PARALLEL
)
2216 int len
= XVECLEN (pat
, 0);
2217 int has_use_labelref
= 0;
2219 for (i
= len
- 1; i
>= 0; i
--)
2220 if (GET_CODE (XVECEXP (pat
, 0, i
)) == USE
2221 && (GET_CODE (XEXP (XVECEXP (pat
, 0, i
), 0))
2223 has_use_labelref
= 1;
2225 if (! has_use_labelref
)
2226 for (i
= len
- 1; i
>= 0; i
--)
2227 if (GET_CODE (XVECEXP (pat
, 0, i
)) == SET
2228 && SET_DEST (XVECEXP (pat
, 0, i
)) == pc_rtx
2229 && jmp_uses_reg_or_mem (SET_SRC (XVECEXP (pat
, 0, i
))))
2232 else if (GET_CODE (pat
) == SET
2233 && SET_DEST (pat
) == pc_rtx
2234 && jmp_uses_reg_or_mem (SET_SRC (pat
)))
2240 /* Traverse X via depth-first search, calling F for each
2241 sub-expression (including X itself). F is also passed the DATA.
2242 If F returns -1, do not traverse sub-expressions, but continue
2243 traversing the rest of the tree. If F ever returns any other
2244 non-zero value, stop the traversal, and return the value returned
2245 by F. Otherwise, return 0. This function does not traverse inside
2246 tree structure that contains RTX_EXPRs, or into sub-expressions
2247 whose format code is `0' since it is not known whether or not those
2248 codes are actually RTL.
2250 This routine is very general, and could (should?) be used to
2251 implement many of the other routines in this file. */
2254 for_each_rtx (x
, f
, data
)
2265 result
= (*f
)(x
, data
);
2267 /* Do not traverse sub-expressions. */
2269 else if (result
!= 0)
2270 /* Stop the traversal. */
2274 /* There are no sub-expressions. */
2277 length
= GET_RTX_LENGTH (GET_CODE (*x
));
2278 format
= GET_RTX_FORMAT (GET_CODE (*x
));
2280 for (i
= 0; i
< length
; ++i
)
2285 result
= for_each_rtx (&XEXP (*x
, i
), f
, data
);
2292 if (XVEC (*x
, i
) != 0)
2295 for (j
= 0; j
< XVECLEN (*x
, i
); ++j
)
2297 result
= for_each_rtx (&XVECEXP (*x
, i
, j
), f
, data
);
2305 /* Nothing to do. */
2314 /* Searches X for any reference to REGNO, returning the rtx of the
2315 reference found if any. Otherwise, returns NULL_RTX. */
2318 regno_use_in (regno
, x
)
2322 register const char *fmt
;
2326 if (GET_CODE (x
) == REG
&& REGNO (x
) == regno
)
2329 fmt
= GET_RTX_FORMAT (GET_CODE (x
));
2330 for (i
= GET_RTX_LENGTH (GET_CODE (x
)) - 1; i
>= 0; i
--)
2334 if ((tem
= regno_use_in (regno
, XEXP (x
, i
))))
2337 else if (fmt
[i
] == 'E')
2338 for (j
= XVECLEN (x
, i
) - 1; j
>= 0; j
--)
2339 if ((tem
= regno_use_in (regno
, XVECEXP (x
, i
, j
))))
2347 /* Return 1 if X is an autoincrement side effect and the register is
2348 not the stack pointer. */
2353 switch (GET_CODE (x
))
2361 /* There are no REG_INC notes for SP. */
2362 if (XEXP (x
, 0) != stack_pointer_rtx
)
2370 /* Return 1 if the sequence of instructions beginning with FROM and up
2371 to and including TO is safe to move. If NEW_TO is non-NULL, and
2372 the sequence is not already safe to move, but can be easily
2373 extended to a sequence which is safe, then NEW_TO will point to the
2374 end of the extended sequence.
2376 For now, this function only checks that the region contains whole
2377 exception regiongs, but it could be extended to check additional
2378 conditions as well. */
2381 insns_safe_to_move_p (from
, to
, new_to
)
2386 int eh_region_count
= 0;
2390 /* By default, assume the end of the region will be what was
2397 if (GET_CODE (r
) == NOTE
)
2399 switch (NOTE_LINE_NUMBER (r
))
2401 case NOTE_INSN_EH_REGION_BEG
:
2405 case NOTE_INSN_EH_REGION_END
:
2406 if (eh_region_count
== 0)
2407 /* This sequence of instructions contains the end of
2408 an exception region, but not he beginning. Moving
2409 it will cause chaos. */
2420 /* If we've passed TO, and we see a non-note instruction, we
2421 can't extend the sequence to a movable sequence. */
2427 /* It's OK to move the sequence if there were matched sets of
2428 exception region notes. */
2429 return eh_region_count
== 0;
2434 /* It's OK to move the sequence if there were matched sets of
2435 exception region notes. */
2436 if (past_to_p
&& eh_region_count
== 0)
2442 /* Go to the next instruction. */
2449 /* Return non-zero if IN contains a piece of rtl that has the address LOC */
2451 loc_mentioned_in_p (loc
, in
)
2454 enum rtx_code code
= GET_CODE (in
);
2455 const char *fmt
= GET_RTX_FORMAT (code
);
2458 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
2460 if (loc
== &in
->fld
[i
].rtx
)
2464 if (loc_mentioned_in_p (loc
, XEXP (in
, i
)))
2467 else if (fmt
[i
] == 'E')
2468 for (j
= XVECLEN (in
, i
) - 1; j
>= 0; j
--)
2469 if (loc_mentioned_in_p (loc
, XVECEXP (in
, i
, j
)))