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. */
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 if (x
== frame_pointer_rtx
|| x
== hard_frame_pointer_rtx
73 || x
== arg_pointer_rtx
|| RTX_UNCHANGING_P (x
))
75 #ifndef PIC_OFFSET_TABLE_REG_CALL_CLOBBERED
76 /* ??? When call-clobbered, the value is stable modulo the restore
77 that must happen after a call. This currently screws up local-alloc
78 into believing that the restore is not needed. */
79 if (x
== pic_offset_table_rtx
)
85 if (MEM_VOLATILE_P (x
))
94 fmt
= GET_RTX_FORMAT (code
);
95 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
98 if (rtx_unstable_p (XEXP (x
, i
)))
101 else if (fmt
[i
] == 'E')
104 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
105 if (rtx_unstable_p (XVECEXP (x
, i
, j
)))
112 /* Return 1 if X has a value that can vary even between two
113 executions of the program. 0 means X can be compared reliably
114 against certain constants or near-constants.
115 FOR_ALIAS is nonzero if we are called from alias analysis; if it is
116 zero, we are slightly more conservative.
117 The frame pointer and the arg pointer are considered constant. */
120 rtx_varies_p (x
, for_alias
)
124 register RTX_CODE code
= GET_CODE (x
);
126 register const char *fmt
;
131 return ! RTX_UNCHANGING_P (x
) || rtx_varies_p (XEXP (x
, 0), for_alias
);
144 /* Note that we have to test for the actual rtx used for the frame
145 and arg pointers and not just the register number in case we have
146 eliminated the frame and/or arg pointer and are using it
148 if (x
== frame_pointer_rtx
|| x
== hard_frame_pointer_rtx
149 || x
== arg_pointer_rtx
)
151 if (x
== pic_offset_table_rtx
152 #ifdef PIC_OFFSET_TABLE_REG_CALL_CLOBBERED
153 /* ??? When call-clobbered, the value is stable modulo the restore
154 that must happen after a call. This currently screws up
155 local-alloc into believing that the restore is not needed, so we
156 must return 0 only if we are called from alias analysis. */
164 /* The operand 0 of a LO_SUM is considered constant
165 (in fact is it related specifically to operand 1). */
166 return rtx_varies_p (XEXP (x
, 1), for_alias
);
169 if (MEM_VOLATILE_P (x
))
178 fmt
= GET_RTX_FORMAT (code
);
179 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
182 if (rtx_varies_p (XEXP (x
, i
), for_alias
))
185 else if (fmt
[i
] == 'E')
188 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
189 if (rtx_varies_p (XVECEXP (x
, i
, j
), for_alias
))
196 /* Return 0 if the use of X as an address in a MEM can cause a trap. */
199 rtx_addr_can_trap_p (x
)
202 register enum rtx_code code
= GET_CODE (x
);
208 /* SYMBOL_REF is problematic due to the possible presence of
209 a #pragma weak, but to say that loads from symbols can trap is
210 *very* costly. It's not at all clear what's best here. For
211 now, we ignore the impact of #pragma weak. */
215 /* As in rtx_varies_p, we have to use the actual rtx, not reg number. */
216 return ! (x
== frame_pointer_rtx
|| x
== hard_frame_pointer_rtx
217 || x
== stack_pointer_rtx
|| x
== arg_pointer_rtx
);
220 return rtx_addr_can_trap_p (XEXP (x
, 0));
223 /* An address is assumed not to trap if it is an address that can't
224 trap plus a constant integer or it is the pic register plus a
226 return ! ((! rtx_addr_can_trap_p (XEXP (x
, 0))
227 && GET_CODE (XEXP (x
, 1)) == CONST_INT
)
228 || (XEXP (x
, 0) == pic_offset_table_rtx
229 && CONSTANT_P (XEXP (x
, 1))));
232 return rtx_addr_can_trap_p (XEXP (x
, 1));
238 /* If it isn't one of the case above, it can cause a trap. */
242 /* Return 1 if X refers to a memory location whose address
243 cannot be compared reliably with constant addresses,
244 or if X refers to a BLKmode memory object.
245 FOR_ALIAS is nonzero if we are called from alias analysis; if it is
246 zero, we are slightly more conservative. */
249 rtx_addr_varies_p (x
, for_alias
)
253 register enum rtx_code code
;
255 register const char *fmt
;
262 return GET_MODE (x
) == BLKmode
|| rtx_varies_p (XEXP (x
, 0), for_alias
);
264 fmt
= GET_RTX_FORMAT (code
);
265 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
268 if (rtx_addr_varies_p (XEXP (x
, i
), for_alias
))
271 else if (fmt
[i
] == 'E')
274 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
275 if (rtx_addr_varies_p (XVECEXP (x
, i
, j
), for_alias
))
281 /* Return the value of the integer term in X, if one is apparent;
283 Only obvious integer terms are detected.
284 This is used in cse.c with the `related_value' field.*/
290 if (GET_CODE (x
) == CONST
)
293 if (GET_CODE (x
) == MINUS
294 && GET_CODE (XEXP (x
, 1)) == CONST_INT
)
295 return - INTVAL (XEXP (x
, 1));
296 if (GET_CODE (x
) == PLUS
297 && GET_CODE (XEXP (x
, 1)) == CONST_INT
)
298 return INTVAL (XEXP (x
, 1));
302 /* If X is a constant, return the value sans apparent integer term;
304 Only obvious integer terms are detected. */
307 get_related_value (x
)
310 if (GET_CODE (x
) != CONST
)
313 if (GET_CODE (x
) == PLUS
314 && GET_CODE (XEXP (x
, 1)) == CONST_INT
)
316 else if (GET_CODE (x
) == MINUS
317 && GET_CODE (XEXP (x
, 1)) == CONST_INT
)
322 /* Return the number of places FIND appears within X. If COUNT_DEST is
323 zero, we do not count occurrences inside the destination of a SET. */
326 count_occurrences (x
, find
, count_dest
)
332 const char *format_ptr
;
352 if (GET_CODE (find
) == MEM
&& rtx_equal_p (x
, find
))
357 if (SET_DEST (x
) == find
&& ! count_dest
)
358 return count_occurrences (SET_SRC (x
), find
, count_dest
);
365 format_ptr
= GET_RTX_FORMAT (code
);
368 for (i
= 0; i
< GET_RTX_LENGTH (code
); i
++)
370 switch (*format_ptr
++)
373 count
+= count_occurrences (XEXP (x
, i
), find
, count_dest
);
377 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
378 count
+= count_occurrences (XVECEXP (x
, i
, j
), find
, count_dest
);
385 /* Nonzero if register REG appears somewhere within IN.
386 Also works if REG is not a register; in this case it checks
387 for a subexpression of IN that is Lisp "equal" to REG. */
390 reg_mentioned_p (reg
, in
)
391 register rtx reg
, in
;
393 register const char *fmt
;
395 register enum rtx_code code
;
403 if (GET_CODE (in
) == LABEL_REF
)
404 return reg
== XEXP (in
, 0);
406 code
= GET_CODE (in
);
410 /* Compare registers by number. */
412 return GET_CODE (reg
) == REG
&& REGNO (in
) == REGNO (reg
);
414 /* These codes have no constituent expressions
422 return GET_CODE (reg
) == CONST_INT
&& INTVAL (in
) == INTVAL (reg
);
425 /* These are kept unique for a given value. */
432 if (GET_CODE (reg
) == code
&& rtx_equal_p (reg
, in
))
435 fmt
= GET_RTX_FORMAT (code
);
437 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
442 for (j
= XVECLEN (in
, i
) - 1; j
>= 0; j
--)
443 if (reg_mentioned_p (reg
, XVECEXP (in
, i
, j
)))
446 else if (fmt
[i
] == 'e'
447 && reg_mentioned_p (reg
, XEXP (in
, i
)))
453 /* Return 1 if in between BEG and END, exclusive of BEG and END, there is
454 no CODE_LABEL insn. */
457 no_labels_between_p (beg
, end
)
461 for (p
= NEXT_INSN (beg
); p
!= end
; p
= NEXT_INSN (p
))
462 if (GET_CODE (p
) == CODE_LABEL
)
467 /* Return 1 if in between BEG and END, exclusive of BEG and END, there is
468 no JUMP_INSN insn. */
471 no_jumps_between_p (beg
, end
)
475 for (p
= NEXT_INSN (beg
); p
!= end
; p
= NEXT_INSN (p
))
476 if (GET_CODE (p
) == JUMP_INSN
)
481 /* Nonzero if register REG is used in an insn between
482 FROM_INSN and TO_INSN (exclusive of those two). */
485 reg_used_between_p (reg
, from_insn
, to_insn
)
486 rtx reg
, from_insn
, to_insn
;
490 if (from_insn
== to_insn
)
493 for (insn
= NEXT_INSN (from_insn
); insn
!= to_insn
; insn
= NEXT_INSN (insn
))
495 && (reg_overlap_mentioned_p (reg
, PATTERN (insn
))
496 || (GET_CODE (insn
) == CALL_INSN
497 && (find_reg_fusage (insn
, USE
, reg
)
498 || find_reg_fusage (insn
, CLOBBER
, reg
)))))
503 /* Nonzero if the old value of X, a register, is referenced in BODY. If X
504 is entirely replaced by a new value and the only use is as a SET_DEST,
505 we do not consider it a reference. */
508 reg_referenced_p (x
, body
)
514 switch (GET_CODE (body
))
517 if (reg_overlap_mentioned_p (x
, SET_SRC (body
)))
520 /* If the destination is anything other than CC0, PC, a REG or a SUBREG
521 of a REG that occupies all of the REG, the insn references X if
522 it is mentioned in the destination. */
523 if (GET_CODE (SET_DEST (body
)) != CC0
524 && GET_CODE (SET_DEST (body
)) != PC
525 && GET_CODE (SET_DEST (body
)) != REG
526 && ! (GET_CODE (SET_DEST (body
)) == SUBREG
527 && GET_CODE (SUBREG_REG (SET_DEST (body
))) == REG
528 && (((GET_MODE_SIZE (GET_MODE (SUBREG_REG (SET_DEST (body
))))
529 + (UNITS_PER_WORD
- 1)) / UNITS_PER_WORD
)
530 == ((GET_MODE_SIZE (GET_MODE (SET_DEST (body
)))
531 + (UNITS_PER_WORD
- 1)) / UNITS_PER_WORD
)))
532 && reg_overlap_mentioned_p (x
, SET_DEST (body
)))
537 for (i
= ASM_OPERANDS_INPUT_LENGTH (body
) - 1; i
>= 0; i
--)
538 if (reg_overlap_mentioned_p (x
, ASM_OPERANDS_INPUT (body
, i
)))
545 return reg_overlap_mentioned_p (x
, body
);
548 return reg_overlap_mentioned_p (x
, TRAP_CONDITION (body
));
551 case UNSPEC_VOLATILE
:
552 for (i
= XVECLEN (body
, 0) - 1; i
>= 0; i
--)
553 if (reg_overlap_mentioned_p (x
, XVECEXP (body
, 0, i
)))
558 for (i
= XVECLEN (body
, 0) - 1; i
>= 0; i
--)
559 if (reg_referenced_p (x
, XVECEXP (body
, 0, i
)))
564 if (GET_CODE (XEXP (body
, 0)) == MEM
)
565 if (reg_overlap_mentioned_p (x
, XEXP (XEXP (body
, 0), 0)))
570 if (reg_overlap_mentioned_p (x
, COND_EXEC_TEST (body
)))
572 return reg_referenced_p (x
, COND_EXEC_CODE (body
));
579 /* Nonzero if register REG is referenced in an insn between
580 FROM_INSN and TO_INSN (exclusive of those two). Sets of REG do
584 reg_referenced_between_p (reg
, from_insn
, to_insn
)
585 rtx reg
, from_insn
, to_insn
;
589 if (from_insn
== to_insn
)
592 for (insn
= NEXT_INSN (from_insn
); insn
!= to_insn
; insn
= NEXT_INSN (insn
))
594 && (reg_referenced_p (reg
, PATTERN (insn
))
595 || (GET_CODE (insn
) == CALL_INSN
596 && find_reg_fusage (insn
, USE
, reg
))))
601 /* Nonzero if register REG is set or clobbered in an insn between
602 FROM_INSN and TO_INSN (exclusive of those two). */
605 reg_set_between_p (reg
, from_insn
, to_insn
)
606 rtx reg
, from_insn
, to_insn
;
610 if (from_insn
== to_insn
)
613 for (insn
= NEXT_INSN (from_insn
); insn
!= to_insn
; insn
= NEXT_INSN (insn
))
614 if (INSN_P (insn
) && reg_set_p (reg
, insn
))
619 /* Internals of reg_set_between_p. */
621 static rtx reg_set_reg
;
622 static int reg_set_flag
;
625 reg_set_p_1 (x
, pat
, data
)
627 rtx pat ATTRIBUTE_UNUSED
;
628 void *data ATTRIBUTE_UNUSED
;
630 /* We don't want to return 1 if X is a MEM that contains a register
631 within REG_SET_REG. */
633 if ((GET_CODE (x
) != MEM
)
634 && reg_overlap_mentioned_p (reg_set_reg
, x
))
639 reg_set_p (reg
, insn
)
644 /* We can be passed an insn or part of one. If we are passed an insn,
645 check if a side-effect of the insn clobbers REG. */
648 if (FIND_REG_INC_NOTE (insn
, reg
)
649 || (GET_CODE (insn
) == CALL_INSN
650 /* We'd like to test call_used_regs here, but rtlanal.c can't
651 reference that variable due to its use in genattrtab. So
652 we'll just be more conservative.
654 ??? Unless we could ensure that the CALL_INSN_FUNCTION_USAGE
655 information holds all clobbered registers. */
656 && ((GET_CODE (reg
) == REG
657 && REGNO (reg
) < FIRST_PSEUDO_REGISTER
)
658 || GET_CODE (reg
) == MEM
659 || find_reg_fusage (insn
, CLOBBER
, reg
))))
662 body
= PATTERN (insn
);
667 note_stores (body
, reg_set_p_1
, NULL
);
671 /* Similar to reg_set_between_p, but check all registers in X. Return 0
672 only if none of them are modified between START and END. Do not
673 consider non-registers one way or the other. */
676 regs_set_between_p (x
, start
, end
)
680 enum rtx_code code
= GET_CODE (x
);
696 return reg_set_between_p (x
, start
, end
);
702 fmt
= GET_RTX_FORMAT (code
);
703 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
705 if (fmt
[i
] == 'e' && regs_set_between_p (XEXP (x
, i
), start
, end
))
708 else if (fmt
[i
] == 'E')
709 for (j
= XVECLEN (x
, i
) - 1; j
>= 0; j
--)
710 if (regs_set_between_p (XVECEXP (x
, i
, j
), start
, end
))
717 /* Similar to reg_set_between_p, but check all registers in X. Return 0
718 only if none of them are modified between START and END. Return 1 if
719 X contains a MEM; this routine does not perform any memory aliasing. */
722 modified_between_p (x
, start
, end
)
726 enum rtx_code code
= GET_CODE (x
);
744 /* If the memory is not constant, assume it is modified. If it is
745 constant, we still have to check the address. */
746 if (! RTX_UNCHANGING_P (x
))
751 return reg_set_between_p (x
, start
, end
);
757 fmt
= GET_RTX_FORMAT (code
);
758 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
760 if (fmt
[i
] == 'e' && modified_between_p (XEXP (x
, i
), start
, end
))
763 else if (fmt
[i
] == 'E')
764 for (j
= XVECLEN (x
, i
) - 1; j
>= 0; j
--)
765 if (modified_between_p (XVECEXP (x
, i
, j
), start
, end
))
772 /* Similar to reg_set_p, but check all registers in X. Return 0 only if none
773 of them are modified in INSN. Return 1 if X contains a MEM; this routine
774 does not perform any memory aliasing. */
777 modified_in_p (x
, insn
)
781 enum rtx_code code
= GET_CODE (x
);
799 /* If the memory is not constant, assume it is modified. If it is
800 constant, we still have to check the address. */
801 if (! RTX_UNCHANGING_P (x
))
806 return reg_set_p (x
, insn
);
812 fmt
= GET_RTX_FORMAT (code
);
813 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
815 if (fmt
[i
] == 'e' && modified_in_p (XEXP (x
, i
), insn
))
818 else if (fmt
[i
] == 'E')
819 for (j
= XVECLEN (x
, i
) - 1; j
>= 0; j
--)
820 if (modified_in_p (XVECEXP (x
, i
, j
), insn
))
827 /* Return true if anything in insn X is (anti,output,true) dependent on
828 anything in insn Y. */
831 insn_dependent_p (x
, y
)
836 if (! INSN_P (x
) || ! INSN_P (y
))
840 note_stores (PATTERN (x
), insn_dependent_p_1
, &tmp
);
845 note_stores (PATTERN (y
), insn_dependent_p_1
, &tmp
);
852 /* A helper routine for insn_dependent_p called through note_stores. */
855 insn_dependent_p_1 (x
, pat
, data
)
857 rtx pat ATTRIBUTE_UNUSED
;
860 rtx
* pinsn
= (rtx
*) data
;
862 if (*pinsn
&& reg_mentioned_p (x
, *pinsn
))
866 /* Given an INSN, return a SET expression if this insn has only a single SET.
867 It may also have CLOBBERs, USEs, or SET whose output
868 will not be used, which we ignore. */
871 single_set_2 (insn
, pat
)
875 int set_verified
= 1;
878 if (GET_CODE (pat
) == PARALLEL
)
880 for (i
= 0; i
< XVECLEN (pat
, 0); i
++)
882 rtx sub
= XVECEXP (pat
, 0, i
);
883 switch (GET_CODE (sub
))
890 /* We can consider insns having multiple sets, where all
891 but one are dead as single set insns. In common case
892 only single set is present in the pattern so we want
893 to avoid checking for REG_UNUSED notes unless neccesary.
895 When we reach set first time, we just expect this is
896 the single set we are looking for and only when more
897 sets are found in the insn, we check them. */
900 if (find_reg_note (insn
, REG_UNUSED
, SET_DEST (set
))
901 && !side_effects_p (set
))
907 set
= sub
, set_verified
= 0;
908 else if (!find_reg_note (insn
, REG_UNUSED
, SET_DEST (sub
))
909 || side_effects_p (sub
))
921 /* Given an INSN, return nonzero if it has more than one SET, else return
931 /* INSN must be an insn. */
935 /* Only a PARALLEL can have multiple SETs. */
936 if (GET_CODE (PATTERN (insn
)) == PARALLEL
)
938 for (i
= 0, found
= 0; i
< XVECLEN (PATTERN (insn
), 0); i
++)
939 if (GET_CODE (XVECEXP (PATTERN (insn
), 0, i
)) == SET
)
941 /* If we have already found a SET, then return now. */
949 /* Either zero or one SET. */
953 /* Return the last thing that X was assigned from before *PINSN. If VALID_TO
954 is not NULL_RTX then verify that the object is not modified up to VALID_TO.
955 If the object was modified, if we hit a partial assignment to X, or hit a
956 CODE_LABEL first, return X. If we found an assignment, update *PINSN to
957 point to it. ALLOW_HWREG is set to 1 if hardware registers are allowed to
961 find_last_value (x
, pinsn
, valid_to
, allow_hwreg
)
969 for (p
= PREV_INSN (*pinsn
); p
&& GET_CODE (p
) != CODE_LABEL
;
973 rtx set
= single_set (p
);
974 rtx note
= find_reg_note (p
, REG_EQUAL
, NULL_RTX
);
976 if (set
&& rtx_equal_p (x
, SET_DEST (set
)))
978 rtx src
= SET_SRC (set
);
980 if (note
&& GET_CODE (XEXP (note
, 0)) != EXPR_LIST
)
981 src
= XEXP (note
, 0);
983 if ((valid_to
== NULL_RTX
984 || ! modified_between_p (src
, PREV_INSN (p
), valid_to
))
985 /* Reject hard registers because we don't usually want
986 to use them; we'd rather use a pseudo. */
987 && (! (GET_CODE (src
) == REG
988 && REGNO (src
) < FIRST_PSEUDO_REGISTER
) || allow_hwreg
))
995 /* If set in non-simple way, we don't have a value. */
996 if (reg_set_p (x
, p
))
1003 /* Return nonzero if register in range [REGNO, ENDREGNO)
1004 appears either explicitly or implicitly in X
1005 other than being stored into.
1007 References contained within the substructure at LOC do not count.
1008 LOC may be zero, meaning don't ignore anything. */
1011 refers_to_regno_p (regno
, endregno
, x
, loc
)
1012 unsigned int regno
, endregno
;
1017 unsigned int x_regno
;
1022 /* The contents of a REG_NONNEG note is always zero, so we must come here
1023 upon repeat in case the last REG_NOTE is a REG_NONNEG note. */
1027 code
= GET_CODE (x
);
1032 x_regno
= REGNO (x
);
1034 /* If we modifying the stack, frame, or argument pointer, it will
1035 clobber a virtual register. In fact, we could be more precise,
1036 but it isn't worth it. */
1037 if ((x_regno
== STACK_POINTER_REGNUM
1038 #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
1039 || x_regno
== ARG_POINTER_REGNUM
1041 || x_regno
== FRAME_POINTER_REGNUM
)
1042 && regno
>= FIRST_VIRTUAL_REGISTER
&& regno
<= LAST_VIRTUAL_REGISTER
)
1045 return (endregno
> x_regno
1046 && regno
< x_regno
+ (x_regno
< FIRST_PSEUDO_REGISTER
1047 ? HARD_REGNO_NREGS (x_regno
, GET_MODE (x
))
1051 /* If this is a SUBREG of a hard reg, we can see exactly which
1052 registers are being modified. Otherwise, handle normally. */
1053 if (GET_CODE (SUBREG_REG (x
)) == REG
1054 && REGNO (SUBREG_REG (x
)) < FIRST_PSEUDO_REGISTER
)
1056 unsigned int inner_regno
= REGNO (SUBREG_REG (x
)) + SUBREG_WORD (x
);
1057 unsigned int inner_endregno
1058 = inner_regno
+ (inner_regno
< FIRST_PSEUDO_REGISTER
1059 ? HARD_REGNO_NREGS (regno
, GET_MODE (x
)) : 1);
1061 return endregno
> inner_regno
&& regno
< inner_endregno
;
1067 if (&SET_DEST (x
) != loc
1068 /* Note setting a SUBREG counts as referring to the REG it is in for
1069 a pseudo but not for hard registers since we can
1070 treat each word individually. */
1071 && ((GET_CODE (SET_DEST (x
)) == SUBREG
1072 && loc
!= &SUBREG_REG (SET_DEST (x
))
1073 && GET_CODE (SUBREG_REG (SET_DEST (x
))) == REG
1074 && REGNO (SUBREG_REG (SET_DEST (x
))) >= FIRST_PSEUDO_REGISTER
1075 && refers_to_regno_p (regno
, endregno
,
1076 SUBREG_REG (SET_DEST (x
)), loc
))
1077 || (GET_CODE (SET_DEST (x
)) != REG
1078 && refers_to_regno_p (regno
, endregno
, SET_DEST (x
), loc
))))
1081 if (code
== CLOBBER
|| loc
== &SET_SRC (x
))
1090 /* X does not match, so try its subexpressions. */
1092 fmt
= GET_RTX_FORMAT (code
);
1093 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
1095 if (fmt
[i
] == 'e' && loc
!= &XEXP (x
, i
))
1103 if (refers_to_regno_p (regno
, endregno
, XEXP (x
, i
), loc
))
1106 else if (fmt
[i
] == 'E')
1109 for (j
= XVECLEN (x
, i
) - 1; j
>=0; j
--)
1110 if (loc
!= &XVECEXP (x
, i
, j
)
1111 && refers_to_regno_p (regno
, endregno
, XVECEXP (x
, i
, j
), loc
))
1118 /* Nonzero if modifying X will affect IN. If X is a register or a SUBREG,
1119 we check if any register number in X conflicts with the relevant register
1120 numbers. If X is a constant, return 0. If X is a MEM, return 1 iff IN
1121 contains a MEM (we don't bother checking for memory addresses that can't
1122 conflict because we expect this to be a rare case. */
1125 reg_overlap_mentioned_p (x
, in
)
1128 unsigned int regno
, endregno
;
1130 /* Overly conservative. */
1131 if (GET_CODE (x
) == STRICT_LOW_PART
)
1134 /* If either argument is a constant, then modifying X can not affect IN. */
1135 if (CONSTANT_P (x
) || CONSTANT_P (in
))
1138 switch (GET_CODE (x
))
1141 regno
= REGNO (SUBREG_REG (x
));
1142 if (regno
< FIRST_PSEUDO_REGISTER
)
1143 regno
+= SUBREG_WORD (x
);
1149 endregno
= regno
+ (regno
< FIRST_PSEUDO_REGISTER
1150 ? HARD_REGNO_NREGS (regno
, GET_MODE (x
)) : 1);
1151 return refers_to_regno_p (regno
, endregno
, in
, NULL_PTR
);
1158 if (GET_CODE (in
) == MEM
)
1161 fmt
= GET_RTX_FORMAT (GET_CODE (in
));
1162 for (i
= GET_RTX_LENGTH (GET_CODE (in
)) - 1; i
>= 0; i
--)
1163 if (fmt
[i
] == 'e' && reg_overlap_mentioned_p (x
, XEXP (in
, i
)))
1172 return reg_mentioned_p (x
, in
);
1178 /* Check for a NULL entry, used to indicate that the parameter goes
1179 both on the stack and in registers. */
1180 if (XEXP (XVECEXP (x
, 0, 0), 0))
1185 /* If any register in here refers to it we return true. */
1186 for (n
= XVECLEN (x
, 0); i
< n
; ++i
)
1187 if (reg_overlap_mentioned_p (XEXP (XVECEXP (x
, 0, i
), 0), in
))
1199 /* Used for communications between the next few functions. */
1201 static int reg_set_last_unknown
;
1202 static rtx reg_set_last_value
;
1203 static unsigned int reg_set_last_first_regno
, reg_set_last_last_regno
;
1205 /* Called via note_stores from reg_set_last. */
1208 reg_set_last_1 (x
, pat
, data
)
1211 void *data ATTRIBUTE_UNUSED
;
1213 unsigned int first
, last
;
1215 /* If X is not a register, or is not one in the range we care
1217 if (GET_CODE (x
) != REG
)
1221 last
= first
+ (first
< FIRST_PSEUDO_REGISTER
1222 ? HARD_REGNO_NREGS (first
, GET_MODE (x
)) : 1);
1224 if (first
>= reg_set_last_last_regno
1225 || last
<= reg_set_last_first_regno
)
1228 /* If this is a CLOBBER or is some complex LHS, or doesn't modify
1229 exactly the registers we care about, show we don't know the value. */
1230 if (GET_CODE (pat
) == CLOBBER
|| SET_DEST (pat
) != x
1231 || first
!= reg_set_last_first_regno
1232 || last
!= reg_set_last_last_regno
)
1233 reg_set_last_unknown
= 1;
1235 reg_set_last_value
= SET_SRC (pat
);
1238 /* Return the last value to which REG was set prior to INSN. If we can't
1239 find it easily, return 0.
1241 We only return a REG, SUBREG, or constant because it is too hard to
1242 check if a MEM remains unchanged. */
1245 reg_set_last (x
, insn
)
1249 rtx orig_insn
= insn
;
1251 reg_set_last_first_regno
= REGNO (x
);
1253 reg_set_last_last_regno
1254 = reg_set_last_first_regno
1255 + (reg_set_last_first_regno
< FIRST_PSEUDO_REGISTER
1256 ? HARD_REGNO_NREGS (reg_set_last_first_regno
, GET_MODE (x
)) : 1);
1258 reg_set_last_unknown
= 0;
1259 reg_set_last_value
= 0;
1261 /* Scan backwards until reg_set_last_1 changed one of the above flags.
1262 Stop when we reach a label or X is a hard reg and we reach a
1263 CALL_INSN (if reg_set_last_last_regno is a hard reg).
1265 If we find a set of X, ensure that its SET_SRC remains unchanged. */
1267 /* We compare with <= here, because reg_set_last_last_regno
1268 is actually the number of the first reg *not* in X. */
1270 insn
&& GET_CODE (insn
) != CODE_LABEL
1271 && ! (GET_CODE (insn
) == CALL_INSN
1272 && reg_set_last_last_regno
<= FIRST_PSEUDO_REGISTER
);
1273 insn
= PREV_INSN (insn
))
1276 note_stores (PATTERN (insn
), reg_set_last_1
, NULL
);
1277 if (reg_set_last_unknown
)
1279 else if (reg_set_last_value
)
1281 if (CONSTANT_P (reg_set_last_value
)
1282 || ((GET_CODE (reg_set_last_value
) == REG
1283 || GET_CODE (reg_set_last_value
) == SUBREG
)
1284 && ! reg_set_between_p (reg_set_last_value
,
1286 return reg_set_last_value
;
1295 /* Call FUN on each register or MEM that is stored into or clobbered by X.
1296 (X would be the pattern of an insn).
1297 FUN receives two arguments:
1298 the REG, MEM, CC0 or PC being stored in or clobbered,
1299 the SET or CLOBBER rtx that does the store.
1301 If the item being stored in or clobbered is a SUBREG of a hard register,
1302 the SUBREG will be passed. */
1305 note_stores (x
, fun
, data
)
1307 void (*fun
) PARAMS ((rtx
, rtx
, void *));
1310 if (GET_CODE (x
) == COND_EXEC
)
1311 x
= COND_EXEC_CODE (x
);
1312 if (GET_CODE (x
) == SET
|| GET_CODE (x
) == CLOBBER
)
1314 register rtx dest
= SET_DEST (x
);
1315 while ((GET_CODE (dest
) == SUBREG
1316 && (GET_CODE (SUBREG_REG (dest
)) != REG
1317 || REGNO (SUBREG_REG (dest
)) >= FIRST_PSEUDO_REGISTER
))
1318 || GET_CODE (dest
) == ZERO_EXTRACT
1319 || GET_CODE (dest
) == SIGN_EXTRACT
1320 || GET_CODE (dest
) == STRICT_LOW_PART
)
1321 dest
= XEXP (dest
, 0);
1323 if (GET_CODE (dest
) == PARALLEL
1324 && GET_MODE (dest
) == BLKmode
)
1327 for (i
= XVECLEN (dest
, 0) - 1; i
>= 0; i
--)
1328 (*fun
) (SET_DEST (XVECEXP (dest
, 0, i
)), x
, data
);
1331 (*fun
) (dest
, x
, data
);
1333 else if (GET_CODE (x
) == PARALLEL
)
1336 for (i
= XVECLEN (x
, 0) - 1; i
>= 0; i
--)
1338 register rtx y
= XVECEXP (x
, 0, i
);
1339 if (GET_CODE (y
) == COND_EXEC
)
1340 y
= COND_EXEC_CODE (y
);
1341 if (GET_CODE (y
) == SET
|| GET_CODE (y
) == CLOBBER
)
1343 register rtx dest
= SET_DEST (y
);
1344 while ((GET_CODE (dest
) == SUBREG
1345 && (GET_CODE (SUBREG_REG (dest
)) != REG
1346 || (REGNO (SUBREG_REG (dest
))
1347 >= FIRST_PSEUDO_REGISTER
)))
1348 || GET_CODE (dest
) == ZERO_EXTRACT
1349 || GET_CODE (dest
) == SIGN_EXTRACT
1350 || GET_CODE (dest
) == STRICT_LOW_PART
)
1351 dest
= XEXP (dest
, 0);
1352 if (GET_CODE (dest
) == PARALLEL
1353 && GET_MODE (dest
) == BLKmode
)
1357 for (i
= XVECLEN (dest
, 0) - 1; i
>= 0; i
--)
1358 (*fun
) (SET_DEST (XVECEXP (dest
, 0, i
)), y
, data
);
1361 (*fun
) (dest
, y
, data
);
1367 /* Return nonzero if X's old contents don't survive after INSN.
1368 This will be true if X is (cc0) or if X is a register and
1369 X dies in INSN or because INSN entirely sets X.
1371 "Entirely set" means set directly and not through a SUBREG,
1372 ZERO_EXTRACT or SIGN_EXTRACT, so no trace of the old contents remains.
1373 Likewise, REG_INC does not count.
1375 REG may be a hard or pseudo reg. Renumbering is not taken into account,
1376 but for this use that makes no difference, since regs don't overlap
1377 during their lifetimes. Therefore, this function may be used
1378 at any time after deaths have been computed (in flow.c).
1380 If REG is a hard reg that occupies multiple machine registers, this
1381 function will only return 1 if each of those registers will be replaced
1385 dead_or_set_p (insn
, x
)
1389 unsigned int regno
, last_regno
;
1392 /* Can't use cc0_rtx below since this file is used by genattrtab.c. */
1393 if (GET_CODE (x
) == CC0
)
1396 if (GET_CODE (x
) != REG
)
1400 last_regno
= (regno
>= FIRST_PSEUDO_REGISTER
? regno
1401 : regno
+ HARD_REGNO_NREGS (regno
, GET_MODE (x
)) - 1);
1403 for (i
= regno
; i
<= last_regno
; i
++)
1404 if (! dead_or_set_regno_p (insn
, i
))
1410 /* Utility function for dead_or_set_p to check an individual register. Also
1411 called from flow.c. */
1414 dead_or_set_regno_p (insn
, test_regno
)
1416 unsigned int test_regno
;
1418 unsigned int regno
, endregno
;
1421 /* See if there is a death note for something that includes TEST_REGNO. */
1422 if (find_regno_note (insn
, REG_DEAD
, test_regno
))
1425 if (GET_CODE (insn
) == CALL_INSN
1426 && find_regno_fusage (insn
, CLOBBER
, test_regno
))
1429 pattern
= PATTERN (insn
);
1431 if (GET_CODE (pattern
) == COND_EXEC
)
1432 pattern
= COND_EXEC_CODE (pattern
);
1434 if (GET_CODE (pattern
) == SET
)
1436 rtx dest
= SET_DEST (PATTERN (insn
));
1438 /* A value is totally replaced if it is the destination or the
1439 destination is a SUBREG of REGNO that does not change the number of
1441 if (GET_CODE (dest
) == SUBREG
1442 && (((GET_MODE_SIZE (GET_MODE (dest
))
1443 + UNITS_PER_WORD
- 1) / UNITS_PER_WORD
)
1444 == ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (dest
)))
1445 + UNITS_PER_WORD
- 1) / UNITS_PER_WORD
)))
1446 dest
= SUBREG_REG (dest
);
1448 if (GET_CODE (dest
) != REG
)
1451 regno
= REGNO (dest
);
1452 endregno
= (regno
>= FIRST_PSEUDO_REGISTER
? regno
+ 1
1453 : regno
+ HARD_REGNO_NREGS (regno
, GET_MODE (dest
)));
1455 return (test_regno
>= regno
&& test_regno
< endregno
);
1457 else if (GET_CODE (pattern
) == PARALLEL
)
1461 for (i
= XVECLEN (pattern
, 0) - 1; i
>= 0; i
--)
1463 rtx body
= XVECEXP (pattern
, 0, i
);
1465 if (GET_CODE (body
) == COND_EXEC
)
1466 body
= COND_EXEC_CODE (body
);
1468 if (GET_CODE (body
) == SET
|| GET_CODE (body
) == CLOBBER
)
1470 rtx dest
= SET_DEST (body
);
1472 if (GET_CODE (dest
) == SUBREG
1473 && (((GET_MODE_SIZE (GET_MODE (dest
))
1474 + UNITS_PER_WORD
- 1) / UNITS_PER_WORD
)
1475 == ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (dest
)))
1476 + UNITS_PER_WORD
- 1) / UNITS_PER_WORD
)))
1477 dest
= SUBREG_REG (dest
);
1479 if (GET_CODE (dest
) != REG
)
1482 regno
= REGNO (dest
);
1483 endregno
= (regno
>= FIRST_PSEUDO_REGISTER
? regno
+ 1
1484 : regno
+ HARD_REGNO_NREGS (regno
, GET_MODE (dest
)));
1486 if (test_regno
>= regno
&& test_regno
< endregno
)
1495 /* Return the reg-note of kind KIND in insn INSN, if there is one.
1496 If DATUM is nonzero, look for one whose datum is DATUM. */
1499 find_reg_note (insn
, kind
, datum
)
1506 /* Ignore anything that is not an INSN, JUMP_INSN or CALL_INSN. */
1507 if (! INSN_P (insn
))
1510 for (link
= REG_NOTES (insn
); link
; link
= XEXP (link
, 1))
1511 if (REG_NOTE_KIND (link
) == kind
1512 && (datum
== 0 || datum
== XEXP (link
, 0)))
1517 /* Return the reg-note of kind KIND in insn INSN which applies to register
1518 number REGNO, if any. Return 0 if there is no such reg-note. Note that
1519 the REGNO of this NOTE need not be REGNO if REGNO is a hard register;
1520 it might be the case that the note overlaps REGNO. */
1523 find_regno_note (insn
, kind
, regno
)
1530 /* Ignore anything that is not an INSN, JUMP_INSN or CALL_INSN. */
1531 if (! INSN_P (insn
))
1534 for (link
= REG_NOTES (insn
); link
; link
= XEXP (link
, 1))
1535 if (REG_NOTE_KIND (link
) == kind
1536 /* Verify that it is a register, so that scratch and MEM won't cause a
1538 && GET_CODE (XEXP (link
, 0)) == REG
1539 && REGNO (XEXP (link
, 0)) <= regno
1540 && ((REGNO (XEXP (link
, 0))
1541 + (REGNO (XEXP (link
, 0)) >= FIRST_PSEUDO_REGISTER
? 1
1542 : HARD_REGNO_NREGS (REGNO (XEXP (link
, 0)),
1543 GET_MODE (XEXP (link
, 0)))))
1549 /* Return true if DATUM, or any overlap of DATUM, of kind CODE is found
1550 in the CALL_INSN_FUNCTION_USAGE information of INSN. */
1553 find_reg_fusage (insn
, code
, datum
)
1558 /* If it's not a CALL_INSN, it can't possibly have a
1559 CALL_INSN_FUNCTION_USAGE field, so don't bother checking. */
1560 if (GET_CODE (insn
) != CALL_INSN
)
1566 if (GET_CODE (datum
) != REG
)
1570 for (link
= CALL_INSN_FUNCTION_USAGE (insn
);
1572 link
= XEXP (link
, 1))
1573 if (GET_CODE (XEXP (link
, 0)) == code
1574 && rtx_equal_p (datum
, SET_DEST (XEXP (link
, 0))))
1579 unsigned int regno
= REGNO (datum
);
1581 /* CALL_INSN_FUNCTION_USAGE information cannot contain references
1582 to pseudo registers, so don't bother checking. */
1584 if (regno
< FIRST_PSEUDO_REGISTER
)
1586 unsigned int end_regno
1587 = regno
+ HARD_REGNO_NREGS (regno
, GET_MODE (datum
));
1590 for (i
= regno
; i
< end_regno
; i
++)
1591 if (find_regno_fusage (insn
, code
, i
))
1599 /* Return true if REGNO, or any overlap of REGNO, of kind CODE is found
1600 in the CALL_INSN_FUNCTION_USAGE information of INSN. */
1603 find_regno_fusage (insn
, code
, regno
)
1610 /* CALL_INSN_FUNCTION_USAGE information cannot contain references
1611 to pseudo registers, so don't bother checking. */
1613 if (regno
>= FIRST_PSEUDO_REGISTER
1614 || GET_CODE (insn
) != CALL_INSN
)
1617 for (link
= CALL_INSN_FUNCTION_USAGE (insn
); link
; link
= XEXP (link
, 1))
1619 unsigned int regnote
;
1622 if (GET_CODE (op
= XEXP (link
, 0)) == code
1623 && GET_CODE (reg
= XEXP (op
, 0)) == REG
1624 && (regnote
= REGNO (reg
)) <= regno
1625 && regnote
+ HARD_REGNO_NREGS (regnote
, GET_MODE (reg
)) > regno
)
1632 /* Remove register note NOTE from the REG_NOTES of INSN. */
1635 remove_note (insn
, note
)
1641 if (note
== NULL_RTX
)
1644 if (REG_NOTES (insn
) == note
)
1646 REG_NOTES (insn
) = XEXP (note
, 1);
1650 for (link
= REG_NOTES (insn
); link
; link
= XEXP (link
, 1))
1651 if (XEXP (link
, 1) == note
)
1653 XEXP (link
, 1) = XEXP (note
, 1);
1660 /* Search LISTP (an EXPR_LIST) for NODE and remove NODE from the list
1663 A simple equality test is used to determine if NODE is on the
1667 remove_node_from_expr_list (node
, listp
)
1672 rtx prev
= NULL_RTX
;
1676 if (node
== XEXP (temp
, 0))
1678 /* Splice the node out of the list. */
1680 XEXP (prev
, 1) = XEXP (temp
, 1);
1682 *listp
= XEXP (temp
, 1);
1686 temp
= XEXP (temp
, 1);
1690 /* Nonzero if X contains any volatile instructions. These are instructions
1691 which may cause unpredictable machine state instructions, and thus no
1692 instructions should be moved or combined across them. This includes
1693 only volatile asms and UNSPEC_VOLATILE instructions. */
1699 register RTX_CODE code
;
1701 code
= GET_CODE (x
);
1721 case UNSPEC_VOLATILE
:
1722 /* case TRAP_IF: This isn't clear yet. */
1726 if (MEM_VOLATILE_P (x
))
1733 /* Recursively scan the operands of this expression. */
1736 register const char *fmt
= GET_RTX_FORMAT (code
);
1739 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
1743 if (volatile_insn_p (XEXP (x
, i
)))
1746 else if (fmt
[i
] == 'E')
1749 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
1750 if (volatile_insn_p (XVECEXP (x
, i
, j
)))
1758 /* Nonzero if X contains any volatile memory references
1759 UNSPEC_VOLATILE operations or volatile ASM_OPERANDS expressions. */
1765 register RTX_CODE code
;
1767 code
= GET_CODE (x
);
1786 case UNSPEC_VOLATILE
:
1787 /* case TRAP_IF: This isn't clear yet. */
1792 if (MEM_VOLATILE_P (x
))
1799 /* Recursively scan the operands of this expression. */
1802 register const char *fmt
= GET_RTX_FORMAT (code
);
1805 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
1809 if (volatile_refs_p (XEXP (x
, i
)))
1812 else if (fmt
[i
] == 'E')
1815 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
1816 if (volatile_refs_p (XVECEXP (x
, i
, j
)))
1824 /* Similar to above, except that it also rejects register pre- and post-
1831 register RTX_CODE code
;
1833 code
= GET_CODE (x
);
1851 /* Reject CLOBBER with a non-VOID mode. These are made by combine.c
1852 when some combination can't be done. If we see one, don't think
1853 that we can simplify the expression. */
1854 return (GET_MODE (x
) != VOIDmode
);
1863 case UNSPEC_VOLATILE
:
1864 /* case TRAP_IF: This isn't clear yet. */
1869 if (MEM_VOLATILE_P (x
))
1876 /* Recursively scan the operands of this expression. */
1879 register const char *fmt
= GET_RTX_FORMAT (code
);
1882 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
1886 if (side_effects_p (XEXP (x
, i
)))
1889 else if (fmt
[i
] == 'E')
1892 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
1893 if (side_effects_p (XVECEXP (x
, i
, j
)))
1901 /* Return nonzero if evaluating rtx X might cause a trap. */
1913 code
= GET_CODE (x
);
1916 /* Handle these cases quickly. */
1929 case UNSPEC_VOLATILE
:
1934 return MEM_VOLATILE_P (x
);
1936 /* Memory ref can trap unless it's a static var or a stack slot. */
1938 return rtx_addr_can_trap_p (XEXP (x
, 0));
1940 /* Division by a non-constant might trap. */
1945 if (! CONSTANT_P (XEXP (x
, 1))
1946 || GET_MODE_CLASS (GET_MODE (x
)) == MODE_FLOAT
)
1948 /* This was const0_rtx, but by not using that,
1949 we can link this file into other programs. */
1950 if (GET_CODE (XEXP (x
, 1)) == CONST_INT
&& INTVAL (XEXP (x
, 1)) == 0)
1955 /* An EXPR_LIST is used to represent a function call. This
1956 certainly may trap. */
1964 /* Some floating point comparisons may trap. */
1965 /* ??? There is no machine independent way to check for tests that trap
1966 when COMPARE is used, though many targets do make this distinction.
1967 For instance, sparc uses CCFPE for compares which generate exceptions
1968 and CCFP for compares which do not generate exceptions. */
1969 if (GET_MODE_CLASS (GET_MODE (x
)) == MODE_FLOAT
)
1971 /* But often the compare has some CC mode, so check operand
1973 if (GET_MODE_CLASS (GET_MODE (XEXP (x
, 0))) == MODE_FLOAT
1974 || GET_MODE_CLASS (GET_MODE (XEXP (x
, 1))) == MODE_FLOAT
)
1979 /* Any floating arithmetic may trap. */
1980 if (GET_MODE_CLASS (GET_MODE (x
)) == MODE_FLOAT
)
1984 fmt
= GET_RTX_FORMAT (code
);
1985 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
1989 if (may_trap_p (XEXP (x
, i
)))
1992 else if (fmt
[i
] == 'E')
1995 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
1996 if (may_trap_p (XVECEXP (x
, i
, j
)))
2003 /* Return nonzero if X contains a comparison that is not either EQ or NE,
2004 i.e., an inequality. */
2007 inequality_comparisons_p (x
)
2010 register const char *fmt
;
2011 register int len
, i
;
2012 register enum rtx_code code
= GET_CODE (x
);
2041 len
= GET_RTX_LENGTH (code
);
2042 fmt
= GET_RTX_FORMAT (code
);
2044 for (i
= 0; i
< len
; i
++)
2048 if (inequality_comparisons_p (XEXP (x
, i
)))
2051 else if (fmt
[i
] == 'E')
2054 for (j
= XVECLEN (x
, i
) - 1; j
>= 0; j
--)
2055 if (inequality_comparisons_p (XVECEXP (x
, i
, j
)))
2063 /* Replace any occurrence of FROM in X with TO. The function does
2064 not enter into CONST_DOUBLE for the replace.
2066 Note that copying is not done so X must not be shared unless all copies
2067 are to be modified. */
2070 replace_rtx (x
, from
, to
)
2074 register const char *fmt
;
2076 /* The following prevents loops occurrence when we change MEM in
2077 CONST_DOUBLE onto the same CONST_DOUBLE. */
2078 if (x
!= 0 && GET_CODE (x
) == CONST_DOUBLE
)
2084 /* Allow this function to make replacements in EXPR_LISTs. */
2088 fmt
= GET_RTX_FORMAT (GET_CODE (x
));
2089 for (i
= GET_RTX_LENGTH (GET_CODE (x
)) - 1; i
>= 0; i
--)
2092 XEXP (x
, i
) = replace_rtx (XEXP (x
, i
), from
, to
);
2093 else if (fmt
[i
] == 'E')
2094 for (j
= XVECLEN (x
, i
) - 1; j
>= 0; j
--)
2095 XVECEXP (x
, i
, j
) = replace_rtx (XVECEXP (x
, i
, j
), from
, to
);
2101 /* Throughout the rtx X, replace many registers according to REG_MAP.
2102 Return the replacement for X (which may be X with altered contents).
2103 REG_MAP[R] is the replacement for register R, or 0 for don't replace.
2104 NREGS is the length of REG_MAP; regs >= NREGS are not mapped.
2106 We only support REG_MAP entries of REG or SUBREG. Also, hard registers
2107 should not be mapped to pseudos or vice versa since validate_change
2110 If REPLACE_DEST is 1, replacements are also done in destinations;
2111 otherwise, only sources are replaced. */
2114 replace_regs (x
, reg_map
, nregs
, replace_dest
)
2120 register enum rtx_code code
;
2122 register const char *fmt
;
2127 code
= GET_CODE (x
);
2141 /* Verify that the register has an entry before trying to access it. */
2142 if (REGNO (x
) < nregs
&& reg_map
[REGNO (x
)] != 0)
2144 /* SUBREGs can't be shared. Always return a copy to ensure that if
2145 this replacement occurs more than once then each instance will
2146 get distinct rtx. */
2147 if (GET_CODE (reg_map
[REGNO (x
)]) == SUBREG
)
2148 return copy_rtx (reg_map
[REGNO (x
)]);
2149 return reg_map
[REGNO (x
)];
2154 /* Prevent making nested SUBREGs. */
2155 if (GET_CODE (SUBREG_REG (x
)) == REG
&& REGNO (SUBREG_REG (x
)) < nregs
2156 && reg_map
[REGNO (SUBREG_REG (x
))] != 0
2157 && GET_CODE (reg_map
[REGNO (SUBREG_REG (x
))]) == SUBREG
)
2159 rtx map_val
= reg_map
[REGNO (SUBREG_REG (x
))];
2160 rtx map_inner
= SUBREG_REG (map_val
);
2162 if (GET_MODE (x
) == GET_MODE (map_inner
))
2166 /* We cannot call gen_rtx here since we may be linked with
2168 /* Let's try clobbering the incoming SUBREG and see
2169 if this is really safe. */
2170 SUBREG_REG (x
) = map_inner
;
2171 SUBREG_WORD (x
) += SUBREG_WORD (map_val
);
2174 rtx
new = rtx_alloc (SUBREG
);
2175 PUT_MODE (new, GET_MODE (x
));
2176 SUBREG_REG (new) = map_inner
;
2177 SUBREG_WORD (new) = SUBREG_WORD (x
) + SUBREG_WORD (map_val
);
2185 SET_DEST (x
) = replace_regs (SET_DEST (x
), reg_map
, nregs
, 0);
2187 else if (GET_CODE (SET_DEST (x
)) == MEM
2188 || GET_CODE (SET_DEST (x
)) == STRICT_LOW_PART
)
2189 /* Even if we are not to replace destinations, replace register if it
2190 is CONTAINED in destination (destination is memory or
2191 STRICT_LOW_PART). */
2192 XEXP (SET_DEST (x
), 0) = replace_regs (XEXP (SET_DEST (x
), 0),
2194 else if (GET_CODE (SET_DEST (x
)) == ZERO_EXTRACT
)
2195 /* Similarly, for ZERO_EXTRACT we replace all operands. */
2198 SET_SRC (x
) = replace_regs (SET_SRC (x
), reg_map
, nregs
, 0);
2205 fmt
= GET_RTX_FORMAT (code
);
2206 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
2209 XEXP (x
, i
) = replace_regs (XEXP (x
, i
), reg_map
, nregs
, replace_dest
);
2210 else if (fmt
[i
] == 'E')
2213 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
2214 XVECEXP (x
, i
, j
) = replace_regs (XVECEXP (x
, i
, j
), reg_map
,
2215 nregs
, replace_dest
);
2221 /* Return 1 if X, the SRC_SRC of SET of (pc) contain a REG or MEM that is
2222 not in the constant pool and not in the condition of an IF_THEN_ELSE. */
2225 jmp_uses_reg_or_mem (x
)
2228 enum rtx_code code
= GET_CODE (x
);
2243 return ! (GET_CODE (XEXP (x
, 0)) == SYMBOL_REF
2244 && CONSTANT_POOL_ADDRESS_P (XEXP (x
, 0)));
2247 return (jmp_uses_reg_or_mem (XEXP (x
, 1))
2248 || jmp_uses_reg_or_mem (XEXP (x
, 2)));
2250 case PLUS
: case MINUS
: case MULT
:
2251 return (jmp_uses_reg_or_mem (XEXP (x
, 0))
2252 || jmp_uses_reg_or_mem (XEXP (x
, 1)));
2258 fmt
= GET_RTX_FORMAT (code
);
2259 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
2262 && jmp_uses_reg_or_mem (XEXP (x
, i
)))
2265 else if (fmt
[i
] == 'E')
2266 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
2267 if (jmp_uses_reg_or_mem (XVECEXP (x
, i
, j
)))
2274 /* Return nonzero if INSN is an indirect jump (aka computed jump).
2276 Tablejumps and casesi insns are not considered indirect jumps;
2277 we can recognize them by a (use (label_ref)). */
2280 computed_jump_p (insn
)
2284 if (GET_CODE (insn
) == JUMP_INSN
)
2286 rtx pat
= PATTERN (insn
);
2288 if (GET_CODE (pat
) == PARALLEL
)
2290 int len
= XVECLEN (pat
, 0);
2291 int has_use_labelref
= 0;
2293 for (i
= len
- 1; i
>= 0; i
--)
2294 if (GET_CODE (XVECEXP (pat
, 0, i
)) == USE
2295 && (GET_CODE (XEXP (XVECEXP (pat
, 0, i
), 0))
2297 has_use_labelref
= 1;
2299 if (! has_use_labelref
)
2300 for (i
= len
- 1; i
>= 0; i
--)
2301 if (GET_CODE (XVECEXP (pat
, 0, i
)) == SET
2302 && SET_DEST (XVECEXP (pat
, 0, i
)) == pc_rtx
2303 && jmp_uses_reg_or_mem (SET_SRC (XVECEXP (pat
, 0, i
))))
2306 else if (GET_CODE (pat
) == SET
2307 && SET_DEST (pat
) == pc_rtx
2308 && jmp_uses_reg_or_mem (SET_SRC (pat
)))
2314 /* Traverse X via depth-first search, calling F for each
2315 sub-expression (including X itself). F is also passed the DATA.
2316 If F returns -1, do not traverse sub-expressions, but continue
2317 traversing the rest of the tree. If F ever returns any other
2318 non-zero value, stop the traversal, and return the value returned
2319 by F. Otherwise, return 0. This function does not traverse inside
2320 tree structure that contains RTX_EXPRs, or into sub-expressions
2321 whose format code is `0' since it is not known whether or not those
2322 codes are actually RTL.
2324 This routine is very general, and could (should?) be used to
2325 implement many of the other routines in this file. */
2328 for_each_rtx (x
, f
, data
)
2339 result
= (*f
)(x
, data
);
2341 /* Do not traverse sub-expressions. */
2343 else if (result
!= 0)
2344 /* Stop the traversal. */
2348 /* There are no sub-expressions. */
2351 length
= GET_RTX_LENGTH (GET_CODE (*x
));
2352 format
= GET_RTX_FORMAT (GET_CODE (*x
));
2354 for (i
= 0; i
< length
; ++i
)
2359 result
= for_each_rtx (&XEXP (*x
, i
), f
, data
);
2366 if (XVEC (*x
, i
) != 0)
2369 for (j
= 0; j
< XVECLEN (*x
, i
); ++j
)
2371 result
= for_each_rtx (&XVECEXP (*x
, i
, j
), f
, data
);
2379 /* Nothing to do. */
2388 /* Searches X for any reference to REGNO, returning the rtx of the
2389 reference found if any. Otherwise, returns NULL_RTX. */
2392 regno_use_in (regno
, x
)
2396 register const char *fmt
;
2400 if (GET_CODE (x
) == REG
&& REGNO (x
) == regno
)
2403 fmt
= GET_RTX_FORMAT (GET_CODE (x
));
2404 for (i
= GET_RTX_LENGTH (GET_CODE (x
)) - 1; i
>= 0; i
--)
2408 if ((tem
= regno_use_in (regno
, XEXP (x
, i
))))
2411 else if (fmt
[i
] == 'E')
2412 for (j
= XVECLEN (x
, i
) - 1; j
>= 0; j
--)
2413 if ((tem
= regno_use_in (regno
, XVECEXP (x
, i
, j
))))
2421 /* Return 1 if X is an autoincrement side effect and the register is
2422 not the stack pointer. */
2427 switch (GET_CODE (x
))
2435 /* There are no REG_INC notes for SP. */
2436 if (XEXP (x
, 0) != stack_pointer_rtx
)
2444 /* Return 1 if the sequence of instructions beginning with FROM and up
2445 to and including TO is safe to move. If NEW_TO is non-NULL, and
2446 the sequence is not already safe to move, but can be easily
2447 extended to a sequence which is safe, then NEW_TO will point to the
2448 end of the extended sequence.
2450 For now, this function only checks that the region contains whole
2451 exception regiongs, but it could be extended to check additional
2452 conditions as well. */
2455 insns_safe_to_move_p (from
, to
, new_to
)
2460 int eh_region_count
= 0;
2464 /* By default, assume the end of the region will be what was
2471 if (GET_CODE (r
) == NOTE
)
2473 switch (NOTE_LINE_NUMBER (r
))
2475 case NOTE_INSN_EH_REGION_BEG
:
2479 case NOTE_INSN_EH_REGION_END
:
2480 if (eh_region_count
== 0)
2481 /* This sequence of instructions contains the end of
2482 an exception region, but not he beginning. Moving
2483 it will cause chaos. */
2494 /* If we've passed TO, and we see a non-note instruction, we
2495 can't extend the sequence to a movable sequence. */
2501 /* It's OK to move the sequence if there were matched sets of
2502 exception region notes. */
2503 return eh_region_count
== 0;
2508 /* It's OK to move the sequence if there were matched sets of
2509 exception region notes. */
2510 if (past_to_p
&& eh_region_count
== 0)
2516 /* Go to the next instruction. */
2523 /* Return non-zero if IN contains a piece of rtl that has the address LOC */
2525 loc_mentioned_in_p (loc
, in
)
2528 enum rtx_code code
= GET_CODE (in
);
2529 const char *fmt
= GET_RTX_FORMAT (code
);
2532 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
2534 if (loc
== &in
->fld
[i
].rtx
)
2538 if (loc_mentioned_in_p (loc
, XEXP (in
, i
)))
2541 else if (fmt
[i
] == 'E')
2542 for (j
= XVECLEN (in
, i
) - 1; j
>= 0; j
--)
2543 if (loc_mentioned_in_p (loc
, XVECEXP (in
, i
, j
)))