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 /* Forward declarations */
30 static void set_of_1
PARAMS ((rtx
, rtx
, void *));
31 static void insn_dependent_p_1
PARAMS ((rtx
, rtx
, void *));
32 static int computed_jump_p_1
PARAMS ((rtx
));
33 static int operand_preference
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));
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 /* The arg pointer varies if it is not a fixed register. */
74 || (x
== arg_pointer_rtx
&& fixed_regs
[ARG_POINTER_REGNUM
])
75 || RTX_UNCHANGING_P (x
))
77 #ifndef PIC_OFFSET_TABLE_REG_CALL_CLOBBERED
78 /* ??? When call-clobbered, the value is stable modulo the restore
79 that must happen after a call. This currently screws up local-alloc
80 into believing that the restore is not needed. */
81 if (x
== pic_offset_table_rtx
)
87 if (MEM_VOLATILE_P (x
))
96 fmt
= GET_RTX_FORMAT (code
);
97 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
100 if (rtx_unstable_p (XEXP (x
, i
)))
103 else if (fmt
[i
] == 'E')
106 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
107 if (rtx_unstable_p (XVECEXP (x
, i
, j
)))
114 /* Return 1 if X has a value that can vary even between two
115 executions of the program. 0 means X can be compared reliably
116 against certain constants or near-constants.
117 FOR_ALIAS is nonzero if we are called from alias analysis; if it is
118 zero, we are slightly more conservative.
119 The frame pointer and the arg pointer are considered constant. */
122 rtx_varies_p (x
, for_alias
)
126 register RTX_CODE code
= GET_CODE (x
);
128 register const char *fmt
;
133 return ! RTX_UNCHANGING_P (x
) || rtx_varies_p (XEXP (x
, 0), for_alias
);
146 /* Note that we have to test for the actual rtx used for the frame
147 and arg pointers and not just the register number in case we have
148 eliminated the frame and/or arg pointer and are using it
150 if (x
== frame_pointer_rtx
|| x
== hard_frame_pointer_rtx
151 /* The arg pointer varies if it is not a fixed register. */
152 || (x
== arg_pointer_rtx
&& fixed_regs
[ARG_POINTER_REGNUM
]))
154 if (x
== pic_offset_table_rtx
155 #ifdef PIC_OFFSET_TABLE_REG_CALL_CLOBBERED
156 /* ??? When call-clobbered, the value is stable modulo the restore
157 that must happen after a call. This currently screws up
158 local-alloc into believing that the restore is not needed, so we
159 must return 0 only if we are called from alias analysis. */
167 /* The operand 0 of a LO_SUM is considered constant
168 (in fact it is related specifically to operand 1)
169 during alias analysis. */
170 return (! for_alias
&& rtx_varies_p (XEXP (x
, 0), for_alias
))
171 || rtx_varies_p (XEXP (x
, 1), for_alias
);
174 if (MEM_VOLATILE_P (x
))
183 fmt
= GET_RTX_FORMAT (code
);
184 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
187 if (rtx_varies_p (XEXP (x
, i
), for_alias
))
190 else if (fmt
[i
] == 'E')
193 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
194 if (rtx_varies_p (XVECEXP (x
, i
, j
), for_alias
))
201 /* Return 0 if the use of X as an address in a MEM can cause a trap. */
204 rtx_addr_can_trap_p (x
)
207 register enum rtx_code code
= GET_CODE (x
);
212 return SYMBOL_REF_WEAK (x
);
218 /* As in rtx_varies_p, we have to use the actual rtx, not reg number. */
219 if (x
== frame_pointer_rtx
|| x
== hard_frame_pointer_rtx
220 || x
== stack_pointer_rtx
221 /* The arg pointer varies if it is not a fixed register. */
222 || (x
== arg_pointer_rtx
&& fixed_regs
[ARG_POINTER_REGNUM
]))
224 /* All of the virtual frame registers are stack references. */
225 if (REGNO (x
) >= FIRST_VIRTUAL_REGISTER
226 && REGNO (x
) <= LAST_VIRTUAL_REGISTER
)
231 return rtx_addr_can_trap_p (XEXP (x
, 0));
234 /* An address is assumed not to trap if it is an address that can't
235 trap plus a constant integer or it is the pic register plus a
237 return ! ((! rtx_addr_can_trap_p (XEXP (x
, 0))
238 && GET_CODE (XEXP (x
, 1)) == CONST_INT
)
239 || (XEXP (x
, 0) == pic_offset_table_rtx
240 && CONSTANT_P (XEXP (x
, 1))));
244 return rtx_addr_can_trap_p (XEXP (x
, 1));
251 return rtx_addr_can_trap_p (XEXP (x
, 0));
257 /* If it isn't one of the case above, it can cause a trap. */
261 /* Return 1 if X refers to a memory location whose address
262 cannot be compared reliably with constant addresses,
263 or if X refers to a BLKmode memory object.
264 FOR_ALIAS is nonzero if we are called from alias analysis; if it is
265 zero, we are slightly more conservative. */
268 rtx_addr_varies_p (x
, for_alias
)
272 register enum rtx_code code
;
274 register const char *fmt
;
281 return GET_MODE (x
) == BLKmode
|| rtx_varies_p (XEXP (x
, 0), for_alias
);
283 fmt
= GET_RTX_FORMAT (code
);
284 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
287 if (rtx_addr_varies_p (XEXP (x
, i
), for_alias
))
290 else if (fmt
[i
] == 'E')
293 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
294 if (rtx_addr_varies_p (XVECEXP (x
, i
, j
), for_alias
))
300 /* Return the value of the integer term in X, if one is apparent;
302 Only obvious integer terms are detected.
303 This is used in cse.c with the `related_value' field.*/
309 if (GET_CODE (x
) == CONST
)
312 if (GET_CODE (x
) == MINUS
313 && GET_CODE (XEXP (x
, 1)) == CONST_INT
)
314 return - INTVAL (XEXP (x
, 1));
315 if (GET_CODE (x
) == PLUS
316 && GET_CODE (XEXP (x
, 1)) == CONST_INT
)
317 return INTVAL (XEXP (x
, 1));
321 /* If X is a constant, return the value sans apparent integer term;
323 Only obvious integer terms are detected. */
326 get_related_value (x
)
329 if (GET_CODE (x
) != CONST
)
332 if (GET_CODE (x
) == PLUS
333 && GET_CODE (XEXP (x
, 1)) == CONST_INT
)
335 else if (GET_CODE (x
) == MINUS
336 && GET_CODE (XEXP (x
, 1)) == CONST_INT
)
341 /* Return the number of places FIND appears within X. If COUNT_DEST is
342 zero, we do not count occurrences inside the destination of a SET. */
345 count_occurrences (x
, find
, count_dest
)
351 const char *format_ptr
;
371 if (GET_CODE (find
) == MEM
&& rtx_equal_p (x
, find
))
376 if (SET_DEST (x
) == find
&& ! count_dest
)
377 return count_occurrences (SET_SRC (x
), find
, count_dest
);
384 format_ptr
= GET_RTX_FORMAT (code
);
387 for (i
= 0; i
< GET_RTX_LENGTH (code
); i
++)
389 switch (*format_ptr
++)
392 count
+= count_occurrences (XEXP (x
, i
), find
, count_dest
);
396 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
397 count
+= count_occurrences (XVECEXP (x
, i
, j
), find
, count_dest
);
404 /* Nonzero if register REG appears somewhere within IN.
405 Also works if REG is not a register; in this case it checks
406 for a subexpression of IN that is Lisp "equal" to REG. */
409 reg_mentioned_p (reg
, in
)
410 register rtx reg
, in
;
412 register const char *fmt
;
414 register enum rtx_code code
;
422 if (GET_CODE (in
) == LABEL_REF
)
423 return reg
== XEXP (in
, 0);
425 code
= GET_CODE (in
);
429 /* Compare registers by number. */
431 return GET_CODE (reg
) == REG
&& REGNO (in
) == REGNO (reg
);
433 /* These codes have no constituent expressions
441 return GET_CODE (reg
) == CONST_INT
&& INTVAL (in
) == INTVAL (reg
);
444 /* These are kept unique for a given value. */
451 if (GET_CODE (reg
) == code
&& rtx_equal_p (reg
, in
))
454 fmt
= GET_RTX_FORMAT (code
);
456 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
461 for (j
= XVECLEN (in
, i
) - 1; j
>= 0; j
--)
462 if (reg_mentioned_p (reg
, XVECEXP (in
, i
, j
)))
465 else if (fmt
[i
] == 'e'
466 && reg_mentioned_p (reg
, XEXP (in
, i
)))
472 /* Return 1 if in between BEG and END, exclusive of BEG and END, there is
473 no CODE_LABEL insn. */
476 no_labels_between_p (beg
, end
)
482 for (p
= NEXT_INSN (beg
); p
!= end
; p
= NEXT_INSN (p
))
483 if (GET_CODE (p
) == CODE_LABEL
)
488 /* Return 1 if in between BEG and END, exclusive of BEG and END, there is
489 no JUMP_INSN insn. */
492 no_jumps_between_p (beg
, end
)
496 for (p
= NEXT_INSN (beg
); p
!= end
; p
= NEXT_INSN (p
))
497 if (GET_CODE (p
) == JUMP_INSN
)
502 /* Nonzero if register REG is used in an insn between
503 FROM_INSN and TO_INSN (exclusive of those two). */
506 reg_used_between_p (reg
, from_insn
, to_insn
)
507 rtx reg
, from_insn
, to_insn
;
511 if (from_insn
== to_insn
)
514 for (insn
= NEXT_INSN (from_insn
); insn
!= to_insn
; insn
= NEXT_INSN (insn
))
516 && (reg_overlap_mentioned_p (reg
, PATTERN (insn
))
517 || (GET_CODE (insn
) == CALL_INSN
518 && (find_reg_fusage (insn
, USE
, reg
)
519 || find_reg_fusage (insn
, CLOBBER
, reg
)))))
524 /* Nonzero if the old value of X, a register, is referenced in BODY. If X
525 is entirely replaced by a new value and the only use is as a SET_DEST,
526 we do not consider it a reference. */
529 reg_referenced_p (x
, body
)
535 switch (GET_CODE (body
))
538 if (reg_overlap_mentioned_p (x
, SET_SRC (body
)))
541 /* If the destination is anything other than CC0, PC, a REG or a SUBREG
542 of a REG that occupies all of the REG, the insn references X if
543 it is mentioned in the destination. */
544 if (GET_CODE (SET_DEST (body
)) != CC0
545 && GET_CODE (SET_DEST (body
)) != PC
546 && GET_CODE (SET_DEST (body
)) != REG
547 && ! (GET_CODE (SET_DEST (body
)) == SUBREG
548 && GET_CODE (SUBREG_REG (SET_DEST (body
))) == REG
549 && (((GET_MODE_SIZE (GET_MODE (SUBREG_REG (SET_DEST (body
))))
550 + (UNITS_PER_WORD
- 1)) / UNITS_PER_WORD
)
551 == ((GET_MODE_SIZE (GET_MODE (SET_DEST (body
)))
552 + (UNITS_PER_WORD
- 1)) / UNITS_PER_WORD
)))
553 && reg_overlap_mentioned_p (x
, SET_DEST (body
)))
558 for (i
= ASM_OPERANDS_INPUT_LENGTH (body
) - 1; i
>= 0; i
--)
559 if (reg_overlap_mentioned_p (x
, ASM_OPERANDS_INPUT (body
, i
)))
566 return reg_overlap_mentioned_p (x
, body
);
569 return reg_overlap_mentioned_p (x
, TRAP_CONDITION (body
));
572 case UNSPEC_VOLATILE
:
573 for (i
= XVECLEN (body
, 0) - 1; i
>= 0; i
--)
574 if (reg_overlap_mentioned_p (x
, XVECEXP (body
, 0, i
)))
579 for (i
= XVECLEN (body
, 0) - 1; i
>= 0; i
--)
580 if (reg_referenced_p (x
, XVECEXP (body
, 0, i
)))
585 if (GET_CODE (XEXP (body
, 0)) == MEM
)
586 if (reg_overlap_mentioned_p (x
, XEXP (XEXP (body
, 0), 0)))
591 if (reg_overlap_mentioned_p (x
, COND_EXEC_TEST (body
)))
593 return reg_referenced_p (x
, COND_EXEC_CODE (body
));
600 /* Nonzero if register REG is referenced in an insn between
601 FROM_INSN and TO_INSN (exclusive of those two). Sets of REG do
605 reg_referenced_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
))
615 && (reg_referenced_p (reg
, PATTERN (insn
))
616 || (GET_CODE (insn
) == CALL_INSN
617 && find_reg_fusage (insn
, USE
, reg
))))
622 /* Nonzero if register REG is set or clobbered in an insn between
623 FROM_INSN and TO_INSN (exclusive of those two). */
626 reg_set_between_p (reg
, from_insn
, to_insn
)
627 rtx reg
, from_insn
, to_insn
;
631 if (from_insn
== to_insn
)
634 for (insn
= NEXT_INSN (from_insn
); insn
!= to_insn
; insn
= NEXT_INSN (insn
))
635 if (INSN_P (insn
) && reg_set_p (reg
, insn
))
640 /* Internals of reg_set_between_p. */
642 reg_set_p (reg
, insn
)
647 /* We can be passed an insn or part of one. If we are passed an insn,
648 check if a side-effect of the insn clobbers REG. */
651 if (FIND_REG_INC_NOTE (insn
, reg
)
652 || (GET_CODE (insn
) == CALL_INSN
653 /* We'd like to test call_used_regs here, but rtlanal.c can't
654 reference that variable due to its use in genattrtab. So
655 we'll just be more conservative.
657 ??? Unless we could ensure that the CALL_INSN_FUNCTION_USAGE
658 information holds all clobbered registers. */
659 && ((GET_CODE (reg
) == REG
660 && REGNO (reg
) < FIRST_PSEUDO_REGISTER
)
661 || GET_CODE (reg
) == MEM
662 || find_reg_fusage (insn
, CLOBBER
, reg
))))
665 body
= PATTERN (insn
);
668 return set_of (reg
, insn
) != NULL_RTX
;
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 /* Helper function for set_of. */
874 set_of_1 (x
, pat
, data1
)
879 struct set_of_data
*data
= (struct set_of_data
*) (data1
);
880 if (rtx_equal_p (x
, data
->pat
)
881 || (GET_CODE (x
) != MEM
&& reg_overlap_mentioned_p (data
->pat
, x
)))
885 /* Give an INSN, return a SET or CLOBBER expression that does modify PAT
886 (eighter directly or via STRICT_LOW_PART and similar modifiers). */
891 struct set_of_data data
;
892 data
.found
= NULL_RTX
;
894 note_stores (INSN_P (insn
) ? PATTERN (insn
) : insn
, set_of_1
, &data
);
898 /* Given an INSN, return a SET expression if this insn has only a single SET.
899 It may also have CLOBBERs, USEs, or SET whose output
900 will not be used, which we ignore. */
903 single_set_2 (insn
, pat
)
907 int set_verified
= 1;
910 if (GET_CODE (pat
) == PARALLEL
)
912 for (i
= 0; i
< XVECLEN (pat
, 0); i
++)
914 rtx sub
= XVECEXP (pat
, 0, i
);
915 switch (GET_CODE (sub
))
922 /* We can consider insns having multiple sets, where all
923 but one are dead as single set insns. In common case
924 only single set is present in the pattern so we want
925 to avoid checking for REG_UNUSED notes unless neccesary.
927 When we reach set first time, we just expect this is
928 the single set we are looking for and only when more
929 sets are found in the insn, we check them. */
932 if (find_reg_note (insn
, REG_UNUSED
, SET_DEST (set
))
933 && !side_effects_p (set
))
939 set
= sub
, set_verified
= 0;
940 else if (!find_reg_note (insn
, REG_UNUSED
, SET_DEST (sub
))
941 || side_effects_p (sub
))
953 /* Given an INSN, return nonzero if it has more than one SET, else return
963 /* INSN must be an insn. */
967 /* Only a PARALLEL can have multiple SETs. */
968 if (GET_CODE (PATTERN (insn
)) == PARALLEL
)
970 for (i
= 0, found
= 0; i
< XVECLEN (PATTERN (insn
), 0); i
++)
971 if (GET_CODE (XVECEXP (PATTERN (insn
), 0, i
)) == SET
)
973 /* If we have already found a SET, then return now. */
981 /* Either zero or one SET. */
985 /* Return nonzero if the destination of SET equals the source
986 and there are no side effects. */
992 rtx src
= SET_SRC (set
);
993 rtx dst
= SET_DEST (set
);
995 if (side_effects_p (src
) || side_effects_p (dst
))
998 if (GET_CODE (dst
) == MEM
&& GET_CODE (src
) == MEM
)
999 return rtx_equal_p (dst
, src
);
1001 if (dst
== pc_rtx
&& src
== pc_rtx
)
1004 if (GET_CODE (dst
) == SIGN_EXTRACT
1005 || GET_CODE (dst
) == ZERO_EXTRACT
)
1006 return rtx_equal_p (XEXP (dst
, 0), src
)
1007 && ! BYTES_BIG_ENDIAN
&& XEXP (dst
, 2) == const0_rtx
;
1009 if (GET_CODE (dst
) == STRICT_LOW_PART
)
1010 dst
= XEXP (dst
, 0);
1012 if (GET_CODE (src
) == SUBREG
&& GET_CODE (dst
) == SUBREG
)
1014 if (SUBREG_BYTE (src
) != SUBREG_BYTE (dst
))
1016 src
= SUBREG_REG (src
);
1017 dst
= SUBREG_REG (dst
);
1020 return (GET_CODE (src
) == REG
&& GET_CODE (dst
) == REG
1021 && REGNO (src
) == REGNO (dst
));
1024 /* Return nonzero if an insn consists only of SETs, each of which only sets a
1031 rtx pat
= PATTERN (insn
);
1033 if (INSN_CODE (insn
) == NOOP_MOVE_INSN_CODE
)
1036 /* Insns carrying these notes are useful later on. */
1037 if (find_reg_note (insn
, REG_EQUAL
, NULL_RTX
))
1040 if (GET_CODE (pat
) == SET
&& set_noop_p (pat
))
1043 if (GET_CODE (pat
) == PARALLEL
)
1046 /* If nothing but SETs of registers to themselves,
1047 this insn can also be deleted. */
1048 for (i
= 0; i
< XVECLEN (pat
, 0); i
++)
1050 rtx tem
= XVECEXP (pat
, 0, i
);
1052 if (GET_CODE (tem
) == USE
1053 || GET_CODE (tem
) == CLOBBER
)
1056 if (GET_CODE (tem
) != SET
|| ! set_noop_p (tem
))
1066 /* Return the last thing that X was assigned from before *PINSN. If VALID_TO
1067 is not NULL_RTX then verify that the object is not modified up to VALID_TO.
1068 If the object was modified, if we hit a partial assignment to X, or hit a
1069 CODE_LABEL first, return X. If we found an assignment, update *PINSN to
1070 point to it. ALLOW_HWREG is set to 1 if hardware registers are allowed to
1074 find_last_value (x
, pinsn
, valid_to
, allow_hwreg
)
1082 for (p
= PREV_INSN (*pinsn
); p
&& GET_CODE (p
) != CODE_LABEL
;
1086 rtx set
= single_set (p
);
1087 rtx note
= find_reg_note (p
, REG_EQUAL
, NULL_RTX
);
1089 if (set
&& rtx_equal_p (x
, SET_DEST (set
)))
1091 rtx src
= SET_SRC (set
);
1093 if (note
&& GET_CODE (XEXP (note
, 0)) != EXPR_LIST
)
1094 src
= XEXP (note
, 0);
1096 if ((valid_to
== NULL_RTX
1097 || ! modified_between_p (src
, PREV_INSN (p
), valid_to
))
1098 /* Reject hard registers because we don't usually want
1099 to use them; we'd rather use a pseudo. */
1100 && (! (GET_CODE (src
) == REG
1101 && REGNO (src
) < FIRST_PSEUDO_REGISTER
) || allow_hwreg
))
1108 /* If set in non-simple way, we don't have a value. */
1109 if (reg_set_p (x
, p
))
1116 /* Return nonzero if register in range [REGNO, ENDREGNO)
1117 appears either explicitly or implicitly in X
1118 other than being stored into.
1120 References contained within the substructure at LOC do not count.
1121 LOC may be zero, meaning don't ignore anything. */
1124 refers_to_regno_p (regno
, endregno
, x
, loc
)
1125 unsigned int regno
, endregno
;
1130 unsigned int x_regno
;
1135 /* The contents of a REG_NONNEG note is always zero, so we must come here
1136 upon repeat in case the last REG_NOTE is a REG_NONNEG note. */
1140 code
= GET_CODE (x
);
1145 x_regno
= REGNO (x
);
1147 /* If we modifying the stack, frame, or argument pointer, it will
1148 clobber a virtual register. In fact, we could be more precise,
1149 but it isn't worth it. */
1150 if ((x_regno
== STACK_POINTER_REGNUM
1151 #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
1152 || x_regno
== ARG_POINTER_REGNUM
1154 || x_regno
== FRAME_POINTER_REGNUM
)
1155 && regno
>= FIRST_VIRTUAL_REGISTER
&& regno
<= LAST_VIRTUAL_REGISTER
)
1158 return (endregno
> x_regno
1159 && regno
< x_regno
+ (x_regno
< FIRST_PSEUDO_REGISTER
1160 ? HARD_REGNO_NREGS (x_regno
, GET_MODE (x
))
1164 /* If this is a SUBREG of a hard reg, we can see exactly which
1165 registers are being modified. Otherwise, handle normally. */
1166 if (GET_CODE (SUBREG_REG (x
)) == REG
1167 && REGNO (SUBREG_REG (x
)) < FIRST_PSEUDO_REGISTER
)
1169 unsigned int inner_regno
= subreg_regno (x
);
1170 unsigned int inner_endregno
1171 = inner_regno
+ (inner_regno
< FIRST_PSEUDO_REGISTER
1172 ? HARD_REGNO_NREGS (regno
, GET_MODE (x
)) : 1);
1174 return endregno
> inner_regno
&& regno
< inner_endregno
;
1180 if (&SET_DEST (x
) != loc
1181 /* Note setting a SUBREG counts as referring to the REG it is in for
1182 a pseudo but not for hard registers since we can
1183 treat each word individually. */
1184 && ((GET_CODE (SET_DEST (x
)) == SUBREG
1185 && loc
!= &SUBREG_REG (SET_DEST (x
))
1186 && GET_CODE (SUBREG_REG (SET_DEST (x
))) == REG
1187 && REGNO (SUBREG_REG (SET_DEST (x
))) >= FIRST_PSEUDO_REGISTER
1188 && refers_to_regno_p (regno
, endregno
,
1189 SUBREG_REG (SET_DEST (x
)), loc
))
1190 || (GET_CODE (SET_DEST (x
)) != REG
1191 && refers_to_regno_p (regno
, endregno
, SET_DEST (x
), loc
))))
1194 if (code
== CLOBBER
|| loc
== &SET_SRC (x
))
1203 /* X does not match, so try its subexpressions. */
1205 fmt
= GET_RTX_FORMAT (code
);
1206 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
1208 if (fmt
[i
] == 'e' && loc
!= &XEXP (x
, i
))
1216 if (refers_to_regno_p (regno
, endregno
, XEXP (x
, i
), loc
))
1219 else if (fmt
[i
] == 'E')
1222 for (j
= XVECLEN (x
, i
) - 1; j
>=0; j
--)
1223 if (loc
!= &XVECEXP (x
, i
, j
)
1224 && refers_to_regno_p (regno
, endregno
, XVECEXP (x
, i
, j
), loc
))
1231 /* Nonzero if modifying X will affect IN. If X is a register or a SUBREG,
1232 we check if any register number in X conflicts with the relevant register
1233 numbers. If X is a constant, return 0. If X is a MEM, return 1 iff IN
1234 contains a MEM (we don't bother checking for memory addresses that can't
1235 conflict because we expect this to be a rare case. */
1238 reg_overlap_mentioned_p (x
, in
)
1241 unsigned int regno
, endregno
;
1243 /* Overly conservative. */
1244 if (GET_CODE (x
) == STRICT_LOW_PART
)
1247 /* If either argument is a constant, then modifying X can not affect IN. */
1248 if (CONSTANT_P (x
) || CONSTANT_P (in
))
1251 switch (GET_CODE (x
))
1254 regno
= REGNO (SUBREG_REG (x
));
1255 if (regno
< FIRST_PSEUDO_REGISTER
)
1256 regno
= subreg_regno (x
);
1262 endregno
= regno
+ (regno
< FIRST_PSEUDO_REGISTER
1263 ? HARD_REGNO_NREGS (regno
, GET_MODE (x
)) : 1);
1264 return refers_to_regno_p (regno
, endregno
, in
, (rtx
*)0);
1271 if (GET_CODE (in
) == MEM
)
1274 fmt
= GET_RTX_FORMAT (GET_CODE (in
));
1275 for (i
= GET_RTX_LENGTH (GET_CODE (in
)) - 1; i
>= 0; i
--)
1276 if (fmt
[i
] == 'e' && reg_overlap_mentioned_p (x
, XEXP (in
, i
)))
1285 return reg_mentioned_p (x
, in
);
1291 /* If any register in here refers to it we return true. */
1292 for (i
= XVECLEN (x
, 0) - 1; i
>= 0; i
--)
1293 if (XEXP (XVECEXP (x
, 0, i
), 0) != 0
1294 && reg_overlap_mentioned_p (XEXP (XVECEXP (x
, 0, i
), 0), in
))
1306 /* Return the last value to which REG was set prior to INSN. If we can't
1307 find it easily, return 0.
1309 We only return a REG, SUBREG, or constant because it is too hard to
1310 check if a MEM remains unchanged. */
1313 reg_set_last (x
, insn
)
1317 rtx orig_insn
= insn
;
1319 /* Scan backwards until reg_set_last_1 changed one of the above flags.
1320 Stop when we reach a label or X is a hard reg and we reach a
1321 CALL_INSN (if reg_set_last_last_regno is a hard reg).
1323 If we find a set of X, ensure that its SET_SRC remains unchanged. */
1325 /* We compare with <= here, because reg_set_last_last_regno
1326 is actually the number of the first reg *not* in X. */
1328 insn
&& GET_CODE (insn
) != CODE_LABEL
1329 && ! (GET_CODE (insn
) == CALL_INSN
1330 && REGNO (x
) <= FIRST_PSEUDO_REGISTER
);
1331 insn
= PREV_INSN (insn
))
1334 rtx set
= set_of (x
, insn
);
1335 /* OK, this function modify our register. See if we understand it. */
1339 if (GET_CODE (set
) != SET
|| SET_DEST (set
) != x
)
1341 last_value
= SET_SRC (x
);
1342 if (CONSTANT_P (last_value
)
1343 || ((GET_CODE (last_value
) == REG
1344 || GET_CODE (last_value
) == SUBREG
)
1345 && ! reg_set_between_p (last_value
,
1356 /* Call FUN on each register or MEM that is stored into or clobbered by X.
1357 (X would be the pattern of an insn).
1358 FUN receives two arguments:
1359 the REG, MEM, CC0 or PC being stored in or clobbered,
1360 the SET or CLOBBER rtx that does the store.
1362 If the item being stored in or clobbered is a SUBREG of a hard register,
1363 the SUBREG will be passed. */
1366 note_stores (x
, fun
, data
)
1368 void (*fun
) PARAMS ((rtx
, rtx
, void *));
1373 if (GET_CODE (x
) == COND_EXEC
)
1374 x
= COND_EXEC_CODE (x
);
1376 if (GET_CODE (x
) == SET
|| GET_CODE (x
) == CLOBBER
)
1378 register rtx dest
= SET_DEST (x
);
1380 while ((GET_CODE (dest
) == SUBREG
1381 && (GET_CODE (SUBREG_REG (dest
)) != REG
1382 || REGNO (SUBREG_REG (dest
)) >= FIRST_PSEUDO_REGISTER
))
1383 || GET_CODE (dest
) == ZERO_EXTRACT
1384 || GET_CODE (dest
) == SIGN_EXTRACT
1385 || GET_CODE (dest
) == STRICT_LOW_PART
)
1386 dest
= XEXP (dest
, 0);
1388 /* If we have a PARALLEL, SET_DEST is a list of EXPR_LIST expressions,
1389 each of whose first operand is a register. We can't know what
1390 precisely is being set in these cases, so make up a CLOBBER to pass
1392 if (GET_CODE (dest
) == PARALLEL
)
1394 for (i
= XVECLEN (dest
, 0) - 1; i
>= 0; i
--)
1395 if (XEXP (XVECEXP (dest
, 0, i
), 0) != 0)
1396 (*fun
) (XEXP (XVECEXP (dest
, 0, i
), 0),
1397 gen_rtx_CLOBBER (VOIDmode
,
1398 XEXP (XVECEXP (dest
, 0, i
), 0)),
1402 (*fun
) (dest
, x
, data
);
1405 else if (GET_CODE (x
) == PARALLEL
)
1406 for (i
= XVECLEN (x
, 0) - 1; i
>= 0; i
--)
1407 note_stores (XVECEXP (x
, 0, i
), fun
, data
);
1410 /* Like notes_stores, but call FUN for each expression that is being
1411 referenced in PBODY, a pointer to the PATTERN of an insn. We only call
1412 FUN for each expression, not any interior subexpressions. FUN receives a
1413 pointer to the expression and the DATA passed to this function.
1415 Note that this is not quite the same test as that done in reg_referenced_p
1416 since that considers something as being referenced if it is being
1417 partially set, while we do not. */
1420 note_uses (pbody
, fun
, data
)
1422 void (*fun
) PARAMS ((rtx
*, void *));
1428 switch (GET_CODE (body
))
1431 (*fun
) (&COND_EXEC_TEST (body
), data
);
1432 note_uses (&COND_EXEC_CODE (body
), fun
, data
);
1436 for (i
= XVECLEN (body
, 0) - 1; i
>= 0; i
--)
1437 note_uses (&XVECEXP (body
, 0, i
), fun
, data
);
1441 (*fun
) (&XEXP (body
, 0), data
);
1445 for (i
= ASM_OPERANDS_INPUT_LENGTH (body
) - 1; i
>= 0; i
--)
1446 (*fun
) (&ASM_OPERANDS_INPUT (body
, i
), data
);
1450 (*fun
) (&TRAP_CONDITION (body
), data
);
1454 case UNSPEC_VOLATILE
:
1455 for (i
= XVECLEN (body
, 0) - 1; i
>= 0; i
--)
1456 (*fun
) (&XVECEXP (body
, 0, i
), data
);
1460 if (GET_CODE (XEXP (body
, 0)) == MEM
)
1461 (*fun
) (&XEXP (XEXP (body
, 0), 0), data
);
1466 rtx dest
= SET_DEST (body
);
1468 /* For sets we replace everything in source plus registers in memory
1469 expression in store and operands of a ZERO_EXTRACT. */
1470 (*fun
) (&SET_SRC (body
), data
);
1472 if (GET_CODE (dest
) == ZERO_EXTRACT
)
1474 (*fun
) (&XEXP (dest
, 1), data
);
1475 (*fun
) (&XEXP (dest
, 2), data
);
1478 while (GET_CODE (dest
) == SUBREG
|| GET_CODE (dest
) == STRICT_LOW_PART
)
1479 dest
= XEXP (dest
, 0);
1481 if (GET_CODE (dest
) == MEM
)
1482 (*fun
) (&XEXP (dest
, 0), data
);
1487 /* All the other possibilities never store. */
1488 (*fun
) (pbody
, data
);
1493 /* Return nonzero if X's old contents don't survive after INSN.
1494 This will be true if X is (cc0) or if X is a register and
1495 X dies in INSN or because INSN entirely sets X.
1497 "Entirely set" means set directly and not through a SUBREG,
1498 ZERO_EXTRACT or SIGN_EXTRACT, so no trace of the old contents remains.
1499 Likewise, REG_INC does not count.
1501 REG may be a hard or pseudo reg. Renumbering is not taken into account,
1502 but for this use that makes no difference, since regs don't overlap
1503 during their lifetimes. Therefore, this function may be used
1504 at any time after deaths have been computed (in flow.c).
1506 If REG is a hard reg that occupies multiple machine registers, this
1507 function will only return 1 if each of those registers will be replaced
1511 dead_or_set_p (insn
, x
)
1515 unsigned int regno
, last_regno
;
1518 /* Can't use cc0_rtx below since this file is used by genattrtab.c. */
1519 if (GET_CODE (x
) == CC0
)
1522 if (GET_CODE (x
) != REG
)
1526 last_regno
= (regno
>= FIRST_PSEUDO_REGISTER
? regno
1527 : regno
+ HARD_REGNO_NREGS (regno
, GET_MODE (x
)) - 1);
1529 for (i
= regno
; i
<= last_regno
; i
++)
1530 if (! dead_or_set_regno_p (insn
, i
))
1536 /* Utility function for dead_or_set_p to check an individual register. Also
1537 called from flow.c. */
1540 dead_or_set_regno_p (insn
, test_regno
)
1542 unsigned int test_regno
;
1544 unsigned int regno
, endregno
;
1547 /* See if there is a death note for something that includes TEST_REGNO. */
1548 if (find_regno_note (insn
, REG_DEAD
, test_regno
))
1551 if (GET_CODE (insn
) == CALL_INSN
1552 && find_regno_fusage (insn
, CLOBBER
, test_regno
))
1555 pattern
= PATTERN (insn
);
1557 if (GET_CODE (pattern
) == COND_EXEC
)
1558 pattern
= COND_EXEC_CODE (pattern
);
1560 if (GET_CODE (pattern
) == SET
)
1562 rtx dest
= SET_DEST (PATTERN (insn
));
1564 /* A value is totally replaced if it is the destination or the
1565 destination is a SUBREG of REGNO that does not change the number of
1567 if (GET_CODE (dest
) == SUBREG
1568 && (((GET_MODE_SIZE (GET_MODE (dest
))
1569 + UNITS_PER_WORD
- 1) / UNITS_PER_WORD
)
1570 == ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (dest
)))
1571 + UNITS_PER_WORD
- 1) / UNITS_PER_WORD
)))
1572 dest
= SUBREG_REG (dest
);
1574 if (GET_CODE (dest
) != REG
)
1577 regno
= REGNO (dest
);
1578 endregno
= (regno
>= FIRST_PSEUDO_REGISTER
? regno
+ 1
1579 : regno
+ HARD_REGNO_NREGS (regno
, GET_MODE (dest
)));
1581 return (test_regno
>= regno
&& test_regno
< endregno
);
1583 else if (GET_CODE (pattern
) == PARALLEL
)
1587 for (i
= XVECLEN (pattern
, 0) - 1; i
>= 0; i
--)
1589 rtx body
= XVECEXP (pattern
, 0, i
);
1591 if (GET_CODE (body
) == COND_EXEC
)
1592 body
= COND_EXEC_CODE (body
);
1594 if (GET_CODE (body
) == SET
|| GET_CODE (body
) == CLOBBER
)
1596 rtx dest
= SET_DEST (body
);
1598 if (GET_CODE (dest
) == SUBREG
1599 && (((GET_MODE_SIZE (GET_MODE (dest
))
1600 + UNITS_PER_WORD
- 1) / UNITS_PER_WORD
)
1601 == ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (dest
)))
1602 + UNITS_PER_WORD
- 1) / UNITS_PER_WORD
)))
1603 dest
= SUBREG_REG (dest
);
1605 if (GET_CODE (dest
) != REG
)
1608 regno
= REGNO (dest
);
1609 endregno
= (regno
>= FIRST_PSEUDO_REGISTER
? regno
+ 1
1610 : regno
+ HARD_REGNO_NREGS (regno
, GET_MODE (dest
)));
1612 if (test_regno
>= regno
&& test_regno
< endregno
)
1621 /* Return the reg-note of kind KIND in insn INSN, if there is one.
1622 If DATUM is nonzero, look for one whose datum is DATUM. */
1625 find_reg_note (insn
, kind
, datum
)
1632 /* Ignore anything that is not an INSN, JUMP_INSN or CALL_INSN. */
1633 if (! INSN_P (insn
))
1636 for (link
= REG_NOTES (insn
); link
; link
= XEXP (link
, 1))
1637 if (REG_NOTE_KIND (link
) == kind
1638 && (datum
== 0 || datum
== XEXP (link
, 0)))
1643 /* Return the reg-note of kind KIND in insn INSN which applies to register
1644 number REGNO, if any. Return 0 if there is no such reg-note. Note that
1645 the REGNO of this NOTE need not be REGNO if REGNO is a hard register;
1646 it might be the case that the note overlaps REGNO. */
1649 find_regno_note (insn
, kind
, regno
)
1656 /* Ignore anything that is not an INSN, JUMP_INSN or CALL_INSN. */
1657 if (! INSN_P (insn
))
1660 for (link
= REG_NOTES (insn
); link
; link
= XEXP (link
, 1))
1661 if (REG_NOTE_KIND (link
) == kind
1662 /* Verify that it is a register, so that scratch and MEM won't cause a
1664 && GET_CODE (XEXP (link
, 0)) == REG
1665 && REGNO (XEXP (link
, 0)) <= regno
1666 && ((REGNO (XEXP (link
, 0))
1667 + (REGNO (XEXP (link
, 0)) >= FIRST_PSEUDO_REGISTER
? 1
1668 : HARD_REGNO_NREGS (REGNO (XEXP (link
, 0)),
1669 GET_MODE (XEXP (link
, 0)))))
1675 /* Return a REG_EQUIV or REG_EQUAL note if insn has only a single set and
1679 find_reg_equal_equiv_note (insn
)
1684 if (single_set (insn
) == 0)
1686 else if ((note
= find_reg_note (insn
, REG_EQUIV
, NULL_RTX
)) != 0)
1689 return find_reg_note (insn
, REG_EQUAL
, NULL_RTX
);
1692 /* Return true if DATUM, or any overlap of DATUM, of kind CODE is found
1693 in the CALL_INSN_FUNCTION_USAGE information of INSN. */
1696 find_reg_fusage (insn
, code
, datum
)
1701 /* If it's not a CALL_INSN, it can't possibly have a
1702 CALL_INSN_FUNCTION_USAGE field, so don't bother checking. */
1703 if (GET_CODE (insn
) != CALL_INSN
)
1709 if (GET_CODE (datum
) != REG
)
1713 for (link
= CALL_INSN_FUNCTION_USAGE (insn
);
1715 link
= XEXP (link
, 1))
1716 if (GET_CODE (XEXP (link
, 0)) == code
1717 && rtx_equal_p (datum
, SET_DEST (XEXP (link
, 0))))
1722 unsigned int regno
= REGNO (datum
);
1724 /* CALL_INSN_FUNCTION_USAGE information cannot contain references
1725 to pseudo registers, so don't bother checking. */
1727 if (regno
< FIRST_PSEUDO_REGISTER
)
1729 unsigned int end_regno
1730 = regno
+ HARD_REGNO_NREGS (regno
, GET_MODE (datum
));
1733 for (i
= regno
; i
< end_regno
; i
++)
1734 if (find_regno_fusage (insn
, code
, i
))
1742 /* Return true if REGNO, or any overlap of REGNO, of kind CODE is found
1743 in the CALL_INSN_FUNCTION_USAGE information of INSN. */
1746 find_regno_fusage (insn
, code
, regno
)
1753 /* CALL_INSN_FUNCTION_USAGE information cannot contain references
1754 to pseudo registers, so don't bother checking. */
1756 if (regno
>= FIRST_PSEUDO_REGISTER
1757 || GET_CODE (insn
) != CALL_INSN
)
1760 for (link
= CALL_INSN_FUNCTION_USAGE (insn
); link
; link
= XEXP (link
, 1))
1762 unsigned int regnote
;
1765 if (GET_CODE (op
= XEXP (link
, 0)) == code
1766 && GET_CODE (reg
= XEXP (op
, 0)) == REG
1767 && (regnote
= REGNO (reg
)) <= regno
1768 && regnote
+ HARD_REGNO_NREGS (regnote
, GET_MODE (reg
)) > regno
)
1775 /* Remove register note NOTE from the REG_NOTES of INSN. */
1778 remove_note (insn
, note
)
1784 if (note
== NULL_RTX
)
1787 if (REG_NOTES (insn
) == note
)
1789 REG_NOTES (insn
) = XEXP (note
, 1);
1793 for (link
= REG_NOTES (insn
); link
; link
= XEXP (link
, 1))
1794 if (XEXP (link
, 1) == note
)
1796 XEXP (link
, 1) = XEXP (note
, 1);
1803 /* Search LISTP (an EXPR_LIST) for an entry whose first operand is NODE and
1804 remove that entry from the list if it is found.
1806 A simple equality test is used to determine if NODE matches. */
1809 remove_node_from_expr_list (node
, listp
)
1814 rtx prev
= NULL_RTX
;
1818 if (node
== XEXP (temp
, 0))
1820 /* Splice the node out of the list. */
1822 XEXP (prev
, 1) = XEXP (temp
, 1);
1824 *listp
= XEXP (temp
, 1);
1830 temp
= XEXP (temp
, 1);
1834 /* Nonzero if X contains any volatile instructions. These are instructions
1835 which may cause unpredictable machine state instructions, and thus no
1836 instructions should be moved or combined across them. This includes
1837 only volatile asms and UNSPEC_VOLATILE instructions. */
1843 register RTX_CODE code
;
1845 code
= GET_CODE (x
);
1865 case UNSPEC_VOLATILE
:
1866 /* case TRAP_IF: This isn't clear yet. */
1870 if (MEM_VOLATILE_P (x
))
1877 /* Recursively scan the operands of this expression. */
1880 register const char *fmt
= GET_RTX_FORMAT (code
);
1883 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
1887 if (volatile_insn_p (XEXP (x
, i
)))
1890 else if (fmt
[i
] == 'E')
1893 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
1894 if (volatile_insn_p (XVECEXP (x
, i
, j
)))
1902 /* Nonzero if X contains any volatile memory references
1903 UNSPEC_VOLATILE operations or volatile ASM_OPERANDS expressions. */
1909 register RTX_CODE code
;
1911 code
= GET_CODE (x
);
1930 case UNSPEC_VOLATILE
:
1931 /* case TRAP_IF: This isn't clear yet. */
1936 if (MEM_VOLATILE_P (x
))
1943 /* Recursively scan the operands of this expression. */
1946 register const char *fmt
= GET_RTX_FORMAT (code
);
1949 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
1953 if (volatile_refs_p (XEXP (x
, i
)))
1956 else if (fmt
[i
] == 'E')
1959 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
1960 if (volatile_refs_p (XVECEXP (x
, i
, j
)))
1968 /* Similar to above, except that it also rejects register pre- and post-
1975 register RTX_CODE code
;
1977 code
= GET_CODE (x
);
1995 /* Reject CLOBBER with a non-VOID mode. These are made by combine.c
1996 when some combination can't be done. If we see one, don't think
1997 that we can simplify the expression. */
1998 return (GET_MODE (x
) != VOIDmode
);
2007 case UNSPEC_VOLATILE
:
2008 /* case TRAP_IF: This isn't clear yet. */
2013 if (MEM_VOLATILE_P (x
))
2020 /* Recursively scan the operands of this expression. */
2023 register const char *fmt
= GET_RTX_FORMAT (code
);
2026 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
2030 if (side_effects_p (XEXP (x
, i
)))
2033 else if (fmt
[i
] == 'E')
2036 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
2037 if (side_effects_p (XVECEXP (x
, i
, j
)))
2045 /* Return nonzero if evaluating rtx X might cause a trap. */
2057 code
= GET_CODE (x
);
2060 /* Handle these cases quickly. */
2073 case UNSPEC_VOLATILE
:
2078 return MEM_VOLATILE_P (x
);
2080 /* Memory ref can trap unless it's a static var or a stack slot. */
2082 return rtx_addr_can_trap_p (XEXP (x
, 0));
2084 /* Division by a non-constant might trap. */
2089 if (! CONSTANT_P (XEXP (x
, 1))
2090 || GET_MODE_CLASS (GET_MODE (x
)) == MODE_FLOAT
)
2092 /* This was const0_rtx, but by not using that,
2093 we can link this file into other programs. */
2094 if (GET_CODE (XEXP (x
, 1)) == CONST_INT
&& INTVAL (XEXP (x
, 1)) == 0)
2099 /* An EXPR_LIST is used to represent a function call. This
2100 certainly may trap. */
2108 /* Some floating point comparisons may trap. */
2109 /* ??? There is no machine independent way to check for tests that trap
2110 when COMPARE is used, though many targets do make this distinction.
2111 For instance, sparc uses CCFPE for compares which generate exceptions
2112 and CCFP for compares which do not generate exceptions. */
2113 if (GET_MODE_CLASS (GET_MODE (x
)) == MODE_FLOAT
)
2115 /* But often the compare has some CC mode, so check operand
2117 if (GET_MODE_CLASS (GET_MODE (XEXP (x
, 0))) == MODE_FLOAT
2118 || GET_MODE_CLASS (GET_MODE (XEXP (x
, 1))) == MODE_FLOAT
)
2124 /* These operations don't trap even with floating point. */
2128 /* Any floating arithmetic may trap. */
2129 if (GET_MODE_CLASS (GET_MODE (x
)) == MODE_FLOAT
)
2133 fmt
= GET_RTX_FORMAT (code
);
2134 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
2138 if (may_trap_p (XEXP (x
, i
)))
2141 else if (fmt
[i
] == 'E')
2144 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
2145 if (may_trap_p (XVECEXP (x
, i
, j
)))
2152 /* Return nonzero if X contains a comparison that is not either EQ or NE,
2153 i.e., an inequality. */
2156 inequality_comparisons_p (x
)
2159 register const char *fmt
;
2160 register int len
, i
;
2161 register enum rtx_code code
= GET_CODE (x
);
2190 len
= GET_RTX_LENGTH (code
);
2191 fmt
= GET_RTX_FORMAT (code
);
2193 for (i
= 0; i
< len
; i
++)
2197 if (inequality_comparisons_p (XEXP (x
, i
)))
2200 else if (fmt
[i
] == 'E')
2203 for (j
= XVECLEN (x
, i
) - 1; j
>= 0; j
--)
2204 if (inequality_comparisons_p (XVECEXP (x
, i
, j
)))
2212 /* Replace any occurrence of FROM in X with TO. The function does
2213 not enter into CONST_DOUBLE for the replace.
2215 Note that copying is not done so X must not be shared unless all copies
2216 are to be modified. */
2219 replace_rtx (x
, from
, to
)
2223 register const char *fmt
;
2225 /* The following prevents loops occurrence when we change MEM in
2226 CONST_DOUBLE onto the same CONST_DOUBLE. */
2227 if (x
!= 0 && GET_CODE (x
) == CONST_DOUBLE
)
2233 /* Allow this function to make replacements in EXPR_LISTs. */
2237 fmt
= GET_RTX_FORMAT (GET_CODE (x
));
2238 for (i
= GET_RTX_LENGTH (GET_CODE (x
)) - 1; i
>= 0; i
--)
2241 XEXP (x
, i
) = replace_rtx (XEXP (x
, i
), from
, to
);
2242 else if (fmt
[i
] == 'E')
2243 for (j
= XVECLEN (x
, i
) - 1; j
>= 0; j
--)
2244 XVECEXP (x
, i
, j
) = replace_rtx (XVECEXP (x
, i
, j
), from
, to
);
2250 /* Throughout the rtx X, replace many registers according to REG_MAP.
2251 Return the replacement for X (which may be X with altered contents).
2252 REG_MAP[R] is the replacement for register R, or 0 for don't replace.
2253 NREGS is the length of REG_MAP; regs >= NREGS are not mapped.
2255 We only support REG_MAP entries of REG or SUBREG. Also, hard registers
2256 should not be mapped to pseudos or vice versa since validate_change
2259 If REPLACE_DEST is 1, replacements are also done in destinations;
2260 otherwise, only sources are replaced. */
2263 replace_regs (x
, reg_map
, nregs
, replace_dest
)
2269 register enum rtx_code code
;
2271 register const char *fmt
;
2276 code
= GET_CODE (x
);
2290 /* Verify that the register has an entry before trying to access it. */
2291 if (REGNO (x
) < nregs
&& reg_map
[REGNO (x
)] != 0)
2293 /* SUBREGs can't be shared. Always return a copy to ensure that if
2294 this replacement occurs more than once then each instance will
2295 get distinct rtx. */
2296 if (GET_CODE (reg_map
[REGNO (x
)]) == SUBREG
)
2297 return copy_rtx (reg_map
[REGNO (x
)]);
2298 return reg_map
[REGNO (x
)];
2303 /* Prevent making nested SUBREGs. */
2304 if (GET_CODE (SUBREG_REG (x
)) == REG
&& REGNO (SUBREG_REG (x
)) < nregs
2305 && reg_map
[REGNO (SUBREG_REG (x
))] != 0
2306 && GET_CODE (reg_map
[REGNO (SUBREG_REG (x
))]) == SUBREG
)
2308 rtx map_val
= reg_map
[REGNO (SUBREG_REG (x
))];
2309 return simplify_gen_subreg (GET_MODE (x
), map_val
,
2310 GET_MODE (SUBREG_REG (x
)),
2317 SET_DEST (x
) = replace_regs (SET_DEST (x
), reg_map
, nregs
, 0);
2319 else if (GET_CODE (SET_DEST (x
)) == MEM
2320 || GET_CODE (SET_DEST (x
)) == STRICT_LOW_PART
)
2321 /* Even if we are not to replace destinations, replace register if it
2322 is CONTAINED in destination (destination is memory or
2323 STRICT_LOW_PART). */
2324 XEXP (SET_DEST (x
), 0) = replace_regs (XEXP (SET_DEST (x
), 0),
2326 else if (GET_CODE (SET_DEST (x
)) == ZERO_EXTRACT
)
2327 /* Similarly, for ZERO_EXTRACT we replace all operands. */
2330 SET_SRC (x
) = replace_regs (SET_SRC (x
), reg_map
, nregs
, 0);
2337 fmt
= GET_RTX_FORMAT (code
);
2338 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
2341 XEXP (x
, i
) = replace_regs (XEXP (x
, i
), reg_map
, nregs
, replace_dest
);
2342 else if (fmt
[i
] == 'E')
2345 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
2346 XVECEXP (x
, i
, j
) = replace_regs (XVECEXP (x
, i
, j
), reg_map
,
2347 nregs
, replace_dest
);
2353 /* A subroutine of computed_jump_p, return 1 if X contains a REG or MEM or
2354 constant that is not in the constant pool and not in the condition
2355 of an IF_THEN_ELSE. */
2358 computed_jump_p_1 (x
)
2361 enum rtx_code code
= GET_CODE (x
);
2379 return ! (GET_CODE (XEXP (x
, 0)) == SYMBOL_REF
2380 && CONSTANT_POOL_ADDRESS_P (XEXP (x
, 0)));
2383 return (computed_jump_p_1 (XEXP (x
, 1))
2384 || computed_jump_p_1 (XEXP (x
, 2)));
2390 fmt
= GET_RTX_FORMAT (code
);
2391 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
2394 && computed_jump_p_1 (XEXP (x
, i
)))
2397 else if (fmt
[i
] == 'E')
2398 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
2399 if (computed_jump_p_1 (XVECEXP (x
, i
, j
)))
2406 /* Return nonzero if INSN is an indirect jump (aka computed jump).
2408 Tablejumps and casesi insns are not considered indirect jumps;
2409 we can recognize them by a (use (label_ref)). */
2412 computed_jump_p (insn
)
2416 if (GET_CODE (insn
) == JUMP_INSN
)
2418 rtx pat
= PATTERN (insn
);
2420 if (find_reg_note (insn
, REG_LABEL
, NULL_RTX
))
2422 else if (GET_CODE (pat
) == PARALLEL
)
2424 int len
= XVECLEN (pat
, 0);
2425 int has_use_labelref
= 0;
2427 for (i
= len
- 1; i
>= 0; i
--)
2428 if (GET_CODE (XVECEXP (pat
, 0, i
)) == USE
2429 && (GET_CODE (XEXP (XVECEXP (pat
, 0, i
), 0))
2431 has_use_labelref
= 1;
2433 if (! has_use_labelref
)
2434 for (i
= len
- 1; i
>= 0; i
--)
2435 if (GET_CODE (XVECEXP (pat
, 0, i
)) == SET
2436 && SET_DEST (XVECEXP (pat
, 0, i
)) == pc_rtx
2437 && computed_jump_p_1 (SET_SRC (XVECEXP (pat
, 0, i
))))
2440 else if (GET_CODE (pat
) == SET
2441 && SET_DEST (pat
) == pc_rtx
2442 && computed_jump_p_1 (SET_SRC (pat
)))
2448 /* Traverse X via depth-first search, calling F for each
2449 sub-expression (including X itself). F is also passed the DATA.
2450 If F returns -1, do not traverse sub-expressions, but continue
2451 traversing the rest of the tree. If F ever returns any other
2452 non-zero value, stop the traversal, and return the value returned
2453 by F. Otherwise, return 0. This function does not traverse inside
2454 tree structure that contains RTX_EXPRs, or into sub-expressions
2455 whose format code is `0' since it is not known whether or not those
2456 codes are actually RTL.
2458 This routine is very general, and could (should?) be used to
2459 implement many of the other routines in this file. */
2462 for_each_rtx (x
, f
, data
)
2473 result
= (*f
) (x
, data
);
2475 /* Do not traverse sub-expressions. */
2477 else if (result
!= 0)
2478 /* Stop the traversal. */
2482 /* There are no sub-expressions. */
2485 length
= GET_RTX_LENGTH (GET_CODE (*x
));
2486 format
= GET_RTX_FORMAT (GET_CODE (*x
));
2488 for (i
= 0; i
< length
; ++i
)
2493 result
= for_each_rtx (&XEXP (*x
, i
), f
, data
);
2500 if (XVEC (*x
, i
) != 0)
2503 for (j
= 0; j
< XVECLEN (*x
, i
); ++j
)
2505 result
= for_each_rtx (&XVECEXP (*x
, i
, j
), f
, data
);
2513 /* Nothing to do. */
2522 /* Searches X for any reference to REGNO, returning the rtx of the
2523 reference found if any. Otherwise, returns NULL_RTX. */
2526 regno_use_in (regno
, x
)
2530 register const char *fmt
;
2534 if (GET_CODE (x
) == REG
&& REGNO (x
) == regno
)
2537 fmt
= GET_RTX_FORMAT (GET_CODE (x
));
2538 for (i
= GET_RTX_LENGTH (GET_CODE (x
)) - 1; i
>= 0; i
--)
2542 if ((tem
= regno_use_in (regno
, XEXP (x
, i
))))
2545 else if (fmt
[i
] == 'E')
2546 for (j
= XVECLEN (x
, i
) - 1; j
>= 0; j
--)
2547 if ((tem
= regno_use_in (regno
, XVECEXP (x
, i
, j
))))
2554 /* Return a value indicating whether OP, an operand of a commutative
2555 operation, is preferred as the first or second operand. The higher
2556 the value, the stronger the preference for being the first operand.
2557 We use negative values to indicate a preference for the first operand
2558 and positive values for the second operand. */
2561 operand_preference (op
)
2564 /* Constants always come the second operand. Prefer "nice" constants. */
2565 if (GET_CODE (op
) == CONST_INT
)
2567 if (GET_CODE (op
) == CONST_DOUBLE
)
2569 if (CONSTANT_P (op
))
2572 /* SUBREGs of objects should come second. */
2573 if (GET_CODE (op
) == SUBREG
2574 && GET_RTX_CLASS (GET_CODE (SUBREG_REG (op
))) == 'o')
2577 /* If only one operand is a `neg', `not',
2578 `mult', `plus', or `minus' expression, it will be the first
2580 if (GET_CODE (op
) == NEG
|| GET_CODE (op
) == NOT
2581 || GET_CODE (op
) == MULT
|| GET_CODE (op
) == PLUS
2582 || GET_CODE (op
) == MINUS
)
2585 /* Complex expressions should be the first, so decrease priority
2587 if (GET_RTX_CLASS (GET_CODE (op
)) == 'o')
2592 /* Return 1 iff it is neccesary to swap operands of commutative operation
2593 in order to canonicalize expression. */
2596 swap_commutative_operands_p (x
, y
)
2599 return operand_preference (x
) < operand_preference (y
);
2602 /* Return 1 if X is an autoincrement side effect and the register is
2603 not the stack pointer. */
2608 switch (GET_CODE (x
))
2616 /* There are no REG_INC notes for SP. */
2617 if (XEXP (x
, 0) != stack_pointer_rtx
)
2625 /* Return 1 if the sequence of instructions beginning with FROM and up
2626 to and including TO is safe to move. If NEW_TO is non-NULL, and
2627 the sequence is not already safe to move, but can be easily
2628 extended to a sequence which is safe, then NEW_TO will point to the
2629 end of the extended sequence.
2631 For now, this function only checks that the region contains whole
2632 exception regions, but it could be extended to check additional
2633 conditions as well. */
2636 insns_safe_to_move_p (from
, to
, new_to
)
2641 int eh_region_count
= 0;
2645 /* By default, assume the end of the region will be what was
2652 if (GET_CODE (r
) == NOTE
)
2654 switch (NOTE_LINE_NUMBER (r
))
2656 case NOTE_INSN_EH_REGION_BEG
:
2660 case NOTE_INSN_EH_REGION_END
:
2661 if (eh_region_count
== 0)
2662 /* This sequence of instructions contains the end of
2663 an exception region, but not he beginning. Moving
2664 it will cause chaos. */
2675 /* If we've passed TO, and we see a non-note instruction, we
2676 can't extend the sequence to a movable sequence. */
2682 /* It's OK to move the sequence if there were matched sets of
2683 exception region notes. */
2684 return eh_region_count
== 0;
2689 /* It's OK to move the sequence if there were matched sets of
2690 exception region notes. */
2691 if (past_to_p
&& eh_region_count
== 0)
2697 /* Go to the next instruction. */
2704 /* Return non-zero if IN contains a piece of rtl that has the address LOC */
2706 loc_mentioned_in_p (loc
, in
)
2709 enum rtx_code code
= GET_CODE (in
);
2710 const char *fmt
= GET_RTX_FORMAT (code
);
2713 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
2715 if (loc
== &in
->fld
[i
].rtx
)
2719 if (loc_mentioned_in_p (loc
, XEXP (in
, i
)))
2722 else if (fmt
[i
] == 'E')
2723 for (j
= XVECLEN (in
, i
) - 1; j
>= 0; j
--)
2724 if (loc_mentioned_in_p (loc
, XVECEXP (in
, i
, j
)))
2730 /* This function returns the regno offset of a subreg expression.
2731 xregno - A regno of an inner hard subreg_reg (or what will become one).
2732 xmode - The mode of xregno.
2733 offset - The byte offset.
2734 ymode - The mode of a top level SUBREG (or what may become one).
2735 RETURN - The regno offset which would be used.
2736 This function can be overridden by defining SUBREG_REGNO_OFFSET,
2737 taking the same parameters. */
2739 subreg_regno_offset (xregno
, xmode
, offset
, ymode
)
2740 unsigned int xregno
;
2741 enum machine_mode xmode
;
2742 unsigned int offset
;
2743 enum machine_mode ymode
;
2746 int nregs_xmode
, nregs_ymode
;
2747 int mode_multiple
, nregs_multiple
;
2750 /* Check for an override, and use it instead. */
2751 #ifdef SUBREG_REGNO_OFFSET
2752 ret
= SUBREG_REGNO_OFFSET (xregno
, xmode
, offset
, ymode
)
2754 if (xregno
>= FIRST_PSEUDO_REGISTER
)
2757 nregs_xmode
= HARD_REGNO_NREGS (xregno
, xmode
);
2758 nregs_ymode
= HARD_REGNO_NREGS (xregno
, ymode
);
2759 if (offset
== 0 || nregs_xmode
== nregs_ymode
)
2762 /* size of ymode must not be greater than the size of xmode. */
2763 mode_multiple
= GET_MODE_SIZE (xmode
) / GET_MODE_SIZE (ymode
);
2764 if (mode_multiple
== 0)
2767 y_offset
= offset
/ GET_MODE_SIZE (ymode
);
2768 nregs_multiple
= nregs_xmode
/ nregs_ymode
;
2769 ret
= (y_offset
/ (mode_multiple
/ nregs_multiple
)) * nregs_ymode
;
2775 /* Return the final regno that a subreg expression refers to. */
2781 rtx subreg
= SUBREG_REG (x
);
2782 int regno
= REGNO (subreg
);
2784 ret
= regno
+ subreg_regno_offset (regno
,