1 /* Analyze RTL for C-Compiler
2 Copyright (C) 1987, 88, 92-97, 1998 Free Software Foundation, Inc.
4 This file is part of GNU CC.
6 GNU CC is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GNU CC is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU CC; see the file COPYING. If not, write to
18 the Free Software Foundation, 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
26 static int rtx_addr_can_trap_p
PROTO((rtx
));
27 static void reg_set_p_1
PROTO((rtx
, rtx
));
28 static void reg_set_last_1
PROTO((rtx
, rtx
));
31 /* Forward declarations */
32 static int jmp_uses_reg_or_mem
PROTO((rtx
));
34 /* Bit flags that specify the machine subtype we are compiling for.
35 Bits are tested using macros TARGET_... defined in the tm.h file
36 and set by `-m...' switches. Must be defined in rtlanal.c. */
40 /* Return 1 if the value of X is unstable
41 (would be different at a different point in the program).
42 The frame pointer, arg pointer, etc. are considered stable
43 (within one function) and so is anything marked `unchanging'. */
49 register RTX_CODE code
= GET_CODE (x
);
54 return ! RTX_UNCHANGING_P (x
);
59 if (code
== CONST
|| code
== CONST_INT
)
63 return ! (REGNO (x
) == FRAME_POINTER_REGNUM
64 || REGNO (x
) == HARD_FRAME_POINTER_REGNUM
65 || REGNO (x
) == ARG_POINTER_REGNUM
66 || RTX_UNCHANGING_P (x
));
68 fmt
= GET_RTX_FORMAT (code
);
69 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
71 if (rtx_unstable_p (XEXP (x
, i
)))
76 /* Return 1 if X has a value that can vary even between two
77 executions of the program. 0 means X can be compared reliably
78 against certain constants or near-constants.
79 The frame pointer and the arg pointer are considered constant. */
85 register RTX_CODE code
= GET_CODE (x
);
103 /* Note that we have to test for the actual rtx used for the frame
104 and arg pointers and not just the register number in case we have
105 eliminated the frame and/or arg pointer and are using it
107 return ! (x
== frame_pointer_rtx
|| x
== hard_frame_pointer_rtx
108 || x
== arg_pointer_rtx
|| x
== pic_offset_table_rtx
);
111 /* The operand 0 of a LO_SUM is considered constant
112 (in fact is it related specifically to operand 1). */
113 return rtx_varies_p (XEXP (x
, 1));
119 fmt
= GET_RTX_FORMAT (code
);
120 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
122 if (rtx_varies_p (XEXP (x
, i
)))
127 /* Return 0 if the use of X as an address in a MEM can cause a trap. */
130 rtx_addr_can_trap_p (x
)
133 register enum rtx_code code
= GET_CODE (x
);
139 /* SYMBOL_REF is problematic due to the possible presence of
140 a #pragma weak, but to say that loads from symbols can trap is
141 *very* costly. It's not at all clear what's best here. For
142 now, we ignore the impact of #pragma weak. */
146 /* As in rtx_varies_p, we have to use the actual rtx, not reg number. */
147 return ! (x
== frame_pointer_rtx
|| x
== hard_frame_pointer_rtx
148 || x
== stack_pointer_rtx
|| x
== arg_pointer_rtx
);
151 return rtx_addr_can_trap_p (XEXP (x
, 0));
154 /* An address is assumed not to trap if it is an address that can't
155 trap plus a constant integer. */
156 return (rtx_addr_can_trap_p (XEXP (x
, 0))
157 || GET_CODE (XEXP (x
, 1)) != CONST_INT
);
160 return rtx_addr_can_trap_p (XEXP (x
, 1));
166 /* If it isn't one of the case above, it can cause a trap. */
170 /* Return 1 if X refers to a memory location whose address
171 cannot be compared reliably with constant addresses,
172 or if X refers to a BLKmode memory object. */
175 rtx_addr_varies_p (x
)
178 register enum rtx_code code
;
187 return GET_MODE (x
) == BLKmode
|| rtx_varies_p (XEXP (x
, 0));
189 fmt
= GET_RTX_FORMAT (code
);
190 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
193 if (rtx_addr_varies_p (XEXP (x
, i
)))
196 else if (fmt
[i
] == 'E')
199 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
200 if (rtx_addr_varies_p (XVECEXP (x
, i
, j
)))
206 /* Return the value of the integer term in X, if one is apparent;
208 Only obvious integer terms are detected.
209 This is used in cse.c with the `related_value' field.*/
215 if (GET_CODE (x
) == CONST
)
218 if (GET_CODE (x
) == MINUS
219 && GET_CODE (XEXP (x
, 1)) == CONST_INT
)
220 return - INTVAL (XEXP (x
, 1));
221 if (GET_CODE (x
) == PLUS
222 && GET_CODE (XEXP (x
, 1)) == CONST_INT
)
223 return INTVAL (XEXP (x
, 1));
227 /* If X is a constant, return the value sans apparent integer term;
229 Only obvious integer terms are detected. */
232 get_related_value (x
)
235 if (GET_CODE (x
) != CONST
)
238 if (GET_CODE (x
) == PLUS
239 && GET_CODE (XEXP (x
, 1)) == CONST_INT
)
241 else if (GET_CODE (x
) == MINUS
242 && GET_CODE (XEXP (x
, 1)) == CONST_INT
)
247 /* Nonzero if register REG appears somewhere within IN.
248 Also works if REG is not a register; in this case it checks
249 for a subexpression of IN that is Lisp "equal" to REG. */
252 reg_mentioned_p (reg
, in
)
253 register rtx reg
, in
;
257 register enum rtx_code code
;
265 if (GET_CODE (in
) == LABEL_REF
)
266 return reg
== XEXP (in
, 0);
268 code
= GET_CODE (in
);
272 /* Compare registers by number. */
274 return GET_CODE (reg
) == REG
&& REGNO (in
) == REGNO (reg
);
276 /* These codes have no constituent expressions
284 return GET_CODE (reg
) == CONST_INT
&& INTVAL (in
) == INTVAL (reg
);
287 /* These are kept unique for a given value. */
294 if (GET_CODE (reg
) == code
&& rtx_equal_p (reg
, in
))
297 fmt
= GET_RTX_FORMAT (code
);
299 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
304 for (j
= XVECLEN (in
, i
) - 1; j
>= 0; j
--)
305 if (reg_mentioned_p (reg
, XVECEXP (in
, i
, j
)))
308 else if (fmt
[i
] == 'e'
309 && reg_mentioned_p (reg
, XEXP (in
, i
)))
315 /* Return 1 if in between BEG and END, exclusive of BEG and END, there is
316 no CODE_LABEL insn. */
319 no_labels_between_p (beg
, end
)
323 for (p
= NEXT_INSN (beg
); p
!= end
; p
= NEXT_INSN (p
))
324 if (GET_CODE (p
) == CODE_LABEL
)
329 /* Nonzero if register REG is used in an insn between
330 FROM_INSN and TO_INSN (exclusive of those two). */
333 reg_used_between_p (reg
, from_insn
, to_insn
)
334 rtx reg
, from_insn
, to_insn
;
338 if (from_insn
== to_insn
)
341 for (insn
= NEXT_INSN (from_insn
); insn
!= to_insn
; insn
= NEXT_INSN (insn
))
342 if (GET_RTX_CLASS (GET_CODE (insn
)) == 'i'
343 && (reg_overlap_mentioned_p (reg
, PATTERN (insn
))
344 || (GET_CODE (insn
) == CALL_INSN
345 && (find_reg_fusage (insn
, USE
, reg
)
346 || find_reg_fusage (insn
, CLOBBER
, reg
)))))
351 /* Nonzero if the old value of X, a register, is referenced in BODY. If X
352 is entirely replaced by a new value and the only use is as a SET_DEST,
353 we do not consider it a reference. */
356 reg_referenced_p (x
, body
)
362 switch (GET_CODE (body
))
365 if (reg_overlap_mentioned_p (x
, SET_SRC (body
)))
368 /* If the destination is anything other than CC0, PC, a REG or a SUBREG
369 of a REG that occupies all of the REG, the insn references X if
370 it is mentioned in the destination. */
371 if (GET_CODE (SET_DEST (body
)) != CC0
372 && GET_CODE (SET_DEST (body
)) != PC
373 && GET_CODE (SET_DEST (body
)) != REG
374 && ! (GET_CODE (SET_DEST (body
)) == SUBREG
375 && GET_CODE (SUBREG_REG (SET_DEST (body
))) == REG
376 && (((GET_MODE_SIZE (GET_MODE (SUBREG_REG (SET_DEST (body
))))
377 + (UNITS_PER_WORD
- 1)) / UNITS_PER_WORD
)
378 == ((GET_MODE_SIZE (GET_MODE (SET_DEST (body
)))
379 + (UNITS_PER_WORD
- 1)) / UNITS_PER_WORD
)))
380 && reg_overlap_mentioned_p (x
, SET_DEST (body
)))
385 for (i
= ASM_OPERANDS_INPUT_LENGTH (body
) - 1; i
>= 0; i
--)
386 if (reg_overlap_mentioned_p (x
, ASM_OPERANDS_INPUT (body
, i
)))
392 return reg_overlap_mentioned_p (x
, body
);
395 return reg_overlap_mentioned_p (x
, TRAP_CONDITION (body
));
398 case UNSPEC_VOLATILE
:
400 for (i
= XVECLEN (body
, 0) - 1; i
>= 0; i
--)
401 if (reg_referenced_p (x
, XVECEXP (body
, 0, i
)))
410 /* Nonzero if register REG is referenced in an insn between
411 FROM_INSN and TO_INSN (exclusive of those two). Sets of REG do
415 reg_referenced_between_p (reg
, from_insn
, to_insn
)
416 rtx reg
, from_insn
, to_insn
;
420 if (from_insn
== to_insn
)
423 for (insn
= NEXT_INSN (from_insn
); insn
!= to_insn
; insn
= NEXT_INSN (insn
))
424 if (GET_RTX_CLASS (GET_CODE (insn
)) == 'i'
425 && (reg_referenced_p (reg
, PATTERN (insn
))
426 || (GET_CODE (insn
) == CALL_INSN
427 && find_reg_fusage (insn
, USE
, reg
))))
432 /* Nonzero if register REG is set or clobbered in an insn between
433 FROM_INSN and TO_INSN (exclusive of those two). */
436 reg_set_between_p (reg
, from_insn
, to_insn
)
437 rtx reg
, from_insn
, to_insn
;
441 if (from_insn
== to_insn
)
444 for (insn
= NEXT_INSN (from_insn
); insn
!= to_insn
; insn
= NEXT_INSN (insn
))
445 if (GET_RTX_CLASS (GET_CODE (insn
)) == 'i'
446 && reg_set_p (reg
, insn
))
451 /* Internals of reg_set_between_p. */
453 static rtx reg_set_reg
;
454 static int reg_set_flag
;
459 rtx pat ATTRIBUTE_UNUSED
;
461 /* We don't want to return 1 if X is a MEM that contains a register
462 within REG_SET_REG. */
464 if ((GET_CODE (x
) != MEM
)
465 && reg_overlap_mentioned_p (reg_set_reg
, x
))
470 reg_set_p (reg
, insn
)
475 /* We can be passed an insn or part of one. If we are passed an insn,
476 check if a side-effect of the insn clobbers REG. */
477 if (GET_RTX_CLASS (GET_CODE (insn
)) == 'i')
479 if (FIND_REG_INC_NOTE (insn
, reg
)
480 || (GET_CODE (insn
) == CALL_INSN
481 /* We'd like to test call_used_regs here, but rtlanal.c can't
482 reference that variable due to its use in genattrtab. So
483 we'll just be more conservative.
485 ??? Unless we could ensure that the CALL_INSN_FUNCTION_USAGE
486 information holds all clobbered registers. */
487 && ((GET_CODE (reg
) == REG
488 && REGNO (reg
) < FIRST_PSEUDO_REGISTER
)
489 || GET_CODE (reg
) == MEM
490 || find_reg_fusage (insn
, CLOBBER
, reg
))))
493 body
= PATTERN (insn
);
498 note_stores (body
, reg_set_p_1
);
502 /* Similar to reg_set_between_p, but check all registers in X. Return 0
503 only if none of them are modified between START and END. Return 1 if
504 X contains a MEM; this routine does not perform any memory aliasing. */
507 modified_between_p (x
, start
, end
)
511 enum rtx_code code
= GET_CODE (x
);
529 /* If the memory is not constant, assume it is modified. If it is
530 constant, we still have to check the address. */
531 if (! RTX_UNCHANGING_P (x
))
536 return reg_set_between_p (x
, start
, end
);
542 fmt
= GET_RTX_FORMAT (code
);
543 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
545 if (fmt
[i
] == 'e' && modified_between_p (XEXP (x
, i
), start
, end
))
549 for (j
= XVECLEN (x
, i
) - 1; j
>= 0; j
--)
550 if (modified_between_p (XVECEXP (x
, i
, j
), start
, end
))
557 /* Similar to reg_set_p, but check all registers in X. Return 0 only if none
558 of them are modified in INSN. Return 1 if X contains a MEM; this routine
559 does not perform any memory aliasing. */
562 modified_in_p (x
, insn
)
566 enum rtx_code code
= GET_CODE (x
);
584 /* If the memory is not constant, assume it is modified. If it is
585 constant, we still have to check the address. */
586 if (! RTX_UNCHANGING_P (x
))
591 return reg_set_p (x
, insn
);
597 fmt
= GET_RTX_FORMAT (code
);
598 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
600 if (fmt
[i
] == 'e' && modified_in_p (XEXP (x
, i
), insn
))
604 for (j
= XVECLEN (x
, i
) - 1; j
>= 0; j
--)
605 if (modified_in_p (XVECEXP (x
, i
, j
), insn
))
612 /* Given an INSN, return a SET expression if this insn has only a single SET.
613 It may also have CLOBBERs, USEs, or SET whose output
614 will not be used, which we ignore. */
623 if (GET_RTX_CLASS (GET_CODE (insn
)) != 'i')
626 if (GET_CODE (PATTERN (insn
)) == SET
)
627 return PATTERN (insn
);
629 else if (GET_CODE (PATTERN (insn
)) == PARALLEL
)
631 for (i
= 0, set
= 0; i
< XVECLEN (PATTERN (insn
), 0); i
++)
632 if (GET_CODE (XVECEXP (PATTERN (insn
), 0, i
)) == SET
633 && (! find_reg_note (insn
, REG_UNUSED
,
634 SET_DEST (XVECEXP (PATTERN (insn
), 0, i
)))
635 || side_effects_p (XVECEXP (PATTERN (insn
), 0, i
))))
640 set
= XVECEXP (PATTERN (insn
), 0, i
);
648 /* Return the last thing that X was assigned from before *PINSN. Verify that
649 the object is not modified up to VALID_TO. If it was, if we hit
650 a partial assignment to X, or hit a CODE_LABEL first, return X. If we
651 found an assignment, update *PINSN to point to it. */
654 find_last_value (x
, pinsn
, valid_to
)
661 for (p
= PREV_INSN (*pinsn
); p
&& GET_CODE (p
) != CODE_LABEL
;
663 if (GET_RTX_CLASS (GET_CODE (p
)) == 'i')
665 rtx set
= single_set (p
);
666 rtx note
= find_reg_note (p
, REG_EQUAL
, NULL_RTX
);
668 if (set
&& rtx_equal_p (x
, SET_DEST (set
)))
670 rtx src
= SET_SRC (set
);
672 if (note
&& GET_CODE (XEXP (note
, 0)) != EXPR_LIST
)
673 src
= XEXP (note
, 0);
675 if (! modified_between_p (src
, PREV_INSN (p
), valid_to
)
676 /* Reject hard registers because we don't usually want
677 to use them; we'd rather use a pseudo. */
678 && ! (GET_CODE (src
) == REG
679 && REGNO (src
) < FIRST_PSEUDO_REGISTER
))
686 /* If set in non-simple way, we don't have a value. */
687 if (reg_set_p (x
, p
))
694 /* Return nonzero if register in range [REGNO, ENDREGNO)
695 appears either explicitly or implicitly in X
696 other than being stored into.
698 References contained within the substructure at LOC do not count.
699 LOC may be zero, meaning don't ignore anything. */
702 refers_to_regno_p (regno
, endregno
, x
, loc
)
708 register RTX_CODE code
;
712 /* The contents of a REG_NONNEG note is always zero, so we must come here
713 upon repeat in case the last REG_NOTE is a REG_NONNEG note. */
724 /* If we modifying the stack, frame, or argument pointer, it will
725 clobber a virtual register. In fact, we could be more precise,
726 but it isn't worth it. */
727 if ((i
== STACK_POINTER_REGNUM
728 #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
729 || i
== ARG_POINTER_REGNUM
731 || i
== FRAME_POINTER_REGNUM
)
732 && regno
>= FIRST_VIRTUAL_REGISTER
&& regno
<= LAST_VIRTUAL_REGISTER
)
736 && regno
< i
+ (i
< FIRST_PSEUDO_REGISTER
737 ? HARD_REGNO_NREGS (i
, GET_MODE (x
))
741 /* If this is a SUBREG of a hard reg, we can see exactly which
742 registers are being modified. Otherwise, handle normally. */
743 if (GET_CODE (SUBREG_REG (x
)) == REG
744 && REGNO (SUBREG_REG (x
)) < FIRST_PSEUDO_REGISTER
)
746 int inner_regno
= REGNO (SUBREG_REG (x
)) + SUBREG_WORD (x
);
748 = inner_regno
+ (inner_regno
< FIRST_PSEUDO_REGISTER
749 ? HARD_REGNO_NREGS (regno
, GET_MODE (x
)) : 1);
751 return endregno
> inner_regno
&& regno
< inner_endregno
;
757 if (&SET_DEST (x
) != loc
758 /* Note setting a SUBREG counts as referring to the REG it is in for
759 a pseudo but not for hard registers since we can
760 treat each word individually. */
761 && ((GET_CODE (SET_DEST (x
)) == SUBREG
762 && loc
!= &SUBREG_REG (SET_DEST (x
))
763 && GET_CODE (SUBREG_REG (SET_DEST (x
))) == REG
764 && REGNO (SUBREG_REG (SET_DEST (x
))) >= FIRST_PSEUDO_REGISTER
765 && refers_to_regno_p (regno
, endregno
,
766 SUBREG_REG (SET_DEST (x
)), loc
))
767 || (GET_CODE (SET_DEST (x
)) != REG
768 && refers_to_regno_p (regno
, endregno
, SET_DEST (x
), loc
))))
771 if (code
== CLOBBER
|| loc
== &SET_SRC (x
))
780 /* X does not match, so try its subexpressions. */
782 fmt
= GET_RTX_FORMAT (code
);
783 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
785 if (fmt
[i
] == 'e' && loc
!= &XEXP (x
, i
))
793 if (refers_to_regno_p (regno
, endregno
, XEXP (x
, i
), loc
))
796 else if (fmt
[i
] == 'E')
799 for (j
= XVECLEN (x
, i
) - 1; j
>=0; j
--)
800 if (loc
!= &XVECEXP (x
, i
, j
)
801 && refers_to_regno_p (regno
, endregno
, XVECEXP (x
, i
, j
), loc
))
808 /* Nonzero if modifying X will affect IN. If X is a register or a SUBREG,
809 we check if any register number in X conflicts with the relevant register
810 numbers. If X is a constant, return 0. If X is a MEM, return 1 iff IN
811 contains a MEM (we don't bother checking for memory addresses that can't
812 conflict because we expect this to be a rare case. */
815 reg_overlap_mentioned_p (x
, in
)
820 /* Overly conservative. */
821 if (GET_CODE (x
) == STRICT_LOW_PART
)
824 /* If either argument is a constant, then modifying X can not affect IN. */
825 if (CONSTANT_P (x
) || CONSTANT_P (in
))
827 else if (GET_CODE (x
) == SUBREG
)
829 regno
= REGNO (SUBREG_REG (x
));
830 if (regno
< FIRST_PSEUDO_REGISTER
)
831 regno
+= SUBREG_WORD (x
);
833 else if (GET_CODE (x
) == REG
)
835 else if (GET_CODE (x
) == MEM
)
840 if (GET_CODE (in
) == MEM
)
843 fmt
= GET_RTX_FORMAT (GET_CODE (in
));
845 for (i
= GET_RTX_LENGTH (GET_CODE (in
)) - 1; i
>= 0; i
--)
846 if (fmt
[i
] == 'e' && reg_overlap_mentioned_p (x
, XEXP (in
, i
)))
851 else if (GET_CODE (x
) == SCRATCH
|| GET_CODE (x
) == PC
852 || GET_CODE (x
) == CC0
)
853 return reg_mentioned_p (x
, in
);
854 else if (GET_CODE (x
) == PARALLEL
855 && GET_MODE (x
) == BLKmode
)
859 /* If any register in here refers to it
861 for (i
= XVECLEN (x
, 0) - 1; i
>= 0; i
--)
862 if (reg_overlap_mentioned_p (SET_DEST (XVECEXP (x
, 0, i
)), in
))
869 endregno
= regno
+ (regno
< FIRST_PSEUDO_REGISTER
870 ? HARD_REGNO_NREGS (regno
, GET_MODE (x
)) : 1);
872 return refers_to_regno_p (regno
, endregno
, in
, NULL_PTR
);
875 /* Used for communications between the next few functions. */
877 static int reg_set_last_unknown
;
878 static rtx reg_set_last_value
;
879 static int reg_set_last_first_regno
, reg_set_last_last_regno
;
881 /* Called via note_stores from reg_set_last. */
884 reg_set_last_1 (x
, pat
)
890 /* If X is not a register, or is not one in the range we care
892 if (GET_CODE (x
) != REG
)
896 last
= first
+ (first
< FIRST_PSEUDO_REGISTER
897 ? HARD_REGNO_NREGS (first
, GET_MODE (x
)) : 1);
899 if (first
>= reg_set_last_last_regno
900 || last
<= reg_set_last_first_regno
)
903 /* If this is a CLOBBER or is some complex LHS, or doesn't modify
904 exactly the registers we care about, show we don't know the value. */
905 if (GET_CODE (pat
) == CLOBBER
|| SET_DEST (pat
) != x
906 || first
!= reg_set_last_first_regno
907 || last
!= reg_set_last_last_regno
)
908 reg_set_last_unknown
= 1;
910 reg_set_last_value
= SET_SRC (pat
);
913 /* Return the last value to which REG was set prior to INSN. If we can't
914 find it easily, return 0.
916 We only return a REG, SUBREG, or constant because it is too hard to
917 check if a MEM remains unchanged. */
920 reg_set_last (x
, insn
)
924 rtx orig_insn
= insn
;
926 reg_set_last_first_regno
= REGNO (x
);
928 reg_set_last_last_regno
929 = reg_set_last_first_regno
930 + (reg_set_last_first_regno
< FIRST_PSEUDO_REGISTER
931 ? HARD_REGNO_NREGS (reg_set_last_first_regno
, GET_MODE (x
)) : 1);
933 reg_set_last_unknown
= 0;
934 reg_set_last_value
= 0;
936 /* Scan backwards until reg_set_last_1 changed one of the above flags.
937 Stop when we reach a label or X is a hard reg and we reach a
938 CALL_INSN (if reg_set_last_last_regno is a hard reg).
940 If we find a set of X, ensure that its SET_SRC remains unchanged. */
942 /* We compare with <= here, because reg_set_last_last_regno
943 is actually the number of the first reg *not* in X. */
945 insn
&& GET_CODE (insn
) != CODE_LABEL
946 && ! (GET_CODE (insn
) == CALL_INSN
947 && reg_set_last_last_regno
<= FIRST_PSEUDO_REGISTER
);
948 insn
= PREV_INSN (insn
))
949 if (GET_RTX_CLASS (GET_CODE (insn
)) == 'i')
951 note_stores (PATTERN (insn
), reg_set_last_1
);
952 if (reg_set_last_unknown
)
954 else if (reg_set_last_value
)
956 if (CONSTANT_P (reg_set_last_value
)
957 || ((GET_CODE (reg_set_last_value
) == REG
958 || GET_CODE (reg_set_last_value
) == SUBREG
)
959 && ! reg_set_between_p (reg_set_last_value
,
961 return reg_set_last_value
;
970 /* This is 1 until after the rtl generation pass. */
971 int rtx_equal_function_value_matters
;
973 /* Return 1 if X and Y are identical-looking rtx's.
974 This is the Lisp function EQUAL for rtx arguments. */
982 register enum rtx_code code
;
987 if (x
== 0 || y
== 0)
991 /* Rtx's of different codes cannot be equal. */
992 if (code
!= GET_CODE (y
))
995 /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent.
996 (REG:SI x) and (REG:HI x) are NOT equivalent. */
998 if (GET_MODE (x
) != GET_MODE (y
))
1001 /* REG, LABEL_REF, and SYMBOL_REF can be compared nonrecursively. */
1004 /* Until rtl generation is complete, don't consider a reference to the
1005 return register of the current function the same as the return from a
1006 called function. This eases the job of function integration. Once the
1007 distinction is no longer needed, they can be considered equivalent. */
1008 return (REGNO (x
) == REGNO (y
)
1009 && (! rtx_equal_function_value_matters
1010 || REG_FUNCTION_VALUE_P (x
) == REG_FUNCTION_VALUE_P (y
)));
1011 else if (code
== LABEL_REF
)
1012 return XEXP (x
, 0) == XEXP (y
, 0);
1013 else if (code
== SYMBOL_REF
)
1014 return XSTR (x
, 0) == XSTR (y
, 0);
1015 else if (code
== SCRATCH
|| code
== CONST_DOUBLE
)
1018 /* Compare the elements. If any pair of corresponding elements
1019 fail to match, return 0 for the whole things. */
1021 fmt
= GET_RTX_FORMAT (code
);
1022 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
1027 if (XWINT (x
, i
) != XWINT (y
, i
))
1033 if (XINT (x
, i
) != XINT (y
, i
))
1039 /* Two vectors must have the same length. */
1040 if (XVECLEN (x
, i
) != XVECLEN (y
, i
))
1043 /* And the corresponding elements must match. */
1044 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
1045 if (rtx_equal_p (XVECEXP (x
, i
, j
), XVECEXP (y
, i
, j
)) == 0)
1050 if (rtx_equal_p (XEXP (x
, i
), XEXP (y
, i
)) == 0)
1056 if (strcmp (XSTR (x
, i
), XSTR (y
, i
)))
1061 /* These are just backpointers, so they don't matter. */
1067 /* It is believed that rtx's at this level will never
1068 contain anything but integers and other rtx's,
1069 except for within LABEL_REFs and SYMBOL_REFs. */
1077 /* Call FUN on each register or MEM that is stored into or clobbered by X.
1078 (X would be the pattern of an insn).
1079 FUN receives two arguments:
1080 the REG, MEM, CC0 or PC being stored in or clobbered,
1081 the SET or CLOBBER rtx that does the store.
1083 If the item being stored in or clobbered is a SUBREG of a hard register,
1084 the SUBREG will be passed. */
1087 note_stores (x
, fun
)
1091 if ((GET_CODE (x
) == SET
|| GET_CODE (x
) == CLOBBER
))
1093 register rtx dest
= SET_DEST (x
);
1094 while ((GET_CODE (dest
) == SUBREG
1095 && (GET_CODE (SUBREG_REG (dest
)) != REG
1096 || REGNO (SUBREG_REG (dest
)) >= FIRST_PSEUDO_REGISTER
))
1097 || GET_CODE (dest
) == ZERO_EXTRACT
1098 || GET_CODE (dest
) == SIGN_EXTRACT
1099 || GET_CODE (dest
) == STRICT_LOW_PART
)
1100 dest
= XEXP (dest
, 0);
1102 if (GET_CODE (dest
) == PARALLEL
1103 && GET_MODE (dest
) == BLKmode
)
1106 for (i
= XVECLEN (dest
, 0) - 1; i
>= 0; i
--)
1107 (*fun
) (SET_DEST (XVECEXP (dest
, 0, i
)), x
);
1112 else if (GET_CODE (x
) == PARALLEL
)
1115 for (i
= XVECLEN (x
, 0) - 1; i
>= 0; i
--)
1117 register rtx y
= XVECEXP (x
, 0, i
);
1118 if (GET_CODE (y
) == SET
|| GET_CODE (y
) == CLOBBER
)
1120 register rtx dest
= SET_DEST (y
);
1121 while ((GET_CODE (dest
) == SUBREG
1122 && (GET_CODE (SUBREG_REG (dest
)) != REG
1123 || (REGNO (SUBREG_REG (dest
))
1124 >= FIRST_PSEUDO_REGISTER
)))
1125 || GET_CODE (dest
) == ZERO_EXTRACT
1126 || GET_CODE (dest
) == SIGN_EXTRACT
1127 || GET_CODE (dest
) == STRICT_LOW_PART
)
1128 dest
= XEXP (dest
, 0);
1129 if (GET_CODE (dest
) == PARALLEL
1130 && GET_MODE (dest
) == BLKmode
)
1133 for (i
= XVECLEN (dest
, 0) - 1; i
>= 0; i
--)
1134 (*fun
) (SET_DEST (XVECEXP (dest
, 0, i
)), y
);
1143 /* Return nonzero if X's old contents don't survive after INSN.
1144 This will be true if X is (cc0) or if X is a register and
1145 X dies in INSN or because INSN entirely sets X.
1147 "Entirely set" means set directly and not through a SUBREG,
1148 ZERO_EXTRACT or SIGN_EXTRACT, so no trace of the old contents remains.
1149 Likewise, REG_INC does not count.
1151 REG may be a hard or pseudo reg. Renumbering is not taken into account,
1152 but for this use that makes no difference, since regs don't overlap
1153 during their lifetimes. Therefore, this function may be used
1154 at any time after deaths have been computed (in flow.c).
1156 If REG is a hard reg that occupies multiple machine registers, this
1157 function will only return 1 if each of those registers will be replaced
1161 dead_or_set_p (insn
, x
)
1165 register int regno
, last_regno
;
1168 /* Can't use cc0_rtx below since this file is used by genattrtab.c. */
1169 if (GET_CODE (x
) == CC0
)
1172 if (GET_CODE (x
) != REG
)
1176 last_regno
= (regno
>= FIRST_PSEUDO_REGISTER
? regno
1177 : regno
+ HARD_REGNO_NREGS (regno
, GET_MODE (x
)) - 1);
1179 for (i
= regno
; i
<= last_regno
; i
++)
1180 if (! dead_or_set_regno_p (insn
, i
))
1186 /* Utility function for dead_or_set_p to check an individual register. Also
1187 called from flow.c. */
1190 dead_or_set_regno_p (insn
, test_regno
)
1194 int regno
, endregno
;
1197 /* REG_READ notes are not normally maintained after reload, so we
1198 ignore them if the are invalid. */
1199 if (! reload_completed
1200 #ifdef PRESERVE_DEATH_INFO_REGNO_P
1201 || PRESERVE_DEATH_INFO_REGNO_P (test_regno
)
1205 /* See if there is a death note for something that includes
1207 for (link
= REG_NOTES (insn
); link
; link
= XEXP (link
, 1))
1209 if (REG_NOTE_KIND (link
) != REG_DEAD
1210 || GET_CODE (XEXP (link
, 0)) != REG
)
1213 regno
= REGNO (XEXP (link
, 0));
1214 endregno
= (regno
>= FIRST_PSEUDO_REGISTER
? regno
+ 1
1215 : regno
+ HARD_REGNO_NREGS (regno
,
1216 GET_MODE (XEXP (link
, 0))));
1218 if (test_regno
>= regno
&& test_regno
< endregno
)
1223 if (GET_CODE (insn
) == CALL_INSN
1224 && find_regno_fusage (insn
, CLOBBER
, test_regno
))
1227 if (GET_CODE (PATTERN (insn
)) == SET
)
1229 rtx dest
= SET_DEST (PATTERN (insn
));
1231 /* A value is totally replaced if it is the destination or the
1232 destination is a SUBREG of REGNO that does not change the number of
1234 if (GET_CODE (dest
) == SUBREG
1235 && (((GET_MODE_SIZE (GET_MODE (dest
))
1236 + UNITS_PER_WORD
- 1) / UNITS_PER_WORD
)
1237 == ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (dest
)))
1238 + UNITS_PER_WORD
- 1) / UNITS_PER_WORD
)))
1239 dest
= SUBREG_REG (dest
);
1241 if (GET_CODE (dest
) != REG
)
1244 regno
= REGNO (dest
);
1245 endregno
= (regno
>= FIRST_PSEUDO_REGISTER
? regno
+ 1
1246 : regno
+ HARD_REGNO_NREGS (regno
, GET_MODE (dest
)));
1248 return (test_regno
>= regno
&& test_regno
< endregno
);
1250 else if (GET_CODE (PATTERN (insn
)) == PARALLEL
)
1254 for (i
= XVECLEN (PATTERN (insn
), 0) - 1; i
>= 0; i
--)
1256 rtx body
= XVECEXP (PATTERN (insn
), 0, i
);
1258 if (GET_CODE (body
) == SET
|| GET_CODE (body
) == CLOBBER
)
1260 rtx dest
= SET_DEST (body
);
1262 if (GET_CODE (dest
) == SUBREG
1263 && (((GET_MODE_SIZE (GET_MODE (dest
))
1264 + UNITS_PER_WORD
- 1) / UNITS_PER_WORD
)
1265 == ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (dest
)))
1266 + UNITS_PER_WORD
- 1) / UNITS_PER_WORD
)))
1267 dest
= SUBREG_REG (dest
);
1269 if (GET_CODE (dest
) != REG
)
1272 regno
= REGNO (dest
);
1273 endregno
= (regno
>= FIRST_PSEUDO_REGISTER
? regno
+ 1
1274 : regno
+ HARD_REGNO_NREGS (regno
, GET_MODE (dest
)));
1276 if (test_regno
>= regno
&& test_regno
< endregno
)
1285 /* Return the reg-note of kind KIND in insn INSN, if there is one.
1286 If DATUM is nonzero, look for one whose datum is DATUM. */
1289 find_reg_note (insn
, kind
, datum
)
1296 /* Ignore anything that is not an INSN, JUMP_INSN or CALL_INSN. */
1297 if (GET_RTX_CLASS (GET_CODE (insn
)) != 'i')
1300 for (link
= REG_NOTES (insn
); link
; link
= XEXP (link
, 1))
1301 if (REG_NOTE_KIND (link
) == kind
1302 && (datum
== 0 || datum
== XEXP (link
, 0)))
1307 /* Return the reg-note of kind KIND in insn INSN which applies to register
1308 number REGNO, if any. Return 0 if there is no such reg-note. Note that
1309 the REGNO of this NOTE need not be REGNO if REGNO is a hard register;
1310 it might be the case that the note overlaps REGNO. */
1313 find_regno_note (insn
, kind
, regno
)
1320 /* Ignore anything that is not an INSN, JUMP_INSN or CALL_INSN. */
1321 if (GET_RTX_CLASS (GET_CODE (insn
)) != 'i')
1324 for (link
= REG_NOTES (insn
); link
; link
= XEXP (link
, 1))
1325 if (REG_NOTE_KIND (link
) == kind
1326 /* Verify that it is a register, so that scratch and MEM won't cause a
1328 && GET_CODE (XEXP (link
, 0)) == REG
1329 && REGNO (XEXP (link
, 0)) <= regno
1330 && ((REGNO (XEXP (link
, 0))
1331 + (REGNO (XEXP (link
, 0)) >= FIRST_PSEUDO_REGISTER
? 1
1332 : HARD_REGNO_NREGS (REGNO (XEXP (link
, 0)),
1333 GET_MODE (XEXP (link
, 0)))))
1339 /* Return true if DATUM, or any overlap of DATUM, of kind CODE is found
1340 in the CALL_INSN_FUNCTION_USAGE information of INSN. */
1343 find_reg_fusage (insn
, code
, datum
)
1348 /* If it's not a CALL_INSN, it can't possibly have a
1349 CALL_INSN_FUNCTION_USAGE field, so don't bother checking. */
1350 if (GET_CODE (insn
) != CALL_INSN
)
1356 if (GET_CODE (datum
) != REG
)
1360 for (link
= CALL_INSN_FUNCTION_USAGE (insn
);
1362 link
= XEXP (link
, 1))
1363 if (GET_CODE (XEXP (link
, 0)) == code
1364 && rtx_equal_p (datum
, SET_DEST (XEXP (link
, 0))))
1369 register int regno
= REGNO (datum
);
1371 /* CALL_INSN_FUNCTION_USAGE information cannot contain references
1372 to pseudo registers, so don't bother checking. */
1374 if (regno
< FIRST_PSEUDO_REGISTER
)
1376 int end_regno
= regno
+ HARD_REGNO_NREGS (regno
, GET_MODE (datum
));
1379 for (i
= regno
; i
< end_regno
; i
++)
1380 if (find_regno_fusage (insn
, code
, i
))
1388 /* Return true if REGNO, or any overlap of REGNO, of kind CODE is found
1389 in the CALL_INSN_FUNCTION_USAGE information of INSN. */
1392 find_regno_fusage (insn
, code
, regno
)
1399 /* CALL_INSN_FUNCTION_USAGE information cannot contain references
1400 to pseudo registers, so don't bother checking. */
1402 if (regno
>= FIRST_PSEUDO_REGISTER
1403 || GET_CODE (insn
) != CALL_INSN
)
1406 for (link
= CALL_INSN_FUNCTION_USAGE (insn
); link
; link
= XEXP (link
, 1))
1408 register int regnote
;
1411 if (GET_CODE (op
= XEXP (link
, 0)) == code
1412 && GET_CODE (SET_DEST (op
)) == REG
1413 && (regnote
= REGNO (SET_DEST (op
))) <= regno
1415 + HARD_REGNO_NREGS (regnote
, GET_MODE (SET_DEST (op
)))
1423 /* Remove register note NOTE from the REG_NOTES of INSN. */
1426 remove_note (insn
, note
)
1432 if (REG_NOTES (insn
) == note
)
1434 REG_NOTES (insn
) = XEXP (note
, 1);
1438 for (link
= REG_NOTES (insn
); link
; link
= XEXP (link
, 1))
1439 if (XEXP (link
, 1) == note
)
1441 XEXP (link
, 1) = XEXP (note
, 1);
1448 /* Nonzero if X contains any volatile instructions. These are instructions
1449 which may cause unpredictable machine state instructions, and thus no
1450 instructions should be moved or combined across them. This includes
1451 only volatile asms and UNSPEC_VOLATILE instructions. */
1457 register RTX_CODE code
;
1459 code
= GET_CODE (x
);
1479 case UNSPEC_VOLATILE
:
1480 /* case TRAP_IF: This isn't clear yet. */
1484 if (MEM_VOLATILE_P (x
))
1491 /* Recursively scan the operands of this expression. */
1494 register char *fmt
= GET_RTX_FORMAT (code
);
1497 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
1501 if (volatile_insn_p (XEXP (x
, i
)))
1507 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
1508 if (volatile_insn_p (XVECEXP (x
, i
, j
)))
1516 /* Nonzero if X contains any volatile memory references
1517 UNSPEC_VOLATILE operations or volatile ASM_OPERANDS expressions. */
1523 register RTX_CODE code
;
1525 code
= GET_CODE (x
);
1544 case UNSPEC_VOLATILE
:
1545 /* case TRAP_IF: This isn't clear yet. */
1550 if (MEM_VOLATILE_P (x
))
1557 /* Recursively scan the operands of this expression. */
1560 register char *fmt
= GET_RTX_FORMAT (code
);
1563 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
1567 if (volatile_refs_p (XEXP (x
, i
)))
1573 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
1574 if (volatile_refs_p (XVECEXP (x
, i
, j
)))
1582 /* Similar to above, except that it also rejects register pre- and post-
1589 register RTX_CODE code
;
1591 code
= GET_CODE (x
);
1609 /* Reject CLOBBER with a non-VOID mode. These are made by combine.c
1610 when some combination can't be done. If we see one, don't think
1611 that we can simplify the expression. */
1612 return (GET_MODE (x
) != VOIDmode
);
1619 case UNSPEC_VOLATILE
:
1620 /* case TRAP_IF: This isn't clear yet. */
1625 if (MEM_VOLATILE_P (x
))
1632 /* Recursively scan the operands of this expression. */
1635 register char *fmt
= GET_RTX_FORMAT (code
);
1638 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
1642 if (side_effects_p (XEXP (x
, i
)))
1648 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
1649 if (side_effects_p (XVECEXP (x
, i
, j
)))
1657 /* Return nonzero if evaluating rtx X might cause a trap. */
1669 code
= GET_CODE (x
);
1672 /* Handle these cases quickly. */
1684 /* Conditional trap can trap! */
1685 case UNSPEC_VOLATILE
:
1689 /* Memory ref can trap unless it's a static var or a stack slot. */
1691 return rtx_addr_can_trap_p (XEXP (x
, 0));
1693 /* Division by a non-constant might trap. */
1698 if (! CONSTANT_P (XEXP (x
, 1))
1699 || GET_MODE_CLASS (GET_MODE (x
)) == MODE_FLOAT
)
1701 /* This was const0_rtx, but by not using that,
1702 we can link this file into other programs. */
1703 if (GET_CODE (XEXP (x
, 1)) == CONST_INT
&& INTVAL (XEXP (x
, 1)) == 0)
1708 /* An EXPR_LIST is used to represent a function call. This
1709 certainly may trap. */
1713 /* Any floating arithmetic may trap. */
1714 if (GET_MODE_CLASS (GET_MODE (x
)) == MODE_FLOAT
)
1718 fmt
= GET_RTX_FORMAT (code
);
1719 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
1723 if (may_trap_p (XEXP (x
, i
)))
1726 else if (fmt
[i
] == 'E')
1729 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
1730 if (may_trap_p (XVECEXP (x
, i
, j
)))
1737 /* Return nonzero if X contains a comparison that is not either EQ or NE,
1738 i.e., an inequality. */
1741 inequality_comparisons_p (x
)
1745 register int len
, i
;
1746 register enum rtx_code code
= GET_CODE (x
);
1775 len
= GET_RTX_LENGTH (code
);
1776 fmt
= GET_RTX_FORMAT (code
);
1778 for (i
= 0; i
< len
; i
++)
1782 if (inequality_comparisons_p (XEXP (x
, i
)))
1785 else if (fmt
[i
] == 'E')
1788 for (j
= XVECLEN (x
, i
) - 1; j
>= 0; j
--)
1789 if (inequality_comparisons_p (XVECEXP (x
, i
, j
)))
1797 /* Replace any occurrence of FROM in X with TO. The function does
1798 not enter into CONST_DOUBLE for the replace.
1800 Note that copying is not done so X must not be shared unless all copies
1801 are to be modified. */
1804 replace_rtx (x
, from
, to
)
1810 /* The following prevents loops occurrence when we change MEM in
1811 CONST_DOUBLE onto the same CONST_DOUBLE. */
1812 if (x
!= 0 && GET_CODE (x
) == CONST_DOUBLE
)
1818 /* Allow this function to make replacements in EXPR_LISTs. */
1822 fmt
= GET_RTX_FORMAT (GET_CODE (x
));
1823 for (i
= GET_RTX_LENGTH (GET_CODE (x
)) - 1; i
>= 0; i
--)
1826 XEXP (x
, i
) = replace_rtx (XEXP (x
, i
), from
, to
);
1827 else if (fmt
[i
] == 'E')
1828 for (j
= XVECLEN (x
, i
) - 1; j
>= 0; j
--)
1829 XVECEXP (x
, i
, j
) = replace_rtx (XVECEXP (x
, i
, j
), from
, to
);
1835 /* Throughout the rtx X, replace many registers according to REG_MAP.
1836 Return the replacement for X (which may be X with altered contents).
1837 REG_MAP[R] is the replacement for register R, or 0 for don't replace.
1838 NREGS is the length of REG_MAP; regs >= NREGS are not mapped.
1840 We only support REG_MAP entries of REG or SUBREG. Also, hard registers
1841 should not be mapped to pseudos or vice versa since validate_change
1844 If REPLACE_DEST is 1, replacements are also done in destinations;
1845 otherwise, only sources are replaced. */
1848 replace_regs (x
, reg_map
, nregs
, replace_dest
)
1854 register enum rtx_code code
;
1861 code
= GET_CODE (x
);
1875 /* Verify that the register has an entry before trying to access it. */
1876 if (REGNO (x
) < nregs
&& reg_map
[REGNO (x
)] != 0)
1878 /* SUBREGs can't be shared. Always return a copy to ensure that if
1879 this replacement occurs more than once then each instance will
1880 get distinct rtx. */
1881 if (GET_CODE (reg_map
[REGNO (x
)]) == SUBREG
)
1882 return copy_rtx (reg_map
[REGNO (x
)]);
1883 return reg_map
[REGNO (x
)];
1888 /* Prevent making nested SUBREGs. */
1889 if (GET_CODE (SUBREG_REG (x
)) == REG
&& REGNO (SUBREG_REG (x
)) < nregs
1890 && reg_map
[REGNO (SUBREG_REG (x
))] != 0
1891 && GET_CODE (reg_map
[REGNO (SUBREG_REG (x
))]) == SUBREG
)
1893 rtx map_val
= reg_map
[REGNO (SUBREG_REG (x
))];
1894 rtx map_inner
= SUBREG_REG (map_val
);
1896 if (GET_MODE (x
) == GET_MODE (map_inner
))
1900 /* We cannot call gen_rtx here since we may be linked with
1902 /* Let's try clobbering the incoming SUBREG and see
1903 if this is really safe. */
1904 SUBREG_REG (x
) = map_inner
;
1905 SUBREG_WORD (x
) += SUBREG_WORD (map_val
);
1908 rtx
new = rtx_alloc (SUBREG
);
1909 PUT_MODE (new, GET_MODE (x
));
1910 SUBREG_REG (new) = map_inner
;
1911 SUBREG_WORD (new) = SUBREG_WORD (x
) + SUBREG_WORD (map_val
);
1919 SET_DEST (x
) = replace_regs (SET_DEST (x
), reg_map
, nregs
, 0);
1921 else if (GET_CODE (SET_DEST (x
)) == MEM
1922 || GET_CODE (SET_DEST (x
)) == STRICT_LOW_PART
)
1923 /* Even if we are not to replace destinations, replace register if it
1924 is CONTAINED in destination (destination is memory or
1925 STRICT_LOW_PART). */
1926 XEXP (SET_DEST (x
), 0) = replace_regs (XEXP (SET_DEST (x
), 0),
1928 else if (GET_CODE (SET_DEST (x
)) == ZERO_EXTRACT
)
1929 /* Similarly, for ZERO_EXTRACT we replace all operands. */
1932 SET_SRC (x
) = replace_regs (SET_SRC (x
), reg_map
, nregs
, 0);
1939 fmt
= GET_RTX_FORMAT (code
);
1940 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
1943 XEXP (x
, i
) = replace_regs (XEXP (x
, i
), reg_map
, nregs
, replace_dest
);
1947 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
1948 XVECEXP (x
, i
, j
) = replace_regs (XVECEXP (x
, i
, j
), reg_map
,
1949 nregs
, replace_dest
);
1955 /* Return 1 if X, the SRC_SRC of SET of (pc) contain a REG or MEM that is
1956 not in the constant pool and not in the condition of an IF_THEN_ELSE. */
1959 jmp_uses_reg_or_mem (x
)
1962 enum rtx_code code
= GET_CODE (x
);
1977 return ! (GET_CODE (XEXP (x
, 0)) == SYMBOL_REF
1978 && CONSTANT_POOL_ADDRESS_P (XEXP (x
, 0)));
1981 return (jmp_uses_reg_or_mem (XEXP (x
, 1))
1982 || jmp_uses_reg_or_mem (XEXP (x
, 2)));
1984 case PLUS
: case MINUS
: case MULT
:
1985 return (jmp_uses_reg_or_mem (XEXP (x
, 0))
1986 || jmp_uses_reg_or_mem (XEXP (x
, 1)));
1992 fmt
= GET_RTX_FORMAT (code
);
1993 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
1996 && jmp_uses_reg_or_mem (XEXP (x
, i
)))
2000 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
2001 if (jmp_uses_reg_or_mem (XVECEXP (x
, i
, j
)))
2008 /* Return nonzero if INSN is an indirect jump (aka computed jump).
2010 Tablejumps and casesi insns are not considered indirect jumps;
2011 we can recognize them by a (use (lael_ref)). */
2014 computed_jump_p (insn
)
2018 if (GET_CODE (insn
) == JUMP_INSN
)
2020 rtx pat
= PATTERN (insn
);
2022 if (GET_CODE (pat
) == PARALLEL
)
2024 int len
= XVECLEN (pat
, 0);
2025 int has_use_labelref
= 0;
2027 for (i
= len
- 1; i
>= 0; i
--)
2028 if (GET_CODE (XVECEXP (pat
, 0, i
)) == USE
2029 && (GET_CODE (XEXP (XVECEXP (pat
, 0, i
), 0))
2031 has_use_labelref
= 1;
2033 if (! has_use_labelref
)
2034 for (i
= len
- 1; i
>= 0; i
--)
2035 if (GET_CODE (XVECEXP (pat
, 0, i
)) == SET
2036 && SET_DEST (XVECEXP (pat
, 0, i
)) == pc_rtx
2037 && jmp_uses_reg_or_mem (SET_SRC (XVECEXP (pat
, 0, i
))))
2040 else if (GET_CODE (pat
) == SET
2041 && SET_DEST (pat
) == pc_rtx
2042 && jmp_uses_reg_or_mem (SET_SRC (pat
)))
2048 /* Traverse X via depth-first search, calling F for each
2049 sub-expression (including X itself). F is also passed the DATA.
2050 If F returns -1, do not traverse sub-expressions, but continue
2051 traversing the rest of the tree. If F ever returns any other
2052 non-zero value, stop the traversal, and return the value returned
2053 by F. Otherwise, return 0. This function does not traverse inside
2054 tree structure that contains RTX_EXPRs, or into sub-expressions
2055 whose format code is `0' since it is not known whether or not those
2056 codes are actually RTL.
2058 This routine is very general, and could (should?) be used to
2059 implement many of the other routines in this file. */
2061 int for_each_rtx (x
, f
, data
)
2072 result
= (*f
)(x
, data
);
2074 /* Do not traverse sub-expressions. */
2076 else if (result
!= 0)
2077 /* Stop the traversal. */
2081 /* There are no sub-expressions. */
2084 length
= GET_RTX_LENGTH (GET_CODE (*x
));
2085 format
= GET_RTX_FORMAT (GET_CODE (*x
));
2087 for (i
= 0; i
< length
; ++i
)
2092 result
= for_each_rtx (&XEXP (*x
, i
), f
, data
);
2099 if (XVEC (*x
, i
) != 0)
2102 for (j
= 0; j
< XVECLEN (*x
, i
); ++j
)
2104 result
= for_each_rtx (&XVECEXP (*x
, i
, j
), f
, data
);
2112 /* Nothing to do. */