1 /* Analyze RTL for C-Compiler
2 Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
25 #include "coretypes.h"
29 #include "hard-reg-set.h"
30 #include "insn-config.h"
34 #include "basic-block.h"
37 /* Forward declarations */
38 static int global_reg_mentioned_p_1
PARAMS ((rtx
*, void *));
39 static void set_of_1
PARAMS ((rtx
, rtx
, void *));
40 static void insn_dependent_p_1
PARAMS ((rtx
, rtx
, void *));
41 static int rtx_referenced_p_1
PARAMS ((rtx
*, void *));
42 static int computed_jump_p_1
PARAMS ((rtx
));
43 static void parms_set
PARAMS ((rtx
, rtx
, void *));
44 static bool hoist_test_store
PARAMS ((rtx
, rtx
, regset
));
45 static void hoist_update_store
PARAMS ((rtx
, rtx
*, rtx
, rtx
));
47 /* Bit flags that specify the machine subtype we are compiling for.
48 Bits are tested using macros TARGET_... defined in the tm.h file
49 and set by `-m...' switches. Must be defined in rtlanal.c. */
53 /* Return 1 if the value of X is unstable
54 (would be different at a different point in the program).
55 The frame pointer, arg pointer, etc. are considered stable
56 (within one function) and so is anything marked `unchanging'. */
62 RTX_CODE code
= GET_CODE (x
);
69 return ! RTX_UNCHANGING_P (x
) || rtx_unstable_p (XEXP (x
, 0));
84 /* As in rtx_varies_p, we have to use the actual rtx, not reg number. */
85 if (x
== frame_pointer_rtx
|| x
== hard_frame_pointer_rtx
86 /* The arg pointer varies if it is not a fixed register. */
87 || (x
== arg_pointer_rtx
&& fixed_regs
[ARG_POINTER_REGNUM
])
88 || RTX_UNCHANGING_P (x
))
90 #ifndef PIC_OFFSET_TABLE_REG_CALL_CLOBBERED
91 /* ??? When call-clobbered, the value is stable modulo the restore
92 that must happen after a call. This currently screws up local-alloc
93 into believing that the restore is not needed. */
94 if (x
== pic_offset_table_rtx
)
100 if (MEM_VOLATILE_P (x
))
109 fmt
= GET_RTX_FORMAT (code
);
110 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
113 if (rtx_unstable_p (XEXP (x
, i
)))
116 else if (fmt
[i
] == 'E')
119 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
120 if (rtx_unstable_p (XVECEXP (x
, i
, j
)))
127 /* Return 1 if X has a value that can vary even between two
128 executions of the program. 0 means X can be compared reliably
129 against certain constants or near-constants.
130 FOR_ALIAS is nonzero if we are called from alias analysis; if it is
131 zero, we are slightly more conservative.
132 The frame pointer and the arg pointer are considered constant. */
135 rtx_varies_p (x
, for_alias
)
139 RTX_CODE code
= GET_CODE (x
);
146 return ! RTX_UNCHANGING_P (x
) || rtx_varies_p (XEXP (x
, 0), for_alias
);
160 /* This will resolve to some offset from the frame pointer. */
164 /* Note that we have to test for the actual rtx used for the frame
165 and arg pointers and not just the register number in case we have
166 eliminated the frame and/or arg pointer and are using it
168 if (x
== frame_pointer_rtx
|| x
== hard_frame_pointer_rtx
169 /* The arg pointer varies if it is not a fixed register. */
170 || (x
== arg_pointer_rtx
&& fixed_regs
[ARG_POINTER_REGNUM
]))
172 if (x
== pic_offset_table_rtx
173 #ifdef PIC_OFFSET_TABLE_REG_CALL_CLOBBERED
174 /* ??? When call-clobbered, the value is stable modulo the restore
175 that must happen after a call. This currently screws up
176 local-alloc into believing that the restore is not needed, so we
177 must return 0 only if we are called from alias analysis. */
185 /* The operand 0 of a LO_SUM is considered constant
186 (in fact it is related specifically to operand 1)
187 during alias analysis. */
188 return (! for_alias
&& rtx_varies_p (XEXP (x
, 0), for_alias
))
189 || rtx_varies_p (XEXP (x
, 1), for_alias
);
192 if (MEM_VOLATILE_P (x
))
201 fmt
= GET_RTX_FORMAT (code
);
202 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
205 if (rtx_varies_p (XEXP (x
, i
), for_alias
))
208 else if (fmt
[i
] == 'E')
211 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
212 if (rtx_varies_p (XVECEXP (x
, i
, j
), for_alias
))
219 /* Return 0 if the use of X as an address in a MEM can cause a trap. */
222 rtx_addr_can_trap_p (x
)
225 enum rtx_code code
= GET_CODE (x
);
230 return SYMBOL_REF_WEAK (x
);
236 /* This will resolve to some offset from the frame pointer. */
240 /* As in rtx_varies_p, we have to use the actual rtx, not reg number. */
241 if (x
== frame_pointer_rtx
|| x
== hard_frame_pointer_rtx
242 || x
== stack_pointer_rtx
243 /* The arg pointer varies if it is not a fixed register. */
244 || (x
== arg_pointer_rtx
&& fixed_regs
[ARG_POINTER_REGNUM
]))
246 /* All of the virtual frame registers are stack references. */
247 if (REGNO (x
) >= FIRST_VIRTUAL_REGISTER
248 && REGNO (x
) <= LAST_VIRTUAL_REGISTER
)
253 return rtx_addr_can_trap_p (XEXP (x
, 0));
256 /* An address is assumed not to trap if it is an address that can't
257 trap plus a constant integer or it is the pic register plus a
259 return ! ((! rtx_addr_can_trap_p (XEXP (x
, 0))
260 && GET_CODE (XEXP (x
, 1)) == CONST_INT
)
261 || (XEXP (x
, 0) == pic_offset_table_rtx
262 && CONSTANT_P (XEXP (x
, 1))));
266 return rtx_addr_can_trap_p (XEXP (x
, 1));
273 return rtx_addr_can_trap_p (XEXP (x
, 0));
279 /* If it isn't one of the case above, it can cause a trap. */
283 /* Return true if X is an address that is known to not be zero. */
286 nonzero_address_p (x
)
289 enum rtx_code code
= GET_CODE (x
);
294 return !SYMBOL_REF_WEAK (x
);
300 /* This will resolve to some offset from the frame pointer. */
304 /* As in rtx_varies_p, we have to use the actual rtx, not reg number. */
305 if (x
== frame_pointer_rtx
|| x
== hard_frame_pointer_rtx
306 || x
== stack_pointer_rtx
307 || (x
== arg_pointer_rtx
&& fixed_regs
[ARG_POINTER_REGNUM
]))
309 /* All of the virtual frame registers are stack references. */
310 if (REGNO (x
) >= FIRST_VIRTUAL_REGISTER
311 && REGNO (x
) <= LAST_VIRTUAL_REGISTER
)
316 return nonzero_address_p (XEXP (x
, 0));
319 if (GET_CODE (XEXP (x
, 1)) == CONST_INT
)
321 /* Pointers aren't allowed to wrap. If we've got a register
322 that is known to be a pointer, and a positive offset, then
323 the composite can't be zero. */
324 if (INTVAL (XEXP (x
, 1)) > 0
325 && REG_P (XEXP (x
, 0))
326 && REG_POINTER (XEXP (x
, 0)))
329 return nonzero_address_p (XEXP (x
, 0));
331 /* Handle PIC references. */
332 else if (XEXP (x
, 0) == pic_offset_table_rtx
333 && CONSTANT_P (XEXP (x
, 1)))
338 /* Similar to the above; allow positive offsets. Further, since
339 auto-inc is only allowed in memories, the register must be a
341 if (GET_CODE (XEXP (x
, 1)) == CONST_INT
342 && INTVAL (XEXP (x
, 1)) > 0)
344 return nonzero_address_p (XEXP (x
, 0));
347 /* Similarly. Further, the offset is always positive. */
354 return nonzero_address_p (XEXP (x
, 0));
357 return nonzero_address_p (XEXP (x
, 1));
363 /* If it isn't one of the case above, might be zero. */
367 /* Return 1 if X refers to a memory location whose address
368 cannot be compared reliably with constant addresses,
369 or if X refers to a BLKmode memory object.
370 FOR_ALIAS is nonzero if we are called from alias analysis; if it is
371 zero, we are slightly more conservative. */
374 rtx_addr_varies_p (x
, for_alias
)
387 return GET_MODE (x
) == BLKmode
|| rtx_varies_p (XEXP (x
, 0), for_alias
);
389 fmt
= GET_RTX_FORMAT (code
);
390 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
393 if (rtx_addr_varies_p (XEXP (x
, i
), for_alias
))
396 else if (fmt
[i
] == 'E')
399 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
400 if (rtx_addr_varies_p (XVECEXP (x
, i
, j
), for_alias
))
406 /* Return the value of the integer term in X, if one is apparent;
408 Only obvious integer terms are detected.
409 This is used in cse.c with the `related_value' field. */
415 if (GET_CODE (x
) == CONST
)
418 if (GET_CODE (x
) == MINUS
419 && GET_CODE (XEXP (x
, 1)) == CONST_INT
)
420 return - INTVAL (XEXP (x
, 1));
421 if (GET_CODE (x
) == PLUS
422 && GET_CODE (XEXP (x
, 1)) == CONST_INT
)
423 return INTVAL (XEXP (x
, 1));
427 /* If X is a constant, return the value sans apparent integer term;
429 Only obvious integer terms are detected. */
432 get_related_value (x
)
435 if (GET_CODE (x
) != CONST
)
438 if (GET_CODE (x
) == PLUS
439 && GET_CODE (XEXP (x
, 1)) == CONST_INT
)
441 else if (GET_CODE (x
) == MINUS
442 && GET_CODE (XEXP (x
, 1)) == CONST_INT
)
447 /* Given a tablejump insn INSN, return the RTL expression for the offset
448 into the jump table. If the offset cannot be determined, then return
451 If EARLIEST is nonzero, it is a pointer to a place where the earliest
452 insn used in locating the offset was found. */
455 get_jump_table_offset (insn
, earliest
)
469 if (!tablejump_p (insn
, &label
, &table
) || !(set
= single_set (insn
)))
474 /* Some targets (eg, ARM) emit a tablejump that also
475 contains the out-of-range target. */
476 if (GET_CODE (x
) == IF_THEN_ELSE
477 && GET_CODE (XEXP (x
, 2)) == LABEL_REF
)
480 /* Search backwards and locate the expression stored in X. */
481 for (old_x
= NULL_RTX
; GET_CODE (x
) == REG
&& x
!= old_x
;
482 old_x
= x
, x
= find_last_value (x
, &insn
, NULL_RTX
, 0))
485 /* If X is an expression using a relative address then strip
486 off the addition / subtraction of PC, PIC_OFFSET_TABLE_REGNUM,
487 or the jump table label. */
488 if (GET_CODE (PATTERN (table
)) == ADDR_DIFF_VEC
489 && (GET_CODE (x
) == PLUS
|| GET_CODE (x
) == MINUS
))
491 for (i
= 0; i
< 2; i
++)
496 if (y
== pc_rtx
|| y
== pic_offset_table_rtx
)
499 for (old_y
= NULL_RTX
; GET_CODE (y
) == REG
&& y
!= old_y
;
500 old_y
= y
, y
= find_last_value (y
, &old_insn
, NULL_RTX
, 0))
503 if ((GET_CODE (y
) == LABEL_REF
&& XEXP (y
, 0) == label
))
512 for (old_x
= NULL_RTX
; GET_CODE (x
) == REG
&& x
!= old_x
;
513 old_x
= x
, x
= find_last_value (x
, &insn
, NULL_RTX
, 0))
517 /* Strip off any sign or zero extension. */
518 if (GET_CODE (x
) == SIGN_EXTEND
|| GET_CODE (x
) == ZERO_EXTEND
)
522 for (old_x
= NULL_RTX
; GET_CODE (x
) == REG
&& x
!= old_x
;
523 old_x
= x
, x
= find_last_value (x
, &insn
, NULL_RTX
, 0))
527 /* If X isn't a MEM then this isn't a tablejump we understand. */
528 if (GET_CODE (x
) != MEM
)
531 /* Strip off the MEM. */
534 for (old_x
= NULL_RTX
; GET_CODE (x
) == REG
&& x
!= old_x
;
535 old_x
= x
, x
= find_last_value (x
, &insn
, NULL_RTX
, 0))
538 /* If X isn't a PLUS than this isn't a tablejump we understand. */
539 if (GET_CODE (x
) != PLUS
)
542 /* At this point we should have an expression representing the jump table
543 plus an offset. Examine each operand in order to determine which one
544 represents the jump table. Knowing that tells us that the other operand
545 must represent the offset. */
546 for (i
= 0; i
< 2; i
++)
551 for (old_y
= NULL_RTX
; GET_CODE (y
) == REG
&& y
!= old_y
;
552 old_y
= y
, y
= find_last_value (y
, &old_insn
, NULL_RTX
, 0))
555 if ((GET_CODE (y
) == CONST
|| GET_CODE (y
) == LABEL_REF
)
556 && reg_mentioned_p (label
, y
))
565 /* Strip off the addition / subtraction of PIC_OFFSET_TABLE_REGNUM. */
566 if (GET_CODE (x
) == PLUS
|| GET_CODE (x
) == MINUS
)
567 for (i
= 0; i
< 2; i
++)
568 if (XEXP (x
, i
) == pic_offset_table_rtx
)
577 /* Return the RTL expression representing the offset. */
581 /* A subroutine of global_reg_mentioned_p, returns 1 if *LOC mentions
582 a global register. */
585 global_reg_mentioned_p_1 (loc
, data
)
587 void *data ATTRIBUTE_UNUSED
;
595 switch (GET_CODE (x
))
598 if (GET_CODE (SUBREG_REG (x
)) == REG
)
600 if (REGNO (SUBREG_REG (x
)) < FIRST_PSEUDO_REGISTER
601 && global_regs
[subreg_regno (x
)])
609 if (regno
< FIRST_PSEUDO_REGISTER
&& global_regs
[regno
])
623 /* A non-constant call might use a global register. */
633 /* Returns nonzero if X mentions a global register. */
636 global_reg_mentioned_p (x
)
641 if (GET_CODE (x
) == CALL_INSN
)
643 if (! CONST_OR_PURE_CALL_P (x
))
645 x
= CALL_INSN_FUNCTION_USAGE (x
);
653 return for_each_rtx (&x
, global_reg_mentioned_p_1
, NULL
);
656 /* Return the number of places FIND appears within X. If COUNT_DEST is
657 zero, we do not count occurrences inside the destination of a SET. */
660 count_occurrences (x
, find
, count_dest
)
666 const char *format_ptr
;
687 if (GET_CODE (find
) == MEM
&& rtx_equal_p (x
, find
))
692 if (SET_DEST (x
) == find
&& ! count_dest
)
693 return count_occurrences (SET_SRC (x
), find
, count_dest
);
700 format_ptr
= GET_RTX_FORMAT (code
);
703 for (i
= 0; i
< GET_RTX_LENGTH (code
); i
++)
705 switch (*format_ptr
++)
708 count
+= count_occurrences (XEXP (x
, i
), find
, count_dest
);
712 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
713 count
+= count_occurrences (XVECEXP (x
, i
, j
), find
, count_dest
);
720 /* Nonzero if register REG appears somewhere within IN.
721 Also works if REG is not a register; in this case it checks
722 for a subexpression of IN that is Lisp "equal" to REG. */
725 reg_mentioned_p (reg
, in
)
738 if (GET_CODE (in
) == LABEL_REF
)
739 return reg
== XEXP (in
, 0);
741 code
= GET_CODE (in
);
745 /* Compare registers by number. */
747 return GET_CODE (reg
) == REG
&& REGNO (in
) == REGNO (reg
);
749 /* These codes have no constituent expressions
757 return GET_CODE (reg
) == CONST_INT
&& INTVAL (in
) == INTVAL (reg
);
761 /* These are kept unique for a given value. */
768 if (GET_CODE (reg
) == code
&& rtx_equal_p (reg
, in
))
771 fmt
= GET_RTX_FORMAT (code
);
773 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
778 for (j
= XVECLEN (in
, i
) - 1; j
>= 0; j
--)
779 if (reg_mentioned_p (reg
, XVECEXP (in
, i
, j
)))
782 else if (fmt
[i
] == 'e'
783 && reg_mentioned_p (reg
, XEXP (in
, i
)))
789 /* Return 1 if in between BEG and END, exclusive of BEG and END, there is
790 no CODE_LABEL insn. */
793 no_labels_between_p (beg
, end
)
799 for (p
= NEXT_INSN (beg
); p
!= end
; p
= NEXT_INSN (p
))
800 if (GET_CODE (p
) == CODE_LABEL
)
805 /* Return 1 if in between BEG and END, exclusive of BEG and END, there is
806 no JUMP_INSN insn. */
809 no_jumps_between_p (beg
, end
)
813 for (p
= NEXT_INSN (beg
); p
!= end
; p
= NEXT_INSN (p
))
814 if (GET_CODE (p
) == JUMP_INSN
)
819 /* Nonzero if register REG is used in an insn between
820 FROM_INSN and TO_INSN (exclusive of those two). */
823 reg_used_between_p (reg
, from_insn
, to_insn
)
824 rtx reg
, from_insn
, to_insn
;
828 if (from_insn
== to_insn
)
831 for (insn
= NEXT_INSN (from_insn
); insn
!= to_insn
; insn
= NEXT_INSN (insn
))
833 && (reg_overlap_mentioned_p (reg
, PATTERN (insn
))
834 || (GET_CODE (insn
) == CALL_INSN
835 && (find_reg_fusage (insn
, USE
, reg
)
836 || find_reg_fusage (insn
, CLOBBER
, reg
)))))
841 /* Nonzero if the old value of X, a register, is referenced in BODY. If X
842 is entirely replaced by a new value and the only use is as a SET_DEST,
843 we do not consider it a reference. */
846 reg_referenced_p (x
, body
)
852 switch (GET_CODE (body
))
855 if (reg_overlap_mentioned_p (x
, SET_SRC (body
)))
858 /* If the destination is anything other than CC0, PC, a REG or a SUBREG
859 of a REG that occupies all of the REG, the insn references X if
860 it is mentioned in the destination. */
861 if (GET_CODE (SET_DEST (body
)) != CC0
862 && GET_CODE (SET_DEST (body
)) != PC
863 && GET_CODE (SET_DEST (body
)) != REG
864 && ! (GET_CODE (SET_DEST (body
)) == SUBREG
865 && GET_CODE (SUBREG_REG (SET_DEST (body
))) == REG
866 && (((GET_MODE_SIZE (GET_MODE (SUBREG_REG (SET_DEST (body
))))
867 + (UNITS_PER_WORD
- 1)) / UNITS_PER_WORD
)
868 == ((GET_MODE_SIZE (GET_MODE (SET_DEST (body
)))
869 + (UNITS_PER_WORD
- 1)) / UNITS_PER_WORD
)))
870 && reg_overlap_mentioned_p (x
, SET_DEST (body
)))
875 for (i
= ASM_OPERANDS_INPUT_LENGTH (body
) - 1; i
>= 0; i
--)
876 if (reg_overlap_mentioned_p (x
, ASM_OPERANDS_INPUT (body
, i
)))
883 return reg_overlap_mentioned_p (x
, body
);
886 return reg_overlap_mentioned_p (x
, TRAP_CONDITION (body
));
889 return reg_overlap_mentioned_p (x
, XEXP (body
, 0));
892 case UNSPEC_VOLATILE
:
893 for (i
= XVECLEN (body
, 0) - 1; i
>= 0; i
--)
894 if (reg_overlap_mentioned_p (x
, XVECEXP (body
, 0, i
)))
899 for (i
= XVECLEN (body
, 0) - 1; i
>= 0; i
--)
900 if (reg_referenced_p (x
, XVECEXP (body
, 0, i
)))
905 if (GET_CODE (XEXP (body
, 0)) == MEM
)
906 if (reg_overlap_mentioned_p (x
, XEXP (XEXP (body
, 0), 0)))
911 if (reg_overlap_mentioned_p (x
, COND_EXEC_TEST (body
)))
913 return reg_referenced_p (x
, COND_EXEC_CODE (body
));
920 /* Nonzero if register REG is referenced in an insn between
921 FROM_INSN and TO_INSN (exclusive of those two). Sets of REG do
925 reg_referenced_between_p (reg
, from_insn
, to_insn
)
926 rtx reg
, from_insn
, to_insn
;
930 if (from_insn
== to_insn
)
933 for (insn
= NEXT_INSN (from_insn
); insn
!= to_insn
; insn
= NEXT_INSN (insn
))
935 && (reg_referenced_p (reg
, PATTERN (insn
))
936 || (GET_CODE (insn
) == CALL_INSN
937 && find_reg_fusage (insn
, USE
, reg
))))
942 /* Nonzero if register REG is set or clobbered in an insn between
943 FROM_INSN and TO_INSN (exclusive of those two). */
946 reg_set_between_p (reg
, from_insn
, to_insn
)
947 rtx reg
, from_insn
, to_insn
;
951 if (from_insn
== to_insn
)
954 for (insn
= NEXT_INSN (from_insn
); insn
!= to_insn
; insn
= NEXT_INSN (insn
))
955 if (INSN_P (insn
) && reg_set_p (reg
, insn
))
960 /* Internals of reg_set_between_p. */
962 reg_set_p (reg
, insn
)
965 /* We can be passed an insn or part of one. If we are passed an insn,
966 check if a side-effect of the insn clobbers REG. */
968 && (FIND_REG_INC_NOTE (insn
, reg
)
969 || (GET_CODE (insn
) == CALL_INSN
970 /* We'd like to test call_used_regs here, but rtlanal.c can't
971 reference that variable due to its use in genattrtab. So
972 we'll just be more conservative.
974 ??? Unless we could ensure that the CALL_INSN_FUNCTION_USAGE
975 information holds all clobbered registers. */
976 && ((GET_CODE (reg
) == REG
977 && REGNO (reg
) < FIRST_PSEUDO_REGISTER
)
978 || GET_CODE (reg
) == MEM
979 || find_reg_fusage (insn
, CLOBBER
, reg
)))))
982 return set_of (reg
, insn
) != NULL_RTX
;
985 /* Similar to reg_set_between_p, but check all registers in X. Return 0
986 only if none of them are modified between START and END. Do not
987 consider non-registers one way or the other. */
990 regs_set_between_p (x
, start
, end
)
994 enum rtx_code code
= GET_CODE (x
);
1011 return reg_set_between_p (x
, start
, end
);
1017 fmt
= GET_RTX_FORMAT (code
);
1018 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
1020 if (fmt
[i
] == 'e' && regs_set_between_p (XEXP (x
, i
), start
, end
))
1023 else if (fmt
[i
] == 'E')
1024 for (j
= XVECLEN (x
, i
) - 1; j
>= 0; j
--)
1025 if (regs_set_between_p (XVECEXP (x
, i
, j
), start
, end
))
1032 /* Similar to reg_set_between_p, but check all registers in X. Return 0
1033 only if none of them are modified between START and END. Return 1 if
1034 X contains a MEM; this routine does usememory aliasing. */
1037 modified_between_p (x
, start
, end
)
1041 enum rtx_code code
= GET_CODE (x
);
1064 if (RTX_UNCHANGING_P (x
))
1066 if (modified_between_p (XEXP (x
, 0), start
, end
))
1068 for (insn
= NEXT_INSN (start
); insn
!= end
; insn
= NEXT_INSN (insn
))
1069 if (memory_modified_in_insn_p (x
, insn
))
1075 return reg_set_between_p (x
, start
, end
);
1081 fmt
= GET_RTX_FORMAT (code
);
1082 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
1084 if (fmt
[i
] == 'e' && modified_between_p (XEXP (x
, i
), start
, end
))
1087 else if (fmt
[i
] == 'E')
1088 for (j
= XVECLEN (x
, i
) - 1; j
>= 0; j
--)
1089 if (modified_between_p (XVECEXP (x
, i
, j
), start
, end
))
1096 /* Similar to reg_set_p, but check all registers in X. Return 0 only if none
1097 of them are modified in INSN. Return 1 if X contains a MEM; this routine
1098 does use memory aliasing. */
1101 modified_in_p (x
, insn
)
1105 enum rtx_code code
= GET_CODE (x
);
1124 if (RTX_UNCHANGING_P (x
))
1126 if (modified_in_p (XEXP (x
, 0), insn
))
1128 if (memory_modified_in_insn_p (x
, insn
))
1134 return reg_set_p (x
, insn
);
1140 fmt
= GET_RTX_FORMAT (code
);
1141 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
1143 if (fmt
[i
] == 'e' && modified_in_p (XEXP (x
, i
), insn
))
1146 else if (fmt
[i
] == 'E')
1147 for (j
= XVECLEN (x
, i
) - 1; j
>= 0; j
--)
1148 if (modified_in_p (XVECEXP (x
, i
, j
), insn
))
1155 /* Return true if anything in insn X is (anti,output,true) dependent on
1156 anything in insn Y. */
1159 insn_dependent_p (x
, y
)
1164 if (! INSN_P (x
) || ! INSN_P (y
))
1168 note_stores (PATTERN (x
), insn_dependent_p_1
, &tmp
);
1169 if (tmp
== NULL_RTX
)
1173 note_stores (PATTERN (y
), insn_dependent_p_1
, &tmp
);
1174 if (tmp
== NULL_RTX
)
1180 /* A helper routine for insn_dependent_p called through note_stores. */
1183 insn_dependent_p_1 (x
, pat
, data
)
1185 rtx pat ATTRIBUTE_UNUSED
;
1188 rtx
* pinsn
= (rtx
*) data
;
1190 if (*pinsn
&& reg_mentioned_p (x
, *pinsn
))
1194 /* Helper function for set_of. */
1202 set_of_1 (x
, pat
, data1
)
1207 struct set_of_data
*data
= (struct set_of_data
*) (data1
);
1208 if (rtx_equal_p (x
, data
->pat
)
1209 || (GET_CODE (x
) != MEM
&& reg_overlap_mentioned_p (data
->pat
, x
)))
1213 /* Give an INSN, return a SET or CLOBBER expression that does modify PAT
1214 (either directly or via STRICT_LOW_PART and similar modifiers). */
1219 struct set_of_data data
;
1220 data
.found
= NULL_RTX
;
1222 note_stores (INSN_P (insn
) ? PATTERN (insn
) : insn
, set_of_1
, &data
);
1226 /* Given an INSN, return a SET expression if this insn has only a single SET.
1227 It may also have CLOBBERs, USEs, or SET whose output
1228 will not be used, which we ignore. */
1231 single_set_2 (insn
, pat
)
1235 int set_verified
= 1;
1238 if (GET_CODE (pat
) == PARALLEL
)
1240 for (i
= 0; i
< XVECLEN (pat
, 0); i
++)
1242 rtx sub
= XVECEXP (pat
, 0, i
);
1243 switch (GET_CODE (sub
))
1250 /* We can consider insns having multiple sets, where all
1251 but one are dead as single set insns. In common case
1252 only single set is present in the pattern so we want
1253 to avoid checking for REG_UNUSED notes unless necessary.
1255 When we reach set first time, we just expect this is
1256 the single set we are looking for and only when more
1257 sets are found in the insn, we check them. */
1260 if (find_reg_note (insn
, REG_UNUSED
, SET_DEST (set
))
1261 && !side_effects_p (set
))
1267 set
= sub
, set_verified
= 0;
1268 else if (!find_reg_note (insn
, REG_UNUSED
, SET_DEST (sub
))
1269 || side_effects_p (sub
))
1281 /* Given an INSN, return nonzero if it has more than one SET, else return
1285 multiple_sets (insn
)
1291 /* INSN must be an insn. */
1292 if (! INSN_P (insn
))
1295 /* Only a PARALLEL can have multiple SETs. */
1296 if (GET_CODE (PATTERN (insn
)) == PARALLEL
)
1298 for (i
= 0, found
= 0; i
< XVECLEN (PATTERN (insn
), 0); i
++)
1299 if (GET_CODE (XVECEXP (PATTERN (insn
), 0, i
)) == SET
)
1301 /* If we have already found a SET, then return now. */
1309 /* Either zero or one SET. */
1313 /* Return nonzero if the destination of SET equals the source
1314 and there are no side effects. */
1320 rtx src
= SET_SRC (set
);
1321 rtx dst
= SET_DEST (set
);
1323 if (dst
== pc_rtx
&& src
== pc_rtx
)
1326 if (GET_CODE (dst
) == MEM
&& GET_CODE (src
) == MEM
)
1327 return rtx_equal_p (dst
, src
) && !side_effects_p (dst
);
1329 if (GET_CODE (dst
) == SIGN_EXTRACT
1330 || GET_CODE (dst
) == ZERO_EXTRACT
)
1331 return rtx_equal_p (XEXP (dst
, 0), src
)
1332 && ! BYTES_BIG_ENDIAN
&& XEXP (dst
, 2) == const0_rtx
1333 && !side_effects_p (src
);
1335 if (GET_CODE (dst
) == STRICT_LOW_PART
)
1336 dst
= XEXP (dst
, 0);
1338 if (GET_CODE (src
) == SUBREG
&& GET_CODE (dst
) == SUBREG
)
1340 if (SUBREG_BYTE (src
) != SUBREG_BYTE (dst
))
1342 src
= SUBREG_REG (src
);
1343 dst
= SUBREG_REG (dst
);
1346 return (GET_CODE (src
) == REG
&& GET_CODE (dst
) == REG
1347 && REGNO (src
) == REGNO (dst
));
1350 /* Return nonzero if an insn consists only of SETs, each of which only sets a
1357 rtx pat
= PATTERN (insn
);
1359 if (INSN_CODE (insn
) == NOOP_MOVE_INSN_CODE
)
1362 /* Insns carrying these notes are useful later on. */
1363 if (find_reg_note (insn
, REG_EQUAL
, NULL_RTX
))
1366 /* For now treat an insn with a REG_RETVAL note as a
1367 a special insn which should not be considered a no-op. */
1368 if (find_reg_note (insn
, REG_RETVAL
, NULL_RTX
))
1371 if (GET_CODE (pat
) == SET
&& set_noop_p (pat
))
1374 if (GET_CODE (pat
) == PARALLEL
)
1377 /* If nothing but SETs of registers to themselves,
1378 this insn can also be deleted. */
1379 for (i
= 0; i
< XVECLEN (pat
, 0); i
++)
1381 rtx tem
= XVECEXP (pat
, 0, i
);
1383 if (GET_CODE (tem
) == USE
1384 || GET_CODE (tem
) == CLOBBER
)
1387 if (GET_CODE (tem
) != SET
|| ! set_noop_p (tem
))
1397 /* Return the last thing that X was assigned from before *PINSN. If VALID_TO
1398 is not NULL_RTX then verify that the object is not modified up to VALID_TO.
1399 If the object was modified, if we hit a partial assignment to X, or hit a
1400 CODE_LABEL first, return X. If we found an assignment, update *PINSN to
1401 point to it. ALLOW_HWREG is set to 1 if hardware registers are allowed to
1405 find_last_value (x
, pinsn
, valid_to
, allow_hwreg
)
1413 for (p
= PREV_INSN (*pinsn
); p
&& GET_CODE (p
) != CODE_LABEL
;
1417 rtx set
= single_set (p
);
1418 rtx note
= find_reg_note (p
, REG_EQUAL
, NULL_RTX
);
1420 if (set
&& rtx_equal_p (x
, SET_DEST (set
)))
1422 rtx src
= SET_SRC (set
);
1424 if (note
&& GET_CODE (XEXP (note
, 0)) != EXPR_LIST
)
1425 src
= XEXP (note
, 0);
1427 if ((valid_to
== NULL_RTX
1428 || ! modified_between_p (src
, PREV_INSN (p
), valid_to
))
1429 /* Reject hard registers because we don't usually want
1430 to use them; we'd rather use a pseudo. */
1431 && (! (GET_CODE (src
) == REG
1432 && REGNO (src
) < FIRST_PSEUDO_REGISTER
) || allow_hwreg
))
1439 /* If set in non-simple way, we don't have a value. */
1440 if (reg_set_p (x
, p
))
1447 /* Return nonzero if register in range [REGNO, ENDREGNO)
1448 appears either explicitly or implicitly in X
1449 other than being stored into.
1451 References contained within the substructure at LOC do not count.
1452 LOC may be zero, meaning don't ignore anything. */
1455 refers_to_regno_p (regno
, endregno
, x
, loc
)
1456 unsigned int regno
, endregno
;
1461 unsigned int x_regno
;
1466 /* The contents of a REG_NONNEG note is always zero, so we must come here
1467 upon repeat in case the last REG_NOTE is a REG_NONNEG note. */
1471 code
= GET_CODE (x
);
1476 x_regno
= REGNO (x
);
1478 /* If we modifying the stack, frame, or argument pointer, it will
1479 clobber a virtual register. In fact, we could be more precise,
1480 but it isn't worth it. */
1481 if ((x_regno
== STACK_POINTER_REGNUM
1482 #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
1483 || x_regno
== ARG_POINTER_REGNUM
1485 || x_regno
== FRAME_POINTER_REGNUM
)
1486 && regno
>= FIRST_VIRTUAL_REGISTER
&& regno
<= LAST_VIRTUAL_REGISTER
)
1489 return (endregno
> x_regno
1490 && regno
< x_regno
+ (x_regno
< FIRST_PSEUDO_REGISTER
1491 ? HARD_REGNO_NREGS (x_regno
, GET_MODE (x
))
1495 /* If this is a SUBREG of a hard reg, we can see exactly which
1496 registers are being modified. Otherwise, handle normally. */
1497 if (GET_CODE (SUBREG_REG (x
)) == REG
1498 && REGNO (SUBREG_REG (x
)) < FIRST_PSEUDO_REGISTER
)
1500 unsigned int inner_regno
= subreg_regno (x
);
1501 unsigned int inner_endregno
1502 = inner_regno
+ (inner_regno
< FIRST_PSEUDO_REGISTER
1503 ? HARD_REGNO_NREGS (regno
, GET_MODE (x
)) : 1);
1505 return endregno
> inner_regno
&& regno
< inner_endregno
;
1511 if (&SET_DEST (x
) != loc
1512 /* Note setting a SUBREG counts as referring to the REG it is in for
1513 a pseudo but not for hard registers since we can
1514 treat each word individually. */
1515 && ((GET_CODE (SET_DEST (x
)) == SUBREG
1516 && loc
!= &SUBREG_REG (SET_DEST (x
))
1517 && GET_CODE (SUBREG_REG (SET_DEST (x
))) == REG
1518 && REGNO (SUBREG_REG (SET_DEST (x
))) >= FIRST_PSEUDO_REGISTER
1519 && refers_to_regno_p (regno
, endregno
,
1520 SUBREG_REG (SET_DEST (x
)), loc
))
1521 || (GET_CODE (SET_DEST (x
)) != REG
1522 && refers_to_regno_p (regno
, endregno
, SET_DEST (x
), loc
))))
1525 if (code
== CLOBBER
|| loc
== &SET_SRC (x
))
1534 /* X does not match, so try its subexpressions. */
1536 fmt
= GET_RTX_FORMAT (code
);
1537 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
1539 if (fmt
[i
] == 'e' && loc
!= &XEXP (x
, i
))
1547 if (refers_to_regno_p (regno
, endregno
, XEXP (x
, i
), loc
))
1550 else if (fmt
[i
] == 'E')
1553 for (j
= XVECLEN (x
, i
) - 1; j
>= 0; j
--)
1554 if (loc
!= &XVECEXP (x
, i
, j
)
1555 && refers_to_regno_p (regno
, endregno
, XVECEXP (x
, i
, j
), loc
))
1562 /* Nonzero if modifying X will affect IN. If X is a register or a SUBREG,
1563 we check if any register number in X conflicts with the relevant register
1564 numbers. If X is a constant, return 0. If X is a MEM, return 1 iff IN
1565 contains a MEM (we don't bother checking for memory addresses that can't
1566 conflict because we expect this to be a rare case. */
1569 reg_overlap_mentioned_p (x
, in
)
1572 unsigned int regno
, endregno
;
1574 /* Overly conservative. */
1575 if (GET_CODE (x
) == STRICT_LOW_PART
1576 || GET_CODE (x
) == ZERO_EXTRACT
1577 || GET_CODE (x
) == SIGN_EXTRACT
)
1580 /* If either argument is a constant, then modifying X can not affect IN. */
1581 if (CONSTANT_P (x
) || CONSTANT_P (in
))
1584 switch (GET_CODE (x
))
1587 regno
= REGNO (SUBREG_REG (x
));
1588 if (regno
< FIRST_PSEUDO_REGISTER
)
1589 regno
= subreg_regno (x
);
1595 endregno
= regno
+ (regno
< FIRST_PSEUDO_REGISTER
1596 ? HARD_REGNO_NREGS (regno
, GET_MODE (x
)) : 1);
1597 return refers_to_regno_p (regno
, endregno
, in
, (rtx
*) 0);
1604 if (GET_CODE (in
) == MEM
)
1607 fmt
= GET_RTX_FORMAT (GET_CODE (in
));
1608 for (i
= GET_RTX_LENGTH (GET_CODE (in
)) - 1; i
>= 0; i
--)
1609 if (fmt
[i
] == 'e' && reg_overlap_mentioned_p (x
, XEXP (in
, i
)))
1618 return reg_mentioned_p (x
, in
);
1624 /* If any register in here refers to it we return true. */
1625 for (i
= XVECLEN (x
, 0) - 1; i
>= 0; i
--)
1626 if (XEXP (XVECEXP (x
, 0, i
), 0) != 0
1627 && reg_overlap_mentioned_p (XEXP (XVECEXP (x
, 0, i
), 0), in
))
1639 /* Return the last value to which REG was set prior to INSN. If we can't
1640 find it easily, return 0.
1642 We only return a REG, SUBREG, or constant because it is too hard to
1643 check if a MEM remains unchanged. */
1646 reg_set_last (x
, insn
)
1650 rtx orig_insn
= insn
;
1652 /* Scan backwards until reg_set_last_1 changed one of the above flags.
1653 Stop when we reach a label or X is a hard reg and we reach a
1654 CALL_INSN (if reg_set_last_last_regno is a hard reg).
1656 If we find a set of X, ensure that its SET_SRC remains unchanged. */
1658 /* We compare with <= here, because reg_set_last_last_regno
1659 is actually the number of the first reg *not* in X. */
1661 insn
&& GET_CODE (insn
) != CODE_LABEL
1662 && ! (GET_CODE (insn
) == CALL_INSN
1663 && REGNO (x
) <= FIRST_PSEUDO_REGISTER
);
1664 insn
= PREV_INSN (insn
))
1667 rtx set
= set_of (x
, insn
);
1668 /* OK, this function modify our register. See if we understand it. */
1672 if (GET_CODE (set
) != SET
|| SET_DEST (set
) != x
)
1674 last_value
= SET_SRC (x
);
1675 if (CONSTANT_P (last_value
)
1676 || ((GET_CODE (last_value
) == REG
1677 || GET_CODE (last_value
) == SUBREG
)
1678 && ! reg_set_between_p (last_value
,
1689 /* Call FUN on each register or MEM that is stored into or clobbered by X.
1690 (X would be the pattern of an insn).
1691 FUN receives two arguments:
1692 the REG, MEM, CC0 or PC being stored in or clobbered,
1693 the SET or CLOBBER rtx that does the store.
1695 If the item being stored in or clobbered is a SUBREG of a hard register,
1696 the SUBREG will be passed. */
1699 note_stores (x
, fun
, data
)
1701 void (*fun
) PARAMS ((rtx
, rtx
, void *));
1706 if (GET_CODE (x
) == COND_EXEC
)
1707 x
= COND_EXEC_CODE (x
);
1709 if (GET_CODE (x
) == SET
|| GET_CODE (x
) == CLOBBER
)
1711 rtx dest
= SET_DEST (x
);
1713 while ((GET_CODE (dest
) == SUBREG
1714 && (GET_CODE (SUBREG_REG (dest
)) != REG
1715 || REGNO (SUBREG_REG (dest
)) >= FIRST_PSEUDO_REGISTER
))
1716 || GET_CODE (dest
) == ZERO_EXTRACT
1717 || GET_CODE (dest
) == SIGN_EXTRACT
1718 || GET_CODE (dest
) == STRICT_LOW_PART
)
1719 dest
= XEXP (dest
, 0);
1721 /* If we have a PARALLEL, SET_DEST is a list of EXPR_LIST expressions,
1722 each of whose first operand is a register. */
1723 if (GET_CODE (dest
) == PARALLEL
)
1725 for (i
= XVECLEN (dest
, 0) - 1; i
>= 0; i
--)
1726 if (XEXP (XVECEXP (dest
, 0, i
), 0) != 0)
1727 (*fun
) (XEXP (XVECEXP (dest
, 0, i
), 0), x
, data
);
1730 (*fun
) (dest
, x
, data
);
1733 else if (GET_CODE (x
) == PARALLEL
)
1734 for (i
= XVECLEN (x
, 0) - 1; i
>= 0; i
--)
1735 note_stores (XVECEXP (x
, 0, i
), fun
, data
);
1738 /* Like notes_stores, but call FUN for each expression that is being
1739 referenced in PBODY, a pointer to the PATTERN of an insn. We only call
1740 FUN for each expression, not any interior subexpressions. FUN receives a
1741 pointer to the expression and the DATA passed to this function.
1743 Note that this is not quite the same test as that done in reg_referenced_p
1744 since that considers something as being referenced if it is being
1745 partially set, while we do not. */
1748 note_uses (pbody
, fun
, data
)
1750 void (*fun
) PARAMS ((rtx
*, void *));
1756 switch (GET_CODE (body
))
1759 (*fun
) (&COND_EXEC_TEST (body
), data
);
1760 note_uses (&COND_EXEC_CODE (body
), fun
, data
);
1764 for (i
= XVECLEN (body
, 0) - 1; i
>= 0; i
--)
1765 note_uses (&XVECEXP (body
, 0, i
), fun
, data
);
1769 (*fun
) (&XEXP (body
, 0), data
);
1773 for (i
= ASM_OPERANDS_INPUT_LENGTH (body
) - 1; i
>= 0; i
--)
1774 (*fun
) (&ASM_OPERANDS_INPUT (body
, i
), data
);
1778 (*fun
) (&TRAP_CONDITION (body
), data
);
1782 (*fun
) (&XEXP (body
, 0), data
);
1786 case UNSPEC_VOLATILE
:
1787 for (i
= XVECLEN (body
, 0) - 1; i
>= 0; i
--)
1788 (*fun
) (&XVECEXP (body
, 0, i
), data
);
1792 if (GET_CODE (XEXP (body
, 0)) == MEM
)
1793 (*fun
) (&XEXP (XEXP (body
, 0), 0), data
);
1798 rtx dest
= SET_DEST (body
);
1800 /* For sets we replace everything in source plus registers in memory
1801 expression in store and operands of a ZERO_EXTRACT. */
1802 (*fun
) (&SET_SRC (body
), data
);
1804 if (GET_CODE (dest
) == ZERO_EXTRACT
)
1806 (*fun
) (&XEXP (dest
, 1), data
);
1807 (*fun
) (&XEXP (dest
, 2), data
);
1810 while (GET_CODE (dest
) == SUBREG
|| GET_CODE (dest
) == STRICT_LOW_PART
)
1811 dest
= XEXP (dest
, 0);
1813 if (GET_CODE (dest
) == MEM
)
1814 (*fun
) (&XEXP (dest
, 0), data
);
1819 /* All the other possibilities never store. */
1820 (*fun
) (pbody
, data
);
1825 /* Return nonzero if X's old contents don't survive after INSN.
1826 This will be true if X is (cc0) or if X is a register and
1827 X dies in INSN or because INSN entirely sets X.
1829 "Entirely set" means set directly and not through a SUBREG,
1830 ZERO_EXTRACT or SIGN_EXTRACT, so no trace of the old contents remains.
1831 Likewise, REG_INC does not count.
1833 REG may be a hard or pseudo reg. Renumbering is not taken into account,
1834 but for this use that makes no difference, since regs don't overlap
1835 during their lifetimes. Therefore, this function may be used
1836 at any time after deaths have been computed (in flow.c).
1838 If REG is a hard reg that occupies multiple machine registers, this
1839 function will only return 1 if each of those registers will be replaced
1843 dead_or_set_p (insn
, x
)
1847 unsigned int regno
, last_regno
;
1850 /* Can't use cc0_rtx below since this file is used by genattrtab.c. */
1851 if (GET_CODE (x
) == CC0
)
1854 if (GET_CODE (x
) != REG
)
1858 last_regno
= (regno
>= FIRST_PSEUDO_REGISTER
? regno
1859 : regno
+ HARD_REGNO_NREGS (regno
, GET_MODE (x
)) - 1);
1861 for (i
= regno
; i
<= last_regno
; i
++)
1862 if (! dead_or_set_regno_p (insn
, i
))
1868 /* Utility function for dead_or_set_p to check an individual register. Also
1869 called from flow.c. */
1872 dead_or_set_regno_p (insn
, test_regno
)
1874 unsigned int test_regno
;
1876 unsigned int regno
, endregno
;
1879 /* See if there is a death note for something that includes TEST_REGNO. */
1880 if (find_regno_note (insn
, REG_DEAD
, test_regno
))
1883 if (GET_CODE (insn
) == CALL_INSN
1884 && find_regno_fusage (insn
, CLOBBER
, test_regno
))
1887 pattern
= PATTERN (insn
);
1889 if (GET_CODE (pattern
) == COND_EXEC
)
1890 pattern
= COND_EXEC_CODE (pattern
);
1892 if (GET_CODE (pattern
) == SET
)
1894 rtx dest
= SET_DEST (pattern
);
1896 /* A value is totally replaced if it is the destination or the
1897 destination is a SUBREG of REGNO that does not change the number of
1899 if (GET_CODE (dest
) == SUBREG
1900 && (((GET_MODE_SIZE (GET_MODE (dest
))
1901 + UNITS_PER_WORD
- 1) / UNITS_PER_WORD
)
1902 == ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (dest
)))
1903 + UNITS_PER_WORD
- 1) / UNITS_PER_WORD
)))
1904 dest
= SUBREG_REG (dest
);
1906 if (GET_CODE (dest
) != REG
)
1909 regno
= REGNO (dest
);
1910 endregno
= (regno
>= FIRST_PSEUDO_REGISTER
? regno
+ 1
1911 : regno
+ HARD_REGNO_NREGS (regno
, GET_MODE (dest
)));
1913 return (test_regno
>= regno
&& test_regno
< endregno
);
1915 else if (GET_CODE (pattern
) == PARALLEL
)
1919 for (i
= XVECLEN (pattern
, 0) - 1; i
>= 0; i
--)
1921 rtx body
= XVECEXP (pattern
, 0, i
);
1923 if (GET_CODE (body
) == COND_EXEC
)
1924 body
= COND_EXEC_CODE (body
);
1926 if (GET_CODE (body
) == SET
|| GET_CODE (body
) == CLOBBER
)
1928 rtx dest
= SET_DEST (body
);
1930 if (GET_CODE (dest
) == SUBREG
1931 && (((GET_MODE_SIZE (GET_MODE (dest
))
1932 + UNITS_PER_WORD
- 1) / UNITS_PER_WORD
)
1933 == ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (dest
)))
1934 + UNITS_PER_WORD
- 1) / UNITS_PER_WORD
)))
1935 dest
= SUBREG_REG (dest
);
1937 if (GET_CODE (dest
) != REG
)
1940 regno
= REGNO (dest
);
1941 endregno
= (regno
>= FIRST_PSEUDO_REGISTER
? regno
+ 1
1942 : regno
+ HARD_REGNO_NREGS (regno
, GET_MODE (dest
)));
1944 if (test_regno
>= regno
&& test_regno
< endregno
)
1953 /* Return the reg-note of kind KIND in insn INSN, if there is one.
1954 If DATUM is nonzero, look for one whose datum is DATUM. */
1957 find_reg_note (insn
, kind
, datum
)
1964 /* Ignore anything that is not an INSN, JUMP_INSN or CALL_INSN. */
1965 if (! INSN_P (insn
))
1968 for (link
= REG_NOTES (insn
); link
; link
= XEXP (link
, 1))
1969 if (REG_NOTE_KIND (link
) == kind
1970 && (datum
== 0 || datum
== XEXP (link
, 0)))
1975 /* Return the reg-note of kind KIND in insn INSN which applies to register
1976 number REGNO, if any. Return 0 if there is no such reg-note. Note that
1977 the REGNO of this NOTE need not be REGNO if REGNO is a hard register;
1978 it might be the case that the note overlaps REGNO. */
1981 find_regno_note (insn
, kind
, regno
)
1988 /* Ignore anything that is not an INSN, JUMP_INSN or CALL_INSN. */
1989 if (! INSN_P (insn
))
1992 for (link
= REG_NOTES (insn
); link
; link
= XEXP (link
, 1))
1993 if (REG_NOTE_KIND (link
) == kind
1994 /* Verify that it is a register, so that scratch and MEM won't cause a
1996 && GET_CODE (XEXP (link
, 0)) == REG
1997 && REGNO (XEXP (link
, 0)) <= regno
1998 && ((REGNO (XEXP (link
, 0))
1999 + (REGNO (XEXP (link
, 0)) >= FIRST_PSEUDO_REGISTER
? 1
2000 : HARD_REGNO_NREGS (REGNO (XEXP (link
, 0)),
2001 GET_MODE (XEXP (link
, 0)))))
2007 /* Return a REG_EQUIV or REG_EQUAL note if insn has only a single set and
2011 find_reg_equal_equiv_note (insn
)
2018 for (link
= REG_NOTES (insn
); link
; link
= XEXP (link
, 1))
2019 if (REG_NOTE_KIND (link
) == REG_EQUAL
2020 || REG_NOTE_KIND (link
) == REG_EQUIV
)
2022 if (single_set (insn
) == 0)
2029 /* Return true if DATUM, or any overlap of DATUM, of kind CODE is found
2030 in the CALL_INSN_FUNCTION_USAGE information of INSN. */
2033 find_reg_fusage (insn
, code
, datum
)
2038 /* If it's not a CALL_INSN, it can't possibly have a
2039 CALL_INSN_FUNCTION_USAGE field, so don't bother checking. */
2040 if (GET_CODE (insn
) != CALL_INSN
)
2046 if (GET_CODE (datum
) != REG
)
2050 for (link
= CALL_INSN_FUNCTION_USAGE (insn
);
2052 link
= XEXP (link
, 1))
2053 if (GET_CODE (XEXP (link
, 0)) == code
2054 && rtx_equal_p (datum
, XEXP (XEXP (link
, 0), 0)))
2059 unsigned int regno
= REGNO (datum
);
2061 /* CALL_INSN_FUNCTION_USAGE information cannot contain references
2062 to pseudo registers, so don't bother checking. */
2064 if (regno
< FIRST_PSEUDO_REGISTER
)
2066 unsigned int end_regno
2067 = regno
+ HARD_REGNO_NREGS (regno
, GET_MODE (datum
));
2070 for (i
= regno
; i
< end_regno
; i
++)
2071 if (find_regno_fusage (insn
, code
, i
))
2079 /* Return true if REGNO, or any overlap of REGNO, of kind CODE is found
2080 in the CALL_INSN_FUNCTION_USAGE information of INSN. */
2083 find_regno_fusage (insn
, code
, regno
)
2090 /* CALL_INSN_FUNCTION_USAGE information cannot contain references
2091 to pseudo registers, so don't bother checking. */
2093 if (regno
>= FIRST_PSEUDO_REGISTER
2094 || GET_CODE (insn
) != CALL_INSN
)
2097 for (link
= CALL_INSN_FUNCTION_USAGE (insn
); link
; link
= XEXP (link
, 1))
2099 unsigned int regnote
;
2102 if (GET_CODE (op
= XEXP (link
, 0)) == code
2103 && GET_CODE (reg
= XEXP (op
, 0)) == REG
2104 && (regnote
= REGNO (reg
)) <= regno
2105 && regnote
+ HARD_REGNO_NREGS (regnote
, GET_MODE (reg
)) > regno
)
2112 /* Return true if INSN is a call to a pure function. */
2120 if (GET_CODE (insn
) != CALL_INSN
|| ! CONST_OR_PURE_CALL_P (insn
))
2123 /* Look for the note that differentiates const and pure functions. */
2124 for (link
= CALL_INSN_FUNCTION_USAGE (insn
); link
; link
= XEXP (link
, 1))
2128 if (GET_CODE (u
= XEXP (link
, 0)) == USE
2129 && GET_CODE (m
= XEXP (u
, 0)) == MEM
&& GET_MODE (m
) == BLKmode
2130 && GET_CODE (XEXP (m
, 0)) == SCRATCH
)
2137 /* Remove register note NOTE from the REG_NOTES of INSN. */
2140 remove_note (insn
, note
)
2146 if (note
== NULL_RTX
)
2149 if (REG_NOTES (insn
) == note
)
2151 REG_NOTES (insn
) = XEXP (note
, 1);
2155 for (link
= REG_NOTES (insn
); link
; link
= XEXP (link
, 1))
2156 if (XEXP (link
, 1) == note
)
2158 XEXP (link
, 1) = XEXP (note
, 1);
2165 /* Search LISTP (an EXPR_LIST) for an entry whose first operand is NODE and
2166 return 1 if it is found. A simple equality test is used to determine if
2170 in_expr_list_p (listp
, node
)
2176 for (x
= listp
; x
; x
= XEXP (x
, 1))
2177 if (node
== XEXP (x
, 0))
2183 /* Search LISTP (an EXPR_LIST) for an entry whose first operand is NODE and
2184 remove that entry from the list if it is found.
2186 A simple equality test is used to determine if NODE matches. */
2189 remove_node_from_expr_list (node
, listp
)
2194 rtx prev
= NULL_RTX
;
2198 if (node
== XEXP (temp
, 0))
2200 /* Splice the node out of the list. */
2202 XEXP (prev
, 1) = XEXP (temp
, 1);
2204 *listp
= XEXP (temp
, 1);
2210 temp
= XEXP (temp
, 1);
2214 /* Nonzero if X contains any volatile instructions. These are instructions
2215 which may cause unpredictable machine state instructions, and thus no
2216 instructions should be moved or combined across them. This includes
2217 only volatile asms and UNSPEC_VOLATILE instructions. */
2225 code
= GET_CODE (x
);
2245 case UNSPEC_VOLATILE
:
2246 /* case TRAP_IF: This isn't clear yet. */
2251 if (MEM_VOLATILE_P (x
))
2258 /* Recursively scan the operands of this expression. */
2261 const char *fmt
= GET_RTX_FORMAT (code
);
2264 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
2268 if (volatile_insn_p (XEXP (x
, i
)))
2271 else if (fmt
[i
] == 'E')
2274 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
2275 if (volatile_insn_p (XVECEXP (x
, i
, j
)))
2283 /* Nonzero if X contains any volatile memory references
2284 UNSPEC_VOLATILE operations or volatile ASM_OPERANDS expressions. */
2292 code
= GET_CODE (x
);
2310 case UNSPEC_VOLATILE
:
2316 if (MEM_VOLATILE_P (x
))
2323 /* Recursively scan the operands of this expression. */
2326 const char *fmt
= GET_RTX_FORMAT (code
);
2329 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
2333 if (volatile_refs_p (XEXP (x
, i
)))
2336 else if (fmt
[i
] == 'E')
2339 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
2340 if (volatile_refs_p (XVECEXP (x
, i
, j
)))
2348 /* Similar to above, except that it also rejects register pre- and post-
2357 code
= GET_CODE (x
);
2375 /* Reject CLOBBER with a non-VOID mode. These are made by combine.c
2376 when some combination can't be done. If we see one, don't think
2377 that we can simplify the expression. */
2378 return (GET_MODE (x
) != VOIDmode
);
2387 case UNSPEC_VOLATILE
:
2388 /* case TRAP_IF: This isn't clear yet. */
2394 if (MEM_VOLATILE_P (x
))
2401 /* Recursively scan the operands of this expression. */
2404 const char *fmt
= GET_RTX_FORMAT (code
);
2407 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
2411 if (side_effects_p (XEXP (x
, i
)))
2414 else if (fmt
[i
] == 'E')
2417 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
2418 if (side_effects_p (XVECEXP (x
, i
, j
)))
2426 /* Return nonzero if evaluating rtx X might cause a trap. */
2438 code
= GET_CODE (x
);
2441 /* Handle these cases quickly. */
2455 case UNSPEC_VOLATILE
:
2460 return MEM_VOLATILE_P (x
);
2462 /* Memory ref can trap unless it's a static var or a stack slot. */
2464 if (MEM_NOTRAP_P (x
))
2466 return rtx_addr_can_trap_p (XEXP (x
, 0));
2468 /* Division by a non-constant might trap. */
2473 if (HONOR_SNANS (GET_MODE (x
)))
2475 if (! CONSTANT_P (XEXP (x
, 1))
2476 || (GET_MODE_CLASS (GET_MODE (x
)) == MODE_FLOAT
2477 && flag_trapping_math
))
2479 /* This was const0_rtx, but by not using that,
2480 we can link this file into other programs. */
2481 if (GET_CODE (XEXP (x
, 1)) == CONST_INT
&& INTVAL (XEXP (x
, 1)) == 0)
2486 /* An EXPR_LIST is used to represent a function call. This
2487 certainly may trap. */
2495 /* Some floating point comparisons may trap. */
2496 if (!flag_trapping_math
)
2498 /* ??? There is no machine independent way to check for tests that trap
2499 when COMPARE is used, though many targets do make this distinction.
2500 For instance, sparc uses CCFPE for compares which generate exceptions
2501 and CCFP for compares which do not generate exceptions. */
2502 if (HONOR_NANS (GET_MODE (x
)))
2504 /* But often the compare has some CC mode, so check operand
2506 if (HONOR_NANS (GET_MODE (XEXP (x
, 0)))
2507 || HONOR_NANS (GET_MODE (XEXP (x
, 1))))
2513 if (HONOR_SNANS (GET_MODE (x
)))
2515 /* Often comparison is CC mode, so check operand modes. */
2516 if (HONOR_SNANS (GET_MODE (XEXP (x
, 0)))
2517 || HONOR_SNANS (GET_MODE (XEXP (x
, 1))))
2522 /* Conversion of floating point might trap. */
2523 if (flag_trapping_math
&& HONOR_NANS (GET_MODE (XEXP (x
, 0))))
2529 /* These operations don't trap even with floating point. */
2533 /* Any floating arithmetic may trap. */
2534 if (GET_MODE_CLASS (GET_MODE (x
)) == MODE_FLOAT
2535 && flag_trapping_math
)
2539 fmt
= GET_RTX_FORMAT (code
);
2540 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
2544 if (may_trap_p (XEXP (x
, i
)))
2547 else if (fmt
[i
] == 'E')
2550 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
2551 if (may_trap_p (XVECEXP (x
, i
, j
)))
2558 /* Return nonzero if X contains a comparison that is not either EQ or NE,
2559 i.e., an inequality. */
2562 inequality_comparisons_p (x
)
2567 enum rtx_code code
= GET_CODE (x
);
2597 len
= GET_RTX_LENGTH (code
);
2598 fmt
= GET_RTX_FORMAT (code
);
2600 for (i
= 0; i
< len
; i
++)
2604 if (inequality_comparisons_p (XEXP (x
, i
)))
2607 else if (fmt
[i
] == 'E')
2610 for (j
= XVECLEN (x
, i
) - 1; j
>= 0; j
--)
2611 if (inequality_comparisons_p (XVECEXP (x
, i
, j
)))
2619 /* Replace any occurrence of FROM in X with TO. The function does
2620 not enter into CONST_DOUBLE for the replace.
2622 Note that copying is not done so X must not be shared unless all copies
2623 are to be modified. */
2626 replace_rtx (x
, from
, to
)
2632 /* The following prevents loops occurrence when we change MEM in
2633 CONST_DOUBLE onto the same CONST_DOUBLE. */
2634 if (x
!= 0 && GET_CODE (x
) == CONST_DOUBLE
)
2640 /* Allow this function to make replacements in EXPR_LISTs. */
2644 if (GET_CODE (x
) == SUBREG
)
2646 rtx
new = replace_rtx (SUBREG_REG (x
), from
, to
);
2648 if (GET_CODE (new) == CONST_INT
)
2650 x
= simplify_subreg (GET_MODE (x
), new,
2651 GET_MODE (SUBREG_REG (x
)),
2657 SUBREG_REG (x
) = new;
2661 else if (GET_CODE (x
) == ZERO_EXTEND
)
2663 rtx
new = replace_rtx (XEXP (x
, 0), from
, to
);
2665 if (GET_CODE (new) == CONST_INT
)
2667 x
= simplify_unary_operation (ZERO_EXTEND
, GET_MODE (x
),
2668 new, GET_MODE (XEXP (x
, 0)));
2678 fmt
= GET_RTX_FORMAT (GET_CODE (x
));
2679 for (i
= GET_RTX_LENGTH (GET_CODE (x
)) - 1; i
>= 0; i
--)
2682 XEXP (x
, i
) = replace_rtx (XEXP (x
, i
), from
, to
);
2683 else if (fmt
[i
] == 'E')
2684 for (j
= XVECLEN (x
, i
) - 1; j
>= 0; j
--)
2685 XVECEXP (x
, i
, j
) = replace_rtx (XVECEXP (x
, i
, j
), from
, to
);
2691 /* Throughout the rtx X, replace many registers according to REG_MAP.
2692 Return the replacement for X (which may be X with altered contents).
2693 REG_MAP[R] is the replacement for register R, or 0 for don't replace.
2694 NREGS is the length of REG_MAP; regs >= NREGS are not mapped.
2696 We only support REG_MAP entries of REG or SUBREG. Also, hard registers
2697 should not be mapped to pseudos or vice versa since validate_change
2700 If REPLACE_DEST is 1, replacements are also done in destinations;
2701 otherwise, only sources are replaced. */
2704 replace_regs (x
, reg_map
, nregs
, replace_dest
)
2717 code
= GET_CODE (x
);
2732 /* Verify that the register has an entry before trying to access it. */
2733 if (REGNO (x
) < nregs
&& reg_map
[REGNO (x
)] != 0)
2735 /* SUBREGs can't be shared. Always return a copy to ensure that if
2736 this replacement occurs more than once then each instance will
2737 get distinct rtx. */
2738 if (GET_CODE (reg_map
[REGNO (x
)]) == SUBREG
)
2739 return copy_rtx (reg_map
[REGNO (x
)]);
2740 return reg_map
[REGNO (x
)];
2745 /* Prevent making nested SUBREGs. */
2746 if (GET_CODE (SUBREG_REG (x
)) == REG
&& REGNO (SUBREG_REG (x
)) < nregs
2747 && reg_map
[REGNO (SUBREG_REG (x
))] != 0
2748 && GET_CODE (reg_map
[REGNO (SUBREG_REG (x
))]) == SUBREG
)
2750 rtx map_val
= reg_map
[REGNO (SUBREG_REG (x
))];
2751 return simplify_gen_subreg (GET_MODE (x
), map_val
,
2752 GET_MODE (SUBREG_REG (x
)),
2759 SET_DEST (x
) = replace_regs (SET_DEST (x
), reg_map
, nregs
, 0);
2761 else if (GET_CODE (SET_DEST (x
)) == MEM
2762 || GET_CODE (SET_DEST (x
)) == STRICT_LOW_PART
)
2763 /* Even if we are not to replace destinations, replace register if it
2764 is CONTAINED in destination (destination is memory or
2765 STRICT_LOW_PART). */
2766 XEXP (SET_DEST (x
), 0) = replace_regs (XEXP (SET_DEST (x
), 0),
2768 else if (GET_CODE (SET_DEST (x
)) == ZERO_EXTRACT
)
2769 /* Similarly, for ZERO_EXTRACT we replace all operands. */
2772 SET_SRC (x
) = replace_regs (SET_SRC (x
), reg_map
, nregs
, 0);
2779 fmt
= GET_RTX_FORMAT (code
);
2780 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
2783 XEXP (x
, i
) = replace_regs (XEXP (x
, i
), reg_map
, nregs
, replace_dest
);
2784 else if (fmt
[i
] == 'E')
2787 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
2788 XVECEXP (x
, i
, j
) = replace_regs (XVECEXP (x
, i
, j
), reg_map
,
2789 nregs
, replace_dest
);
2795 /* Replace occurrences of the old label in *X with the new one.
2796 DATA is a REPLACE_LABEL_DATA containing the old and new labels. */
2799 replace_label (x
, data
)
2805 rtx old_label
= ((replace_label_data
*) data
)->r1
;
2806 rtx new_label
= ((replace_label_data
*) data
)->r2
;
2807 bool update_label_nuses
= ((replace_label_data
*) data
)->update_label_nuses
;
2812 if (GET_CODE (l
) == MEM
2813 && (tmp
= XEXP (l
, 0)) != NULL_RTX
2814 && GET_CODE (tmp
) == SYMBOL_REF
2815 && CONSTANT_POOL_ADDRESS_P (tmp
))
2817 rtx c
= get_pool_constant (tmp
);
2818 if (rtx_referenced_p (old_label
, c
))
2821 replace_label_data
*d
= (replace_label_data
*) data
;
2823 /* Create a copy of constant C; replace the label inside
2824 but do not update LABEL_NUSES because uses in constant pool
2826 new_c
= copy_rtx (c
);
2827 d
->update_label_nuses
= false;
2828 for_each_rtx (&new_c
, replace_label
, data
);
2829 d
->update_label_nuses
= update_label_nuses
;
2831 /* Add the new constant NEW_C to constant pool and replace
2832 the old reference to constant by new reference. */
2833 new_l
= force_const_mem (get_pool_mode (tmp
), new_c
);
2834 *x
= replace_rtx (l
, l
, new_l
);
2839 /* If this is a JUMP_INSN, then we also need to fix the JUMP_LABEL
2840 field. This is not handled by for_each_rtx because it doesn't
2841 handle unprinted ('0') fields. */
2842 if (GET_CODE (l
) == JUMP_INSN
&& JUMP_LABEL (l
) == old_label
)
2843 JUMP_LABEL (l
) = new_label
;
2845 if ((GET_CODE (l
) == LABEL_REF
2846 || GET_CODE (l
) == INSN_LIST
)
2847 && XEXP (l
, 0) == old_label
)
2849 XEXP (l
, 0) = new_label
;
2850 if (update_label_nuses
)
2852 ++LABEL_NUSES (new_label
);
2853 --LABEL_NUSES (old_label
);
2861 /* When *BODY is equal to X or X is directly referenced by *BODY
2862 return nonzero, thus FOR_EACH_RTX stops traversing and returns nonzero
2863 too, otherwise FOR_EACH_RTX continues traversing *BODY. */
2866 rtx_referenced_p_1 (body
, x
)
2872 if (*body
== NULL_RTX
)
2873 return y
== NULL_RTX
;
2875 /* Return true if a label_ref *BODY refers to label Y. */
2876 if (GET_CODE (*body
) == LABEL_REF
&& GET_CODE (y
) == CODE_LABEL
)
2877 return XEXP (*body
, 0) == y
;
2879 /* If *BODY is a reference to pool constant traverse the constant. */
2880 if (GET_CODE (*body
) == SYMBOL_REF
2881 && CONSTANT_POOL_ADDRESS_P (*body
))
2882 return rtx_referenced_p (y
, get_pool_constant (*body
));
2884 /* By default, compare the RTL expressions. */
2885 return rtx_equal_p (*body
, y
);
2888 /* Return true if X is referenced in BODY. */
2891 rtx_referenced_p (x
, body
)
2895 return for_each_rtx (&body
, rtx_referenced_p_1
, x
);
2898 /* If INSN is a jump to jumptable insn rturn true and store the label (which
2899 INSN jumps to) to *LABEL and the tablejump insn to *TABLE.
2900 LABEL and TABLE may be NULL. */
2903 tablejump_p (insn
, label
, table
)
2910 if (onlyjump_p (insn
)
2911 && (l
= JUMP_LABEL (insn
)) != NULL_RTX
2912 && (t
= NEXT_INSN (l
)) != NULL_RTX
2913 && GET_CODE (t
) == JUMP_INSN
2914 && (GET_CODE (PATTERN (t
)) == ADDR_VEC
2915 || GET_CODE (PATTERN (t
)) == ADDR_DIFF_VEC
))
2926 /* A subroutine of computed_jump_p, return 1 if X contains a REG or MEM or
2927 constant that is not in the constant pool and not in the condition
2928 of an IF_THEN_ELSE. */
2931 computed_jump_p_1 (x
)
2934 enum rtx_code code
= GET_CODE (x
);
2953 return ! (GET_CODE (XEXP (x
, 0)) == SYMBOL_REF
2954 && CONSTANT_POOL_ADDRESS_P (XEXP (x
, 0)));
2957 return (computed_jump_p_1 (XEXP (x
, 1))
2958 || computed_jump_p_1 (XEXP (x
, 2)));
2964 fmt
= GET_RTX_FORMAT (code
);
2965 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
2968 && computed_jump_p_1 (XEXP (x
, i
)))
2971 else if (fmt
[i
] == 'E')
2972 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
2973 if (computed_jump_p_1 (XVECEXP (x
, i
, j
)))
2980 /* Return nonzero if INSN is an indirect jump (aka computed jump).
2982 Tablejumps and casesi insns are not considered indirect jumps;
2983 we can recognize them by a (use (label_ref)). */
2986 computed_jump_p (insn
)
2990 if (GET_CODE (insn
) == JUMP_INSN
)
2992 rtx pat
= PATTERN (insn
);
2994 if (find_reg_note (insn
, REG_LABEL
, NULL_RTX
))
2996 else if (GET_CODE (pat
) == PARALLEL
)
2998 int len
= XVECLEN (pat
, 0);
2999 int has_use_labelref
= 0;
3001 for (i
= len
- 1; i
>= 0; i
--)
3002 if (GET_CODE (XVECEXP (pat
, 0, i
)) == USE
3003 && (GET_CODE (XEXP (XVECEXP (pat
, 0, i
), 0))
3005 has_use_labelref
= 1;
3007 if (! has_use_labelref
)
3008 for (i
= len
- 1; i
>= 0; i
--)
3009 if (GET_CODE (XVECEXP (pat
, 0, i
)) == SET
3010 && SET_DEST (XVECEXP (pat
, 0, i
)) == pc_rtx
3011 && computed_jump_p_1 (SET_SRC (XVECEXP (pat
, 0, i
))))
3014 else if (GET_CODE (pat
) == SET
3015 && SET_DEST (pat
) == pc_rtx
3016 && computed_jump_p_1 (SET_SRC (pat
)))
3022 /* Traverse X via depth-first search, calling F for each
3023 sub-expression (including X itself). F is also passed the DATA.
3024 If F returns -1, do not traverse sub-expressions, but continue
3025 traversing the rest of the tree. If F ever returns any other
3026 nonzero value, stop the traversal, and return the value returned
3027 by F. Otherwise, return 0. This function does not traverse inside
3028 tree structure that contains RTX_EXPRs, or into sub-expressions
3029 whose format code is `0' since it is not known whether or not those
3030 codes are actually RTL.
3032 This routine is very general, and could (should?) be used to
3033 implement many of the other routines in this file. */
3036 for_each_rtx (x
, f
, data
)
3047 result
= (*f
) (x
, data
);
3049 /* Do not traverse sub-expressions. */
3051 else if (result
!= 0)
3052 /* Stop the traversal. */
3056 /* There are no sub-expressions. */
3059 length
= GET_RTX_LENGTH (GET_CODE (*x
));
3060 format
= GET_RTX_FORMAT (GET_CODE (*x
));
3062 for (i
= 0; i
< length
; ++i
)
3067 result
= for_each_rtx (&XEXP (*x
, i
), f
, data
);
3074 if (XVEC (*x
, i
) != 0)
3077 for (j
= 0; j
< XVECLEN (*x
, i
); ++j
)
3079 result
= for_each_rtx (&XVECEXP (*x
, i
, j
), f
, data
);
3087 /* Nothing to do. */
3096 /* Searches X for any reference to REGNO, returning the rtx of the
3097 reference found if any. Otherwise, returns NULL_RTX. */
3100 regno_use_in (regno
, x
)
3108 if (GET_CODE (x
) == REG
&& REGNO (x
) == regno
)
3111 fmt
= GET_RTX_FORMAT (GET_CODE (x
));
3112 for (i
= GET_RTX_LENGTH (GET_CODE (x
)) - 1; i
>= 0; i
--)
3116 if ((tem
= regno_use_in (regno
, XEXP (x
, i
))))
3119 else if (fmt
[i
] == 'E')
3120 for (j
= XVECLEN (x
, i
) - 1; j
>= 0; j
--)
3121 if ((tem
= regno_use_in (regno
, XVECEXP (x
, i
, j
))))
3128 /* Return a value indicating whether OP, an operand of a commutative
3129 operation, is preferred as the first or second operand. The higher
3130 the value, the stronger the preference for being the first operand.
3131 We use negative values to indicate a preference for the first operand
3132 and positive values for the second operand. */
3135 commutative_operand_precedence (op
)
3138 /* Constants always come the second operand. Prefer "nice" constants. */
3139 if (GET_CODE (op
) == CONST_INT
)
3141 if (GET_CODE (op
) == CONST_DOUBLE
)
3143 if (CONSTANT_P (op
))
3146 /* SUBREGs of objects should come second. */
3147 if (GET_CODE (op
) == SUBREG
3148 && GET_RTX_CLASS (GET_CODE (SUBREG_REG (op
))) == 'o')
3151 /* If only one operand is a `neg', `not',
3152 `mult', `plus', or `minus' expression, it will be the first
3154 if (GET_CODE (op
) == NEG
|| GET_CODE (op
) == NOT
3155 || GET_CODE (op
) == MULT
|| GET_CODE (op
) == PLUS
3156 || GET_CODE (op
) == MINUS
)
3159 /* Complex expressions should be the first, so decrease priority
3161 if (GET_RTX_CLASS (GET_CODE (op
)) == 'o')
3166 /* Return 1 iff it is necessary to swap operands of commutative operation
3167 in order to canonicalize expression. */
3170 swap_commutative_operands_p (x
, y
)
3173 return (commutative_operand_precedence (x
)
3174 < commutative_operand_precedence (y
));
3177 /* Return 1 if X is an autoincrement side effect and the register is
3178 not the stack pointer. */
3183 switch (GET_CODE (x
))
3191 /* There are no REG_INC notes for SP. */
3192 if (XEXP (x
, 0) != stack_pointer_rtx
)
3200 /* Return 1 if the sequence of instructions beginning with FROM and up
3201 to and including TO is safe to move. If NEW_TO is non-NULL, and
3202 the sequence is not already safe to move, but can be easily
3203 extended to a sequence which is safe, then NEW_TO will point to the
3204 end of the extended sequence.
3206 For now, this function only checks that the region contains whole
3207 exception regions, but it could be extended to check additional
3208 conditions as well. */
3211 insns_safe_to_move_p (from
, to
, new_to
)
3216 int eh_region_count
= 0;
3220 /* By default, assume the end of the region will be what was
3227 if (GET_CODE (r
) == NOTE
)
3229 switch (NOTE_LINE_NUMBER (r
))
3231 case NOTE_INSN_EH_REGION_BEG
:
3235 case NOTE_INSN_EH_REGION_END
:
3236 if (eh_region_count
== 0)
3237 /* This sequence of instructions contains the end of
3238 an exception region, but not he beginning. Moving
3239 it will cause chaos. */
3250 /* If we've passed TO, and we see a non-note instruction, we
3251 can't extend the sequence to a movable sequence. */
3257 /* It's OK to move the sequence if there were matched sets of
3258 exception region notes. */
3259 return eh_region_count
== 0;
3264 /* It's OK to move the sequence if there were matched sets of
3265 exception region notes. */
3266 if (past_to_p
&& eh_region_count
== 0)
3272 /* Go to the next instruction. */
3279 /* Return nonzero if IN contains a piece of rtl that has the address LOC */
3281 loc_mentioned_in_p (loc
, in
)
3284 enum rtx_code code
= GET_CODE (in
);
3285 const char *fmt
= GET_RTX_FORMAT (code
);
3288 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
3290 if (loc
== &in
->fld
[i
].rtx
)
3294 if (loc_mentioned_in_p (loc
, XEXP (in
, i
)))
3297 else if (fmt
[i
] == 'E')
3298 for (j
= XVECLEN (in
, i
) - 1; j
>= 0; j
--)
3299 if (loc_mentioned_in_p (loc
, XVECEXP (in
, i
, j
)))
3305 /* Given a subreg X, return the bit offset where the subreg begins
3306 (counting from the least significant bit of the reg). */
3312 enum machine_mode inner_mode
= GET_MODE (SUBREG_REG (x
));
3313 enum machine_mode mode
= GET_MODE (x
);
3314 unsigned int bitpos
;
3318 /* A paradoxical subreg begins at bit position 0. */
3319 if (GET_MODE_BITSIZE (mode
) > GET_MODE_BITSIZE (inner_mode
))
3322 if (WORDS_BIG_ENDIAN
!= BYTES_BIG_ENDIAN
)
3323 /* If the subreg crosses a word boundary ensure that
3324 it also begins and ends on a word boundary. */
3325 if ((SUBREG_BYTE (x
) % UNITS_PER_WORD
3326 + GET_MODE_SIZE (mode
)) > UNITS_PER_WORD
3327 && (SUBREG_BYTE (x
) % UNITS_PER_WORD
3328 || GET_MODE_SIZE (mode
) % UNITS_PER_WORD
))
3331 if (WORDS_BIG_ENDIAN
)
3332 word
= (GET_MODE_SIZE (inner_mode
)
3333 - (SUBREG_BYTE (x
) + GET_MODE_SIZE (mode
))) / UNITS_PER_WORD
;
3335 word
= SUBREG_BYTE (x
) / UNITS_PER_WORD
;
3336 bitpos
= word
* BITS_PER_WORD
;
3338 if (BYTES_BIG_ENDIAN
)
3339 byte
= (GET_MODE_SIZE (inner_mode
)
3340 - (SUBREG_BYTE (x
) + GET_MODE_SIZE (mode
))) % UNITS_PER_WORD
;
3342 byte
= SUBREG_BYTE (x
) % UNITS_PER_WORD
;
3343 bitpos
+= byte
* BITS_PER_UNIT
;
3348 /* This function returns the regno offset of a subreg expression.
3349 xregno - A regno of an inner hard subreg_reg (or what will become one).
3350 xmode - The mode of xregno.
3351 offset - The byte offset.
3352 ymode - The mode of a top level SUBREG (or what may become one).
3353 RETURN - The regno offset which would be used. */
3355 subreg_regno_offset (xregno
, xmode
, offset
, ymode
)
3356 unsigned int xregno
;
3357 enum machine_mode xmode
;
3358 unsigned int offset
;
3359 enum machine_mode ymode
;
3361 int nregs_xmode
, nregs_ymode
;
3362 int mode_multiple
, nregs_multiple
;
3365 if (xregno
>= FIRST_PSEUDO_REGISTER
)
3368 nregs_xmode
= HARD_REGNO_NREGS (xregno
, xmode
);
3369 nregs_ymode
= HARD_REGNO_NREGS (xregno
, ymode
);
3371 /* If this is a big endian paradoxical subreg, which uses more actual
3372 hard registers than the original register, we must return a negative
3373 offset so that we find the proper highpart of the register. */
3375 && nregs_ymode
> nregs_xmode
3376 && (GET_MODE_SIZE (ymode
) > UNITS_PER_WORD
3377 ? WORDS_BIG_ENDIAN
: BYTES_BIG_ENDIAN
))
3378 return nregs_xmode
- nregs_ymode
;
3380 if (offset
== 0 || nregs_xmode
== nregs_ymode
)
3383 /* size of ymode must not be greater than the size of xmode. */
3384 mode_multiple
= GET_MODE_SIZE (xmode
) / GET_MODE_SIZE (ymode
);
3385 if (mode_multiple
== 0)
3388 y_offset
= offset
/ GET_MODE_SIZE (ymode
);
3389 nregs_multiple
= nregs_xmode
/ nregs_ymode
;
3390 return (y_offset
/ (mode_multiple
/ nregs_multiple
)) * nregs_ymode
;
3393 /* This function returns true when the offset is representable via
3394 subreg_offset in the given regno.
3395 xregno - A regno of an inner hard subreg_reg (or what will become one).
3396 xmode - The mode of xregno.
3397 offset - The byte offset.
3398 ymode - The mode of a top level SUBREG (or what may become one).
3399 RETURN - The regno offset which would be used. */
3401 subreg_offset_representable_p (xregno
, xmode
, offset
, ymode
)
3402 unsigned int xregno
;
3403 enum machine_mode xmode
;
3404 unsigned int offset
;
3405 enum machine_mode ymode
;
3407 int nregs_xmode
, nregs_ymode
;
3408 int mode_multiple
, nregs_multiple
;
3411 if (xregno
>= FIRST_PSEUDO_REGISTER
)
3414 nregs_xmode
= HARD_REGNO_NREGS (xregno
, xmode
);
3415 nregs_ymode
= HARD_REGNO_NREGS (xregno
, ymode
);
3417 /* paradoxical subregs are always valid. */
3419 && nregs_ymode
> nregs_xmode
3420 && (GET_MODE_SIZE (ymode
) > UNITS_PER_WORD
3421 ? WORDS_BIG_ENDIAN
: BYTES_BIG_ENDIAN
))
3424 /* Lowpart subregs are always valid. */
3425 if (offset
== subreg_lowpart_offset (ymode
, xmode
))
3428 #ifdef ENABLE_CHECKING
3429 /* This should always pass, otherwise we don't know how to verify the
3432 These conditions may be relaxed but subreg_offset would need to be
3434 if (GET_MODE_SIZE (xmode
) % GET_MODE_SIZE (ymode
)
3435 || GET_MODE_SIZE (ymode
) % nregs_ymode
3436 || (GET_MODE_BITSIZE (mode_for_size (GET_MODE_BITSIZE (xmode
)
3439 != GET_MODE_BITSIZE (xmode
) / nregs_xmode
)
3440 || nregs_xmode
% nregs_ymode
)
3444 /* The XMODE value can be seen as an vector of NREGS_XMODE
3445 values. The subreg must represent an lowpart of given field.
3446 Compute what field it is. */
3447 offset
-= subreg_lowpart_offset (ymode
,
3448 mode_for_size (GET_MODE_BITSIZE (xmode
)
3452 /* size of ymode must not be greater than the size of xmode. */
3453 mode_multiple
= GET_MODE_SIZE (xmode
) / GET_MODE_SIZE (ymode
);
3454 if (mode_multiple
== 0)
3457 y_offset
= offset
/ GET_MODE_SIZE (ymode
);
3458 nregs_multiple
= nregs_xmode
/ nregs_ymode
;
3459 #ifdef ENABLE_CHECKING
3460 if (offset
% GET_MODE_SIZE (ymode
)
3461 || mode_multiple
% nregs_multiple
)
3464 return (!(y_offset
% (mode_multiple
/ nregs_multiple
)));
3467 /* Return the final regno that a subreg expression refers to. */
3473 rtx subreg
= SUBREG_REG (x
);
3474 int regno
= REGNO (subreg
);
3476 ret
= regno
+ subreg_regno_offset (regno
,
3483 struct parms_set_data
3489 /* Helper function for noticing stores to parameter registers. */
3491 parms_set (x
, pat
, data
)
3492 rtx x
, pat ATTRIBUTE_UNUSED
;
3495 struct parms_set_data
*d
= data
;
3496 if (REG_P (x
) && REGNO (x
) < FIRST_PSEUDO_REGISTER
3497 && TEST_HARD_REG_BIT (d
->regs
, REGNO (x
)))
3499 CLEAR_HARD_REG_BIT (d
->regs
, REGNO (x
));
3504 /* Look backward for first parameter to be loaded.
3505 Do not skip BOUNDARY. */
3507 find_first_parameter_load (call_insn
, boundary
)
3508 rtx call_insn
, boundary
;
3510 struct parms_set_data parm
;
3513 /* Since different machines initialize their parameter registers
3514 in different orders, assume nothing. Collect the set of all
3515 parameter registers. */
3516 CLEAR_HARD_REG_SET (parm
.regs
);
3518 for (p
= CALL_INSN_FUNCTION_USAGE (call_insn
); p
; p
= XEXP (p
, 1))
3519 if (GET_CODE (XEXP (p
, 0)) == USE
3520 && GET_CODE (XEXP (XEXP (p
, 0), 0)) == REG
)
3522 if (REGNO (XEXP (XEXP (p
, 0), 0)) >= FIRST_PSEUDO_REGISTER
)
3525 /* We only care about registers which can hold function
3527 if (!FUNCTION_ARG_REGNO_P (REGNO (XEXP (XEXP (p
, 0), 0))))
3530 SET_HARD_REG_BIT (parm
.regs
, REGNO (XEXP (XEXP (p
, 0), 0)));
3535 /* Search backward for the first set of a register in this set. */
3536 while (parm
.nregs
&& before
!= boundary
)
3538 before
= PREV_INSN (before
);
3540 /* It is possible that some loads got CSEed from one call to
3541 another. Stop in that case. */
3542 if (GET_CODE (before
) == CALL_INSN
)
3545 /* Our caller needs either ensure that we will find all sets
3546 (in case code has not been optimized yet), or take care
3547 for possible labels in a way by setting boundary to preceding
3549 if (GET_CODE (before
) == CODE_LABEL
)
3551 if (before
!= boundary
)
3556 if (INSN_P (before
))
3557 note_stores (PATTERN (before
), parms_set
, &parm
);
3562 /* Return true if we should avoid inserting code between INSN and preceding
3563 call instruction. */
3566 keep_with_call_p (insn
)
3571 if (INSN_P (insn
) && (set
= single_set (insn
)) != NULL
)
3573 if (GET_CODE (SET_DEST (set
)) == REG
3574 && REGNO (SET_DEST (set
)) < FIRST_PSEUDO_REGISTER
3575 && fixed_regs
[REGNO (SET_DEST (set
))]
3576 && general_operand (SET_SRC (set
), VOIDmode
))
3578 if (GET_CODE (SET_SRC (set
)) == REG
3579 && FUNCTION_VALUE_REGNO_P (REGNO (SET_SRC (set
)))
3580 && GET_CODE (SET_DEST (set
)) == REG
3581 && REGNO (SET_DEST (set
)) >= FIRST_PSEUDO_REGISTER
)
3583 /* There may be a stack pop just after the call and before the store
3584 of the return register. Search for the actual store when deciding
3585 if we can break or not. */
3586 if (SET_DEST (set
) == stack_pointer_rtx
)
3588 rtx i2
= next_nonnote_insn (insn
);
3589 if (i2
&& keep_with_call_p (i2
))
3596 /* Return true when store to register X can be hoisted to the place
3597 with LIVE registers (can be NULL). Value VAL contains destination
3598 whose value will be used. */
3601 hoist_test_store (x
, val
, live
)
3605 if (GET_CODE (x
) == SCRATCH
)
3608 if (rtx_equal_p (x
, val
))
3611 /* Allow subreg of X in case it is not writting just part of multireg pseudo.
3612 Then we would need to update all users to care hoisting the store too.
3613 Caller may represent that by specifying whole subreg as val. */
3615 if (GET_CODE (x
) == SUBREG
&& rtx_equal_p (SUBREG_REG (x
), val
))
3617 if (GET_MODE_SIZE (GET_MODE (SUBREG_REG (x
))) > UNITS_PER_WORD
3618 && GET_MODE_BITSIZE (GET_MODE (x
)) <
3619 GET_MODE_BITSIZE (GET_MODE (SUBREG_REG (x
))))
3623 if (GET_CODE (x
) == SUBREG
)
3626 /* Anything except register store is not hoistable. This includes the
3627 partial stores to registers. */
3632 /* Pseudo registers can be allways replaced by another pseudo to avoid
3633 the side effect, for hard register we must ensure that they are dead.
3634 Eventually we may want to add code to try turn pseudos to hards, but it
3635 is unlikely useful. */
3637 if (REGNO (x
) < FIRST_PSEUDO_REGISTER
)
3639 int regno
= REGNO (x
);
3640 int n
= HARD_REGNO_NREGS (regno
, GET_MODE (x
));
3644 if (REGNO_REG_SET_P (live
, regno
))
3647 if (REGNO_REG_SET_P (live
, regno
+ n
))
3654 /* Return true if INSN can be hoisted to place with LIVE hard registers
3655 (LIVE can be NULL when unknown). VAL is expected to be stored by the insn
3656 and used by the hoisting pass. */
3659 can_hoist_insn_p (insn
, val
, live
)
3663 rtx pat
= PATTERN (insn
);
3666 /* It probably does not worth the complexity to handle multiple
3668 if (!single_set (insn
))
3670 /* We can move CALL_INSN, but we need to check that all caller clobbered
3672 if (GET_CODE (insn
) == CALL_INSN
)
3674 /* In future we will handle hoisting of libcall sequences, but
3676 if (find_reg_note (insn
, REG_RETVAL
, NULL_RTX
))
3678 switch (GET_CODE (pat
))
3681 if (!hoist_test_store (SET_DEST (pat
), val
, live
))
3685 /* USES do have sick semantics, so do not move them. */
3689 if (!hoist_test_store (XEXP (pat
, 0), val
, live
))
3693 for (i
= 0; i
< XVECLEN (pat
, 0); i
++)
3695 rtx x
= XVECEXP (pat
, 0, i
);
3696 switch (GET_CODE (x
))
3699 if (!hoist_test_store (SET_DEST (x
), val
, live
))
3703 /* We need to fix callers to really ensure availability
3704 of all values inisn uses, but for now it is safe to prohibit
3705 hoisting of any insn having such a hidden uses. */
3709 if (!hoist_test_store (SET_DEST (x
), val
, live
))
3723 /* Update store after hoisting - replace all stores to pseudo registers
3724 by new ones to avoid clobbering of values except for store to VAL that will
3725 be updated to NEW. */
3728 hoist_update_store (insn
, xp
, val
, new)
3729 rtx insn
, *xp
, val
, new;
3733 if (GET_CODE (x
) == SCRATCH
)
3736 if (GET_CODE (x
) == SUBREG
&& SUBREG_REG (x
) == val
)
3737 validate_change (insn
, xp
,
3738 simplify_gen_subreg (GET_MODE (x
), new, GET_MODE (new),
3739 SUBREG_BYTE (x
)), 1);
3740 if (rtx_equal_p (x
, val
))
3742 validate_change (insn
, xp
, new, 1);
3745 if (GET_CODE (x
) == SUBREG
)
3747 xp
= &SUBREG_REG (x
);
3754 /* We've verified that hard registers are dead, so we may keep the side
3755 effect. Otherwise replace it by new pseudo. */
3756 if (REGNO (x
) >= FIRST_PSEUDO_REGISTER
)
3757 validate_change (insn
, xp
, gen_reg_rtx (GET_MODE (x
)), 1);
3759 = alloc_EXPR_LIST (REG_UNUSED
, *xp
, REG_NOTES (insn
));
3762 /* Create a copy of INSN after AFTER replacing store of VAL to NEW
3763 and each other side effect to pseudo register by new pseudo register. */
3766 hoist_insn_after (insn
, after
, val
, new)
3767 rtx insn
, after
, val
, new;
3773 insn
= emit_copy_of_insn_after (insn
, after
);
3774 pat
= PATTERN (insn
);
3776 /* Remove REG_UNUSED notes as we will re-emit them. */
3777 while ((note
= find_reg_note (insn
, REG_UNUSED
, NULL_RTX
)))
3778 remove_note (insn
, note
);
3780 /* To get this working callers must ensure to move everything referenced
3781 by REG_EQUAL/REG_EQUIV notes too. Lets remove them, it is probably
3783 while ((note
= find_reg_note (insn
, REG_EQUAL
, NULL_RTX
)))
3784 remove_note (insn
, note
);
3785 while ((note
= find_reg_note (insn
, REG_EQUIV
, NULL_RTX
)))
3786 remove_note (insn
, note
);
3788 /* Remove REG_DEAD notes as they might not be valid anymore in case
3789 we create redundancy. */
3790 while ((note
= find_reg_note (insn
, REG_DEAD
, NULL_RTX
)))
3791 remove_note (insn
, note
);
3792 switch (GET_CODE (pat
))
3795 hoist_update_store (insn
, &SET_DEST (pat
), val
, new);
3800 hoist_update_store (insn
, &XEXP (pat
, 0), val
, new);
3803 for (i
= 0; i
< XVECLEN (pat
, 0); i
++)
3805 rtx x
= XVECEXP (pat
, 0, i
);
3806 switch (GET_CODE (x
))
3809 hoist_update_store (insn
, &SET_DEST (x
), val
, new);
3814 hoist_update_store (insn
, &SET_DEST (x
), val
, new);
3824 if (!apply_change_group ())
3831 hoist_insn_to_edge (insn
, e
, val
, new)
3837 /* We cannot insert instructions on an abnormal critical edge.
3838 It will be easier to find the culprit if we die now. */
3839 if ((e
->flags
& EDGE_ABNORMAL
) && EDGE_CRITICAL_P (e
))
3842 /* Do not use emit_insn_on_edge as we want to preserve notes and similar
3843 stuff. We also emit CALL_INSNS and firends. */
3844 if (e
->insns
== NULL_RTX
)
3847 emit_note (NULL
, NOTE_INSN_DELETED
);
3850 push_to_sequence (e
->insns
);
3852 new_insn
= hoist_insn_after (insn
, get_last_insn (), val
, new);
3854 e
->insns
= get_insns ();