1 /* Analyze RTL for C-Compiler
2 Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002, 2003, 2004 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"
36 #include "basic-block.h"
40 /* Forward declarations */
41 static int global_reg_mentioned_p_1 (rtx
*, void *);
42 static void set_of_1 (rtx
, rtx
, void *);
43 static void insn_dependent_p_1 (rtx
, rtx
, void *);
44 static int rtx_referenced_p_1 (rtx
*, void *);
45 static int computed_jump_p_1 (rtx
);
46 static void parms_set (rtx
, rtx
, void *);
47 static bool hoist_test_store (rtx
, rtx
, regset
);
48 static void hoist_update_store (rtx
, rtx
*, rtx
, rtx
);
50 /* Bit flags that specify the machine subtype we are compiling for.
51 Bits are tested using macros TARGET_... defined in the tm.h file
52 and set by `-m...' switches. Must be defined in rtlanal.c. */
56 /* Return 1 if the value of X is unstable
57 (would be different at a different point in the program).
58 The frame pointer, arg pointer, etc. are considered stable
59 (within one function) and so is anything marked `unchanging'. */
62 rtx_unstable_p (rtx x
)
64 RTX_CODE code
= GET_CODE (x
);
71 return ! RTX_UNCHANGING_P (x
) || rtx_unstable_p (XEXP (x
, 0));
86 /* As in rtx_varies_p, we have to use the actual rtx, not reg number. */
87 if (x
== frame_pointer_rtx
|| x
== hard_frame_pointer_rtx
88 /* The arg pointer varies if it is not a fixed register. */
89 || (x
== arg_pointer_rtx
&& fixed_regs
[ARG_POINTER_REGNUM
])
90 || RTX_UNCHANGING_P (x
))
92 #ifndef PIC_OFFSET_TABLE_REG_CALL_CLOBBERED
93 /* ??? When call-clobbered, the value is stable modulo the restore
94 that must happen after a call. This currently screws up local-alloc
95 into believing that the restore is not needed. */
96 if (x
== pic_offset_table_rtx
)
102 if (MEM_VOLATILE_P (x
))
111 fmt
= GET_RTX_FORMAT (code
);
112 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
115 if (rtx_unstable_p (XEXP (x
, i
)))
118 else if (fmt
[i
] == 'E')
121 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
122 if (rtx_unstable_p (XVECEXP (x
, i
, j
)))
129 /* Return 1 if X has a value that can vary even between two
130 executions of the program. 0 means X can be compared reliably
131 against certain constants or near-constants.
132 FOR_ALIAS is nonzero if we are called from alias analysis; if it is
133 zero, we are slightly more conservative.
134 The frame pointer and the arg pointer are considered constant. */
137 rtx_varies_p (rtx x
, int for_alias
)
150 return ! RTX_UNCHANGING_P (x
) || rtx_varies_p (XEXP (x
, 0), for_alias
);
164 /* This will resolve to some offset from the frame pointer. */
168 /* Note that we have to test for the actual rtx used for the frame
169 and arg pointers and not just the register number in case we have
170 eliminated the frame and/or arg pointer and are using it
172 if (x
== frame_pointer_rtx
|| x
== hard_frame_pointer_rtx
173 /* The arg pointer varies if it is not a fixed register. */
174 || (x
== arg_pointer_rtx
&& fixed_regs
[ARG_POINTER_REGNUM
]))
176 if (x
== pic_offset_table_rtx
177 #ifdef PIC_OFFSET_TABLE_REG_CALL_CLOBBERED
178 /* ??? When call-clobbered, the value is stable modulo the restore
179 that must happen after a call. This currently screws up
180 local-alloc into believing that the restore is not needed, so we
181 must return 0 only if we are called from alias analysis. */
189 /* The operand 0 of a LO_SUM is considered constant
190 (in fact it is related specifically to operand 1)
191 during alias analysis. */
192 return (! for_alias
&& rtx_varies_p (XEXP (x
, 0), for_alias
))
193 || rtx_varies_p (XEXP (x
, 1), for_alias
);
196 if (MEM_VOLATILE_P (x
))
205 fmt
= GET_RTX_FORMAT (code
);
206 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
209 if (rtx_varies_p (XEXP (x
, i
), for_alias
))
212 else if (fmt
[i
] == 'E')
215 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
216 if (rtx_varies_p (XVECEXP (x
, i
, j
), for_alias
))
223 /* Return 0 if the use of X as an address in a MEM can cause a trap. */
226 rtx_addr_can_trap_p (rtx x
)
228 enum rtx_code code
= GET_CODE (x
);
233 return SYMBOL_REF_WEAK (x
);
239 /* This will resolve to some offset from the frame pointer. */
243 /* As in rtx_varies_p, we have to use the actual rtx, not reg number. */
244 if (x
== frame_pointer_rtx
|| x
== hard_frame_pointer_rtx
245 || x
== stack_pointer_rtx
246 /* The arg pointer varies if it is not a fixed register. */
247 || (x
== arg_pointer_rtx
&& fixed_regs
[ARG_POINTER_REGNUM
]))
249 /* All of the virtual frame registers are stack references. */
250 if (REGNO (x
) >= FIRST_VIRTUAL_REGISTER
251 && REGNO (x
) <= LAST_VIRTUAL_REGISTER
)
256 return rtx_addr_can_trap_p (XEXP (x
, 0));
259 /* An address is assumed not to trap if it is an address that can't
260 trap plus a constant integer or it is the pic register plus a
262 return ! ((! rtx_addr_can_trap_p (XEXP (x
, 0))
263 && GET_CODE (XEXP (x
, 1)) == CONST_INT
)
264 || (XEXP (x
, 0) == pic_offset_table_rtx
265 && CONSTANT_P (XEXP (x
, 1))));
269 return rtx_addr_can_trap_p (XEXP (x
, 1));
276 return rtx_addr_can_trap_p (XEXP (x
, 0));
282 /* If it isn't one of the case above, it can cause a trap. */
286 /* Return true if X is an address that is known to not be zero. */
289 nonzero_address_p (rtx x
)
291 enum rtx_code code
= GET_CODE (x
);
296 return !SYMBOL_REF_WEAK (x
);
302 /* This will resolve to some offset from the frame pointer. */
306 /* As in rtx_varies_p, we have to use the actual rtx, not reg number. */
307 if (x
== frame_pointer_rtx
|| x
== hard_frame_pointer_rtx
308 || x
== stack_pointer_rtx
309 || (x
== arg_pointer_rtx
&& fixed_regs
[ARG_POINTER_REGNUM
]))
311 /* All of the virtual frame registers are stack references. */
312 if (REGNO (x
) >= FIRST_VIRTUAL_REGISTER
313 && REGNO (x
) <= LAST_VIRTUAL_REGISTER
)
318 return nonzero_address_p (XEXP (x
, 0));
321 if (GET_CODE (XEXP (x
, 1)) == CONST_INT
)
323 /* Pointers aren't allowed to wrap. If we've got a register
324 that is known to be a pointer, and a positive offset, then
325 the composite can't be zero. */
326 if (INTVAL (XEXP (x
, 1)) > 0
327 && REG_P (XEXP (x
, 0))
328 && REG_POINTER (XEXP (x
, 0)))
331 return nonzero_address_p (XEXP (x
, 0));
333 /* Handle PIC references. */
334 else if (XEXP (x
, 0) == pic_offset_table_rtx
335 && CONSTANT_P (XEXP (x
, 1)))
340 /* Similar to the above; allow positive offsets. Further, since
341 auto-inc is only allowed in memories, the register must be a
343 if (GET_CODE (XEXP (x
, 1)) == CONST_INT
344 && INTVAL (XEXP (x
, 1)) > 0)
346 return nonzero_address_p (XEXP (x
, 0));
349 /* Similarly. Further, the offset is always positive. */
356 return nonzero_address_p (XEXP (x
, 0));
359 return nonzero_address_p (XEXP (x
, 1));
365 /* If it isn't one of the case above, might be zero. */
369 /* Return 1 if X refers to a memory location whose address
370 cannot be compared reliably with constant addresses,
371 or if X refers to a BLKmode memory object.
372 FOR_ALIAS is nonzero if we are called from alias analysis; if it is
373 zero, we are slightly more conservative. */
376 rtx_addr_varies_p (rtx x
, int 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. */
412 get_integer_term (rtx x
)
414 if (GET_CODE (x
) == CONST
)
417 if (GET_CODE (x
) == MINUS
418 && GET_CODE (XEXP (x
, 1)) == CONST_INT
)
419 return - INTVAL (XEXP (x
, 1));
420 if (GET_CODE (x
) == PLUS
421 && GET_CODE (XEXP (x
, 1)) == CONST_INT
)
422 return INTVAL (XEXP (x
, 1));
426 /* If X is a constant, return the value sans apparent integer term;
428 Only obvious integer terms are detected. */
431 get_related_value (rtx x
)
433 if (GET_CODE (x
) != CONST
)
436 if (GET_CODE (x
) == PLUS
437 && GET_CODE (XEXP (x
, 1)) == CONST_INT
)
439 else if (GET_CODE (x
) == MINUS
440 && GET_CODE (XEXP (x
, 1)) == CONST_INT
)
445 /* Given a tablejump insn INSN, return the RTL expression for the offset
446 into the jump table. If the offset cannot be determined, then return
449 If EARLIEST is nonzero, it is a pointer to a place where the earliest
450 insn used in locating the offset was found. */
453 get_jump_table_offset (rtx insn
, rtx
*earliest
)
465 if (!tablejump_p (insn
, &label
, &table
) || !(set
= single_set (insn
)))
470 /* Some targets (eg, ARM) emit a tablejump that also
471 contains the out-of-range target. */
472 if (GET_CODE (x
) == IF_THEN_ELSE
473 && GET_CODE (XEXP (x
, 2)) == LABEL_REF
)
476 /* Search backwards and locate the expression stored in X. */
477 for (old_x
= NULL_RTX
; GET_CODE (x
) == REG
&& x
!= old_x
;
478 old_x
= x
, x
= find_last_value (x
, &insn
, NULL_RTX
, 0))
481 /* If X is an expression using a relative address then strip
482 off the addition / subtraction of PC, PIC_OFFSET_TABLE_REGNUM,
483 or the jump table label. */
484 if (GET_CODE (PATTERN (table
)) == ADDR_DIFF_VEC
485 && (GET_CODE (x
) == PLUS
|| GET_CODE (x
) == MINUS
))
487 for (i
= 0; i
< 2; i
++)
492 if (y
== pc_rtx
|| y
== pic_offset_table_rtx
)
495 for (old_y
= NULL_RTX
; GET_CODE (y
) == REG
&& y
!= old_y
;
496 old_y
= y
, y
= find_last_value (y
, &old_insn
, NULL_RTX
, 0))
499 if ((GET_CODE (y
) == LABEL_REF
&& XEXP (y
, 0) == label
))
508 for (old_x
= NULL_RTX
; GET_CODE (x
) == REG
&& x
!= old_x
;
509 old_x
= x
, x
= find_last_value (x
, &insn
, NULL_RTX
, 0))
513 /* Strip off any sign or zero extension. */
514 if (GET_CODE (x
) == SIGN_EXTEND
|| GET_CODE (x
) == ZERO_EXTEND
)
518 for (old_x
= NULL_RTX
; GET_CODE (x
) == REG
&& x
!= old_x
;
519 old_x
= x
, x
= find_last_value (x
, &insn
, NULL_RTX
, 0))
523 /* If X isn't a MEM then this isn't a tablejump we understand. */
524 if (GET_CODE (x
) != MEM
)
527 /* Strip off the MEM. */
530 for (old_x
= NULL_RTX
; GET_CODE (x
) == REG
&& x
!= old_x
;
531 old_x
= x
, x
= find_last_value (x
, &insn
, NULL_RTX
, 0))
534 /* If X isn't a PLUS than this isn't a tablejump we understand. */
535 if (GET_CODE (x
) != PLUS
)
538 /* At this point we should have an expression representing the jump table
539 plus an offset. Examine each operand in order to determine which one
540 represents the jump table. Knowing that tells us that the other operand
541 must represent the offset. */
542 for (i
= 0; i
< 2; i
++)
547 for (old_y
= NULL_RTX
; GET_CODE (y
) == REG
&& y
!= old_y
;
548 old_y
= y
, y
= find_last_value (y
, &old_insn
, NULL_RTX
, 0))
551 if ((GET_CODE (y
) == CONST
|| GET_CODE (y
) == LABEL_REF
)
552 && reg_mentioned_p (label
, y
))
561 /* Strip off the addition / subtraction of PIC_OFFSET_TABLE_REGNUM. */
562 if (GET_CODE (x
) == PLUS
|| GET_CODE (x
) == MINUS
)
563 for (i
= 0; i
< 2; i
++)
564 if (XEXP (x
, i
) == pic_offset_table_rtx
)
573 /* Return the RTL expression representing the offset. */
577 /* A subroutine of global_reg_mentioned_p, returns 1 if *LOC mentions
578 a global register. */
581 global_reg_mentioned_p_1 (rtx
*loc
, void *data ATTRIBUTE_UNUSED
)
589 switch (GET_CODE (x
))
592 if (GET_CODE (SUBREG_REG (x
)) == REG
)
594 if (REGNO (SUBREG_REG (x
)) < FIRST_PSEUDO_REGISTER
595 && global_regs
[subreg_regno (x
)])
603 if (regno
< FIRST_PSEUDO_REGISTER
&& global_regs
[regno
])
617 /* A non-constant call might use a global register. */
627 /* Returns nonzero if X mentions a global register. */
630 global_reg_mentioned_p (rtx x
)
634 if (GET_CODE (x
) == CALL_INSN
)
636 if (! CONST_OR_PURE_CALL_P (x
))
638 x
= CALL_INSN_FUNCTION_USAGE (x
);
646 return for_each_rtx (&x
, global_reg_mentioned_p_1
, NULL
);
649 /* Return the number of places FIND appears within X. If COUNT_DEST is
650 zero, we do not count occurrences inside the destination of a SET. */
653 count_occurrences (rtx x
, rtx find
, int count_dest
)
657 const char *format_ptr
;
678 if (GET_CODE (find
) == MEM
&& rtx_equal_p (x
, find
))
683 if (SET_DEST (x
) == find
&& ! count_dest
)
684 return count_occurrences (SET_SRC (x
), find
, count_dest
);
691 format_ptr
= GET_RTX_FORMAT (code
);
694 for (i
= 0; i
< GET_RTX_LENGTH (code
); i
++)
696 switch (*format_ptr
++)
699 count
+= count_occurrences (XEXP (x
, i
), find
, count_dest
);
703 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
704 count
+= count_occurrences (XVECEXP (x
, i
, j
), find
, count_dest
);
711 /* Nonzero if register REG appears somewhere within IN.
712 Also works if REG is not a register; in this case it checks
713 for a subexpression of IN that is Lisp "equal" to REG. */
716 reg_mentioned_p (rtx reg
, rtx in
)
728 if (GET_CODE (in
) == LABEL_REF
)
729 return reg
== XEXP (in
, 0);
731 code
= GET_CODE (in
);
735 /* Compare registers by number. */
737 return GET_CODE (reg
) == REG
&& REGNO (in
) == REGNO (reg
);
739 /* These codes have no constituent expressions
749 /* These are kept unique for a given value. */
756 if (GET_CODE (reg
) == code
&& rtx_equal_p (reg
, in
))
759 fmt
= GET_RTX_FORMAT (code
);
761 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
766 for (j
= XVECLEN (in
, i
) - 1; j
>= 0; j
--)
767 if (reg_mentioned_p (reg
, XVECEXP (in
, i
, j
)))
770 else if (fmt
[i
] == 'e'
771 && reg_mentioned_p (reg
, XEXP (in
, i
)))
777 /* Return 1 if in between BEG and END, exclusive of BEG and END, there is
778 no CODE_LABEL insn. */
781 no_labels_between_p (rtx beg
, rtx end
)
786 for (p
= NEXT_INSN (beg
); p
!= end
; p
= NEXT_INSN (p
))
787 if (GET_CODE (p
) == CODE_LABEL
)
792 /* Return 1 if in between BEG and END, exclusive of BEG and END, there is
793 no JUMP_INSN insn. */
796 no_jumps_between_p (rtx beg
, rtx end
)
799 for (p
= NEXT_INSN (beg
); p
!= end
; p
= NEXT_INSN (p
))
800 if (GET_CODE (p
) == JUMP_INSN
)
805 /* Nonzero if register REG is used in an insn between
806 FROM_INSN and TO_INSN (exclusive of those two). */
809 reg_used_between_p (rtx reg
, rtx from_insn
, rtx to_insn
)
813 if (from_insn
== to_insn
)
816 for (insn
= NEXT_INSN (from_insn
); insn
!= to_insn
; insn
= NEXT_INSN (insn
))
818 && (reg_overlap_mentioned_p (reg
, PATTERN (insn
))
819 || (GET_CODE (insn
) == CALL_INSN
820 && (find_reg_fusage (insn
, USE
, reg
)
821 || find_reg_fusage (insn
, CLOBBER
, reg
)))))
826 /* Nonzero if the old value of X, a register, is referenced in BODY. If X
827 is entirely replaced by a new value and the only use is as a SET_DEST,
828 we do not consider it a reference. */
831 reg_referenced_p (rtx x
, rtx body
)
835 switch (GET_CODE (body
))
838 if (reg_overlap_mentioned_p (x
, SET_SRC (body
)))
841 /* If the destination is anything other than CC0, PC, a REG or a SUBREG
842 of a REG that occupies all of the REG, the insn references X if
843 it is mentioned in the destination. */
844 if (GET_CODE (SET_DEST (body
)) != CC0
845 && GET_CODE (SET_DEST (body
)) != PC
846 && GET_CODE (SET_DEST (body
)) != REG
847 && ! (GET_CODE (SET_DEST (body
)) == SUBREG
848 && GET_CODE (SUBREG_REG (SET_DEST (body
))) == REG
849 && (((GET_MODE_SIZE (GET_MODE (SUBREG_REG (SET_DEST (body
))))
850 + (UNITS_PER_WORD
- 1)) / UNITS_PER_WORD
)
851 == ((GET_MODE_SIZE (GET_MODE (SET_DEST (body
)))
852 + (UNITS_PER_WORD
- 1)) / UNITS_PER_WORD
)))
853 && reg_overlap_mentioned_p (x
, SET_DEST (body
)))
858 for (i
= ASM_OPERANDS_INPUT_LENGTH (body
) - 1; i
>= 0; i
--)
859 if (reg_overlap_mentioned_p (x
, ASM_OPERANDS_INPUT (body
, i
)))
866 return reg_overlap_mentioned_p (x
, body
);
869 return reg_overlap_mentioned_p (x
, TRAP_CONDITION (body
));
872 return reg_overlap_mentioned_p (x
, XEXP (body
, 0));
875 case UNSPEC_VOLATILE
:
876 for (i
= XVECLEN (body
, 0) - 1; i
>= 0; i
--)
877 if (reg_overlap_mentioned_p (x
, XVECEXP (body
, 0, i
)))
882 for (i
= XVECLEN (body
, 0) - 1; i
>= 0; i
--)
883 if (reg_referenced_p (x
, XVECEXP (body
, 0, i
)))
888 if (GET_CODE (XEXP (body
, 0)) == MEM
)
889 if (reg_overlap_mentioned_p (x
, XEXP (XEXP (body
, 0), 0)))
894 if (reg_overlap_mentioned_p (x
, COND_EXEC_TEST (body
)))
896 return reg_referenced_p (x
, COND_EXEC_CODE (body
));
903 /* Nonzero if register REG is referenced in an insn between
904 FROM_INSN and TO_INSN (exclusive of those two). Sets of REG do
908 reg_referenced_between_p (rtx reg
, rtx from_insn
, rtx to_insn
)
912 if (from_insn
== to_insn
)
915 for (insn
= NEXT_INSN (from_insn
); insn
!= to_insn
; insn
= NEXT_INSN (insn
))
917 && (reg_referenced_p (reg
, PATTERN (insn
))
918 || (GET_CODE (insn
) == CALL_INSN
919 && find_reg_fusage (insn
, USE
, reg
))))
924 /* Nonzero if register REG is set or clobbered in an insn between
925 FROM_INSN and TO_INSN (exclusive of those two). */
928 reg_set_between_p (rtx reg
, rtx from_insn
, rtx to_insn
)
932 if (from_insn
== to_insn
)
935 for (insn
= NEXT_INSN (from_insn
); insn
!= to_insn
; insn
= NEXT_INSN (insn
))
936 if (INSN_P (insn
) && reg_set_p (reg
, insn
))
941 /* Internals of reg_set_between_p. */
943 reg_set_p (rtx reg
, rtx insn
)
945 /* We can be passed an insn or part of one. If we are passed an insn,
946 check if a side-effect of the insn clobbers REG. */
948 && (FIND_REG_INC_NOTE (insn
, reg
)
949 || (GET_CODE (insn
) == CALL_INSN
950 /* We'd like to test call_used_regs here, but rtlanal.c can't
951 reference that variable due to its use in genattrtab. So
952 we'll just be more conservative.
954 ??? Unless we could ensure that the CALL_INSN_FUNCTION_USAGE
955 information holds all clobbered registers. */
956 && ((GET_CODE (reg
) == REG
957 && REGNO (reg
) < FIRST_PSEUDO_REGISTER
)
958 || GET_CODE (reg
) == MEM
959 || find_reg_fusage (insn
, CLOBBER
, reg
)))))
962 return set_of (reg
, insn
) != NULL_RTX
;
965 /* Similar to reg_set_between_p, but check all registers in X. Return 0
966 only if none of them are modified between START and END. Do not
967 consider non-registers one way or the other. */
970 regs_set_between_p (rtx x
, rtx start
, rtx end
)
972 enum rtx_code code
= GET_CODE (x
);
989 return reg_set_between_p (x
, start
, end
);
995 fmt
= GET_RTX_FORMAT (code
);
996 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
998 if (fmt
[i
] == 'e' && regs_set_between_p (XEXP (x
, i
), start
, end
))
1001 else if (fmt
[i
] == 'E')
1002 for (j
= XVECLEN (x
, i
) - 1; j
>= 0; j
--)
1003 if (regs_set_between_p (XVECEXP (x
, i
, j
), start
, end
))
1010 /* Similar to reg_set_between_p, but check all registers in X. Return 0
1011 only if none of them are modified between START and END. Return 1 if
1012 X contains a MEM; this routine does usememory aliasing. */
1015 modified_between_p (rtx x
, rtx start
, rtx end
)
1017 enum rtx_code code
= GET_CODE (x
);
1040 if (RTX_UNCHANGING_P (x
))
1042 if (modified_between_p (XEXP (x
, 0), start
, end
))
1044 for (insn
= NEXT_INSN (start
); insn
!= end
; insn
= NEXT_INSN (insn
))
1045 if (memory_modified_in_insn_p (x
, insn
))
1051 return reg_set_between_p (x
, start
, end
);
1057 fmt
= GET_RTX_FORMAT (code
);
1058 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
1060 if (fmt
[i
] == 'e' && modified_between_p (XEXP (x
, i
), start
, end
))
1063 else if (fmt
[i
] == 'E')
1064 for (j
= XVECLEN (x
, i
) - 1; j
>= 0; j
--)
1065 if (modified_between_p (XVECEXP (x
, i
, j
), start
, end
))
1072 /* Similar to reg_set_p, but check all registers in X. Return 0 only if none
1073 of them are modified in INSN. Return 1 if X contains a MEM; this routine
1074 does use memory aliasing. */
1077 modified_in_p (rtx x
, rtx insn
)
1079 enum rtx_code code
= GET_CODE (x
);
1098 if (RTX_UNCHANGING_P (x
))
1100 if (modified_in_p (XEXP (x
, 0), insn
))
1102 if (memory_modified_in_insn_p (x
, insn
))
1108 return reg_set_p (x
, insn
);
1114 fmt
= GET_RTX_FORMAT (code
);
1115 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
1117 if (fmt
[i
] == 'e' && modified_in_p (XEXP (x
, i
), insn
))
1120 else if (fmt
[i
] == 'E')
1121 for (j
= XVECLEN (x
, i
) - 1; j
>= 0; j
--)
1122 if (modified_in_p (XVECEXP (x
, i
, j
), insn
))
1129 /* Return true if anything in insn X is (anti,output,true) dependent on
1130 anything in insn Y. */
1133 insn_dependent_p (rtx x
, rtx y
)
1137 if (! INSN_P (x
) || ! INSN_P (y
))
1141 note_stores (PATTERN (x
), insn_dependent_p_1
, &tmp
);
1142 if (tmp
== NULL_RTX
)
1146 note_stores (PATTERN (y
), insn_dependent_p_1
, &tmp
);
1147 if (tmp
== NULL_RTX
)
1153 /* A helper routine for insn_dependent_p called through note_stores. */
1156 insn_dependent_p_1 (rtx x
, rtx pat ATTRIBUTE_UNUSED
, void *data
)
1158 rtx
* pinsn
= (rtx
*) data
;
1160 if (*pinsn
&& reg_mentioned_p (x
, *pinsn
))
1164 /* Helper function for set_of. */
1172 set_of_1 (rtx x
, rtx pat
, void *data1
)
1174 struct set_of_data
*data
= (struct set_of_data
*) (data1
);
1175 if (rtx_equal_p (x
, data
->pat
)
1176 || (GET_CODE (x
) != MEM
&& reg_overlap_mentioned_p (data
->pat
, x
)))
1180 /* Give an INSN, return a SET or CLOBBER expression that does modify PAT
1181 (either directly or via STRICT_LOW_PART and similar modifiers). */
1183 set_of (rtx pat
, rtx insn
)
1185 struct set_of_data data
;
1186 data
.found
= NULL_RTX
;
1188 note_stores (INSN_P (insn
) ? PATTERN (insn
) : insn
, set_of_1
, &data
);
1192 /* Given an INSN, return a SET expression if this insn has only a single SET.
1193 It may also have CLOBBERs, USEs, or SET whose output
1194 will not be used, which we ignore. */
1197 single_set_2 (rtx insn
, rtx pat
)
1200 int set_verified
= 1;
1203 if (GET_CODE (pat
) == PARALLEL
)
1205 for (i
= 0; i
< XVECLEN (pat
, 0); i
++)
1207 rtx sub
= XVECEXP (pat
, 0, i
);
1208 switch (GET_CODE (sub
))
1215 /* We can consider insns having multiple sets, where all
1216 but one are dead as single set insns. In common case
1217 only single set is present in the pattern so we want
1218 to avoid checking for REG_UNUSED notes unless necessary.
1220 When we reach set first time, we just expect this is
1221 the single set we are looking for and only when more
1222 sets are found in the insn, we check them. */
1225 if (find_reg_note (insn
, REG_UNUSED
, SET_DEST (set
))
1226 && !side_effects_p (set
))
1232 set
= sub
, set_verified
= 0;
1233 else if (!find_reg_note (insn
, REG_UNUSED
, SET_DEST (sub
))
1234 || side_effects_p (sub
))
1246 /* Given an INSN, return nonzero if it has more than one SET, else return
1250 multiple_sets (rtx insn
)
1255 /* INSN must be an insn. */
1256 if (! INSN_P (insn
))
1259 /* Only a PARALLEL can have multiple SETs. */
1260 if (GET_CODE (PATTERN (insn
)) == PARALLEL
)
1262 for (i
= 0, found
= 0; i
< XVECLEN (PATTERN (insn
), 0); i
++)
1263 if (GET_CODE (XVECEXP (PATTERN (insn
), 0, i
)) == SET
)
1265 /* If we have already found a SET, then return now. */
1273 /* Either zero or one SET. */
1277 /* Return nonzero if the destination of SET equals the source
1278 and there are no side effects. */
1281 set_noop_p (rtx set
)
1283 rtx src
= SET_SRC (set
);
1284 rtx dst
= SET_DEST (set
);
1286 if (dst
== pc_rtx
&& src
== pc_rtx
)
1289 if (GET_CODE (dst
) == MEM
&& GET_CODE (src
) == MEM
)
1290 return rtx_equal_p (dst
, src
) && !side_effects_p (dst
);
1292 if (GET_CODE (dst
) == SIGN_EXTRACT
1293 || GET_CODE (dst
) == ZERO_EXTRACT
)
1294 return rtx_equal_p (XEXP (dst
, 0), src
)
1295 && ! BYTES_BIG_ENDIAN
&& XEXP (dst
, 2) == const0_rtx
1296 && !side_effects_p (src
);
1298 if (GET_CODE (dst
) == STRICT_LOW_PART
)
1299 dst
= XEXP (dst
, 0);
1301 if (GET_CODE (src
) == SUBREG
&& GET_CODE (dst
) == SUBREG
)
1303 if (SUBREG_BYTE (src
) != SUBREG_BYTE (dst
))
1305 src
= SUBREG_REG (src
);
1306 dst
= SUBREG_REG (dst
);
1309 return (GET_CODE (src
) == REG
&& GET_CODE (dst
) == REG
1310 && REGNO (src
) == REGNO (dst
));
1313 /* Return nonzero if an insn consists only of SETs, each of which only sets a
1317 noop_move_p (rtx insn
)
1319 rtx pat
= PATTERN (insn
);
1321 if (INSN_CODE (insn
) == NOOP_MOVE_INSN_CODE
)
1324 /* Insns carrying these notes are useful later on. */
1325 if (find_reg_note (insn
, REG_EQUAL
, NULL_RTX
))
1328 /* For now treat an insn with a REG_RETVAL note as a
1329 a special insn which should not be considered a no-op. */
1330 if (find_reg_note (insn
, REG_RETVAL
, NULL_RTX
))
1333 if (GET_CODE (pat
) == SET
&& set_noop_p (pat
))
1336 if (GET_CODE (pat
) == PARALLEL
)
1339 /* If nothing but SETs of registers to themselves,
1340 this insn can also be deleted. */
1341 for (i
= 0; i
< XVECLEN (pat
, 0); i
++)
1343 rtx tem
= XVECEXP (pat
, 0, i
);
1345 if (GET_CODE (tem
) == USE
1346 || GET_CODE (tem
) == CLOBBER
)
1349 if (GET_CODE (tem
) != SET
|| ! set_noop_p (tem
))
1359 /* Return the last thing that X was assigned from before *PINSN. If VALID_TO
1360 is not NULL_RTX then verify that the object is not modified up to VALID_TO.
1361 If the object was modified, if we hit a partial assignment to X, or hit a
1362 CODE_LABEL first, return X. If we found an assignment, update *PINSN to
1363 point to it. ALLOW_HWREG is set to 1 if hardware registers are allowed to
1367 find_last_value (rtx x
, rtx
*pinsn
, rtx valid_to
, int allow_hwreg
)
1371 for (p
= PREV_INSN (*pinsn
); p
&& GET_CODE (p
) != CODE_LABEL
;
1375 rtx set
= single_set (p
);
1376 rtx note
= find_reg_note (p
, REG_EQUAL
, NULL_RTX
);
1378 if (set
&& rtx_equal_p (x
, SET_DEST (set
)))
1380 rtx src
= SET_SRC (set
);
1382 if (note
&& GET_CODE (XEXP (note
, 0)) != EXPR_LIST
)
1383 src
= XEXP (note
, 0);
1385 if ((valid_to
== NULL_RTX
1386 || ! modified_between_p (src
, PREV_INSN (p
), valid_to
))
1387 /* Reject hard registers because we don't usually want
1388 to use them; we'd rather use a pseudo. */
1389 && (! (GET_CODE (src
) == REG
1390 && REGNO (src
) < FIRST_PSEUDO_REGISTER
) || allow_hwreg
))
1397 /* If set in non-simple way, we don't have a value. */
1398 if (reg_set_p (x
, p
))
1405 /* Return nonzero if register in range [REGNO, ENDREGNO)
1406 appears either explicitly or implicitly in X
1407 other than being stored into.
1409 References contained within the substructure at LOC do not count.
1410 LOC may be zero, meaning don't ignore anything. */
1413 refers_to_regno_p (unsigned int regno
, unsigned int endregno
, rtx x
,
1417 unsigned int x_regno
;
1422 /* The contents of a REG_NONNEG note is always zero, so we must come here
1423 upon repeat in case the last REG_NOTE is a REG_NONNEG note. */
1427 code
= GET_CODE (x
);
1432 x_regno
= REGNO (x
);
1434 /* If we modifying the stack, frame, or argument pointer, it will
1435 clobber a virtual register. In fact, we could be more precise,
1436 but it isn't worth it. */
1437 if ((x_regno
== STACK_POINTER_REGNUM
1438 #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
1439 || x_regno
== ARG_POINTER_REGNUM
1441 || x_regno
== FRAME_POINTER_REGNUM
)
1442 && regno
>= FIRST_VIRTUAL_REGISTER
&& regno
<= LAST_VIRTUAL_REGISTER
)
1445 return (endregno
> x_regno
1446 && regno
< x_regno
+ (x_regno
< FIRST_PSEUDO_REGISTER
1447 ? hard_regno_nregs
[x_regno
][GET_MODE (x
)]
1451 /* If this is a SUBREG of a hard reg, we can see exactly which
1452 registers are being modified. Otherwise, handle normally. */
1453 if (GET_CODE (SUBREG_REG (x
)) == REG
1454 && REGNO (SUBREG_REG (x
)) < FIRST_PSEUDO_REGISTER
)
1456 unsigned int inner_regno
= subreg_regno (x
);
1457 unsigned int inner_endregno
1458 = inner_regno
+ (inner_regno
< FIRST_PSEUDO_REGISTER
1459 ? hard_regno_nregs
[inner_regno
][GET_MODE (x
)] : 1);
1461 return endregno
> inner_regno
&& regno
< inner_endregno
;
1467 if (&SET_DEST (x
) != loc
1468 /* Note setting a SUBREG counts as referring to the REG it is in for
1469 a pseudo but not for hard registers since we can
1470 treat each word individually. */
1471 && ((GET_CODE (SET_DEST (x
)) == SUBREG
1472 && loc
!= &SUBREG_REG (SET_DEST (x
))
1473 && GET_CODE (SUBREG_REG (SET_DEST (x
))) == REG
1474 && REGNO (SUBREG_REG (SET_DEST (x
))) >= FIRST_PSEUDO_REGISTER
1475 && refers_to_regno_p (regno
, endregno
,
1476 SUBREG_REG (SET_DEST (x
)), loc
))
1477 || (GET_CODE (SET_DEST (x
)) != REG
1478 && refers_to_regno_p (regno
, endregno
, SET_DEST (x
), loc
))))
1481 if (code
== CLOBBER
|| loc
== &SET_SRC (x
))
1490 /* X does not match, so try its subexpressions. */
1492 fmt
= GET_RTX_FORMAT (code
);
1493 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
1495 if (fmt
[i
] == 'e' && loc
!= &XEXP (x
, i
))
1503 if (refers_to_regno_p (regno
, endregno
, XEXP (x
, i
), loc
))
1506 else if (fmt
[i
] == 'E')
1509 for (j
= XVECLEN (x
, i
) - 1; j
>= 0; j
--)
1510 if (loc
!= &XVECEXP (x
, i
, j
)
1511 && refers_to_regno_p (regno
, endregno
, XVECEXP (x
, i
, j
), loc
))
1518 /* Nonzero if modifying X will affect IN. If X is a register or a SUBREG,
1519 we check if any register number in X conflicts with the relevant register
1520 numbers. If X is a constant, return 0. If X is a MEM, return 1 iff IN
1521 contains a MEM (we don't bother checking for memory addresses that can't
1522 conflict because we expect this to be a rare case. */
1525 reg_overlap_mentioned_p (rtx x
, rtx in
)
1527 unsigned int regno
, endregno
;
1529 /* If either argument is a constant, then modifying X can not
1530 affect IN. Here we look at IN, we can profitably combine
1531 CONSTANT_P (x) with the switch statement below. */
1532 if (CONSTANT_P (in
))
1536 switch (GET_CODE (x
))
1538 case STRICT_LOW_PART
:
1541 /* Overly conservative. */
1546 regno
= REGNO (SUBREG_REG (x
));
1547 if (regno
< FIRST_PSEUDO_REGISTER
)
1548 regno
= subreg_regno (x
);
1554 endregno
= regno
+ (regno
< FIRST_PSEUDO_REGISTER
1555 ? hard_regno_nregs
[regno
][GET_MODE (x
)] : 1);
1556 return refers_to_regno_p (regno
, endregno
, in
, (rtx
*) 0);
1563 if (GET_CODE (in
) == MEM
)
1566 fmt
= GET_RTX_FORMAT (GET_CODE (in
));
1567 for (i
= GET_RTX_LENGTH (GET_CODE (in
)) - 1; i
>= 0; i
--)
1568 if (fmt
[i
] == 'e' && reg_overlap_mentioned_p (x
, XEXP (in
, i
)))
1577 return reg_mentioned_p (x
, in
);
1583 /* If any register in here refers to it we return true. */
1584 for (i
= XVECLEN (x
, 0) - 1; i
>= 0; i
--)
1585 if (XEXP (XVECEXP (x
, 0, i
), 0) != 0
1586 && reg_overlap_mentioned_p (XEXP (XVECEXP (x
, 0, i
), 0), in
))
1592 #ifdef ENABLE_CHECKING
1593 if (!CONSTANT_P (x
))
1601 /* Return the last value to which REG was set prior to INSN. If we can't
1602 find it easily, return 0.
1604 We only return a REG, SUBREG, or constant because it is too hard to
1605 check if a MEM remains unchanged. */
1608 reg_set_last (rtx x
, rtx insn
)
1610 rtx orig_insn
= insn
;
1612 /* Scan backwards until reg_set_last_1 changed one of the above flags.
1613 Stop when we reach a label or X is a hard reg and we reach a
1614 CALL_INSN (if reg_set_last_last_regno is a hard reg).
1616 If we find a set of X, ensure that its SET_SRC remains unchanged. */
1618 /* We compare with <= here, because reg_set_last_last_regno
1619 is actually the number of the first reg *not* in X. */
1621 insn
&& GET_CODE (insn
) != CODE_LABEL
1622 && ! (GET_CODE (insn
) == CALL_INSN
1623 && REGNO (x
) <= FIRST_PSEUDO_REGISTER
);
1624 insn
= PREV_INSN (insn
))
1627 rtx set
= set_of (x
, insn
);
1628 /* OK, this function modify our register. See if we understand it. */
1632 if (GET_CODE (set
) != SET
|| SET_DEST (set
) != x
)
1634 last_value
= SET_SRC (x
);
1635 if (CONSTANT_P (last_value
)
1636 || ((GET_CODE (last_value
) == REG
1637 || GET_CODE (last_value
) == SUBREG
)
1638 && ! reg_set_between_p (last_value
,
1649 /* Call FUN on each register or MEM that is stored into or clobbered by X.
1650 (X would be the pattern of an insn).
1651 FUN receives two arguments:
1652 the REG, MEM, CC0 or PC being stored in or clobbered,
1653 the SET or CLOBBER rtx that does the store.
1655 If the item being stored in or clobbered is a SUBREG of a hard register,
1656 the SUBREG will be passed. */
1659 note_stores (rtx x
, void (*fun
) (rtx
, rtx
, void *), void *data
)
1663 if (GET_CODE (x
) == COND_EXEC
)
1664 x
= COND_EXEC_CODE (x
);
1666 if (GET_CODE (x
) == SET
|| GET_CODE (x
) == CLOBBER
)
1668 rtx dest
= SET_DEST (x
);
1670 while ((GET_CODE (dest
) == SUBREG
1671 && (GET_CODE (SUBREG_REG (dest
)) != REG
1672 || REGNO (SUBREG_REG (dest
)) >= FIRST_PSEUDO_REGISTER
))
1673 || GET_CODE (dest
) == ZERO_EXTRACT
1674 || GET_CODE (dest
) == SIGN_EXTRACT
1675 || GET_CODE (dest
) == STRICT_LOW_PART
)
1676 dest
= XEXP (dest
, 0);
1678 /* If we have a PARALLEL, SET_DEST is a list of EXPR_LIST expressions,
1679 each of whose first operand is a register. */
1680 if (GET_CODE (dest
) == PARALLEL
)
1682 for (i
= XVECLEN (dest
, 0) - 1; i
>= 0; i
--)
1683 if (XEXP (XVECEXP (dest
, 0, i
), 0) != 0)
1684 (*fun
) (XEXP (XVECEXP (dest
, 0, i
), 0), x
, data
);
1687 (*fun
) (dest
, x
, data
);
1690 else if (GET_CODE (x
) == PARALLEL
)
1691 for (i
= XVECLEN (x
, 0) - 1; i
>= 0; i
--)
1692 note_stores (XVECEXP (x
, 0, i
), fun
, data
);
1695 /* Like notes_stores, but call FUN for each expression that is being
1696 referenced in PBODY, a pointer to the PATTERN of an insn. We only call
1697 FUN for each expression, not any interior subexpressions. FUN receives a
1698 pointer to the expression and the DATA passed to this function.
1700 Note that this is not quite the same test as that done in reg_referenced_p
1701 since that considers something as being referenced if it is being
1702 partially set, while we do not. */
1705 note_uses (rtx
*pbody
, void (*fun
) (rtx
*, void *), void *data
)
1710 switch (GET_CODE (body
))
1713 (*fun
) (&COND_EXEC_TEST (body
), data
);
1714 note_uses (&COND_EXEC_CODE (body
), fun
, data
);
1718 for (i
= XVECLEN (body
, 0) - 1; i
>= 0; i
--)
1719 note_uses (&XVECEXP (body
, 0, i
), fun
, data
);
1723 (*fun
) (&XEXP (body
, 0), data
);
1727 for (i
= ASM_OPERANDS_INPUT_LENGTH (body
) - 1; i
>= 0; i
--)
1728 (*fun
) (&ASM_OPERANDS_INPUT (body
, i
), data
);
1732 (*fun
) (&TRAP_CONDITION (body
), data
);
1736 (*fun
) (&XEXP (body
, 0), data
);
1740 case UNSPEC_VOLATILE
:
1741 for (i
= XVECLEN (body
, 0) - 1; i
>= 0; i
--)
1742 (*fun
) (&XVECEXP (body
, 0, i
), data
);
1746 if (GET_CODE (XEXP (body
, 0)) == MEM
)
1747 (*fun
) (&XEXP (XEXP (body
, 0), 0), data
);
1752 rtx dest
= SET_DEST (body
);
1754 /* For sets we replace everything in source plus registers in memory
1755 expression in store and operands of a ZERO_EXTRACT. */
1756 (*fun
) (&SET_SRC (body
), data
);
1758 if (GET_CODE (dest
) == ZERO_EXTRACT
)
1760 (*fun
) (&XEXP (dest
, 1), data
);
1761 (*fun
) (&XEXP (dest
, 2), data
);
1764 while (GET_CODE (dest
) == SUBREG
|| GET_CODE (dest
) == STRICT_LOW_PART
)
1765 dest
= XEXP (dest
, 0);
1767 if (GET_CODE (dest
) == MEM
)
1768 (*fun
) (&XEXP (dest
, 0), data
);
1773 /* All the other possibilities never store. */
1774 (*fun
) (pbody
, data
);
1779 /* Return nonzero if X's old contents don't survive after INSN.
1780 This will be true if X is (cc0) or if X is a register and
1781 X dies in INSN or because INSN entirely sets X.
1783 "Entirely set" means set directly and not through a SUBREG,
1784 ZERO_EXTRACT or SIGN_EXTRACT, so no trace of the old contents remains.
1785 Likewise, REG_INC does not count.
1787 REG may be a hard or pseudo reg. Renumbering is not taken into account,
1788 but for this use that makes no difference, since regs don't overlap
1789 during their lifetimes. Therefore, this function may be used
1790 at any time after deaths have been computed (in flow.c).
1792 If REG is a hard reg that occupies multiple machine registers, this
1793 function will only return 1 if each of those registers will be replaced
1797 dead_or_set_p (rtx insn
, rtx x
)
1799 unsigned int regno
, last_regno
;
1802 /* Can't use cc0_rtx below since this file is used by genattrtab.c. */
1803 if (GET_CODE (x
) == CC0
)
1806 if (GET_CODE (x
) != REG
)
1810 last_regno
= (regno
>= FIRST_PSEUDO_REGISTER
? regno
1811 : regno
+ hard_regno_nregs
[regno
][GET_MODE (x
)] - 1);
1813 for (i
= regno
; i
<= last_regno
; i
++)
1814 if (! dead_or_set_regno_p (insn
, i
))
1820 /* Utility function for dead_or_set_p to check an individual register. Also
1821 called from flow.c. */
1824 dead_or_set_regno_p (rtx insn
, unsigned int test_regno
)
1826 unsigned int regno
, endregno
;
1829 /* See if there is a death note for something that includes TEST_REGNO. */
1830 if (find_regno_note (insn
, REG_DEAD
, test_regno
))
1833 if (GET_CODE (insn
) == CALL_INSN
1834 && find_regno_fusage (insn
, CLOBBER
, test_regno
))
1837 pattern
= PATTERN (insn
);
1839 if (GET_CODE (pattern
) == COND_EXEC
)
1840 pattern
= COND_EXEC_CODE (pattern
);
1842 if (GET_CODE (pattern
) == SET
)
1844 rtx dest
= SET_DEST (pattern
);
1846 /* A value is totally replaced if it is the destination or the
1847 destination is a SUBREG of REGNO that does not change the number of
1849 if (GET_CODE (dest
) == SUBREG
1850 && (((GET_MODE_SIZE (GET_MODE (dest
))
1851 + UNITS_PER_WORD
- 1) / UNITS_PER_WORD
)
1852 == ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (dest
)))
1853 + UNITS_PER_WORD
- 1) / UNITS_PER_WORD
)))
1854 dest
= SUBREG_REG (dest
);
1856 if (GET_CODE (dest
) != REG
)
1859 regno
= REGNO (dest
);
1860 endregno
= (regno
>= FIRST_PSEUDO_REGISTER
? regno
+ 1
1861 : regno
+ hard_regno_nregs
[regno
][GET_MODE (dest
)]);
1863 return (test_regno
>= regno
&& test_regno
< endregno
);
1865 else if (GET_CODE (pattern
) == PARALLEL
)
1869 for (i
= XVECLEN (pattern
, 0) - 1; i
>= 0; i
--)
1871 rtx body
= XVECEXP (pattern
, 0, i
);
1873 if (GET_CODE (body
) == COND_EXEC
)
1874 body
= COND_EXEC_CODE (body
);
1876 if (GET_CODE (body
) == SET
|| GET_CODE (body
) == CLOBBER
)
1878 rtx dest
= SET_DEST (body
);
1880 if (GET_CODE (dest
) == SUBREG
1881 && (((GET_MODE_SIZE (GET_MODE (dest
))
1882 + UNITS_PER_WORD
- 1) / UNITS_PER_WORD
)
1883 == ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (dest
)))
1884 + UNITS_PER_WORD
- 1) / UNITS_PER_WORD
)))
1885 dest
= SUBREG_REG (dest
);
1887 if (GET_CODE (dest
) != REG
)
1890 regno
= REGNO (dest
);
1891 endregno
= (regno
>= FIRST_PSEUDO_REGISTER
? regno
+ 1
1892 : regno
+ hard_regno_nregs
[regno
][GET_MODE (dest
)]);
1894 if (test_regno
>= regno
&& test_regno
< endregno
)
1903 /* Return the reg-note of kind KIND in insn INSN, if there is one.
1904 If DATUM is nonzero, look for one whose datum is DATUM. */
1907 find_reg_note (rtx insn
, enum reg_note kind
, rtx datum
)
1911 /* Ignore anything that is not an INSN, JUMP_INSN or CALL_INSN. */
1912 if (! INSN_P (insn
))
1916 for (link
= REG_NOTES (insn
); link
; link
= XEXP (link
, 1))
1917 if (REG_NOTE_KIND (link
) == kind
)
1922 for (link
= REG_NOTES (insn
); link
; link
= XEXP (link
, 1))
1923 if (REG_NOTE_KIND (link
) == kind
&& datum
== XEXP (link
, 0))
1928 /* Return the reg-note of kind KIND in insn INSN which applies to register
1929 number REGNO, if any. Return 0 if there is no such reg-note. Note that
1930 the REGNO of this NOTE need not be REGNO if REGNO is a hard register;
1931 it might be the case that the note overlaps REGNO. */
1934 find_regno_note (rtx insn
, enum reg_note kind
, unsigned int regno
)
1938 /* Ignore anything that is not an INSN, JUMP_INSN or CALL_INSN. */
1939 if (! INSN_P (insn
))
1942 for (link
= REG_NOTES (insn
); link
; link
= XEXP (link
, 1))
1943 if (REG_NOTE_KIND (link
) == kind
1944 /* Verify that it is a register, so that scratch and MEM won't cause a
1946 && GET_CODE (XEXP (link
, 0)) == REG
1947 && REGNO (XEXP (link
, 0)) <= regno
1948 && ((REGNO (XEXP (link
, 0))
1949 + (REGNO (XEXP (link
, 0)) >= FIRST_PSEUDO_REGISTER
? 1
1950 : hard_regno_nregs
[REGNO (XEXP (link
, 0))]
1951 [GET_MODE (XEXP (link
, 0))]))
1957 /* Return a REG_EQUIV or REG_EQUAL note if insn has only a single set and
1961 find_reg_equal_equiv_note (rtx insn
)
1967 for (link
= REG_NOTES (insn
); link
; link
= XEXP (link
, 1))
1968 if (REG_NOTE_KIND (link
) == REG_EQUAL
1969 || REG_NOTE_KIND (link
) == REG_EQUIV
)
1971 if (single_set (insn
) == 0)
1978 /* Return true if DATUM, or any overlap of DATUM, of kind CODE is found
1979 in the CALL_INSN_FUNCTION_USAGE information of INSN. */
1982 find_reg_fusage (rtx insn
, enum rtx_code code
, rtx datum
)
1984 /* If it's not a CALL_INSN, it can't possibly have a
1985 CALL_INSN_FUNCTION_USAGE field, so don't bother checking. */
1986 if (GET_CODE (insn
) != CALL_INSN
)
1992 if (GET_CODE (datum
) != REG
)
1996 for (link
= CALL_INSN_FUNCTION_USAGE (insn
);
1998 link
= XEXP (link
, 1))
1999 if (GET_CODE (XEXP (link
, 0)) == code
2000 && rtx_equal_p (datum
, XEXP (XEXP (link
, 0), 0)))
2005 unsigned int regno
= REGNO (datum
);
2007 /* CALL_INSN_FUNCTION_USAGE information cannot contain references
2008 to pseudo registers, so don't bother checking. */
2010 if (regno
< FIRST_PSEUDO_REGISTER
)
2012 unsigned int end_regno
2013 = regno
+ hard_regno_nregs
[regno
][GET_MODE (datum
)];
2016 for (i
= regno
; i
< end_regno
; i
++)
2017 if (find_regno_fusage (insn
, code
, i
))
2025 /* Return true if REGNO, or any overlap of REGNO, of kind CODE is found
2026 in the CALL_INSN_FUNCTION_USAGE information of INSN. */
2029 find_regno_fusage (rtx insn
, enum rtx_code code
, unsigned int regno
)
2033 /* CALL_INSN_FUNCTION_USAGE information cannot contain references
2034 to pseudo registers, so don't bother checking. */
2036 if (regno
>= FIRST_PSEUDO_REGISTER
2037 || GET_CODE (insn
) != CALL_INSN
)
2040 for (link
= CALL_INSN_FUNCTION_USAGE (insn
); link
; link
= XEXP (link
, 1))
2042 unsigned int regnote
;
2045 if (GET_CODE (op
= XEXP (link
, 0)) == code
2046 && GET_CODE (reg
= XEXP (op
, 0)) == REG
2047 && (regnote
= REGNO (reg
)) <= regno
2048 && regnote
+ hard_regno_nregs
[regnote
][GET_MODE (reg
)] > regno
)
2055 /* Return true if INSN is a call to a pure function. */
2058 pure_call_p (rtx insn
)
2062 if (GET_CODE (insn
) != CALL_INSN
|| ! CONST_OR_PURE_CALL_P (insn
))
2065 /* Look for the note that differentiates const and pure functions. */
2066 for (link
= CALL_INSN_FUNCTION_USAGE (insn
); link
; link
= XEXP (link
, 1))
2070 if (GET_CODE (u
= XEXP (link
, 0)) == USE
2071 && GET_CODE (m
= XEXP (u
, 0)) == MEM
&& GET_MODE (m
) == BLKmode
2072 && GET_CODE (XEXP (m
, 0)) == SCRATCH
)
2079 /* Remove register note NOTE from the REG_NOTES of INSN. */
2082 remove_note (rtx insn
, rtx note
)
2086 if (note
== NULL_RTX
)
2089 if (REG_NOTES (insn
) == note
)
2091 REG_NOTES (insn
) = XEXP (note
, 1);
2095 for (link
= REG_NOTES (insn
); link
; link
= XEXP (link
, 1))
2096 if (XEXP (link
, 1) == note
)
2098 XEXP (link
, 1) = XEXP (note
, 1);
2105 /* Search LISTP (an EXPR_LIST) for an entry whose first operand is NODE and
2106 return 1 if it is found. A simple equality test is used to determine if
2110 in_expr_list_p (rtx listp
, rtx node
)
2114 for (x
= listp
; x
; x
= XEXP (x
, 1))
2115 if (node
== XEXP (x
, 0))
2121 /* Search LISTP (an EXPR_LIST) for an entry whose first operand is NODE and
2122 remove that entry from the list if it is found.
2124 A simple equality test is used to determine if NODE matches. */
2127 remove_node_from_expr_list (rtx node
, rtx
*listp
)
2130 rtx prev
= NULL_RTX
;
2134 if (node
== XEXP (temp
, 0))
2136 /* Splice the node out of the list. */
2138 XEXP (prev
, 1) = XEXP (temp
, 1);
2140 *listp
= XEXP (temp
, 1);
2146 temp
= XEXP (temp
, 1);
2150 /* Nonzero if X contains any volatile instructions. These are instructions
2151 which may cause unpredictable machine state instructions, and thus no
2152 instructions should be moved or combined across them. This includes
2153 only volatile asms and UNSPEC_VOLATILE instructions. */
2156 volatile_insn_p (rtx x
)
2160 code
= GET_CODE (x
);
2180 case UNSPEC_VOLATILE
:
2181 /* case TRAP_IF: This isn't clear yet. */
2186 if (MEM_VOLATILE_P (x
))
2193 /* Recursively scan the operands of this expression. */
2196 const char *fmt
= GET_RTX_FORMAT (code
);
2199 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
2203 if (volatile_insn_p (XEXP (x
, i
)))
2206 else if (fmt
[i
] == 'E')
2209 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
2210 if (volatile_insn_p (XVECEXP (x
, i
, j
)))
2218 /* Nonzero if X contains any volatile memory references
2219 UNSPEC_VOLATILE operations or volatile ASM_OPERANDS expressions. */
2222 volatile_refs_p (rtx x
)
2226 code
= GET_CODE (x
);
2244 case UNSPEC_VOLATILE
:
2250 if (MEM_VOLATILE_P (x
))
2257 /* Recursively scan the operands of this expression. */
2260 const char *fmt
= GET_RTX_FORMAT (code
);
2263 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
2267 if (volatile_refs_p (XEXP (x
, i
)))
2270 else if (fmt
[i
] == 'E')
2273 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
2274 if (volatile_refs_p (XVECEXP (x
, i
, j
)))
2282 /* Similar to above, except that it also rejects register pre- and post-
2286 side_effects_p (rtx x
)
2290 code
= GET_CODE (x
);
2308 /* Reject CLOBBER with a non-VOID mode. These are made by combine.c
2309 when some combination can't be done. If we see one, don't think
2310 that we can simplify the expression. */
2311 return (GET_MODE (x
) != VOIDmode
);
2320 case UNSPEC_VOLATILE
:
2321 /* case TRAP_IF: This isn't clear yet. */
2327 if (MEM_VOLATILE_P (x
))
2334 /* Recursively scan the operands of this expression. */
2337 const char *fmt
= GET_RTX_FORMAT (code
);
2340 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
2344 if (side_effects_p (XEXP (x
, i
)))
2347 else if (fmt
[i
] == 'E')
2350 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
2351 if (side_effects_p (XVECEXP (x
, i
, j
)))
2359 /* Return nonzero if evaluating rtx X might cause a trap. */
2370 code
= GET_CODE (x
);
2373 /* Handle these cases quickly. */
2387 case UNSPEC_VOLATILE
:
2392 return MEM_VOLATILE_P (x
);
2394 /* Memory ref can trap unless it's a static var or a stack slot. */
2396 if (MEM_NOTRAP_P (x
))
2398 return rtx_addr_can_trap_p (XEXP (x
, 0));
2400 /* Division by a non-constant might trap. */
2405 if (HONOR_SNANS (GET_MODE (x
)))
2407 if (! CONSTANT_P (XEXP (x
, 1))
2408 || (GET_MODE_CLASS (GET_MODE (x
)) == MODE_FLOAT
2409 && flag_trapping_math
))
2411 if (XEXP (x
, 1) == const0_rtx
)
2416 /* An EXPR_LIST is used to represent a function call. This
2417 certainly may trap. */
2425 /* Some floating point comparisons may trap. */
2426 if (!flag_trapping_math
)
2428 /* ??? There is no machine independent way to check for tests that trap
2429 when COMPARE is used, though many targets do make this distinction.
2430 For instance, sparc uses CCFPE for compares which generate exceptions
2431 and CCFP for compares which do not generate exceptions. */
2432 if (HONOR_NANS (GET_MODE (x
)))
2434 /* But often the compare has some CC mode, so check operand
2436 if (HONOR_NANS (GET_MODE (XEXP (x
, 0)))
2437 || HONOR_NANS (GET_MODE (XEXP (x
, 1))))
2443 if (HONOR_SNANS (GET_MODE (x
)))
2445 /* Often comparison is CC mode, so check operand modes. */
2446 if (HONOR_SNANS (GET_MODE (XEXP (x
, 0)))
2447 || HONOR_SNANS (GET_MODE (XEXP (x
, 1))))
2452 /* Conversion of floating point might trap. */
2453 if (flag_trapping_math
&& HONOR_NANS (GET_MODE (XEXP (x
, 0))))
2459 /* These operations don't trap even with floating point. */
2463 /* Any floating arithmetic may trap. */
2464 if (GET_MODE_CLASS (GET_MODE (x
)) == MODE_FLOAT
2465 && flag_trapping_math
)
2469 fmt
= GET_RTX_FORMAT (code
);
2470 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
2474 if (may_trap_p (XEXP (x
, i
)))
2477 else if (fmt
[i
] == 'E')
2480 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
2481 if (may_trap_p (XVECEXP (x
, i
, j
)))
2488 /* Return nonzero if X contains a comparison that is not either EQ or NE,
2489 i.e., an inequality. */
2492 inequality_comparisons_p (rtx x
)
2496 enum rtx_code code
= GET_CODE (x
);
2526 len
= GET_RTX_LENGTH (code
);
2527 fmt
= GET_RTX_FORMAT (code
);
2529 for (i
= 0; i
< len
; i
++)
2533 if (inequality_comparisons_p (XEXP (x
, i
)))
2536 else if (fmt
[i
] == 'E')
2539 for (j
= XVECLEN (x
, i
) - 1; j
>= 0; j
--)
2540 if (inequality_comparisons_p (XVECEXP (x
, i
, j
)))
2548 /* Replace any occurrence of FROM in X with TO. The function does
2549 not enter into CONST_DOUBLE for the replace.
2551 Note that copying is not done so X must not be shared unless all copies
2552 are to be modified. */
2555 replace_rtx (rtx x
, rtx from
, rtx to
)
2560 /* The following prevents loops occurrence when we change MEM in
2561 CONST_DOUBLE onto the same CONST_DOUBLE. */
2562 if (x
!= 0 && GET_CODE (x
) == CONST_DOUBLE
)
2568 /* Allow this function to make replacements in EXPR_LISTs. */
2572 if (GET_CODE (x
) == SUBREG
)
2574 rtx
new = replace_rtx (SUBREG_REG (x
), from
, to
);
2576 if (GET_CODE (new) == CONST_INT
)
2578 x
= simplify_subreg (GET_MODE (x
), new,
2579 GET_MODE (SUBREG_REG (x
)),
2585 SUBREG_REG (x
) = new;
2589 else if (GET_CODE (x
) == ZERO_EXTEND
)
2591 rtx
new = replace_rtx (XEXP (x
, 0), from
, to
);
2593 if (GET_CODE (new) == CONST_INT
)
2595 x
= simplify_unary_operation (ZERO_EXTEND
, GET_MODE (x
),
2596 new, GET_MODE (XEXP (x
, 0)));
2606 fmt
= GET_RTX_FORMAT (GET_CODE (x
));
2607 for (i
= GET_RTX_LENGTH (GET_CODE (x
)) - 1; i
>= 0; i
--)
2610 XEXP (x
, i
) = replace_rtx (XEXP (x
, i
), from
, to
);
2611 else if (fmt
[i
] == 'E')
2612 for (j
= XVECLEN (x
, i
) - 1; j
>= 0; j
--)
2613 XVECEXP (x
, i
, j
) = replace_rtx (XVECEXP (x
, i
, j
), from
, to
);
2619 /* Throughout the rtx X, replace many registers according to REG_MAP.
2620 Return the replacement for X (which may be X with altered contents).
2621 REG_MAP[R] is the replacement for register R, or 0 for don't replace.
2622 NREGS is the length of REG_MAP; regs >= NREGS are not mapped.
2624 We only support REG_MAP entries of REG or SUBREG. Also, hard registers
2625 should not be mapped to pseudos or vice versa since validate_change
2628 If REPLACE_DEST is 1, replacements are also done in destinations;
2629 otherwise, only sources are replaced. */
2632 replace_regs (rtx x
, rtx
*reg_map
, unsigned int nregs
, int replace_dest
)
2641 code
= GET_CODE (x
);
2656 /* Verify that the register has an entry before trying to access it. */
2657 if (REGNO (x
) < nregs
&& reg_map
[REGNO (x
)] != 0)
2659 /* SUBREGs can't be shared. Always return a copy to ensure that if
2660 this replacement occurs more than once then each instance will
2661 get distinct rtx. */
2662 if (GET_CODE (reg_map
[REGNO (x
)]) == SUBREG
)
2663 return copy_rtx (reg_map
[REGNO (x
)]);
2664 return reg_map
[REGNO (x
)];
2669 /* Prevent making nested SUBREGs. */
2670 if (GET_CODE (SUBREG_REG (x
)) == REG
&& REGNO (SUBREG_REG (x
)) < nregs
2671 && reg_map
[REGNO (SUBREG_REG (x
))] != 0
2672 && GET_CODE (reg_map
[REGNO (SUBREG_REG (x
))]) == SUBREG
)
2674 rtx map_val
= reg_map
[REGNO (SUBREG_REG (x
))];
2675 return simplify_gen_subreg (GET_MODE (x
), map_val
,
2676 GET_MODE (SUBREG_REG (x
)),
2683 SET_DEST (x
) = replace_regs (SET_DEST (x
), reg_map
, nregs
, 0);
2685 else if (GET_CODE (SET_DEST (x
)) == MEM
2686 || GET_CODE (SET_DEST (x
)) == STRICT_LOW_PART
)
2687 /* Even if we are not to replace destinations, replace register if it
2688 is CONTAINED in destination (destination is memory or
2689 STRICT_LOW_PART). */
2690 XEXP (SET_DEST (x
), 0) = replace_regs (XEXP (SET_DEST (x
), 0),
2692 else if (GET_CODE (SET_DEST (x
)) == ZERO_EXTRACT
)
2693 /* Similarly, for ZERO_EXTRACT we replace all operands. */
2696 SET_SRC (x
) = replace_regs (SET_SRC (x
), reg_map
, nregs
, 0);
2703 fmt
= GET_RTX_FORMAT (code
);
2704 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
2707 XEXP (x
, i
) = replace_regs (XEXP (x
, i
), reg_map
, nregs
, replace_dest
);
2708 else if (fmt
[i
] == 'E')
2711 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
2712 XVECEXP (x
, i
, j
) = replace_regs (XVECEXP (x
, i
, j
), reg_map
,
2713 nregs
, replace_dest
);
2719 /* Replace occurrences of the old label in *X with the new one.
2720 DATA is a REPLACE_LABEL_DATA containing the old and new labels. */
2723 replace_label (rtx
*x
, void *data
)
2726 rtx old_label
= ((replace_label_data
*) data
)->r1
;
2727 rtx new_label
= ((replace_label_data
*) data
)->r2
;
2728 bool update_label_nuses
= ((replace_label_data
*) data
)->update_label_nuses
;
2733 if (GET_CODE (l
) == SYMBOL_REF
2734 && CONSTANT_POOL_ADDRESS_P (l
))
2736 rtx c
= get_pool_constant (l
);
2737 if (rtx_referenced_p (old_label
, c
))
2740 replace_label_data
*d
= (replace_label_data
*) data
;
2742 /* Create a copy of constant C; replace the label inside
2743 but do not update LABEL_NUSES because uses in constant pool
2745 new_c
= copy_rtx (c
);
2746 d
->update_label_nuses
= false;
2747 for_each_rtx (&new_c
, replace_label
, data
);
2748 d
->update_label_nuses
= update_label_nuses
;
2750 /* Add the new constant NEW_C to constant pool and replace
2751 the old reference to constant by new reference. */
2752 new_l
= XEXP (force_const_mem (get_pool_mode (l
), new_c
), 0);
2753 *x
= replace_rtx (l
, l
, new_l
);
2758 /* If this is a JUMP_INSN, then we also need to fix the JUMP_LABEL
2759 field. This is not handled by for_each_rtx because it doesn't
2760 handle unprinted ('0') fields. */
2761 if (GET_CODE (l
) == JUMP_INSN
&& JUMP_LABEL (l
) == old_label
)
2762 JUMP_LABEL (l
) = new_label
;
2764 if ((GET_CODE (l
) == LABEL_REF
2765 || GET_CODE (l
) == INSN_LIST
)
2766 && XEXP (l
, 0) == old_label
)
2768 XEXP (l
, 0) = new_label
;
2769 if (update_label_nuses
)
2771 ++LABEL_NUSES (new_label
);
2772 --LABEL_NUSES (old_label
);
2780 /* When *BODY is equal to X or X is directly referenced by *BODY
2781 return nonzero, thus FOR_EACH_RTX stops traversing and returns nonzero
2782 too, otherwise FOR_EACH_RTX continues traversing *BODY. */
2785 rtx_referenced_p_1 (rtx
*body
, void *x
)
2789 if (*body
== NULL_RTX
)
2790 return y
== NULL_RTX
;
2792 /* Return true if a label_ref *BODY refers to label Y. */
2793 if (GET_CODE (*body
) == LABEL_REF
&& GET_CODE (y
) == CODE_LABEL
)
2794 return XEXP (*body
, 0) == y
;
2796 /* If *BODY is a reference to pool constant traverse the constant. */
2797 if (GET_CODE (*body
) == SYMBOL_REF
2798 && CONSTANT_POOL_ADDRESS_P (*body
))
2799 return rtx_referenced_p (y
, get_pool_constant (*body
));
2801 /* By default, compare the RTL expressions. */
2802 return rtx_equal_p (*body
, y
);
2805 /* Return true if X is referenced in BODY. */
2808 rtx_referenced_p (rtx x
, rtx body
)
2810 return for_each_rtx (&body
, rtx_referenced_p_1
, x
);
2813 /* If INSN is a tablejump return true and store the label (before jump table) to
2814 *LABELP and the jump table to *TABLEP. LABELP and TABLEP may be NULL. */
2817 tablejump_p (rtx insn
, rtx
*labelp
, rtx
*tablep
)
2821 if (GET_CODE (insn
) == JUMP_INSN
2822 && (label
= JUMP_LABEL (insn
)) != NULL_RTX
2823 && (table
= next_active_insn (label
)) != NULL_RTX
2824 && GET_CODE (table
) == JUMP_INSN
2825 && (GET_CODE (PATTERN (table
)) == ADDR_VEC
2826 || GET_CODE (PATTERN (table
)) == ADDR_DIFF_VEC
))
2837 /* A subroutine of computed_jump_p, return 1 if X contains a REG or MEM or
2838 constant that is not in the constant pool and not in the condition
2839 of an IF_THEN_ELSE. */
2842 computed_jump_p_1 (rtx x
)
2844 enum rtx_code code
= GET_CODE (x
);
2863 return ! (GET_CODE (XEXP (x
, 0)) == SYMBOL_REF
2864 && CONSTANT_POOL_ADDRESS_P (XEXP (x
, 0)));
2867 return (computed_jump_p_1 (XEXP (x
, 1))
2868 || computed_jump_p_1 (XEXP (x
, 2)));
2874 fmt
= GET_RTX_FORMAT (code
);
2875 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
2878 && computed_jump_p_1 (XEXP (x
, i
)))
2881 else if (fmt
[i
] == 'E')
2882 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
2883 if (computed_jump_p_1 (XVECEXP (x
, i
, j
)))
2890 /* Return nonzero if INSN is an indirect jump (aka computed jump).
2892 Tablejumps and casesi insns are not considered indirect jumps;
2893 we can recognize them by a (use (label_ref)). */
2896 computed_jump_p (rtx insn
)
2899 if (GET_CODE (insn
) == JUMP_INSN
)
2901 rtx pat
= PATTERN (insn
);
2903 if (find_reg_note (insn
, REG_LABEL
, NULL_RTX
))
2905 else if (GET_CODE (pat
) == PARALLEL
)
2907 int len
= XVECLEN (pat
, 0);
2908 int has_use_labelref
= 0;
2910 for (i
= len
- 1; i
>= 0; i
--)
2911 if (GET_CODE (XVECEXP (pat
, 0, i
)) == USE
2912 && (GET_CODE (XEXP (XVECEXP (pat
, 0, i
), 0))
2914 has_use_labelref
= 1;
2916 if (! has_use_labelref
)
2917 for (i
= len
- 1; i
>= 0; i
--)
2918 if (GET_CODE (XVECEXP (pat
, 0, i
)) == SET
2919 && SET_DEST (XVECEXP (pat
, 0, i
)) == pc_rtx
2920 && computed_jump_p_1 (SET_SRC (XVECEXP (pat
, 0, i
))))
2923 else if (GET_CODE (pat
) == SET
2924 && SET_DEST (pat
) == pc_rtx
2925 && computed_jump_p_1 (SET_SRC (pat
)))
2931 /* Traverse X via depth-first search, calling F for each
2932 sub-expression (including X itself). F is also passed the DATA.
2933 If F returns -1, do not traverse sub-expressions, but continue
2934 traversing the rest of the tree. If F ever returns any other
2935 nonzero value, stop the traversal, and return the value returned
2936 by F. Otherwise, return 0. This function does not traverse inside
2937 tree structure that contains RTX_EXPRs, or into sub-expressions
2938 whose format code is `0' since it is not known whether or not those
2939 codes are actually RTL.
2941 This routine is very general, and could (should?) be used to
2942 implement many of the other routines in this file. */
2945 for_each_rtx (rtx
*x
, rtx_function f
, void *data
)
2953 result
= (*f
) (x
, data
);
2955 /* Do not traverse sub-expressions. */
2957 else if (result
!= 0)
2958 /* Stop the traversal. */
2962 /* There are no sub-expressions. */
2965 length
= GET_RTX_LENGTH (GET_CODE (*x
));
2966 format
= GET_RTX_FORMAT (GET_CODE (*x
));
2968 for (i
= 0; i
< length
; ++i
)
2973 result
= for_each_rtx (&XEXP (*x
, i
), f
, data
);
2980 if (XVEC (*x
, i
) != 0)
2983 for (j
= 0; j
< XVECLEN (*x
, i
); ++j
)
2985 result
= for_each_rtx (&XVECEXP (*x
, i
, j
), f
, data
);
2993 /* Nothing to do. */
3002 /* Searches X for any reference to REGNO, returning the rtx of the
3003 reference found if any. Otherwise, returns NULL_RTX. */
3006 regno_use_in (unsigned int regno
, rtx x
)
3012 if (GET_CODE (x
) == REG
&& REGNO (x
) == regno
)
3015 fmt
= GET_RTX_FORMAT (GET_CODE (x
));
3016 for (i
= GET_RTX_LENGTH (GET_CODE (x
)) - 1; i
>= 0; i
--)
3020 if ((tem
= regno_use_in (regno
, XEXP (x
, i
))))
3023 else if (fmt
[i
] == 'E')
3024 for (j
= XVECLEN (x
, i
) - 1; j
>= 0; j
--)
3025 if ((tem
= regno_use_in (regno
, XVECEXP (x
, i
, j
))))
3032 /* Return a value indicating whether OP, an operand of a commutative
3033 operation, is preferred as the first or second operand. The higher
3034 the value, the stronger the preference for being the first operand.
3035 We use negative values to indicate a preference for the first operand
3036 and positive values for the second operand. */
3039 commutative_operand_precedence (rtx op
)
3041 enum rtx_code code
= GET_CODE (op
);
3043 /* Constants always come the second operand. Prefer "nice" constants. */
3044 if (code
== CONST_INT
)
3046 if (code
== CONST_DOUBLE
)
3048 op
= avoid_constant_pool_reference (op
);
3050 switch (GET_RTX_CLASS (code
))
3053 if (code
== CONST_INT
)
3055 if (code
== CONST_DOUBLE
)
3060 /* SUBREGs of objects should come second. */
3061 if (code
== SUBREG
&& OBJECT_P (SUBREG_REG (op
)))
3064 if (!CONSTANT_P (op
))
3067 /* As for RTX_CONST_OBJ. */
3071 /* Complex expressions should be the first, so decrease priority
3075 case RTX_COMM_ARITH
:
3076 /* Prefer operands that are themselves commutative to be first.
3077 This helps to make things linear. In particular,
3078 (and (and (reg) (reg)) (not (reg))) is canonical. */
3082 /* If only one operand is a binary expression, it will be the first
3083 operand. In particular, (plus (minus (reg) (reg)) (neg (reg)))
3084 is canonical, although it will usually be further simplified. */
3088 /* Then prefer NEG and NOT. */
3089 if (code
== NEG
|| code
== NOT
)
3097 /* Return 1 iff it is necessary to swap operands of commutative operation
3098 in order to canonicalize expression. */
3101 swap_commutative_operands_p (rtx x
, rtx y
)
3103 return (commutative_operand_precedence (x
)
3104 < commutative_operand_precedence (y
));
3107 /* Return 1 if X is an autoincrement side effect and the register is
3108 not the stack pointer. */
3112 switch (GET_CODE (x
))
3120 /* There are no REG_INC notes for SP. */
3121 if (XEXP (x
, 0) != stack_pointer_rtx
)
3129 /* Return 1 if the sequence of instructions beginning with FROM and up
3130 to and including TO is safe to move. If NEW_TO is non-NULL, and
3131 the sequence is not already safe to move, but can be easily
3132 extended to a sequence which is safe, then NEW_TO will point to the
3133 end of the extended sequence.
3135 For now, this function only checks that the region contains whole
3136 exception regions, but it could be extended to check additional
3137 conditions as well. */
3140 insns_safe_to_move_p (rtx from
, rtx to
, rtx
*new_to
)
3142 int eh_region_count
= 0;
3146 /* By default, assume the end of the region will be what was
3153 if (GET_CODE (r
) == NOTE
)
3155 switch (NOTE_LINE_NUMBER (r
))
3157 case NOTE_INSN_EH_REGION_BEG
:
3161 case NOTE_INSN_EH_REGION_END
:
3162 if (eh_region_count
== 0)
3163 /* This sequence of instructions contains the end of
3164 an exception region, but not he beginning. Moving
3165 it will cause chaos. */
3176 /* If we've passed TO, and we see a non-note instruction, we
3177 can't extend the sequence to a movable sequence. */
3183 /* It's OK to move the sequence if there were matched sets of
3184 exception region notes. */
3185 return eh_region_count
== 0;
3190 /* It's OK to move the sequence if there were matched sets of
3191 exception region notes. */
3192 if (past_to_p
&& eh_region_count
== 0)
3198 /* Go to the next instruction. */
3205 /* Return nonzero if IN contains a piece of rtl that has the address LOC. */
3207 loc_mentioned_in_p (rtx
*loc
, rtx in
)
3209 enum rtx_code code
= GET_CODE (in
);
3210 const char *fmt
= GET_RTX_FORMAT (code
);
3213 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
3215 if (loc
== &in
->u
.fld
[i
].rtx
)
3219 if (loc_mentioned_in_p (loc
, XEXP (in
, i
)))
3222 else if (fmt
[i
] == 'E')
3223 for (j
= XVECLEN (in
, i
) - 1; j
>= 0; j
--)
3224 if (loc_mentioned_in_p (loc
, XVECEXP (in
, i
, j
)))
3230 /* Helper function for subreg_lsb. Given a subreg's OUTER_MODE, INNER_MODE,
3231 and SUBREG_BYTE, return the bit offset where the subreg begins
3232 (counting from the least significant bit of the operand). */
3235 subreg_lsb_1 (enum machine_mode outer_mode
,
3236 enum machine_mode inner_mode
,
3237 unsigned int subreg_byte
)
3239 unsigned int bitpos
;
3243 /* A paradoxical subreg begins at bit position 0. */
3244 if (GET_MODE_BITSIZE (outer_mode
) > GET_MODE_BITSIZE (inner_mode
))
3247 if (WORDS_BIG_ENDIAN
!= BYTES_BIG_ENDIAN
)
3248 /* If the subreg crosses a word boundary ensure that
3249 it also begins and ends on a word boundary. */
3250 if ((subreg_byte
% UNITS_PER_WORD
3251 + GET_MODE_SIZE (outer_mode
)) > UNITS_PER_WORD
3252 && (subreg_byte
% UNITS_PER_WORD
3253 || GET_MODE_SIZE (outer_mode
) % UNITS_PER_WORD
))
3256 if (WORDS_BIG_ENDIAN
)
3257 word
= (GET_MODE_SIZE (inner_mode
)
3258 - (subreg_byte
+ GET_MODE_SIZE (outer_mode
))) / UNITS_PER_WORD
;
3260 word
= subreg_byte
/ UNITS_PER_WORD
;
3261 bitpos
= word
* BITS_PER_WORD
;
3263 if (BYTES_BIG_ENDIAN
)
3264 byte
= (GET_MODE_SIZE (inner_mode
)
3265 - (subreg_byte
+ GET_MODE_SIZE (outer_mode
))) % UNITS_PER_WORD
;
3267 byte
= subreg_byte
% UNITS_PER_WORD
;
3268 bitpos
+= byte
* BITS_PER_UNIT
;
3273 /* Given a subreg X, return the bit offset where the subreg begins
3274 (counting from the least significant bit of the reg). */
3279 return subreg_lsb_1 (GET_MODE (x
), GET_MODE (SUBREG_REG (x
)),
3283 /* This function returns the regno offset of a subreg expression.
3284 xregno - A regno of an inner hard subreg_reg (or what will become one).
3285 xmode - The mode of xregno.
3286 offset - The byte offset.
3287 ymode - The mode of a top level SUBREG (or what may become one).
3288 RETURN - The regno offset which would be used. */
3290 subreg_regno_offset (unsigned int xregno
, enum machine_mode xmode
,
3291 unsigned int offset
, enum machine_mode ymode
)
3293 int nregs_xmode
, nregs_ymode
;
3294 int mode_multiple
, nregs_multiple
;
3297 if (xregno
>= FIRST_PSEUDO_REGISTER
)
3300 nregs_xmode
= hard_regno_nregs
[xregno
][xmode
];
3301 nregs_ymode
= hard_regno_nregs
[xregno
][ymode
];
3303 /* If this is a big endian paradoxical subreg, which uses more actual
3304 hard registers than the original register, we must return a negative
3305 offset so that we find the proper highpart of the register. */
3307 && nregs_ymode
> nregs_xmode
3308 && (GET_MODE_SIZE (ymode
) > UNITS_PER_WORD
3309 ? WORDS_BIG_ENDIAN
: BYTES_BIG_ENDIAN
))
3310 return nregs_xmode
- nregs_ymode
;
3312 if (offset
== 0 || nregs_xmode
== nregs_ymode
)
3315 /* size of ymode must not be greater than the size of xmode. */
3316 mode_multiple
= GET_MODE_SIZE (xmode
) / GET_MODE_SIZE (ymode
);
3317 if (mode_multiple
== 0)
3320 y_offset
= offset
/ GET_MODE_SIZE (ymode
);
3321 nregs_multiple
= nregs_xmode
/ nregs_ymode
;
3322 return (y_offset
/ (mode_multiple
/ nregs_multiple
)) * nregs_ymode
;
3325 /* This function returns true when the offset is representable via
3326 subreg_offset in the given regno.
3327 xregno - A regno of an inner hard subreg_reg (or what will become one).
3328 xmode - The mode of xregno.
3329 offset - The byte offset.
3330 ymode - The mode of a top level SUBREG (or what may become one).
3331 RETURN - The regno offset which would be used. */
3333 subreg_offset_representable_p (unsigned int xregno
, enum machine_mode xmode
,
3334 unsigned int offset
, enum machine_mode ymode
)
3336 int nregs_xmode
, nregs_ymode
;
3337 int mode_multiple
, nregs_multiple
;
3340 if (xregno
>= FIRST_PSEUDO_REGISTER
)
3343 nregs_xmode
= hard_regno_nregs
[xregno
][xmode
];
3344 nregs_ymode
= hard_regno_nregs
[xregno
][ymode
];
3346 /* Paradoxical subregs are always valid. */
3348 && nregs_ymode
> nregs_xmode
3349 && (GET_MODE_SIZE (ymode
) > UNITS_PER_WORD
3350 ? WORDS_BIG_ENDIAN
: BYTES_BIG_ENDIAN
))
3353 /* Lowpart subregs are always valid. */
3354 if (offset
== subreg_lowpart_offset (ymode
, xmode
))
3357 #ifdef ENABLE_CHECKING
3358 /* This should always pass, otherwise we don't know how to verify the
3359 constraint. These conditions may be relaxed but subreg_offset would
3360 need to be redesigned. */
3361 if (GET_MODE_SIZE (xmode
) % GET_MODE_SIZE (ymode
)
3362 || GET_MODE_SIZE (ymode
) % nregs_ymode
3363 || nregs_xmode
% nregs_ymode
)
3367 /* The XMODE value can be seen as a vector of NREGS_XMODE
3368 values. The subreg must represent a lowpart of given field.
3369 Compute what field it is. */
3370 offset
-= subreg_lowpart_offset (ymode
,
3371 mode_for_size (GET_MODE_BITSIZE (xmode
)
3375 /* size of ymode must not be greater than the size of xmode. */
3376 mode_multiple
= GET_MODE_SIZE (xmode
) / GET_MODE_SIZE (ymode
);
3377 if (mode_multiple
== 0)
3380 y_offset
= offset
/ GET_MODE_SIZE (ymode
);
3381 nregs_multiple
= nregs_xmode
/ nregs_ymode
;
3382 #ifdef ENABLE_CHECKING
3383 if (offset
% GET_MODE_SIZE (ymode
)
3384 || mode_multiple
% nregs_multiple
)
3387 return (!(y_offset
% (mode_multiple
/ nregs_multiple
)));
3390 /* Return the final regno that a subreg expression refers to. */
3392 subreg_regno (rtx x
)
3395 rtx subreg
= SUBREG_REG (x
);
3396 int regno
= REGNO (subreg
);
3398 ret
= regno
+ subreg_regno_offset (regno
,
3405 struct parms_set_data
3411 /* Helper function for noticing stores to parameter registers. */
3413 parms_set (rtx x
, rtx pat ATTRIBUTE_UNUSED
, void *data
)
3415 struct parms_set_data
*d
= data
;
3416 if (REG_P (x
) && REGNO (x
) < FIRST_PSEUDO_REGISTER
3417 && TEST_HARD_REG_BIT (d
->regs
, REGNO (x
)))
3419 CLEAR_HARD_REG_BIT (d
->regs
, REGNO (x
));
3424 /* Look backward for first parameter to be loaded.
3425 Do not skip BOUNDARY. */
3427 find_first_parameter_load (rtx call_insn
, rtx boundary
)
3429 struct parms_set_data parm
;
3432 /* Since different machines initialize their parameter registers
3433 in different orders, assume nothing. Collect the set of all
3434 parameter registers. */
3435 CLEAR_HARD_REG_SET (parm
.regs
);
3437 for (p
= CALL_INSN_FUNCTION_USAGE (call_insn
); p
; p
= XEXP (p
, 1))
3438 if (GET_CODE (XEXP (p
, 0)) == USE
3439 && GET_CODE (XEXP (XEXP (p
, 0), 0)) == REG
)
3441 if (REGNO (XEXP (XEXP (p
, 0), 0)) >= FIRST_PSEUDO_REGISTER
)
3444 /* We only care about registers which can hold function
3446 if (!FUNCTION_ARG_REGNO_P (REGNO (XEXP (XEXP (p
, 0), 0))))
3449 SET_HARD_REG_BIT (parm
.regs
, REGNO (XEXP (XEXP (p
, 0), 0)));
3454 /* Search backward for the first set of a register in this set. */
3455 while (parm
.nregs
&& before
!= boundary
)
3457 before
= PREV_INSN (before
);
3459 /* It is possible that some loads got CSEed from one call to
3460 another. Stop in that case. */
3461 if (GET_CODE (before
) == CALL_INSN
)
3464 /* Our caller needs either ensure that we will find all sets
3465 (in case code has not been optimized yet), or take care
3466 for possible labels in a way by setting boundary to preceding
3468 if (GET_CODE (before
) == CODE_LABEL
)
3470 if (before
!= boundary
)
3475 if (INSN_P (before
))
3476 note_stores (PATTERN (before
), parms_set
, &parm
);
3481 /* Return true if we should avoid inserting code between INSN and preceding
3482 call instruction. */
3485 keep_with_call_p (rtx insn
)
3489 if (INSN_P (insn
) && (set
= single_set (insn
)) != NULL
)
3491 if (GET_CODE (SET_DEST (set
)) == REG
3492 && REGNO (SET_DEST (set
)) < FIRST_PSEUDO_REGISTER
3493 && fixed_regs
[REGNO (SET_DEST (set
))]
3494 && general_operand (SET_SRC (set
), VOIDmode
))
3496 if (GET_CODE (SET_SRC (set
)) == REG
3497 && FUNCTION_VALUE_REGNO_P (REGNO (SET_SRC (set
)))
3498 && GET_CODE (SET_DEST (set
)) == REG
3499 && REGNO (SET_DEST (set
)) >= FIRST_PSEUDO_REGISTER
)
3501 /* There may be a stack pop just after the call and before the store
3502 of the return register. Search for the actual store when deciding
3503 if we can break or not. */
3504 if (SET_DEST (set
) == stack_pointer_rtx
)
3506 rtx i2
= next_nonnote_insn (insn
);
3507 if (i2
&& keep_with_call_p (i2
))
3514 /* Return true when store to register X can be hoisted to the place
3515 with LIVE registers (can be NULL). Value VAL contains destination
3516 whose value will be used. */
3519 hoist_test_store (rtx x
, rtx val
, regset live
)
3521 if (GET_CODE (x
) == SCRATCH
)
3524 if (rtx_equal_p (x
, val
))
3527 /* Allow subreg of X in case it is not writing just part of multireg pseudo.
3528 Then we would need to update all users to care hoisting the store too.
3529 Caller may represent that by specifying whole subreg as val. */
3531 if (GET_CODE (x
) == SUBREG
&& rtx_equal_p (SUBREG_REG (x
), val
))
3533 if (GET_MODE_SIZE (GET_MODE (SUBREG_REG (x
))) > UNITS_PER_WORD
3534 && GET_MODE_BITSIZE (GET_MODE (x
)) <
3535 GET_MODE_BITSIZE (GET_MODE (SUBREG_REG (x
))))
3539 if (GET_CODE (x
) == SUBREG
)
3542 /* Anything except register store is not hoistable. This includes the
3543 partial stores to registers. */
3548 /* Pseudo registers can be always replaced by another pseudo to avoid
3549 the side effect, for hard register we must ensure that they are dead.
3550 Eventually we may want to add code to try turn pseudos to hards, but it
3551 is unlikely useful. */
3553 if (REGNO (x
) < FIRST_PSEUDO_REGISTER
)
3555 int regno
= REGNO (x
);
3556 int n
= hard_regno_nregs
[regno
][GET_MODE (x
)];
3560 if (REGNO_REG_SET_P (live
, regno
))
3563 if (REGNO_REG_SET_P (live
, regno
+ n
))
3570 /* Return true if INSN can be hoisted to place with LIVE hard registers
3571 (LIVE can be NULL when unknown). VAL is expected to be stored by the insn
3572 and used by the hoisting pass. */
3575 can_hoist_insn_p (rtx insn
, rtx val
, regset live
)
3577 rtx pat
= PATTERN (insn
);
3580 /* It probably does not worth the complexity to handle multiple
3582 if (!single_set (insn
))
3584 /* We can move CALL_INSN, but we need to check that all caller clobbered
3586 if (GET_CODE (insn
) == CALL_INSN
)
3588 /* In future we will handle hoisting of libcall sequences, but
3590 if (find_reg_note (insn
, REG_RETVAL
, NULL_RTX
))
3592 switch (GET_CODE (pat
))
3595 if (!hoist_test_store (SET_DEST (pat
), val
, live
))
3599 /* USES do have sick semantics, so do not move them. */
3603 if (!hoist_test_store (XEXP (pat
, 0), val
, live
))
3607 for (i
= 0; i
< XVECLEN (pat
, 0); i
++)
3609 rtx x
= XVECEXP (pat
, 0, i
);
3610 switch (GET_CODE (x
))
3613 if (!hoist_test_store (SET_DEST (x
), val
, live
))
3617 /* We need to fix callers to really ensure availability
3618 of all values insn uses, but for now it is safe to prohibit
3619 hoisting of any insn having such a hidden uses. */
3623 if (!hoist_test_store (SET_DEST (x
), val
, live
))
3637 /* Update store after hoisting - replace all stores to pseudo registers
3638 by new ones to avoid clobbering of values except for store to VAL that will
3639 be updated to NEW. */
3642 hoist_update_store (rtx insn
, rtx
*xp
, rtx val
, rtx
new)
3646 if (GET_CODE (x
) == SCRATCH
)
3649 if (GET_CODE (x
) == SUBREG
&& SUBREG_REG (x
) == val
)
3650 validate_change (insn
, xp
,
3651 simplify_gen_subreg (GET_MODE (x
), new, GET_MODE (new),
3652 SUBREG_BYTE (x
)), 1);
3653 if (rtx_equal_p (x
, val
))
3655 validate_change (insn
, xp
, new, 1);
3658 if (GET_CODE (x
) == SUBREG
)
3660 xp
= &SUBREG_REG (x
);
3667 /* We've verified that hard registers are dead, so we may keep the side
3668 effect. Otherwise replace it by new pseudo. */
3669 if (REGNO (x
) >= FIRST_PSEUDO_REGISTER
)
3670 validate_change (insn
, xp
, gen_reg_rtx (GET_MODE (x
)), 1);
3672 = alloc_EXPR_LIST (REG_UNUSED
, *xp
, REG_NOTES (insn
));
3675 /* Create a copy of INSN after AFTER replacing store of VAL to NEW
3676 and each other side effect to pseudo register by new pseudo register. */
3679 hoist_insn_after (rtx insn
, rtx after
, rtx val
, rtx
new)
3685 insn
= emit_copy_of_insn_after (insn
, after
);
3686 pat
= PATTERN (insn
);
3688 /* Remove REG_UNUSED notes as we will re-emit them. */
3689 while ((note
= find_reg_note (insn
, REG_UNUSED
, NULL_RTX
)))
3690 remove_note (insn
, note
);
3692 /* To get this working callers must ensure to move everything referenced
3693 by REG_EQUAL/REG_EQUIV notes too. Lets remove them, it is probably
3695 while ((note
= find_reg_note (insn
, REG_EQUAL
, NULL_RTX
)))
3696 remove_note (insn
, note
);
3697 while ((note
= find_reg_note (insn
, REG_EQUIV
, NULL_RTX
)))
3698 remove_note (insn
, note
);
3700 /* Remove REG_DEAD notes as they might not be valid anymore in case
3701 we create redundancy. */
3702 while ((note
= find_reg_note (insn
, REG_DEAD
, NULL_RTX
)))
3703 remove_note (insn
, note
);
3704 switch (GET_CODE (pat
))
3707 hoist_update_store (insn
, &SET_DEST (pat
), val
, new);
3712 hoist_update_store (insn
, &XEXP (pat
, 0), val
, new);
3715 for (i
= 0; i
< XVECLEN (pat
, 0); i
++)
3717 rtx x
= XVECEXP (pat
, 0, i
);
3718 switch (GET_CODE (x
))
3721 hoist_update_store (insn
, &SET_DEST (x
), val
, new);
3726 hoist_update_store (insn
, &SET_DEST (x
), val
, new);
3736 if (!apply_change_group ())
3743 hoist_insn_to_edge (rtx insn
, edge e
, rtx val
, rtx
new)
3747 /* We cannot insert instructions on an abnormal critical edge.
3748 It will be easier to find the culprit if we die now. */
3749 if ((e
->flags
& EDGE_ABNORMAL
) && EDGE_CRITICAL_P (e
))
3752 /* Do not use emit_insn_on_edge as we want to preserve notes and similar
3753 stuff. We also emit CALL_INSNS and friends. */
3754 if (e
->insns
== NULL_RTX
)
3757 emit_note (NOTE_INSN_DELETED
);
3760 push_to_sequence (e
->insns
);
3762 new_insn
= hoist_insn_after (insn
, get_last_insn (), val
, new);
3764 e
->insns
= get_insns ();
3769 /* Return true if LABEL is a target of JUMP_INSN. This applies only
3770 to non-complex jumps. That is, direct unconditional, conditional,
3771 and tablejumps, but not computed jumps or returns. It also does
3772 not apply to the fallthru case of a conditional jump. */
3775 label_is_jump_target_p (rtx label
, rtx jump_insn
)
3777 rtx tmp
= JUMP_LABEL (jump_insn
);
3782 if (tablejump_p (jump_insn
, NULL
, &tmp
))
3784 rtvec vec
= XVEC (PATTERN (tmp
),
3785 GET_CODE (PATTERN (tmp
)) == ADDR_DIFF_VEC
);
3786 int i
, veclen
= GET_NUM_ELEM (vec
);
3788 for (i
= 0; i
< veclen
; ++i
)
3789 if (XEXP (RTVEC_ELT (vec
, i
), 0) == label
)
3797 /* Return an estimate of the cost of computing rtx X.
3798 One use is in cse, to decide which expression to keep in the hash table.
3799 Another is in rtl generation, to pick the cheapest way to multiply.
3800 Other uses like the latter are expected in the future. */
3803 rtx_cost (rtx x
, enum rtx_code outer_code ATTRIBUTE_UNUSED
)
3813 /* Compute the default costs of certain things.
3814 Note that targetm.rtx_costs can override the defaults. */
3816 code
= GET_CODE (x
);
3820 total
= COSTS_N_INSNS (5);
3826 total
= COSTS_N_INSNS (7);
3829 /* Used in loop.c and combine.c as a marker. */
3833 total
= COSTS_N_INSNS (1);
3842 /* If we can't tie these modes, make this expensive. The larger
3843 the mode, the more expensive it is. */
3844 if (! MODES_TIEABLE_P (GET_MODE (x
), GET_MODE (SUBREG_REG (x
))))
3845 return COSTS_N_INSNS (2
3846 + GET_MODE_SIZE (GET_MODE (x
)) / UNITS_PER_WORD
);
3850 if (targetm
.rtx_costs (x
, code
, outer_code
, &total
))
3855 /* Sum the costs of the sub-rtx's, plus cost of this operation,
3856 which is already in total. */
3858 fmt
= GET_RTX_FORMAT (code
);
3859 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
3861 total
+= rtx_cost (XEXP (x
, i
), code
);
3862 else if (fmt
[i
] == 'E')
3863 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
3864 total
+= rtx_cost (XVECEXP (x
, i
, j
), code
);
3869 /* Return cost of address expression X.
3870 Expect that X is properly formed address reference. */
3873 address_cost (rtx x
, enum machine_mode mode
)
3875 /* The address_cost target hook does not deal with ADDRESSOF nodes. But,
3876 during CSE, such nodes are present. Using an ADDRESSOF node which
3877 refers to the address of a REG is a good thing because we can then
3878 turn (MEM (ADDRESSOF (REG))) into just plain REG. */
3880 if (GET_CODE (x
) == ADDRESSOF
&& REG_P (XEXP ((x
), 0)))
3883 /* We may be asked for cost of various unusual addresses, such as operands
3884 of push instruction. It is not worthwhile to complicate writing
3885 of the target hook by such cases. */
3887 if (!memory_address_p (mode
, x
))
3890 return targetm
.address_cost (x
);
3893 /* If the target doesn't override, compute the cost as with arithmetic. */
3896 default_address_cost (rtx x
)
3898 return rtx_cost (x
, MEM
);