1 /* Analyze RTL for C-Compiler
2 Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001 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 #include "hard-reg-set.h"
29 static void set_of_1
PARAMS ((rtx
, rtx
, void *));
30 static void insn_dependent_p_1
PARAMS ((rtx
, rtx
, void *));
32 /* Forward declarations */
33 static int computed_jump_p_1
PARAMS ((rtx
));
35 /* Bit flags that specify the machine subtype we are compiling for.
36 Bits are tested using macros TARGET_... defined in the tm.h file
37 and set by `-m...' switches. Must be defined in rtlanal.c. */
41 /* Return 1 if the value of X is unstable
42 (would be different at a different point in the program).
43 The frame pointer, arg pointer, etc. are considered stable
44 (within one function) and so is anything marked `unchanging'. */
50 register RTX_CODE code
= GET_CODE (x
);
52 register const char *fmt
;
57 return ! RTX_UNCHANGING_P (x
) || rtx_unstable_p (XEXP (x
, 0));
70 /* As in rtx_varies_p, we have to use the actual rtx, not reg number. */
71 if (x
== frame_pointer_rtx
|| x
== hard_frame_pointer_rtx
72 /* The arg pointer varies if it is not a fixed register. */
73 || (x
== arg_pointer_rtx
&& fixed_regs
[ARG_POINTER_REGNUM
])
74 || RTX_UNCHANGING_P (x
))
76 #ifndef PIC_OFFSET_TABLE_REG_CALL_CLOBBERED
77 /* ??? When call-clobbered, the value is stable modulo the restore
78 that must happen after a call. This currently screws up local-alloc
79 into believing that the restore is not needed. */
80 if (x
== pic_offset_table_rtx
)
86 if (MEM_VOLATILE_P (x
))
95 fmt
= GET_RTX_FORMAT (code
);
96 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
99 if (rtx_unstable_p (XEXP (x
, i
)))
102 else if (fmt
[i
] == 'E')
105 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
106 if (rtx_unstable_p (XVECEXP (x
, i
, j
)))
113 /* Return 1 if X has a value that can vary even between two
114 executions of the program. 0 means X can be compared reliably
115 against certain constants or near-constants.
116 FOR_ALIAS is nonzero if we are called from alias analysis; if it is
117 zero, we are slightly more conservative.
118 The frame pointer and the arg pointer are considered constant. */
121 rtx_varies_p (x
, for_alias
)
125 register RTX_CODE code
= GET_CODE (x
);
127 register const char *fmt
;
132 return ! RTX_UNCHANGING_P (x
) || rtx_varies_p (XEXP (x
, 0), for_alias
);
145 /* Note that we have to test for the actual rtx used for the frame
146 and arg pointers and not just the register number in case we have
147 eliminated the frame and/or arg pointer and are using it
149 if (x
== frame_pointer_rtx
|| x
== hard_frame_pointer_rtx
150 /* The arg pointer varies if it is not a fixed register. */
151 || (x
== arg_pointer_rtx
&& fixed_regs
[ARG_POINTER_REGNUM
]))
153 if (x
== pic_offset_table_rtx
154 #ifdef PIC_OFFSET_TABLE_REG_CALL_CLOBBERED
155 /* ??? When call-clobbered, the value is stable modulo the restore
156 that must happen after a call. This currently screws up
157 local-alloc into believing that the restore is not needed, so we
158 must return 0 only if we are called from alias analysis. */
166 /* The operand 0 of a LO_SUM is considered constant
167 (in fact it is related specifically to operand 1)
168 during alias analysis. */
169 return (! for_alias
&& rtx_varies_p (XEXP (x
, 0), for_alias
))
170 || rtx_varies_p (XEXP (x
, 1), for_alias
);
173 if (MEM_VOLATILE_P (x
))
182 fmt
= GET_RTX_FORMAT (code
);
183 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
186 if (rtx_varies_p (XEXP (x
, i
), for_alias
))
189 else if (fmt
[i
] == 'E')
192 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
193 if (rtx_varies_p (XVECEXP (x
, i
, j
), for_alias
))
200 /* Return 0 if the use of X as an address in a MEM can cause a trap. */
203 rtx_addr_can_trap_p (x
)
206 register enum rtx_code code
= GET_CODE (x
);
211 return SYMBOL_REF_WEAK (x
);
217 /* As in rtx_varies_p, we have to use the actual rtx, not reg number. */
218 if (x
== frame_pointer_rtx
|| x
== hard_frame_pointer_rtx
219 || x
== stack_pointer_rtx
220 /* The arg pointer varies if it is not a fixed register. */
221 || (x
== arg_pointer_rtx
&& fixed_regs
[ARG_POINTER_REGNUM
]))
223 /* All of the virtual frame registers are stack references. */
224 if (REGNO (x
) >= FIRST_VIRTUAL_REGISTER
225 && REGNO (x
) <= LAST_VIRTUAL_REGISTER
)
230 return rtx_addr_can_trap_p (XEXP (x
, 0));
233 /* An address is assumed not to trap if it is an address that can't
234 trap plus a constant integer or it is the pic register plus a
236 return ! ((! rtx_addr_can_trap_p (XEXP (x
, 0))
237 && GET_CODE (XEXP (x
, 1)) == CONST_INT
)
238 || (XEXP (x
, 0) == pic_offset_table_rtx
239 && CONSTANT_P (XEXP (x
, 1))));
243 return rtx_addr_can_trap_p (XEXP (x
, 1));
250 return rtx_addr_can_trap_p (XEXP (x
, 0));
256 /* If it isn't one of the case above, it can cause a trap. */
260 /* Return 1 if X refers to a memory location whose address
261 cannot be compared reliably with constant addresses,
262 or if X refers to a BLKmode memory object.
263 FOR_ALIAS is nonzero if we are called from alias analysis; if it is
264 zero, we are slightly more conservative. */
267 rtx_addr_varies_p (x
, for_alias
)
271 register enum rtx_code code
;
273 register const char *fmt
;
280 return GET_MODE (x
) == BLKmode
|| rtx_varies_p (XEXP (x
, 0), for_alias
);
282 fmt
= GET_RTX_FORMAT (code
);
283 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
286 if (rtx_addr_varies_p (XEXP (x
, i
), for_alias
))
289 else if (fmt
[i
] == 'E')
292 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
293 if (rtx_addr_varies_p (XVECEXP (x
, i
, j
), for_alias
))
299 /* Return the value of the integer term in X, if one is apparent;
301 Only obvious integer terms are detected.
302 This is used in cse.c with the `related_value' field.*/
308 if (GET_CODE (x
) == CONST
)
311 if (GET_CODE (x
) == MINUS
312 && GET_CODE (XEXP (x
, 1)) == CONST_INT
)
313 return - INTVAL (XEXP (x
, 1));
314 if (GET_CODE (x
) == PLUS
315 && GET_CODE (XEXP (x
, 1)) == CONST_INT
)
316 return INTVAL (XEXP (x
, 1));
320 /* If X is a constant, return the value sans apparent integer term;
322 Only obvious integer terms are detected. */
325 get_related_value (x
)
328 if (GET_CODE (x
) != CONST
)
331 if (GET_CODE (x
) == PLUS
332 && GET_CODE (XEXP (x
, 1)) == CONST_INT
)
334 else if (GET_CODE (x
) == MINUS
335 && GET_CODE (XEXP (x
, 1)) == CONST_INT
)
340 /* Return the number of places FIND appears within X. If COUNT_DEST is
341 zero, we do not count occurrences inside the destination of a SET. */
344 count_occurrences (x
, find
, count_dest
)
350 const char *format_ptr
;
370 if (GET_CODE (find
) == MEM
&& rtx_equal_p (x
, find
))
375 if (SET_DEST (x
) == find
&& ! count_dest
)
376 return count_occurrences (SET_SRC (x
), find
, count_dest
);
383 format_ptr
= GET_RTX_FORMAT (code
);
386 for (i
= 0; i
< GET_RTX_LENGTH (code
); i
++)
388 switch (*format_ptr
++)
391 count
+= count_occurrences (XEXP (x
, i
), find
, count_dest
);
395 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
396 count
+= count_occurrences (XVECEXP (x
, i
, j
), find
, count_dest
);
403 /* Nonzero if register REG appears somewhere within IN.
404 Also works if REG is not a register; in this case it checks
405 for a subexpression of IN that is Lisp "equal" to REG. */
408 reg_mentioned_p (reg
, in
)
409 register rtx reg
, in
;
411 register const char *fmt
;
413 register enum rtx_code code
;
421 if (GET_CODE (in
) == LABEL_REF
)
422 return reg
== XEXP (in
, 0);
424 code
= GET_CODE (in
);
428 /* Compare registers by number. */
430 return GET_CODE (reg
) == REG
&& REGNO (in
) == REGNO (reg
);
432 /* These codes have no constituent expressions
440 return GET_CODE (reg
) == CONST_INT
&& INTVAL (in
) == INTVAL (reg
);
443 /* These are kept unique for a given value. */
450 if (GET_CODE (reg
) == code
&& rtx_equal_p (reg
, in
))
453 fmt
= GET_RTX_FORMAT (code
);
455 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
460 for (j
= XVECLEN (in
, i
) - 1; j
>= 0; j
--)
461 if (reg_mentioned_p (reg
, XVECEXP (in
, i
, j
)))
464 else if (fmt
[i
] == 'e'
465 && reg_mentioned_p (reg
, XEXP (in
, i
)))
471 /* Return 1 if in between BEG and END, exclusive of BEG and END, there is
472 no CODE_LABEL insn. */
475 no_labels_between_p (beg
, end
)
479 for (p
= NEXT_INSN (beg
); p
!= end
; p
= NEXT_INSN (p
))
480 if (GET_CODE (p
) == CODE_LABEL
)
485 /* Return 1 if in between BEG and END, exclusive of BEG and END, there is
486 no JUMP_INSN insn. */
489 no_jumps_between_p (beg
, end
)
493 for (p
= NEXT_INSN (beg
); p
!= end
; p
= NEXT_INSN (p
))
494 if (GET_CODE (p
) == JUMP_INSN
)
499 /* Nonzero if register REG is used in an insn between
500 FROM_INSN and TO_INSN (exclusive of those two). */
503 reg_used_between_p (reg
, from_insn
, to_insn
)
504 rtx reg
, from_insn
, to_insn
;
508 if (from_insn
== to_insn
)
511 for (insn
= NEXT_INSN (from_insn
); insn
!= to_insn
; insn
= NEXT_INSN (insn
))
513 && (reg_overlap_mentioned_p (reg
, PATTERN (insn
))
514 || (GET_CODE (insn
) == CALL_INSN
515 && (find_reg_fusage (insn
, USE
, reg
)
516 || find_reg_fusage (insn
, CLOBBER
, reg
)))))
521 /* Nonzero if the old value of X, a register, is referenced in BODY. If X
522 is entirely replaced by a new value and the only use is as a SET_DEST,
523 we do not consider it a reference. */
526 reg_referenced_p (x
, body
)
532 switch (GET_CODE (body
))
535 if (reg_overlap_mentioned_p (x
, SET_SRC (body
)))
538 /* If the destination is anything other than CC0, PC, a REG or a SUBREG
539 of a REG that occupies all of the REG, the insn references X if
540 it is mentioned in the destination. */
541 if (GET_CODE (SET_DEST (body
)) != CC0
542 && GET_CODE (SET_DEST (body
)) != PC
543 && GET_CODE (SET_DEST (body
)) != REG
544 && ! (GET_CODE (SET_DEST (body
)) == SUBREG
545 && GET_CODE (SUBREG_REG (SET_DEST (body
))) == REG
546 && (((GET_MODE_SIZE (GET_MODE (SUBREG_REG (SET_DEST (body
))))
547 + (UNITS_PER_WORD
- 1)) / UNITS_PER_WORD
)
548 == ((GET_MODE_SIZE (GET_MODE (SET_DEST (body
)))
549 + (UNITS_PER_WORD
- 1)) / UNITS_PER_WORD
)))
550 && reg_overlap_mentioned_p (x
, SET_DEST (body
)))
555 for (i
= ASM_OPERANDS_INPUT_LENGTH (body
) - 1; i
>= 0; i
--)
556 if (reg_overlap_mentioned_p (x
, ASM_OPERANDS_INPUT (body
, i
)))
563 return reg_overlap_mentioned_p (x
, body
);
566 return reg_overlap_mentioned_p (x
, TRAP_CONDITION (body
));
569 case UNSPEC_VOLATILE
:
570 for (i
= XVECLEN (body
, 0) - 1; i
>= 0; i
--)
571 if (reg_overlap_mentioned_p (x
, XVECEXP (body
, 0, i
)))
576 for (i
= XVECLEN (body
, 0) - 1; i
>= 0; i
--)
577 if (reg_referenced_p (x
, XVECEXP (body
, 0, i
)))
582 if (GET_CODE (XEXP (body
, 0)) == MEM
)
583 if (reg_overlap_mentioned_p (x
, XEXP (XEXP (body
, 0), 0)))
588 if (reg_overlap_mentioned_p (x
, COND_EXEC_TEST (body
)))
590 return reg_referenced_p (x
, COND_EXEC_CODE (body
));
597 /* Nonzero if register REG is referenced in an insn between
598 FROM_INSN and TO_INSN (exclusive of those two). Sets of REG do
602 reg_referenced_between_p (reg
, from_insn
, to_insn
)
603 rtx reg
, from_insn
, to_insn
;
607 if (from_insn
== to_insn
)
610 for (insn
= NEXT_INSN (from_insn
); insn
!= to_insn
; insn
= NEXT_INSN (insn
))
612 && (reg_referenced_p (reg
, PATTERN (insn
))
613 || (GET_CODE (insn
) == CALL_INSN
614 && find_reg_fusage (insn
, USE
, reg
))))
619 /* Nonzero if register REG is set or clobbered in an insn between
620 FROM_INSN and TO_INSN (exclusive of those two). */
623 reg_set_between_p (reg
, from_insn
, to_insn
)
624 rtx reg
, from_insn
, to_insn
;
628 if (from_insn
== to_insn
)
631 for (insn
= NEXT_INSN (from_insn
); insn
!= to_insn
; insn
= NEXT_INSN (insn
))
632 if (INSN_P (insn
) && reg_set_p (reg
, insn
))
637 /* Internals of reg_set_between_p. */
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
);
665 return set_of (reg
, insn
) != NULL_RTX
;
668 /* Similar to reg_set_between_p, but check all registers in X. Return 0
669 only if none of them are modified between START and END. Do not
670 consider non-registers one way or the other. */
673 regs_set_between_p (x
, start
, end
)
677 enum rtx_code code
= GET_CODE (x
);
693 return reg_set_between_p (x
, start
, end
);
699 fmt
= GET_RTX_FORMAT (code
);
700 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
702 if (fmt
[i
] == 'e' && regs_set_between_p (XEXP (x
, i
), start
, end
))
705 else if (fmt
[i
] == 'E')
706 for (j
= XVECLEN (x
, i
) - 1; j
>= 0; j
--)
707 if (regs_set_between_p (XVECEXP (x
, i
, j
), start
, end
))
714 /* Similar to reg_set_between_p, but check all registers in X. Return 0
715 only if none of them are modified between START and END. Return 1 if
716 X contains a MEM; this routine does not perform any memory aliasing. */
719 modified_between_p (x
, start
, end
)
723 enum rtx_code code
= GET_CODE (x
);
741 /* If the memory is not constant, assume it is modified. If it is
742 constant, we still have to check the address. */
743 if (! RTX_UNCHANGING_P (x
))
748 return reg_set_between_p (x
, start
, end
);
754 fmt
= GET_RTX_FORMAT (code
);
755 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
757 if (fmt
[i
] == 'e' && modified_between_p (XEXP (x
, i
), start
, end
))
760 else if (fmt
[i
] == 'E')
761 for (j
= XVECLEN (x
, i
) - 1; j
>= 0; j
--)
762 if (modified_between_p (XVECEXP (x
, i
, j
), start
, end
))
769 /* Similar to reg_set_p, but check all registers in X. Return 0 only if none
770 of them are modified in INSN. Return 1 if X contains a MEM; this routine
771 does not perform any memory aliasing. */
774 modified_in_p (x
, insn
)
778 enum rtx_code code
= GET_CODE (x
);
796 /* If the memory is not constant, assume it is modified. If it is
797 constant, we still have to check the address. */
798 if (! RTX_UNCHANGING_P (x
))
803 return reg_set_p (x
, insn
);
809 fmt
= GET_RTX_FORMAT (code
);
810 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
812 if (fmt
[i
] == 'e' && modified_in_p (XEXP (x
, i
), insn
))
815 else if (fmt
[i
] == 'E')
816 for (j
= XVECLEN (x
, i
) - 1; j
>= 0; j
--)
817 if (modified_in_p (XVECEXP (x
, i
, j
), insn
))
824 /* Return true if anything in insn X is (anti,output,true) dependent on
825 anything in insn Y. */
828 insn_dependent_p (x
, y
)
833 if (! INSN_P (x
) || ! INSN_P (y
))
837 note_stores (PATTERN (x
), insn_dependent_p_1
, &tmp
);
842 note_stores (PATTERN (y
), insn_dependent_p_1
, &tmp
);
849 /* A helper routine for insn_dependent_p called through note_stores. */
852 insn_dependent_p_1 (x
, pat
, data
)
854 rtx pat ATTRIBUTE_UNUSED
;
857 rtx
* pinsn
= (rtx
*) data
;
859 if (*pinsn
&& reg_mentioned_p (x
, *pinsn
))
863 /* Helper function for set_of. */
871 set_of_1 (x
, pat
, data1
)
876 struct set_of_data
*data
= (struct set_of_data
*) (data1
);
877 if (rtx_equal_p (x
, data
->pat
)
878 || (GET_CODE (x
) != MEM
&& reg_overlap_mentioned_p (data
->pat
, x
)))
882 /* Give an INSN, return a SET or CLOBBER expression that does modify PAT
883 (eighter directly or via STRICT_LOW_PART and similar modifiers). */
888 struct set_of_data data
;
889 data
.found
= NULL_RTX
;
891 note_stores (INSN_P (insn
) ? PATTERN (insn
) : insn
, set_of_1
, &data
);
895 /* Given an INSN, return a SET expression if this insn has only a single SET.
896 It may also have CLOBBERs, USEs, or SET whose output
897 will not be used, which we ignore. */
900 single_set_2 (insn
, pat
)
904 int set_verified
= 1;
907 if (GET_CODE (pat
) == PARALLEL
)
909 for (i
= 0; i
< XVECLEN (pat
, 0); i
++)
911 rtx sub
= XVECEXP (pat
, 0, i
);
912 switch (GET_CODE (sub
))
919 /* We can consider insns having multiple sets, where all
920 but one are dead as single set insns. In common case
921 only single set is present in the pattern so we want
922 to avoid checking for REG_UNUSED notes unless neccesary.
924 When we reach set first time, we just expect this is
925 the single set we are looking for and only when more
926 sets are found in the insn, we check them. */
929 if (find_reg_note (insn
, REG_UNUSED
, SET_DEST (set
))
930 && !side_effects_p (set
))
936 set
= sub
, set_verified
= 0;
937 else if (!find_reg_note (insn
, REG_UNUSED
, SET_DEST (sub
))
938 || side_effects_p (sub
))
950 /* Given an INSN, return nonzero if it has more than one SET, else return
960 /* INSN must be an insn. */
964 /* Only a PARALLEL can have multiple SETs. */
965 if (GET_CODE (PATTERN (insn
)) == PARALLEL
)
967 for (i
= 0, found
= 0; i
< XVECLEN (PATTERN (insn
), 0); i
++)
968 if (GET_CODE (XVECEXP (PATTERN (insn
), 0, i
)) == SET
)
970 /* If we have already found a SET, then return now. */
978 /* Either zero or one SET. */
982 /* Return the last thing that X was assigned from before *PINSN. If VALID_TO
983 is not NULL_RTX then verify that the object is not modified up to VALID_TO.
984 If the object was modified, if we hit a partial assignment to X, or hit a
985 CODE_LABEL first, return X. If we found an assignment, update *PINSN to
986 point to it. ALLOW_HWREG is set to 1 if hardware registers are allowed to
990 find_last_value (x
, pinsn
, valid_to
, allow_hwreg
)
998 for (p
= PREV_INSN (*pinsn
); p
&& GET_CODE (p
) != CODE_LABEL
;
1002 rtx set
= single_set (p
);
1003 rtx note
= find_reg_note (p
, REG_EQUAL
, NULL_RTX
);
1005 if (set
&& rtx_equal_p (x
, SET_DEST (set
)))
1007 rtx src
= SET_SRC (set
);
1009 if (note
&& GET_CODE (XEXP (note
, 0)) != EXPR_LIST
)
1010 src
= XEXP (note
, 0);
1012 if ((valid_to
== NULL_RTX
1013 || ! modified_between_p (src
, PREV_INSN (p
), valid_to
))
1014 /* Reject hard registers because we don't usually want
1015 to use them; we'd rather use a pseudo. */
1016 && (! (GET_CODE (src
) == REG
1017 && REGNO (src
) < FIRST_PSEUDO_REGISTER
) || allow_hwreg
))
1024 /* If set in non-simple way, we don't have a value. */
1025 if (reg_set_p (x
, p
))
1032 /* Return nonzero if register in range [REGNO, ENDREGNO)
1033 appears either explicitly or implicitly in X
1034 other than being stored into.
1036 References contained within the substructure at LOC do not count.
1037 LOC may be zero, meaning don't ignore anything. */
1040 refers_to_regno_p (regno
, endregno
, x
, loc
)
1041 unsigned int regno
, endregno
;
1046 unsigned int x_regno
;
1051 /* The contents of a REG_NONNEG note is always zero, so we must come here
1052 upon repeat in case the last REG_NOTE is a REG_NONNEG note. */
1056 code
= GET_CODE (x
);
1061 x_regno
= REGNO (x
);
1063 /* If we modifying the stack, frame, or argument pointer, it will
1064 clobber a virtual register. In fact, we could be more precise,
1065 but it isn't worth it. */
1066 if ((x_regno
== STACK_POINTER_REGNUM
1067 #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
1068 || x_regno
== ARG_POINTER_REGNUM
1070 || x_regno
== FRAME_POINTER_REGNUM
)
1071 && regno
>= FIRST_VIRTUAL_REGISTER
&& regno
<= LAST_VIRTUAL_REGISTER
)
1074 return (endregno
> x_regno
1075 && regno
< x_regno
+ (x_regno
< FIRST_PSEUDO_REGISTER
1076 ? HARD_REGNO_NREGS (x_regno
, GET_MODE (x
))
1080 /* If this is a SUBREG of a hard reg, we can see exactly which
1081 registers are being modified. Otherwise, handle normally. */
1082 if (GET_CODE (SUBREG_REG (x
)) == REG
1083 && REGNO (SUBREG_REG (x
)) < FIRST_PSEUDO_REGISTER
)
1085 unsigned int inner_regno
= REGNO (SUBREG_REG (x
)) + SUBREG_WORD (x
);
1086 unsigned int inner_endregno
1087 = inner_regno
+ (inner_regno
< FIRST_PSEUDO_REGISTER
1088 ? HARD_REGNO_NREGS (regno
, GET_MODE (x
)) : 1);
1090 return endregno
> inner_regno
&& regno
< inner_endregno
;
1096 if (&SET_DEST (x
) != loc
1097 /* Note setting a SUBREG counts as referring to the REG it is in for
1098 a pseudo but not for hard registers since we can
1099 treat each word individually. */
1100 && ((GET_CODE (SET_DEST (x
)) == SUBREG
1101 && loc
!= &SUBREG_REG (SET_DEST (x
))
1102 && GET_CODE (SUBREG_REG (SET_DEST (x
))) == REG
1103 && REGNO (SUBREG_REG (SET_DEST (x
))) >= FIRST_PSEUDO_REGISTER
1104 && refers_to_regno_p (regno
, endregno
,
1105 SUBREG_REG (SET_DEST (x
)), loc
))
1106 || (GET_CODE (SET_DEST (x
)) != REG
1107 && refers_to_regno_p (regno
, endregno
, SET_DEST (x
), loc
))))
1110 if (code
== CLOBBER
|| loc
== &SET_SRC (x
))
1119 /* X does not match, so try its subexpressions. */
1121 fmt
= GET_RTX_FORMAT (code
);
1122 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
1124 if (fmt
[i
] == 'e' && loc
!= &XEXP (x
, i
))
1132 if (refers_to_regno_p (regno
, endregno
, XEXP (x
, i
), loc
))
1135 else if (fmt
[i
] == 'E')
1138 for (j
= XVECLEN (x
, i
) - 1; j
>=0; j
--)
1139 if (loc
!= &XVECEXP (x
, i
, j
)
1140 && refers_to_regno_p (regno
, endregno
, XVECEXP (x
, i
, j
), loc
))
1147 /* Nonzero if modifying X will affect IN. If X is a register or a SUBREG,
1148 we check if any register number in X conflicts with the relevant register
1149 numbers. If X is a constant, return 0. If X is a MEM, return 1 iff IN
1150 contains a MEM (we don't bother checking for memory addresses that can't
1151 conflict because we expect this to be a rare case. */
1154 reg_overlap_mentioned_p (x
, in
)
1157 unsigned int regno
, endregno
;
1159 /* Overly conservative. */
1160 if (GET_CODE (x
) == STRICT_LOW_PART
)
1163 /* If either argument is a constant, then modifying X can not affect IN. */
1164 if (CONSTANT_P (x
) || CONSTANT_P (in
))
1167 switch (GET_CODE (x
))
1170 regno
= REGNO (SUBREG_REG (x
));
1171 if (regno
< FIRST_PSEUDO_REGISTER
)
1172 regno
+= SUBREG_WORD (x
);
1178 endregno
= regno
+ (regno
< FIRST_PSEUDO_REGISTER
1179 ? HARD_REGNO_NREGS (regno
, GET_MODE (x
)) : 1);
1180 return refers_to_regno_p (regno
, endregno
, in
, NULL_PTR
);
1187 if (GET_CODE (in
) == MEM
)
1190 fmt
= GET_RTX_FORMAT (GET_CODE (in
));
1191 for (i
= GET_RTX_LENGTH (GET_CODE (in
)) - 1; i
>= 0; i
--)
1192 if (fmt
[i
] == 'e' && reg_overlap_mentioned_p (x
, XEXP (in
, i
)))
1201 return reg_mentioned_p (x
, in
);
1207 /* If any register in here refers to it we return true. */
1208 for (i
= XVECLEN (x
, 0) - 1; i
>= 0; i
--)
1209 if (XEXP (XVECEXP (x
, 0, i
), 0) != 0
1210 && reg_overlap_mentioned_p (XEXP (XVECEXP (x
, 0, i
), 0), in
))
1222 /* Return the last value to which REG was set prior to INSN. If we can't
1223 find it easily, return 0.
1225 We only return a REG, SUBREG, or constant because it is too hard to
1226 check if a MEM remains unchanged. */
1229 reg_set_last (x
, insn
)
1233 rtx orig_insn
= insn
;
1235 /* Scan backwards until reg_set_last_1 changed one of the above flags.
1236 Stop when we reach a label or X is a hard reg and we reach a
1237 CALL_INSN (if reg_set_last_last_regno is a hard reg).
1239 If we find a set of X, ensure that its SET_SRC remains unchanged. */
1241 /* We compare with <= here, because reg_set_last_last_regno
1242 is actually the number of the first reg *not* in X. */
1244 insn
&& GET_CODE (insn
) != CODE_LABEL
1245 && ! (GET_CODE (insn
) == CALL_INSN
1246 && REGNO (x
) <= FIRST_PSEUDO_REGISTER
);
1247 insn
= PREV_INSN (insn
))
1250 rtx set
= set_of (x
, insn
);
1251 /* OK, this function modify our register. See if we understand it. */
1255 if (GET_CODE (set
) != SET
|| SET_DEST (set
) != x
)
1257 last_value
= SET_SRC (x
);
1258 if (CONSTANT_P (last_value
)
1259 || ((GET_CODE (last_value
) == REG
1260 || GET_CODE (last_value
) == SUBREG
)
1261 && ! reg_set_between_p (last_value
,
1272 /* Call FUN on each register or MEM that is stored into or clobbered by X.
1273 (X would be the pattern of an insn).
1274 FUN receives two arguments:
1275 the REG, MEM, CC0 or PC being stored in or clobbered,
1276 the SET or CLOBBER rtx that does the store.
1278 If the item being stored in or clobbered is a SUBREG of a hard register,
1279 the SUBREG will be passed. */
1282 note_stores (x
, fun
, data
)
1284 void (*fun
) PARAMS ((rtx
, rtx
, void *));
1289 if (GET_CODE (x
) == COND_EXEC
)
1290 x
= COND_EXEC_CODE (x
);
1292 if (GET_CODE (x
) == SET
|| GET_CODE (x
) == CLOBBER
)
1294 register rtx dest
= SET_DEST (x
);
1296 while ((GET_CODE (dest
) == SUBREG
1297 && (GET_CODE (SUBREG_REG (dest
)) != REG
1298 || REGNO (SUBREG_REG (dest
)) >= FIRST_PSEUDO_REGISTER
))
1299 || GET_CODE (dest
) == ZERO_EXTRACT
1300 || GET_CODE (dest
) == SIGN_EXTRACT
1301 || GET_CODE (dest
) == STRICT_LOW_PART
)
1302 dest
= XEXP (dest
, 0);
1304 /* If we have a PARALLEL, SET_DEST is a list of EXPR_LIST expressions,
1305 each of whose first operand is a register. We can't know what
1306 precisely is being set in these cases, so make up a CLOBBER to pass
1308 if (GET_CODE (dest
) == PARALLEL
)
1310 for (i
= XVECLEN (dest
, 0) - 1; i
>= 0; i
--)
1311 if (XEXP (XVECEXP (dest
, 0, i
), 0) != 0)
1312 (*fun
) (XEXP (XVECEXP (dest
, 0, i
), 0),
1313 gen_rtx_CLOBBER (VOIDmode
,
1314 XEXP (XVECEXP (dest
, 0, i
), 0)),
1318 (*fun
) (dest
, x
, data
);
1321 else if (GET_CODE (x
) == PARALLEL
)
1322 for (i
= XVECLEN (x
, 0) - 1; i
>= 0; i
--)
1323 note_stores (XVECEXP (x
, 0, i
), fun
, data
);
1326 /* Return nonzero if X's old contents don't survive after INSN.
1327 This will be true if X is (cc0) or if X is a register and
1328 X dies in INSN or because INSN entirely sets X.
1330 "Entirely set" means set directly and not through a SUBREG,
1331 ZERO_EXTRACT or SIGN_EXTRACT, so no trace of the old contents remains.
1332 Likewise, REG_INC does not count.
1334 REG may be a hard or pseudo reg. Renumbering is not taken into account,
1335 but for this use that makes no difference, since regs don't overlap
1336 during their lifetimes. Therefore, this function may be used
1337 at any time after deaths have been computed (in flow.c).
1339 If REG is a hard reg that occupies multiple machine registers, this
1340 function will only return 1 if each of those registers will be replaced
1344 dead_or_set_p (insn
, x
)
1348 unsigned int regno
, last_regno
;
1351 /* Can't use cc0_rtx below since this file is used by genattrtab.c. */
1352 if (GET_CODE (x
) == CC0
)
1355 if (GET_CODE (x
) != REG
)
1359 last_regno
= (regno
>= FIRST_PSEUDO_REGISTER
? regno
1360 : regno
+ HARD_REGNO_NREGS (regno
, GET_MODE (x
)) - 1);
1362 for (i
= regno
; i
<= last_regno
; i
++)
1363 if (! dead_or_set_regno_p (insn
, i
))
1369 /* Utility function for dead_or_set_p to check an individual register. Also
1370 called from flow.c. */
1373 dead_or_set_regno_p (insn
, test_regno
)
1375 unsigned int test_regno
;
1377 unsigned int regno
, endregno
;
1380 /* See if there is a death note for something that includes TEST_REGNO. */
1381 if (find_regno_note (insn
, REG_DEAD
, test_regno
))
1384 if (GET_CODE (insn
) == CALL_INSN
1385 && find_regno_fusage (insn
, CLOBBER
, test_regno
))
1388 pattern
= PATTERN (insn
);
1390 if (GET_CODE (pattern
) == COND_EXEC
)
1391 pattern
= COND_EXEC_CODE (pattern
);
1393 if (GET_CODE (pattern
) == SET
)
1395 rtx dest
= SET_DEST (PATTERN (insn
));
1397 /* A value is totally replaced if it is the destination or the
1398 destination is a SUBREG of REGNO that does not change the number of
1400 if (GET_CODE (dest
) == SUBREG
1401 && (((GET_MODE_SIZE (GET_MODE (dest
))
1402 + UNITS_PER_WORD
- 1) / UNITS_PER_WORD
)
1403 == ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (dest
)))
1404 + UNITS_PER_WORD
- 1) / UNITS_PER_WORD
)))
1405 dest
= SUBREG_REG (dest
);
1407 if (GET_CODE (dest
) != REG
)
1410 regno
= REGNO (dest
);
1411 endregno
= (regno
>= FIRST_PSEUDO_REGISTER
? regno
+ 1
1412 : regno
+ HARD_REGNO_NREGS (regno
, GET_MODE (dest
)));
1414 return (test_regno
>= regno
&& test_regno
< endregno
);
1416 else if (GET_CODE (pattern
) == PARALLEL
)
1420 for (i
= XVECLEN (pattern
, 0) - 1; i
>= 0; i
--)
1422 rtx body
= XVECEXP (pattern
, 0, i
);
1424 if (GET_CODE (body
) == COND_EXEC
)
1425 body
= COND_EXEC_CODE (body
);
1427 if (GET_CODE (body
) == SET
|| GET_CODE (body
) == CLOBBER
)
1429 rtx dest
= SET_DEST (body
);
1431 if (GET_CODE (dest
) == SUBREG
1432 && (((GET_MODE_SIZE (GET_MODE (dest
))
1433 + UNITS_PER_WORD
- 1) / UNITS_PER_WORD
)
1434 == ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (dest
)))
1435 + UNITS_PER_WORD
- 1) / UNITS_PER_WORD
)))
1436 dest
= SUBREG_REG (dest
);
1438 if (GET_CODE (dest
) != REG
)
1441 regno
= REGNO (dest
);
1442 endregno
= (regno
>= FIRST_PSEUDO_REGISTER
? regno
+ 1
1443 : regno
+ HARD_REGNO_NREGS (regno
, GET_MODE (dest
)));
1445 if (test_regno
>= regno
&& test_regno
< endregno
)
1454 /* Return the reg-note of kind KIND in insn INSN, if there is one.
1455 If DATUM is nonzero, look for one whose datum is DATUM. */
1458 find_reg_note (insn
, kind
, datum
)
1465 /* Ignore anything that is not an INSN, JUMP_INSN or CALL_INSN. */
1466 if (! INSN_P (insn
))
1469 for (link
= REG_NOTES (insn
); link
; link
= XEXP (link
, 1))
1470 if (REG_NOTE_KIND (link
) == kind
1471 && (datum
== 0 || datum
== XEXP (link
, 0)))
1476 /* Return the reg-note of kind KIND in insn INSN which applies to register
1477 number REGNO, if any. Return 0 if there is no such reg-note. Note that
1478 the REGNO of this NOTE need not be REGNO if REGNO is a hard register;
1479 it might be the case that the note overlaps REGNO. */
1482 find_regno_note (insn
, kind
, regno
)
1489 /* Ignore anything that is not an INSN, JUMP_INSN or CALL_INSN. */
1490 if (! INSN_P (insn
))
1493 for (link
= REG_NOTES (insn
); link
; link
= XEXP (link
, 1))
1494 if (REG_NOTE_KIND (link
) == kind
1495 /* Verify that it is a register, so that scratch and MEM won't cause a
1497 && GET_CODE (XEXP (link
, 0)) == REG
1498 && REGNO (XEXP (link
, 0)) <= regno
1499 && ((REGNO (XEXP (link
, 0))
1500 + (REGNO (XEXP (link
, 0)) >= FIRST_PSEUDO_REGISTER
? 1
1501 : HARD_REGNO_NREGS (REGNO (XEXP (link
, 0)),
1502 GET_MODE (XEXP (link
, 0)))))
1508 /* Return true if DATUM, or any overlap of DATUM, of kind CODE is found
1509 in the CALL_INSN_FUNCTION_USAGE information of INSN. */
1512 find_reg_fusage (insn
, code
, datum
)
1517 /* If it's not a CALL_INSN, it can't possibly have a
1518 CALL_INSN_FUNCTION_USAGE field, so don't bother checking. */
1519 if (GET_CODE (insn
) != CALL_INSN
)
1525 if (GET_CODE (datum
) != REG
)
1529 for (link
= CALL_INSN_FUNCTION_USAGE (insn
);
1531 link
= XEXP (link
, 1))
1532 if (GET_CODE (XEXP (link
, 0)) == code
1533 && rtx_equal_p (datum
, SET_DEST (XEXP (link
, 0))))
1538 unsigned int regno
= REGNO (datum
);
1540 /* CALL_INSN_FUNCTION_USAGE information cannot contain references
1541 to pseudo registers, so don't bother checking. */
1543 if (regno
< FIRST_PSEUDO_REGISTER
)
1545 unsigned int end_regno
1546 = regno
+ HARD_REGNO_NREGS (regno
, GET_MODE (datum
));
1549 for (i
= regno
; i
< end_regno
; i
++)
1550 if (find_regno_fusage (insn
, code
, i
))
1558 /* Return true if REGNO, or any overlap of REGNO, of kind CODE is found
1559 in the CALL_INSN_FUNCTION_USAGE information of INSN. */
1562 find_regno_fusage (insn
, code
, regno
)
1569 /* CALL_INSN_FUNCTION_USAGE information cannot contain references
1570 to pseudo registers, so don't bother checking. */
1572 if (regno
>= FIRST_PSEUDO_REGISTER
1573 || GET_CODE (insn
) != CALL_INSN
)
1576 for (link
= CALL_INSN_FUNCTION_USAGE (insn
); link
; link
= XEXP (link
, 1))
1578 unsigned int regnote
;
1581 if (GET_CODE (op
= XEXP (link
, 0)) == code
1582 && GET_CODE (reg
= XEXP (op
, 0)) == REG
1583 && (regnote
= REGNO (reg
)) <= regno
1584 && regnote
+ HARD_REGNO_NREGS (regnote
, GET_MODE (reg
)) > regno
)
1591 /* Remove register note NOTE from the REG_NOTES of INSN. */
1594 remove_note (insn
, note
)
1600 if (note
== NULL_RTX
)
1603 if (REG_NOTES (insn
) == note
)
1605 REG_NOTES (insn
) = XEXP (note
, 1);
1609 for (link
= REG_NOTES (insn
); link
; link
= XEXP (link
, 1))
1610 if (XEXP (link
, 1) == note
)
1612 XEXP (link
, 1) = XEXP (note
, 1);
1619 /* Search LISTP (an EXPR_LIST) for an entry whose first operand is NODE and
1620 remove that entry from the list if it is found.
1622 A simple equality test is used to determine if NODE matches. */
1625 remove_node_from_expr_list (node
, listp
)
1630 rtx prev
= NULL_RTX
;
1634 if (node
== XEXP (temp
, 0))
1636 /* Splice the node out of the list. */
1638 XEXP (prev
, 1) = XEXP (temp
, 1);
1640 *listp
= XEXP (temp
, 1);
1646 temp
= XEXP (temp
, 1);
1650 /* Nonzero if X contains any volatile instructions. These are instructions
1651 which may cause unpredictable machine state instructions, and thus no
1652 instructions should be moved or combined across them. This includes
1653 only volatile asms and UNSPEC_VOLATILE instructions. */
1659 register RTX_CODE code
;
1661 code
= GET_CODE (x
);
1681 case UNSPEC_VOLATILE
:
1682 /* case TRAP_IF: This isn't clear yet. */
1686 if (MEM_VOLATILE_P (x
))
1693 /* Recursively scan the operands of this expression. */
1696 register const char *fmt
= GET_RTX_FORMAT (code
);
1699 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
1703 if (volatile_insn_p (XEXP (x
, i
)))
1706 else if (fmt
[i
] == 'E')
1709 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
1710 if (volatile_insn_p (XVECEXP (x
, i
, j
)))
1718 /* Nonzero if X contains any volatile memory references
1719 UNSPEC_VOLATILE operations or volatile ASM_OPERANDS expressions. */
1725 register RTX_CODE code
;
1727 code
= GET_CODE (x
);
1746 case UNSPEC_VOLATILE
:
1747 /* case TRAP_IF: This isn't clear yet. */
1752 if (MEM_VOLATILE_P (x
))
1759 /* Recursively scan the operands of this expression. */
1762 register const char *fmt
= GET_RTX_FORMAT (code
);
1765 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
1769 if (volatile_refs_p (XEXP (x
, i
)))
1772 else if (fmt
[i
] == 'E')
1775 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
1776 if (volatile_refs_p (XVECEXP (x
, i
, j
)))
1784 /* Similar to above, except that it also rejects register pre- and post-
1791 register RTX_CODE code
;
1793 code
= GET_CODE (x
);
1811 /* Reject CLOBBER with a non-VOID mode. These are made by combine.c
1812 when some combination can't be done. If we see one, don't think
1813 that we can simplify the expression. */
1814 return (GET_MODE (x
) != VOIDmode
);
1823 case UNSPEC_VOLATILE
:
1824 /* case TRAP_IF: This isn't clear yet. */
1829 if (MEM_VOLATILE_P (x
))
1836 /* Recursively scan the operands of this expression. */
1839 register const char *fmt
= GET_RTX_FORMAT (code
);
1842 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
1846 if (side_effects_p (XEXP (x
, i
)))
1849 else if (fmt
[i
] == 'E')
1852 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
1853 if (side_effects_p (XVECEXP (x
, i
, j
)))
1861 /* Return nonzero if evaluating rtx X might cause a trap. */
1873 code
= GET_CODE (x
);
1876 /* Handle these cases quickly. */
1889 case UNSPEC_VOLATILE
:
1894 return MEM_VOLATILE_P (x
);
1896 /* Memory ref can trap unless it's a static var or a stack slot. */
1898 return rtx_addr_can_trap_p (XEXP (x
, 0));
1900 /* Division by a non-constant might trap. */
1905 if (! CONSTANT_P (XEXP (x
, 1))
1906 || GET_MODE_CLASS (GET_MODE (x
)) == MODE_FLOAT
)
1908 /* This was const0_rtx, but by not using that,
1909 we can link this file into other programs. */
1910 if (GET_CODE (XEXP (x
, 1)) == CONST_INT
&& INTVAL (XEXP (x
, 1)) == 0)
1915 /* An EXPR_LIST is used to represent a function call. This
1916 certainly may trap. */
1924 /* Some floating point comparisons may trap. */
1925 /* ??? There is no machine independent way to check for tests that trap
1926 when COMPARE is used, though many targets do make this distinction.
1927 For instance, sparc uses CCFPE for compares which generate exceptions
1928 and CCFP for compares which do not generate exceptions. */
1929 if (GET_MODE_CLASS (GET_MODE (x
)) == MODE_FLOAT
)
1931 /* But often the compare has some CC mode, so check operand
1933 if (GET_MODE_CLASS (GET_MODE (XEXP (x
, 0))) == MODE_FLOAT
1934 || GET_MODE_CLASS (GET_MODE (XEXP (x
, 1))) == MODE_FLOAT
)
1939 /* Any floating arithmetic may trap. */
1940 if (GET_MODE_CLASS (GET_MODE (x
)) == MODE_FLOAT
)
1944 fmt
= GET_RTX_FORMAT (code
);
1945 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
1949 if (may_trap_p (XEXP (x
, i
)))
1952 else if (fmt
[i
] == 'E')
1955 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
1956 if (may_trap_p (XVECEXP (x
, i
, j
)))
1963 /* Return nonzero if X contains a comparison that is not either EQ or NE,
1964 i.e., an inequality. */
1967 inequality_comparisons_p (x
)
1970 register const char *fmt
;
1971 register int len
, i
;
1972 register enum rtx_code code
= GET_CODE (x
);
2001 len
= GET_RTX_LENGTH (code
);
2002 fmt
= GET_RTX_FORMAT (code
);
2004 for (i
= 0; i
< len
; i
++)
2008 if (inequality_comparisons_p (XEXP (x
, i
)))
2011 else if (fmt
[i
] == 'E')
2014 for (j
= XVECLEN (x
, i
) - 1; j
>= 0; j
--)
2015 if (inequality_comparisons_p (XVECEXP (x
, i
, j
)))
2023 /* Replace any occurrence of FROM in X with TO. The function does
2024 not enter into CONST_DOUBLE for the replace.
2026 Note that copying is not done so X must not be shared unless all copies
2027 are to be modified. */
2030 replace_rtx (x
, from
, to
)
2034 register const char *fmt
;
2036 /* The following prevents loops occurrence when we change MEM in
2037 CONST_DOUBLE onto the same CONST_DOUBLE. */
2038 if (x
!= 0 && GET_CODE (x
) == CONST_DOUBLE
)
2044 /* Allow this function to make replacements in EXPR_LISTs. */
2048 fmt
= GET_RTX_FORMAT (GET_CODE (x
));
2049 for (i
= GET_RTX_LENGTH (GET_CODE (x
)) - 1; i
>= 0; i
--)
2052 XEXP (x
, i
) = replace_rtx (XEXP (x
, i
), from
, to
);
2053 else if (fmt
[i
] == 'E')
2054 for (j
= XVECLEN (x
, i
) - 1; j
>= 0; j
--)
2055 XVECEXP (x
, i
, j
) = replace_rtx (XVECEXP (x
, i
, j
), from
, to
);
2061 /* Throughout the rtx X, replace many registers according to REG_MAP.
2062 Return the replacement for X (which may be X with altered contents).
2063 REG_MAP[R] is the replacement for register R, or 0 for don't replace.
2064 NREGS is the length of REG_MAP; regs >= NREGS are not mapped.
2066 We only support REG_MAP entries of REG or SUBREG. Also, hard registers
2067 should not be mapped to pseudos or vice versa since validate_change
2070 If REPLACE_DEST is 1, replacements are also done in destinations;
2071 otherwise, only sources are replaced. */
2074 replace_regs (x
, reg_map
, nregs
, replace_dest
)
2080 register enum rtx_code code
;
2082 register const char *fmt
;
2087 code
= GET_CODE (x
);
2101 /* Verify that the register has an entry before trying to access it. */
2102 if (REGNO (x
) < nregs
&& reg_map
[REGNO (x
)] != 0)
2104 /* SUBREGs can't be shared. Always return a copy to ensure that if
2105 this replacement occurs more than once then each instance will
2106 get distinct rtx. */
2107 if (GET_CODE (reg_map
[REGNO (x
)]) == SUBREG
)
2108 return copy_rtx (reg_map
[REGNO (x
)]);
2109 return reg_map
[REGNO (x
)];
2114 /* Prevent making nested SUBREGs. */
2115 if (GET_CODE (SUBREG_REG (x
)) == REG
&& REGNO (SUBREG_REG (x
)) < nregs
2116 && reg_map
[REGNO (SUBREG_REG (x
))] != 0
2117 && GET_CODE (reg_map
[REGNO (SUBREG_REG (x
))]) == SUBREG
)
2119 rtx map_val
= reg_map
[REGNO (SUBREG_REG (x
))];
2120 rtx map_inner
= SUBREG_REG (map_val
);
2122 if (GET_MODE (x
) == GET_MODE (map_inner
))
2126 /* We cannot call gen_rtx here since we may be linked with
2128 /* Let's try clobbering the incoming SUBREG and see
2129 if this is really safe. */
2130 SUBREG_REG (x
) = map_inner
;
2131 SUBREG_WORD (x
) += SUBREG_WORD (map_val
);
2134 rtx
new = rtx_alloc (SUBREG
);
2135 PUT_MODE (new, GET_MODE (x
));
2136 SUBREG_REG (new) = map_inner
;
2137 SUBREG_WORD (new) = SUBREG_WORD (x
) + SUBREG_WORD (map_val
);
2145 SET_DEST (x
) = replace_regs (SET_DEST (x
), reg_map
, nregs
, 0);
2147 else if (GET_CODE (SET_DEST (x
)) == MEM
2148 || GET_CODE (SET_DEST (x
)) == STRICT_LOW_PART
)
2149 /* Even if we are not to replace destinations, replace register if it
2150 is CONTAINED in destination (destination is memory or
2151 STRICT_LOW_PART). */
2152 XEXP (SET_DEST (x
), 0) = replace_regs (XEXP (SET_DEST (x
), 0),
2154 else if (GET_CODE (SET_DEST (x
)) == ZERO_EXTRACT
)
2155 /* Similarly, for ZERO_EXTRACT we replace all operands. */
2158 SET_SRC (x
) = replace_regs (SET_SRC (x
), reg_map
, nregs
, 0);
2165 fmt
= GET_RTX_FORMAT (code
);
2166 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
2169 XEXP (x
, i
) = replace_regs (XEXP (x
, i
), reg_map
, nregs
, replace_dest
);
2170 else if (fmt
[i
] == 'E')
2173 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
2174 XVECEXP (x
, i
, j
) = replace_regs (XVECEXP (x
, i
, j
), reg_map
,
2175 nregs
, replace_dest
);
2181 /* A subroutine of computed_jump_p, return 1 if X contains a REG or MEM or
2182 constant that is not in the constant pool and not in the condition
2183 of an IF_THEN_ELSE. */
2186 computed_jump_p_1 (x
)
2189 enum rtx_code code
= GET_CODE (x
);
2207 return ! (GET_CODE (XEXP (x
, 0)) == SYMBOL_REF
2208 && CONSTANT_POOL_ADDRESS_P (XEXP (x
, 0)));
2211 return (computed_jump_p_1 (XEXP (x
, 1))
2212 || computed_jump_p_1 (XEXP (x
, 2)));
2218 fmt
= GET_RTX_FORMAT (code
);
2219 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
2222 && computed_jump_p_1 (XEXP (x
, i
)))
2225 else if (fmt
[i
] == 'E')
2226 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
2227 if (computed_jump_p_1 (XVECEXP (x
, i
, j
)))
2234 /* Return nonzero if INSN is an indirect jump (aka computed jump).
2236 Tablejumps and casesi insns are not considered indirect jumps;
2237 we can recognize them by a (use (label_ref)). */
2240 computed_jump_p (insn
)
2244 if (GET_CODE (insn
) == JUMP_INSN
)
2246 rtx pat
= PATTERN (insn
);
2248 if (find_reg_note (insn
, REG_LABEL
, NULL_RTX
))
2250 else if (GET_CODE (pat
) == PARALLEL
)
2252 int len
= XVECLEN (pat
, 0);
2253 int has_use_labelref
= 0;
2255 for (i
= len
- 1; i
>= 0; i
--)
2256 if (GET_CODE (XVECEXP (pat
, 0, i
)) == USE
2257 && (GET_CODE (XEXP (XVECEXP (pat
, 0, i
), 0))
2259 has_use_labelref
= 1;
2261 if (! has_use_labelref
)
2262 for (i
= len
- 1; i
>= 0; i
--)
2263 if (GET_CODE (XVECEXP (pat
, 0, i
)) == SET
2264 && SET_DEST (XVECEXP (pat
, 0, i
)) == pc_rtx
2265 && computed_jump_p_1 (SET_SRC (XVECEXP (pat
, 0, i
))))
2268 else if (GET_CODE (pat
) == SET
2269 && SET_DEST (pat
) == pc_rtx
2270 && computed_jump_p_1 (SET_SRC (pat
)))
2276 /* Traverse X via depth-first search, calling F for each
2277 sub-expression (including X itself). F is also passed the DATA.
2278 If F returns -1, do not traverse sub-expressions, but continue
2279 traversing the rest of the tree. If F ever returns any other
2280 non-zero value, stop the traversal, and return the value returned
2281 by F. Otherwise, return 0. This function does not traverse inside
2282 tree structure that contains RTX_EXPRs, or into sub-expressions
2283 whose format code is `0' since it is not known whether or not those
2284 codes are actually RTL.
2286 This routine is very general, and could (should?) be used to
2287 implement many of the other routines in this file. */
2290 for_each_rtx (x
, f
, data
)
2301 result
= (*f
)(x
, data
);
2303 /* Do not traverse sub-expressions. */
2305 else if (result
!= 0)
2306 /* Stop the traversal. */
2310 /* There are no sub-expressions. */
2313 length
= GET_RTX_LENGTH (GET_CODE (*x
));
2314 format
= GET_RTX_FORMAT (GET_CODE (*x
));
2316 for (i
= 0; i
< length
; ++i
)
2321 result
= for_each_rtx (&XEXP (*x
, i
), f
, data
);
2328 if (XVEC (*x
, i
) != 0)
2331 for (j
= 0; j
< XVECLEN (*x
, i
); ++j
)
2333 result
= for_each_rtx (&XVECEXP (*x
, i
, j
), f
, data
);
2341 /* Nothing to do. */
2350 /* Searches X for any reference to REGNO, returning the rtx of the
2351 reference found if any. Otherwise, returns NULL_RTX. */
2354 regno_use_in (regno
, x
)
2358 register const char *fmt
;
2362 if (GET_CODE (x
) == REG
&& REGNO (x
) == regno
)
2365 fmt
= GET_RTX_FORMAT (GET_CODE (x
));
2366 for (i
= GET_RTX_LENGTH (GET_CODE (x
)) - 1; i
>= 0; i
--)
2370 if ((tem
= regno_use_in (regno
, XEXP (x
, i
))))
2373 else if (fmt
[i
] == 'E')
2374 for (j
= XVECLEN (x
, i
) - 1; j
>= 0; j
--)
2375 if ((tem
= regno_use_in (regno
, XVECEXP (x
, i
, j
))))
2383 /* Return 1 if X is an autoincrement side effect and the register is
2384 not the stack pointer. */
2389 switch (GET_CODE (x
))
2397 /* There are no REG_INC notes for SP. */
2398 if (XEXP (x
, 0) != stack_pointer_rtx
)
2406 /* Return 1 if the sequence of instructions beginning with FROM and up
2407 to and including TO is safe to move. If NEW_TO is non-NULL, and
2408 the sequence is not already safe to move, but can be easily
2409 extended to a sequence which is safe, then NEW_TO will point to the
2410 end of the extended sequence.
2412 For now, this function only checks that the region contains whole
2413 exception regions, but it could be extended to check additional
2414 conditions as well. */
2417 insns_safe_to_move_p (from
, to
, new_to
)
2422 int eh_region_count
= 0;
2426 /* By default, assume the end of the region will be what was
2433 if (GET_CODE (r
) == NOTE
)
2435 switch (NOTE_LINE_NUMBER (r
))
2437 case NOTE_INSN_EH_REGION_BEG
:
2441 case NOTE_INSN_EH_REGION_END
:
2442 if (eh_region_count
== 0)
2443 /* This sequence of instructions contains the end of
2444 an exception region, but not he beginning. Moving
2445 it will cause chaos. */
2456 /* If we've passed TO, and we see a non-note instruction, we
2457 can't extend the sequence to a movable sequence. */
2463 /* It's OK to move the sequence if there were matched sets of
2464 exception region notes. */
2465 return eh_region_count
== 0;
2470 /* It's OK to move the sequence if there were matched sets of
2471 exception region notes. */
2472 if (past_to_p
&& eh_region_count
== 0)
2478 /* Go to the next instruction. */
2485 /* Return non-zero if IN contains a piece of rtl that has the address LOC */
2487 loc_mentioned_in_p (loc
, in
)
2490 enum rtx_code code
= GET_CODE (in
);
2491 const char *fmt
= GET_RTX_FORMAT (code
);
2494 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
2496 if (loc
== &in
->fld
[i
].rtx
)
2500 if (loc_mentioned_in_p (loc
, XEXP (in
, i
)))
2503 else if (fmt
[i
] == 'E')
2504 for (j
= XVECLEN (in
, i
) - 1; j
>= 0; j
--)
2505 if (loc_mentioned_in_p (loc
, XVECEXP (in
, i
, j
)))