1 /* Analyze RTL for C-Compiler
2 Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001 Free Software Foundation, Inc.
5 This file is part of GNU CC.
7 GNU CC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU CC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU CC; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
27 #include "hard-reg-set.h"
29 /* Forward declarations */
30 static void set_of_1 PARAMS ((rtx, rtx, void *));
31 static void insn_dependent_p_1 PARAMS ((rtx, rtx, void *));
32 static int computed_jump_p_1 PARAMS ((rtx));
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);
51 register const char *fmt;
56 return ! RTX_UNCHANGING_P (x) || rtx_unstable_p (XEXP (x, 0));
69 /* As in rtx_varies_p, we have to use the actual rtx, not reg number. */
70 if (x == frame_pointer_rtx || x == hard_frame_pointer_rtx
71 /* The arg pointer varies if it is not a fixed register. */
72 || (x == arg_pointer_rtx && fixed_regs[ARG_POINTER_REGNUM])
73 || RTX_UNCHANGING_P (x))
75 #ifndef PIC_OFFSET_TABLE_REG_CALL_CLOBBERED
76 /* ??? When call-clobbered, the value is stable modulo the restore
77 that must happen after a call. This currently screws up local-alloc
78 into believing that the restore is not needed. */
79 if (x == pic_offset_table_rtx)
85 if (MEM_VOLATILE_P (x))
94 fmt = GET_RTX_FORMAT (code);
95 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
98 if (rtx_unstable_p (XEXP (x, i)))
101 else if (fmt[i] == 'E')
104 for (j = 0; j < XVECLEN (x, i); j++)
105 if (rtx_unstable_p (XVECEXP (x, i, j)))
112 /* Return 1 if X has a value that can vary even between two
113 executions of the program. 0 means X can be compared reliably
114 against certain constants or near-constants.
115 FOR_ALIAS is nonzero if we are called from alias analysis; if it is
116 zero, we are slightly more conservative.
117 The frame pointer and the arg pointer are considered constant. */
120 rtx_varies_p (x, for_alias)
124 register RTX_CODE code = GET_CODE (x);
126 register const char *fmt;
131 return ! RTX_UNCHANGING_P (x) || rtx_varies_p (XEXP (x, 0), for_alias);
144 /* Note that we have to test for the actual rtx used for the frame
145 and arg pointers and not just the register number in case we have
146 eliminated the frame and/or arg pointer and are using it
148 if (x == frame_pointer_rtx || x == hard_frame_pointer_rtx
149 /* The arg pointer varies if it is not a fixed register. */
150 || (x == arg_pointer_rtx && fixed_regs[ARG_POINTER_REGNUM]))
152 if (x == pic_offset_table_rtx
153 #ifdef PIC_OFFSET_TABLE_REG_CALL_CLOBBERED
154 /* ??? When call-clobbered, the value is stable modulo the restore
155 that must happen after a call. This currently screws up
156 local-alloc into believing that the restore is not needed, so we
157 must return 0 only if we are called from alias analysis. */
165 /* The operand 0 of a LO_SUM is considered constant
166 (in fact is it related specifically to operand 1). */
167 return rtx_varies_p (XEXP (x, 1), for_alias);
170 if (MEM_VOLATILE_P (x))
179 fmt = GET_RTX_FORMAT (code);
180 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
183 if (rtx_varies_p (XEXP (x, i), for_alias))
186 else if (fmt[i] == 'E')
189 for (j = 0; j < XVECLEN (x, i); j++)
190 if (rtx_varies_p (XVECEXP (x, i, j), for_alias))
197 /* Return 0 if the use of X as an address in a MEM can cause a trap. */
200 rtx_addr_can_trap_p (x)
203 register enum rtx_code code = GET_CODE (x);
209 /* SYMBOL_REF is problematic due to the possible presence of
210 a #pragma weak, but to say that loads from symbols can trap is
211 *very* costly. It's not at all clear what's best here. For
212 now, we ignore the impact of #pragma weak. */
216 /* As in rtx_varies_p, we have to use the actual rtx, not reg number. */
217 return ! (x == frame_pointer_rtx || x == hard_frame_pointer_rtx
218 || x == stack_pointer_rtx
219 /* The arg pointer varies if it is not a fixed register. */
220 || (x == arg_pointer_rtx && fixed_regs[ARG_POINTER_REGNUM]));
223 return rtx_addr_can_trap_p (XEXP (x, 0));
226 /* An address is assumed not to trap if it is an address that can't
227 trap plus a constant integer or it is the pic register plus a
229 return ! ((! rtx_addr_can_trap_p (XEXP (x, 0))
230 && GET_CODE (XEXP (x, 1)) == CONST_INT)
231 || (XEXP (x, 0) == pic_offset_table_rtx
232 && CONSTANT_P (XEXP (x, 1))));
235 return rtx_addr_can_trap_p (XEXP (x, 1));
241 /* If it isn't one of the case above, it can cause a trap. */
245 /* Return 1 if X refers to a memory location whose address
246 cannot be compared reliably with constant addresses,
247 or if X refers to a BLKmode memory object.
248 FOR_ALIAS is nonzero if we are called from alias analysis; if it is
249 zero, we are slightly more conservative. */
252 rtx_addr_varies_p (x, for_alias)
256 register enum rtx_code code;
258 register const char *fmt;
265 return GET_MODE (x) == BLKmode || rtx_varies_p (XEXP (x, 0), for_alias);
267 fmt = GET_RTX_FORMAT (code);
268 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
271 if (rtx_addr_varies_p (XEXP (x, i), for_alias))
274 else if (fmt[i] == 'E')
277 for (j = 0; j < XVECLEN (x, i); j++)
278 if (rtx_addr_varies_p (XVECEXP (x, i, j), for_alias))
284 /* Return the value of the integer term in X, if one is apparent;
286 Only obvious integer terms are detected.
287 This is used in cse.c with the `related_value' field.*/
293 if (GET_CODE (x) == CONST)
296 if (GET_CODE (x) == MINUS
297 && GET_CODE (XEXP (x, 1)) == CONST_INT)
298 return - INTVAL (XEXP (x, 1));
299 if (GET_CODE (x) == PLUS
300 && GET_CODE (XEXP (x, 1)) == CONST_INT)
301 return INTVAL (XEXP (x, 1));
305 /* If X is a constant, return the value sans apparent integer term;
307 Only obvious integer terms are detected. */
310 get_related_value (x)
313 if (GET_CODE (x) != CONST)
316 if (GET_CODE (x) == PLUS
317 && GET_CODE (XEXP (x, 1)) == CONST_INT)
319 else if (GET_CODE (x) == MINUS
320 && GET_CODE (XEXP (x, 1)) == CONST_INT)
325 /* Return the number of places FIND appears within X. If COUNT_DEST is
326 zero, we do not count occurrences inside the destination of a SET. */
329 count_occurrences (x, find, count_dest)
335 const char *format_ptr;
355 if (GET_CODE (find) == MEM && rtx_equal_p (x, find))
360 if (SET_DEST (x) == find && ! count_dest)
361 return count_occurrences (SET_SRC (x), find, count_dest);
368 format_ptr = GET_RTX_FORMAT (code);
371 for (i = 0; i < GET_RTX_LENGTH (code); i++)
373 switch (*format_ptr++)
376 count += count_occurrences (XEXP (x, i), find, count_dest);
380 for (j = 0; j < XVECLEN (x, i); j++)
381 count += count_occurrences (XVECEXP (x, i, j), find, count_dest);
388 /* Nonzero if register REG appears somewhere within IN.
389 Also works if REG is not a register; in this case it checks
390 for a subexpression of IN that is Lisp "equal" to REG. */
393 reg_mentioned_p (reg, in)
394 register rtx reg, in;
396 register const char *fmt;
398 register enum rtx_code code;
406 if (GET_CODE (in) == LABEL_REF)
407 return reg == XEXP (in, 0);
409 code = GET_CODE (in);
413 /* Compare registers by number. */
415 return GET_CODE (reg) == REG && REGNO (in) == REGNO (reg);
417 /* These codes have no constituent expressions
425 return GET_CODE (reg) == CONST_INT && INTVAL (in) == INTVAL (reg);
428 /* These are kept unique for a given value. */
435 if (GET_CODE (reg) == code && rtx_equal_p (reg, in))
438 fmt = GET_RTX_FORMAT (code);
440 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
445 for (j = XVECLEN (in, i) - 1; j >= 0; j--)
446 if (reg_mentioned_p (reg, XVECEXP (in, i, j)))
449 else if (fmt[i] == 'e'
450 && reg_mentioned_p (reg, XEXP (in, i)))
456 /* Return 1 if in between BEG and END, exclusive of BEG and END, there is
457 no CODE_LABEL insn. */
460 no_labels_between_p (beg, end)
464 for (p = NEXT_INSN (beg); p != end; p = NEXT_INSN (p))
465 if (GET_CODE (p) == CODE_LABEL)
470 /* Return 1 if in between BEG and END, exclusive of BEG and END, there is
471 no JUMP_INSN insn. */
474 no_jumps_between_p (beg, end)
478 for (p = NEXT_INSN (beg); p != end; p = NEXT_INSN (p))
479 if (GET_CODE (p) == JUMP_INSN)
484 /* Nonzero if register REG is used in an insn between
485 FROM_INSN and TO_INSN (exclusive of those two). */
488 reg_used_between_p (reg, from_insn, to_insn)
489 rtx reg, from_insn, to_insn;
493 if (from_insn == to_insn)
496 for (insn = NEXT_INSN (from_insn); insn != to_insn; insn = NEXT_INSN (insn))
498 && (reg_overlap_mentioned_p (reg, PATTERN (insn))
499 || (GET_CODE (insn) == CALL_INSN
500 && (find_reg_fusage (insn, USE, reg)
501 || find_reg_fusage (insn, CLOBBER, reg)))))
506 /* Nonzero if the old value of X, a register, is referenced in BODY. If X
507 is entirely replaced by a new value and the only use is as a SET_DEST,
508 we do not consider it a reference. */
511 reg_referenced_p (x, body)
517 switch (GET_CODE (body))
520 if (reg_overlap_mentioned_p (x, SET_SRC (body)))
523 /* If the destination is anything other than CC0, PC, a REG or a SUBREG
524 of a REG that occupies all of the REG, the insn references X if
525 it is mentioned in the destination. */
526 if (GET_CODE (SET_DEST (body)) != CC0
527 && GET_CODE (SET_DEST (body)) != PC
528 && GET_CODE (SET_DEST (body)) != REG
529 && ! (GET_CODE (SET_DEST (body)) == SUBREG
530 && GET_CODE (SUBREG_REG (SET_DEST (body))) == REG
531 && (((GET_MODE_SIZE (GET_MODE (SUBREG_REG (SET_DEST (body))))
532 + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD)
533 == ((GET_MODE_SIZE (GET_MODE (SET_DEST (body)))
534 + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD)))
535 && reg_overlap_mentioned_p (x, SET_DEST (body)))
540 for (i = ASM_OPERANDS_INPUT_LENGTH (body) - 1; i >= 0; i--)
541 if (reg_overlap_mentioned_p (x, ASM_OPERANDS_INPUT (body, i)))
548 return reg_overlap_mentioned_p (x, body);
551 return reg_overlap_mentioned_p (x, TRAP_CONDITION (body));
554 case UNSPEC_VOLATILE:
555 for (i = XVECLEN (body, 0) - 1; i >= 0; i--)
556 if (reg_overlap_mentioned_p (x, XVECEXP (body, 0, i)))
561 for (i = XVECLEN (body, 0) - 1; i >= 0; i--)
562 if (reg_referenced_p (x, XVECEXP (body, 0, i)))
567 if (GET_CODE (XEXP (body, 0)) == MEM)
568 if (reg_overlap_mentioned_p (x, XEXP (XEXP (body, 0), 0)))
573 if (reg_overlap_mentioned_p (x, COND_EXEC_TEST (body)))
575 return reg_referenced_p (x, COND_EXEC_CODE (body));
582 /* Nonzero if register REG is referenced in an insn between
583 FROM_INSN and TO_INSN (exclusive of those two). Sets of REG do
587 reg_referenced_between_p (reg, from_insn, to_insn)
588 rtx reg, from_insn, to_insn;
592 if (from_insn == to_insn)
595 for (insn = NEXT_INSN (from_insn); insn != to_insn; insn = NEXT_INSN (insn))
597 && (reg_referenced_p (reg, PATTERN (insn))
598 || (GET_CODE (insn) == CALL_INSN
599 && find_reg_fusage (insn, USE, reg))))
604 /* Nonzero if register REG is set or clobbered in an insn between
605 FROM_INSN and TO_INSN (exclusive of those two). */
608 reg_set_between_p (reg, from_insn, to_insn)
609 rtx reg, from_insn, to_insn;
613 if (from_insn == to_insn)
616 for (insn = NEXT_INSN (from_insn); insn != to_insn; insn = NEXT_INSN (insn))
617 if (INSN_P (insn) && reg_set_p (reg, insn))
622 /* Internals of reg_set_between_p. */
624 reg_set_p (reg, insn)
629 /* We can be passed an insn or part of one. If we are passed an insn,
630 check if a side-effect of the insn clobbers REG. */
633 if (FIND_REG_INC_NOTE (insn, reg)
634 || (GET_CODE (insn) == CALL_INSN
635 /* We'd like to test call_used_regs here, but rtlanal.c can't
636 reference that variable due to its use in genattrtab. So
637 we'll just be more conservative.
639 ??? Unless we could ensure that the CALL_INSN_FUNCTION_USAGE
640 information holds all clobbered registers. */
641 && ((GET_CODE (reg) == REG
642 && REGNO (reg) < FIRST_PSEUDO_REGISTER)
643 || GET_CODE (reg) == MEM
644 || find_reg_fusage (insn, CLOBBER, reg))))
647 body = PATTERN (insn);
650 return set_of (reg, insn) != NULL_RTX;
653 /* Similar to reg_set_between_p, but check all registers in X. Return 0
654 only if none of them are modified between START and END. Do not
655 consider non-registers one way or the other. */
658 regs_set_between_p (x, start, end)
662 enum rtx_code code = GET_CODE (x);
678 return reg_set_between_p (x, start, end);
684 fmt = GET_RTX_FORMAT (code);
685 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
687 if (fmt[i] == 'e' && regs_set_between_p (XEXP (x, i), start, end))
690 else if (fmt[i] == 'E')
691 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
692 if (regs_set_between_p (XVECEXP (x, i, j), start, end))
699 /* Similar to reg_set_between_p, but check all registers in X. Return 0
700 only if none of them are modified between START and END. Return 1 if
701 X contains a MEM; this routine does not perform any memory aliasing. */
704 modified_between_p (x, start, end)
708 enum rtx_code code = GET_CODE (x);
726 /* If the memory is not constant, assume it is modified. If it is
727 constant, we still have to check the address. */
728 if (! RTX_UNCHANGING_P (x))
733 return reg_set_between_p (x, start, end);
739 fmt = GET_RTX_FORMAT (code);
740 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
742 if (fmt[i] == 'e' && modified_between_p (XEXP (x, i), start, end))
745 else if (fmt[i] == 'E')
746 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
747 if (modified_between_p (XVECEXP (x, i, j), start, end))
754 /* Similar to reg_set_p, but check all registers in X. Return 0 only if none
755 of them are modified in INSN. Return 1 if X contains a MEM; this routine
756 does not perform any memory aliasing. */
759 modified_in_p (x, insn)
763 enum rtx_code code = GET_CODE (x);
781 /* If the memory is not constant, assume it is modified. If it is
782 constant, we still have to check the address. */
783 if (! RTX_UNCHANGING_P (x))
788 return reg_set_p (x, insn);
794 fmt = GET_RTX_FORMAT (code);
795 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
797 if (fmt[i] == 'e' && modified_in_p (XEXP (x, i), insn))
800 else if (fmt[i] == 'E')
801 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
802 if (modified_in_p (XVECEXP (x, i, j), insn))
809 /* Return true if anything in insn X is (anti,output,true) dependent on
810 anything in insn Y. */
813 insn_dependent_p (x, y)
818 if (! INSN_P (x) || ! INSN_P (y))
822 note_stores (PATTERN (x), insn_dependent_p_1, &tmp);
827 note_stores (PATTERN (y), insn_dependent_p_1, &tmp);
834 /* A helper routine for insn_dependent_p called through note_stores. */
837 insn_dependent_p_1 (x, pat, data)
839 rtx pat ATTRIBUTE_UNUSED;
842 rtx * pinsn = (rtx *) data;
844 if (*pinsn && reg_mentioned_p (x, *pinsn))
848 /* Helper function for set_of. */
856 set_of_1 (x, pat, data1)
861 struct set_of_data *data = (struct set_of_data *) (data1);
862 if (rtx_equal_p (x, data->pat)
863 || (GET_CODE (x) != MEM && reg_overlap_mentioned_p (data->pat, x)))
867 /* Give an INSN, return a SET or CLOBBER expression that does modify PAT
868 (eighter directly or via STRICT_LOW_PART and similar modifiers). */
873 struct set_of_data data;
874 data.found = NULL_RTX;
876 note_stores (INSN_P (insn) ? PATTERN (insn) : insn, set_of_1, &data);
880 /* Given an INSN, return a SET expression if this insn has only a single SET.
881 It may also have CLOBBERs, USEs, or SET whose output
882 will not be used, which we ignore. */
885 single_set_2 (insn, pat)
889 int set_verified = 1;
892 if (GET_CODE (pat) == PARALLEL)
894 for (i = 0; i < XVECLEN (pat, 0); i++)
896 rtx sub = XVECEXP (pat, 0, i);
897 switch (GET_CODE (sub))
904 /* We can consider insns having multiple sets, where all
905 but one are dead as single set insns. In common case
906 only single set is present in the pattern so we want
907 to avoid checking for REG_UNUSED notes unless neccesary.
909 When we reach set first time, we just expect this is
910 the single set we are looking for and only when more
911 sets are found in the insn, we check them. */
914 if (find_reg_note (insn, REG_UNUSED, SET_DEST (set))
915 && !side_effects_p (set))
921 set = sub, set_verified = 0;
922 else if (!find_reg_note (insn, REG_UNUSED, SET_DEST (sub))
923 || side_effects_p (sub))
935 /* Given an INSN, return nonzero if it has more than one SET, else return
945 /* INSN must be an insn. */
949 /* Only a PARALLEL can have multiple SETs. */
950 if (GET_CODE (PATTERN (insn)) == PARALLEL)
952 for (i = 0, found = 0; i < XVECLEN (PATTERN (insn), 0); i++)
953 if (GET_CODE (XVECEXP (PATTERN (insn), 0, i)) == SET)
955 /* If we have already found a SET, then return now. */
963 /* Either zero or one SET. */
967 /* Return the last thing that X was assigned from before *PINSN. If VALID_TO
968 is not NULL_RTX then verify that the object is not modified up to VALID_TO.
969 If the object was modified, if we hit a partial assignment to X, or hit a
970 CODE_LABEL first, return X. If we found an assignment, update *PINSN to
971 point to it. ALLOW_HWREG is set to 1 if hardware registers are allowed to
975 find_last_value (x, pinsn, valid_to, allow_hwreg)
983 for (p = PREV_INSN (*pinsn); p && GET_CODE (p) != CODE_LABEL;
987 rtx set = single_set (p);
988 rtx note = find_reg_note (p, REG_EQUAL, NULL_RTX);
990 if (set && rtx_equal_p (x, SET_DEST (set)))
992 rtx src = SET_SRC (set);
994 if (note && GET_CODE (XEXP (note, 0)) != EXPR_LIST)
995 src = XEXP (note, 0);
997 if ((valid_to == NULL_RTX
998 || ! modified_between_p (src, PREV_INSN (p), valid_to))
999 /* Reject hard registers because we don't usually want
1000 to use them; we'd rather use a pseudo. */
1001 && (! (GET_CODE (src) == REG
1002 && REGNO (src) < FIRST_PSEUDO_REGISTER) || allow_hwreg))
1009 /* If set in non-simple way, we don't have a value. */
1010 if (reg_set_p (x, p))
1017 /* Return nonzero if register in range [REGNO, ENDREGNO)
1018 appears either explicitly or implicitly in X
1019 other than being stored into.
1021 References contained within the substructure at LOC do not count.
1022 LOC may be zero, meaning don't ignore anything. */
1025 refers_to_regno_p (regno, endregno, x, loc)
1026 unsigned int regno, endregno;
1031 unsigned int x_regno;
1036 /* The contents of a REG_NONNEG note is always zero, so we must come here
1037 upon repeat in case the last REG_NOTE is a REG_NONNEG note. */
1041 code = GET_CODE (x);
1046 x_regno = REGNO (x);
1048 /* If we modifying the stack, frame, or argument pointer, it will
1049 clobber a virtual register. In fact, we could be more precise,
1050 but it isn't worth it. */
1051 if ((x_regno == STACK_POINTER_REGNUM
1052 #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
1053 || x_regno == ARG_POINTER_REGNUM
1055 || x_regno == FRAME_POINTER_REGNUM)
1056 && regno >= FIRST_VIRTUAL_REGISTER && regno <= LAST_VIRTUAL_REGISTER)
1059 return (endregno > x_regno
1060 && regno < x_regno + (x_regno < FIRST_PSEUDO_REGISTER
1061 ? HARD_REGNO_NREGS (x_regno, GET_MODE (x))
1065 /* If this is a SUBREG of a hard reg, we can see exactly which
1066 registers are being modified. Otherwise, handle normally. */
1067 if (GET_CODE (SUBREG_REG (x)) == REG
1068 && REGNO (SUBREG_REG (x)) < FIRST_PSEUDO_REGISTER)
1070 unsigned int inner_regno = REGNO (SUBREG_REG (x)) + SUBREG_WORD (x);
1071 unsigned int inner_endregno
1072 = inner_regno + (inner_regno < FIRST_PSEUDO_REGISTER
1073 ? HARD_REGNO_NREGS (regno, GET_MODE (x)) : 1);
1075 return endregno > inner_regno && regno < inner_endregno;
1081 if (&SET_DEST (x) != loc
1082 /* Note setting a SUBREG counts as referring to the REG it is in for
1083 a pseudo but not for hard registers since we can
1084 treat each word individually. */
1085 && ((GET_CODE (SET_DEST (x)) == SUBREG
1086 && loc != &SUBREG_REG (SET_DEST (x))
1087 && GET_CODE (SUBREG_REG (SET_DEST (x))) == REG
1088 && REGNO (SUBREG_REG (SET_DEST (x))) >= FIRST_PSEUDO_REGISTER
1089 && refers_to_regno_p (regno, endregno,
1090 SUBREG_REG (SET_DEST (x)), loc))
1091 || (GET_CODE (SET_DEST (x)) != REG
1092 && refers_to_regno_p (regno, endregno, SET_DEST (x), loc))))
1095 if (code == CLOBBER || loc == &SET_SRC (x))
1104 /* X does not match, so try its subexpressions. */
1106 fmt = GET_RTX_FORMAT (code);
1107 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
1109 if (fmt[i] == 'e' && loc != &XEXP (x, i))
1117 if (refers_to_regno_p (regno, endregno, XEXP (x, i), loc))
1120 else if (fmt[i] == 'E')
1123 for (j = XVECLEN (x, i) - 1; j >=0; j--)
1124 if (loc != &XVECEXP (x, i, j)
1125 && refers_to_regno_p (regno, endregno, XVECEXP (x, i, j), loc))
1132 /* Nonzero if modifying X will affect IN. If X is a register or a SUBREG,
1133 we check if any register number in X conflicts with the relevant register
1134 numbers. If X is a constant, return 0. If X is a MEM, return 1 iff IN
1135 contains a MEM (we don't bother checking for memory addresses that can't
1136 conflict because we expect this to be a rare case. */
1139 reg_overlap_mentioned_p (x, in)
1142 unsigned int regno, endregno;
1144 /* Overly conservative. */
1145 if (GET_CODE (x) == STRICT_LOW_PART)
1148 /* If either argument is a constant, then modifying X can not affect IN. */
1149 if (CONSTANT_P (x) || CONSTANT_P (in))
1152 switch (GET_CODE (x))
1155 regno = REGNO (SUBREG_REG (x));
1156 if (regno < FIRST_PSEUDO_REGISTER)
1157 regno += SUBREG_WORD (x);
1163 endregno = regno + (regno < FIRST_PSEUDO_REGISTER
1164 ? HARD_REGNO_NREGS (regno, GET_MODE (x)) : 1);
1165 return refers_to_regno_p (regno, endregno, in, NULL_PTR);
1172 if (GET_CODE (in) == MEM)
1175 fmt = GET_RTX_FORMAT (GET_CODE (in));
1176 for (i = GET_RTX_LENGTH (GET_CODE (in)) - 1; i >= 0; i--)
1177 if (fmt[i] == 'e' && reg_overlap_mentioned_p (x, XEXP (in, i)))
1186 return reg_mentioned_p (x, in);
1192 /* If any register in here refers to it we return true. */
1193 for (i = XVECLEN (x, 0) - 1; i >= 0; i--)
1194 if (XEXP (XVECEXP (x, 0, i), 0) != 0
1195 && reg_overlap_mentioned_p (XEXP (XVECEXP (x, 0, i), 0), in))
1207 /* Return the last value to which REG was set prior to INSN. If we can't
1208 find it easily, return 0.
1210 We only return a REG, SUBREG, or constant because it is too hard to
1211 check if a MEM remains unchanged. */
1214 reg_set_last (x, insn)
1218 rtx orig_insn = insn;
1220 /* Scan backwards until reg_set_last_1 changed one of the above flags.
1221 Stop when we reach a label or X is a hard reg and we reach a
1222 CALL_INSN (if reg_set_last_last_regno is a hard reg).
1224 If we find a set of X, ensure that its SET_SRC remains unchanged. */
1226 /* We compare with <= here, because reg_set_last_last_regno
1227 is actually the number of the first reg *not* in X. */
1229 insn && GET_CODE (insn) != CODE_LABEL
1230 && ! (GET_CODE (insn) == CALL_INSN
1231 && REGNO (x) <= FIRST_PSEUDO_REGISTER);
1232 insn = PREV_INSN (insn))
1235 rtx set = set_of (x, insn);
1236 /* OK, this function modify our register. See if we understand it. */
1240 if (GET_CODE (set) != SET || SET_DEST (set) != x)
1242 last_value = SET_SRC (x);
1243 if (CONSTANT_P (last_value)
1244 || ((GET_CODE (last_value) == REG
1245 || GET_CODE (last_value) == SUBREG)
1246 && ! reg_set_between_p (last_value,
1257 /* Call FUN on each register or MEM that is stored into or clobbered by X.
1258 (X would be the pattern of an insn).
1259 FUN receives two arguments:
1260 the REG, MEM, CC0 or PC being stored in or clobbered,
1261 the SET or CLOBBER rtx that does the store.
1263 If the item being stored in or clobbered is a SUBREG of a hard register,
1264 the SUBREG will be passed. */
1267 note_stores (x, fun, data)
1269 void (*fun) PARAMS ((rtx, rtx, void *));
1274 if (GET_CODE (x) == COND_EXEC)
1275 x = COND_EXEC_CODE (x);
1277 if (GET_CODE (x) == SET || GET_CODE (x) == CLOBBER)
1279 register rtx dest = SET_DEST (x);
1281 while ((GET_CODE (dest) == SUBREG
1282 && (GET_CODE (SUBREG_REG (dest)) != REG
1283 || REGNO (SUBREG_REG (dest)) >= FIRST_PSEUDO_REGISTER))
1284 || GET_CODE (dest) == ZERO_EXTRACT
1285 || GET_CODE (dest) == SIGN_EXTRACT
1286 || GET_CODE (dest) == STRICT_LOW_PART)
1287 dest = XEXP (dest, 0);
1289 /* If we have a PARALLEL, SET_DEST is a list of EXPR_LIST expressions,
1290 each of whose first operand is a register. We can't know what
1291 precisely is being set in these cases, so make up a CLOBBER to pass
1293 if (GET_CODE (dest) == PARALLEL)
1295 for (i = XVECLEN (dest, 0) - 1; i >= 0; i--)
1296 if (XEXP (XVECEXP (dest, 0, i), 0) != 0)
1297 (*fun) (XEXP (XVECEXP (dest, 0, i), 0),
1298 gen_rtx_CLOBBER (VOIDmode,
1299 XEXP (XVECEXP (dest, 0, i), 0)),
1303 (*fun) (dest, x, data);
1306 else if (GET_CODE (x) == PARALLEL)
1307 for (i = XVECLEN (x, 0) - 1; i >= 0; i--)
1308 note_stores (XVECEXP (x, 0, i), fun, data);
1311 /* Like notes_stores, but call FUN for each expression that is being
1312 referenced in PBODY, a pointer to the PATTERN of an insn. We only call
1313 FUN for each expression, not any interior subexpressions. FUN receives a
1314 pointer to the expression and the DATA passed to this function.
1316 Note that this is not quite the same test as that done in reg_referenced_p
1317 since that considers something as being referenced if it is being
1318 partially set, while we do not. */
1321 note_uses (pbody, fun, data)
1323 void (*fun) PARAMS ((rtx *, void *));
1329 switch (GET_CODE (body))
1332 (*fun) (&COND_EXEC_TEST (body), data);
1333 note_uses (&COND_EXEC_CODE (body), fun, data);
1337 for (i = XVECLEN (body, 0) - 1; i >= 0; i--)
1338 note_uses (&XVECEXP (body, 0, i), fun, data);
1342 (*fun) (&XEXP (body, 0), data);
1346 for (i = ASM_OPERANDS_INPUT_LENGTH (body) - 1; i >= 0; i--)
1347 (*fun) (&ASM_OPERANDS_INPUT (body, i), data);
1351 (*fun) (&TRAP_CONDITION (body), data);
1355 case UNSPEC_VOLATILE:
1356 for (i = XVECLEN (body, 0) - 1; i >= 0; i--)
1357 (*fun) (&XVECEXP (body, 0, i), data);
1361 if (GET_CODE (XEXP (body, 0)) == MEM)
1362 (*fun) (&XEXP (XEXP (body, 0), 0), data);
1367 rtx dest = SET_DEST (body);
1369 /* For sets we replace everything in source plus registers in memory
1370 expression in store and operands of a ZERO_EXTRACT. */
1371 (*fun) (&SET_SRC (body), data);
1373 if (GET_CODE (dest) == ZERO_EXTRACT)
1375 (*fun) (&XEXP (dest, 1), data);
1376 (*fun) (&XEXP (dest, 2), data);
1379 while (GET_CODE (dest) == SUBREG || GET_CODE (dest) == STRICT_LOW_PART)
1380 dest = XEXP (dest, 0);
1382 if (GET_CODE (dest) == MEM)
1383 (*fun) (&XEXP (dest, 0), data);
1388 /* All the other possibilities never store. */
1389 (*fun) (pbody, data);
1394 /* Return nonzero if X's old contents don't survive after INSN.
1395 This will be true if X is (cc0) or if X is a register and
1396 X dies in INSN or because INSN entirely sets X.
1398 "Entirely set" means set directly and not through a SUBREG,
1399 ZERO_EXTRACT or SIGN_EXTRACT, so no trace of the old contents remains.
1400 Likewise, REG_INC does not count.
1402 REG may be a hard or pseudo reg. Renumbering is not taken into account,
1403 but for this use that makes no difference, since regs don't overlap
1404 during their lifetimes. Therefore, this function may be used
1405 at any time after deaths have been computed (in flow.c).
1407 If REG is a hard reg that occupies multiple machine registers, this
1408 function will only return 1 if each of those registers will be replaced
1412 dead_or_set_p (insn, x)
1416 unsigned int regno, last_regno;
1419 /* Can't use cc0_rtx below since this file is used by genattrtab.c. */
1420 if (GET_CODE (x) == CC0)
1423 if (GET_CODE (x) != REG)
1427 last_regno = (regno >= FIRST_PSEUDO_REGISTER ? regno
1428 : regno + HARD_REGNO_NREGS (regno, GET_MODE (x)) - 1);
1430 for (i = regno; i <= last_regno; i++)
1431 if (! dead_or_set_regno_p (insn, i))
1437 /* Utility function for dead_or_set_p to check an individual register. Also
1438 called from flow.c. */
1441 dead_or_set_regno_p (insn, test_regno)
1443 unsigned int test_regno;
1445 unsigned int regno, endregno;
1448 /* See if there is a death note for something that includes TEST_REGNO. */
1449 if (find_regno_note (insn, REG_DEAD, test_regno))
1452 if (GET_CODE (insn) == CALL_INSN
1453 && find_regno_fusage (insn, CLOBBER, test_regno))
1456 pattern = PATTERN (insn);
1458 if (GET_CODE (pattern) == COND_EXEC)
1459 pattern = COND_EXEC_CODE (pattern);
1461 if (GET_CODE (pattern) == SET)
1463 rtx dest = SET_DEST (PATTERN (insn));
1465 /* A value is totally replaced if it is the destination or the
1466 destination is a SUBREG of REGNO that does not change the number of
1468 if (GET_CODE (dest) == SUBREG
1469 && (((GET_MODE_SIZE (GET_MODE (dest))
1470 + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
1471 == ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (dest)))
1472 + UNITS_PER_WORD - 1) / UNITS_PER_WORD)))
1473 dest = SUBREG_REG (dest);
1475 if (GET_CODE (dest) != REG)
1478 regno = REGNO (dest);
1479 endregno = (regno >= FIRST_PSEUDO_REGISTER ? regno + 1
1480 : regno + HARD_REGNO_NREGS (regno, GET_MODE (dest)));
1482 return (test_regno >= regno && test_regno < endregno);
1484 else if (GET_CODE (pattern) == PARALLEL)
1488 for (i = XVECLEN (pattern, 0) - 1; i >= 0; i--)
1490 rtx body = XVECEXP (pattern, 0, i);
1492 if (GET_CODE (body) == COND_EXEC)
1493 body = COND_EXEC_CODE (body);
1495 if (GET_CODE (body) == SET || GET_CODE (body) == CLOBBER)
1497 rtx dest = SET_DEST (body);
1499 if (GET_CODE (dest) == SUBREG
1500 && (((GET_MODE_SIZE (GET_MODE (dest))
1501 + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
1502 == ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (dest)))
1503 + UNITS_PER_WORD - 1) / UNITS_PER_WORD)))
1504 dest = SUBREG_REG (dest);
1506 if (GET_CODE (dest) != REG)
1509 regno = REGNO (dest);
1510 endregno = (regno >= FIRST_PSEUDO_REGISTER ? regno + 1
1511 : regno + HARD_REGNO_NREGS (regno, GET_MODE (dest)));
1513 if (test_regno >= regno && test_regno < endregno)
1522 /* Return the reg-note of kind KIND in insn INSN, if there is one.
1523 If DATUM is nonzero, look for one whose datum is DATUM. */
1526 find_reg_note (insn, kind, datum)
1533 /* Ignore anything that is not an INSN, JUMP_INSN or CALL_INSN. */
1534 if (! INSN_P (insn))
1537 for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
1538 if (REG_NOTE_KIND (link) == kind
1539 && (datum == 0 || datum == XEXP (link, 0)))
1544 /* Return the reg-note of kind KIND in insn INSN which applies to register
1545 number REGNO, if any. Return 0 if there is no such reg-note. Note that
1546 the REGNO of this NOTE need not be REGNO if REGNO is a hard register;
1547 it might be the case that the note overlaps REGNO. */
1550 find_regno_note (insn, kind, regno)
1557 /* Ignore anything that is not an INSN, JUMP_INSN or CALL_INSN. */
1558 if (! INSN_P (insn))
1561 for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
1562 if (REG_NOTE_KIND (link) == kind
1563 /* Verify that it is a register, so that scratch and MEM won't cause a
1565 && GET_CODE (XEXP (link, 0)) == REG
1566 && REGNO (XEXP (link, 0)) <= regno
1567 && ((REGNO (XEXP (link, 0))
1568 + (REGNO (XEXP (link, 0)) >= FIRST_PSEUDO_REGISTER ? 1
1569 : HARD_REGNO_NREGS (REGNO (XEXP (link, 0)),
1570 GET_MODE (XEXP (link, 0)))))
1576 /* Return a REG_EQUIV or REG_EQUAL note if insn has only a single set and
1580 find_reg_equal_equiv_note (insn)
1585 if (single_set (insn) == 0)
1587 else if ((note = find_reg_note (insn, REG_EQUIV, NULL_RTX)) != 0)
1590 return find_reg_note (insn, REG_EQUAL, NULL_RTX);
1593 /* Return true if DATUM, or any overlap of DATUM, of kind CODE is found
1594 in the CALL_INSN_FUNCTION_USAGE information of INSN. */
1597 find_reg_fusage (insn, code, datum)
1602 /* If it's not a CALL_INSN, it can't possibly have a
1603 CALL_INSN_FUNCTION_USAGE field, so don't bother checking. */
1604 if (GET_CODE (insn) != CALL_INSN)
1610 if (GET_CODE (datum) != REG)
1614 for (link = CALL_INSN_FUNCTION_USAGE (insn);
1616 link = XEXP (link, 1))
1617 if (GET_CODE (XEXP (link, 0)) == code
1618 && rtx_equal_p (datum, SET_DEST (XEXP (link, 0))))
1623 unsigned int regno = REGNO (datum);
1625 /* CALL_INSN_FUNCTION_USAGE information cannot contain references
1626 to pseudo registers, so don't bother checking. */
1628 if (regno < FIRST_PSEUDO_REGISTER)
1630 unsigned int end_regno
1631 = regno + HARD_REGNO_NREGS (regno, GET_MODE (datum));
1634 for (i = regno; i < end_regno; i++)
1635 if (find_regno_fusage (insn, code, i))
1643 /* Return true if REGNO, or any overlap of REGNO, of kind CODE is found
1644 in the CALL_INSN_FUNCTION_USAGE information of INSN. */
1647 find_regno_fusage (insn, code, regno)
1654 /* CALL_INSN_FUNCTION_USAGE information cannot contain references
1655 to pseudo registers, so don't bother checking. */
1657 if (regno >= FIRST_PSEUDO_REGISTER
1658 || GET_CODE (insn) != CALL_INSN )
1661 for (link = CALL_INSN_FUNCTION_USAGE (insn); link; link = XEXP (link, 1))
1663 unsigned int regnote;
1666 if (GET_CODE (op = XEXP (link, 0)) == code
1667 && GET_CODE (reg = XEXP (op, 0)) == REG
1668 && (regnote = REGNO (reg)) <= regno
1669 && regnote + HARD_REGNO_NREGS (regnote, GET_MODE (reg)) > regno)
1676 /* Remove register note NOTE from the REG_NOTES of INSN. */
1679 remove_note (insn, note)
1685 if (note == NULL_RTX)
1688 if (REG_NOTES (insn) == note)
1690 REG_NOTES (insn) = XEXP (note, 1);
1694 for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
1695 if (XEXP (link, 1) == note)
1697 XEXP (link, 1) = XEXP (note, 1);
1704 /* Search LISTP (an EXPR_LIST) for an entry whose first operand is NODE and
1705 remove that entry from the list if it is found.
1707 A simple equality test is used to determine if NODE matches. */
1710 remove_node_from_expr_list (node, listp)
1715 rtx prev = NULL_RTX;
1719 if (node == XEXP (temp, 0))
1721 /* Splice the node out of the list. */
1723 XEXP (prev, 1) = XEXP (temp, 1);
1725 *listp = XEXP (temp, 1);
1731 temp = XEXP (temp, 1);
1735 /* Nonzero if X contains any volatile instructions. These are instructions
1736 which may cause unpredictable machine state instructions, and thus no
1737 instructions should be moved or combined across them. This includes
1738 only volatile asms and UNSPEC_VOLATILE instructions. */
1744 register RTX_CODE code;
1746 code = GET_CODE (x);
1766 case UNSPEC_VOLATILE:
1767 /* case TRAP_IF: This isn't clear yet. */
1771 if (MEM_VOLATILE_P (x))
1778 /* Recursively scan the operands of this expression. */
1781 register const char *fmt = GET_RTX_FORMAT (code);
1784 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
1788 if (volatile_insn_p (XEXP (x, i)))
1791 else if (fmt[i] == 'E')
1794 for (j = 0; j < XVECLEN (x, i); j++)
1795 if (volatile_insn_p (XVECEXP (x, i, j)))
1803 /* Nonzero if X contains any volatile memory references
1804 UNSPEC_VOLATILE operations or volatile ASM_OPERANDS expressions. */
1810 register RTX_CODE code;
1812 code = GET_CODE (x);
1831 case UNSPEC_VOLATILE:
1832 /* case TRAP_IF: This isn't clear yet. */
1837 if (MEM_VOLATILE_P (x))
1844 /* Recursively scan the operands of this expression. */
1847 register const char *fmt = GET_RTX_FORMAT (code);
1850 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
1854 if (volatile_refs_p (XEXP (x, i)))
1857 else if (fmt[i] == 'E')
1860 for (j = 0; j < XVECLEN (x, i); j++)
1861 if (volatile_refs_p (XVECEXP (x, i, j)))
1869 /* Similar to above, except that it also rejects register pre- and post-
1876 register RTX_CODE code;
1878 code = GET_CODE (x);
1896 /* Reject CLOBBER with a non-VOID mode. These are made by combine.c
1897 when some combination can't be done. If we see one, don't think
1898 that we can simplify the expression. */
1899 return (GET_MODE (x) != VOIDmode);
1908 case UNSPEC_VOLATILE:
1909 /* case TRAP_IF: This isn't clear yet. */
1914 if (MEM_VOLATILE_P (x))
1921 /* Recursively scan the operands of this expression. */
1924 register const char *fmt = GET_RTX_FORMAT (code);
1927 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
1931 if (side_effects_p (XEXP (x, i)))
1934 else if (fmt[i] == 'E')
1937 for (j = 0; j < XVECLEN (x, i); j++)
1938 if (side_effects_p (XVECEXP (x, i, j)))
1946 /* Return nonzero if evaluating rtx X might cause a trap. */
1958 code = GET_CODE (x);
1961 /* Handle these cases quickly. */
1974 case UNSPEC_VOLATILE:
1979 return MEM_VOLATILE_P (x);
1981 /* Memory ref can trap unless it's a static var or a stack slot. */
1983 return rtx_addr_can_trap_p (XEXP (x, 0));
1985 /* Division by a non-constant might trap. */
1990 if (! CONSTANT_P (XEXP (x, 1))
1991 || GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT)
1993 /* This was const0_rtx, but by not using that,
1994 we can link this file into other programs. */
1995 if (GET_CODE (XEXP (x, 1)) == CONST_INT && INTVAL (XEXP (x, 1)) == 0)
2000 /* An EXPR_LIST is used to represent a function call. This
2001 certainly may trap. */
2009 /* Some floating point comparisons may trap. */
2010 /* ??? There is no machine independent way to check for tests that trap
2011 when COMPARE is used, though many targets do make this distinction.
2012 For instance, sparc uses CCFPE for compares which generate exceptions
2013 and CCFP for compares which do not generate exceptions. */
2014 if (GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT)
2016 /* But often the compare has some CC mode, so check operand
2018 if (GET_MODE_CLASS (GET_MODE (XEXP (x, 0))) == MODE_FLOAT
2019 || GET_MODE_CLASS (GET_MODE (XEXP (x, 1))) == MODE_FLOAT)
2025 /* These operations don't trap even with floating point. */
2029 /* Any floating arithmetic may trap. */
2030 if (GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT)
2034 fmt = GET_RTX_FORMAT (code);
2035 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
2039 if (may_trap_p (XEXP (x, i)))
2042 else if (fmt[i] == 'E')
2045 for (j = 0; j < XVECLEN (x, i); j++)
2046 if (may_trap_p (XVECEXP (x, i, j)))
2053 /* Return nonzero if X contains a comparison that is not either EQ or NE,
2054 i.e., an inequality. */
2057 inequality_comparisons_p (x)
2060 register const char *fmt;
2061 register int len, i;
2062 register enum rtx_code code = GET_CODE (x);
2091 len = GET_RTX_LENGTH (code);
2092 fmt = GET_RTX_FORMAT (code);
2094 for (i = 0; i < len; i++)
2098 if (inequality_comparisons_p (XEXP (x, i)))
2101 else if (fmt[i] == 'E')
2104 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
2105 if (inequality_comparisons_p (XVECEXP (x, i, j)))
2113 /* Replace any occurrence of FROM in X with TO. The function does
2114 not enter into CONST_DOUBLE for the replace.
2116 Note that copying is not done so X must not be shared unless all copies
2117 are to be modified. */
2120 replace_rtx (x, from, to)
2124 register const char *fmt;
2126 /* The following prevents loops occurrence when we change MEM in
2127 CONST_DOUBLE onto the same CONST_DOUBLE. */
2128 if (x != 0 && GET_CODE (x) == CONST_DOUBLE)
2134 /* Allow this function to make replacements in EXPR_LISTs. */
2138 fmt = GET_RTX_FORMAT (GET_CODE (x));
2139 for (i = GET_RTX_LENGTH (GET_CODE (x)) - 1; i >= 0; i--)
2142 XEXP (x, i) = replace_rtx (XEXP (x, i), from, to);
2143 else if (fmt[i] == 'E')
2144 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
2145 XVECEXP (x, i, j) = replace_rtx (XVECEXP (x, i, j), from, to);
2151 /* Throughout the rtx X, replace many registers according to REG_MAP.
2152 Return the replacement for X (which may be X with altered contents).
2153 REG_MAP[R] is the replacement for register R, or 0 for don't replace.
2154 NREGS is the length of REG_MAP; regs >= NREGS are not mapped.
2156 We only support REG_MAP entries of REG or SUBREG. Also, hard registers
2157 should not be mapped to pseudos or vice versa since validate_change
2160 If REPLACE_DEST is 1, replacements are also done in destinations;
2161 otherwise, only sources are replaced. */
2164 replace_regs (x, reg_map, nregs, replace_dest)
2170 register enum rtx_code code;
2172 register const char *fmt;
2177 code = GET_CODE (x);
2191 /* Verify that the register has an entry before trying to access it. */
2192 if (REGNO (x) < nregs && reg_map[REGNO (x)] != 0)
2194 /* SUBREGs can't be shared. Always return a copy to ensure that if
2195 this replacement occurs more than once then each instance will
2196 get distinct rtx. */
2197 if (GET_CODE (reg_map[REGNO (x)]) == SUBREG)
2198 return copy_rtx (reg_map[REGNO (x)]);
2199 return reg_map[REGNO (x)];
2204 /* Prevent making nested SUBREGs. */
2205 if (GET_CODE (SUBREG_REG (x)) == REG && REGNO (SUBREG_REG (x)) < nregs
2206 && reg_map[REGNO (SUBREG_REG (x))] != 0
2207 && GET_CODE (reg_map[REGNO (SUBREG_REG (x))]) == SUBREG)
2209 rtx map_val = reg_map[REGNO (SUBREG_REG (x))];
2210 rtx map_inner = SUBREG_REG (map_val);
2212 if (GET_MODE (x) == GET_MODE (map_inner))
2216 /* We cannot call gen_rtx here since we may be linked with
2218 /* Let's try clobbering the incoming SUBREG and see
2219 if this is really safe. */
2220 SUBREG_REG (x) = map_inner;
2221 SUBREG_WORD (x) += SUBREG_WORD (map_val);
2224 rtx new = rtx_alloc (SUBREG);
2225 PUT_MODE (new, GET_MODE (x));
2226 SUBREG_REG (new) = map_inner;
2227 SUBREG_WORD (new) = SUBREG_WORD (x) + SUBREG_WORD (map_val);
2235 SET_DEST (x) = replace_regs (SET_DEST (x), reg_map, nregs, 0);
2237 else if (GET_CODE (SET_DEST (x)) == MEM
2238 || GET_CODE (SET_DEST (x)) == STRICT_LOW_PART)
2239 /* Even if we are not to replace destinations, replace register if it
2240 is CONTAINED in destination (destination is memory or
2241 STRICT_LOW_PART). */
2242 XEXP (SET_DEST (x), 0) = replace_regs (XEXP (SET_DEST (x), 0),
2244 else if (GET_CODE (SET_DEST (x)) == ZERO_EXTRACT)
2245 /* Similarly, for ZERO_EXTRACT we replace all operands. */
2248 SET_SRC (x) = replace_regs (SET_SRC (x), reg_map, nregs, 0);
2255 fmt = GET_RTX_FORMAT (code);
2256 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
2259 XEXP (x, i) = replace_regs (XEXP (x, i), reg_map, nregs, replace_dest);
2260 else if (fmt[i] == 'E')
2263 for (j = 0; j < XVECLEN (x, i); j++)
2264 XVECEXP (x, i, j) = replace_regs (XVECEXP (x, i, j), reg_map,
2265 nregs, replace_dest);
2271 /* A subroutine of computed_jump_p, return 1 if X contains a REG or MEM or
2272 constant that is not in the constant pool and not in the condition
2273 of an IF_THEN_ELSE. */
2276 computed_jump_p_1 (x)
2279 enum rtx_code code = GET_CODE (x);
2297 return ! (GET_CODE (XEXP (x, 0)) == SYMBOL_REF
2298 && CONSTANT_POOL_ADDRESS_P (XEXP (x, 0)));
2301 return (computed_jump_p_1 (XEXP (x, 1))
2302 || computed_jump_p_1 (XEXP (x, 2)));
2308 fmt = GET_RTX_FORMAT (code);
2309 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
2312 && computed_jump_p_1 (XEXP (x, i)))
2315 else if (fmt[i] == 'E')
2316 for (j = 0; j < XVECLEN (x, i); j++)
2317 if (computed_jump_p_1 (XVECEXP (x, i, j)))
2324 /* Return nonzero if INSN is an indirect jump (aka computed jump).
2326 Tablejumps and casesi insns are not considered indirect jumps;
2327 we can recognize them by a (use (label_ref)). */
2330 computed_jump_p (insn)
2334 if (GET_CODE (insn) == JUMP_INSN)
2336 rtx pat = PATTERN (insn);
2338 if (find_reg_note (insn, REG_LABEL, NULL_RTX))
2340 else if (GET_CODE (pat) == PARALLEL)
2342 int len = XVECLEN (pat, 0);
2343 int has_use_labelref = 0;
2345 for (i = len - 1; i >= 0; i--)
2346 if (GET_CODE (XVECEXP (pat, 0, i)) == USE
2347 && (GET_CODE (XEXP (XVECEXP (pat, 0, i), 0))
2349 has_use_labelref = 1;
2351 if (! has_use_labelref)
2352 for (i = len - 1; i >= 0; i--)
2353 if (GET_CODE (XVECEXP (pat, 0, i)) == SET
2354 && SET_DEST (XVECEXP (pat, 0, i)) == pc_rtx
2355 && computed_jump_p_1 (SET_SRC (XVECEXP (pat, 0, i))))
2358 else if (GET_CODE (pat) == SET
2359 && SET_DEST (pat) == pc_rtx
2360 && computed_jump_p_1 (SET_SRC (pat)))
2366 /* Traverse X via depth-first search, calling F for each
2367 sub-expression (including X itself). F is also passed the DATA.
2368 If F returns -1, do not traverse sub-expressions, but continue
2369 traversing the rest of the tree. If F ever returns any other
2370 non-zero value, stop the traversal, and return the value returned
2371 by F. Otherwise, return 0. This function does not traverse inside
2372 tree structure that contains RTX_EXPRs, or into sub-expressions
2373 whose format code is `0' since it is not known whether or not those
2374 codes are actually RTL.
2376 This routine is very general, and could (should?) be used to
2377 implement many of the other routines in this file. */
2380 for_each_rtx (x, f, data)
2391 result = (*f)(x, data);
2393 /* Do not traverse sub-expressions. */
2395 else if (result != 0)
2396 /* Stop the traversal. */
2400 /* There are no sub-expressions. */
2403 length = GET_RTX_LENGTH (GET_CODE (*x));
2404 format = GET_RTX_FORMAT (GET_CODE (*x));
2406 for (i = 0; i < length; ++i)
2411 result = for_each_rtx (&XEXP (*x, i), f, data);
2418 if (XVEC (*x, i) != 0)
2421 for (j = 0; j < XVECLEN (*x, i); ++j)
2423 result = for_each_rtx (&XVECEXP (*x, i, j), f, data);
2431 /* Nothing to do. */
2440 /* Searches X for any reference to REGNO, returning the rtx of the
2441 reference found if any. Otherwise, returns NULL_RTX. */
2444 regno_use_in (regno, x)
2448 register const char *fmt;
2452 if (GET_CODE (x) == REG && REGNO (x) == regno)
2455 fmt = GET_RTX_FORMAT (GET_CODE (x));
2456 for (i = GET_RTX_LENGTH (GET_CODE (x)) - 1; i >= 0; i--)
2460 if ((tem = regno_use_in (regno, XEXP (x, i))))
2463 else if (fmt[i] == 'E')
2464 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
2465 if ((tem = regno_use_in (regno , XVECEXP (x, i, j))))
2473 /* Return 1 if X is an autoincrement side effect and the register is
2474 not the stack pointer. */
2479 switch (GET_CODE (x))
2487 /* There are no REG_INC notes for SP. */
2488 if (XEXP (x, 0) != stack_pointer_rtx)
2496 /* Return 1 if the sequence of instructions beginning with FROM and up
2497 to and including TO is safe to move. If NEW_TO is non-NULL, and
2498 the sequence is not already safe to move, but can be easily
2499 extended to a sequence which is safe, then NEW_TO will point to the
2500 end of the extended sequence.
2502 For now, this function only checks that the region contains whole
2503 exception regions, but it could be extended to check additional
2504 conditions as well. */
2507 insns_safe_to_move_p (from, to, new_to)
2512 int eh_region_count = 0;
2516 /* By default, assume the end of the region will be what was
2523 if (GET_CODE (r) == NOTE)
2525 switch (NOTE_LINE_NUMBER (r))
2527 case NOTE_INSN_EH_REGION_BEG:
2531 case NOTE_INSN_EH_REGION_END:
2532 if (eh_region_count == 0)
2533 /* This sequence of instructions contains the end of
2534 an exception region, but not he beginning. Moving
2535 it will cause chaos. */
2546 /* If we've passed TO, and we see a non-note instruction, we
2547 can't extend the sequence to a movable sequence. */
2553 /* It's OK to move the sequence if there were matched sets of
2554 exception region notes. */
2555 return eh_region_count == 0;
2560 /* It's OK to move the sequence if there were matched sets of
2561 exception region notes. */
2562 if (past_to_p && eh_region_count == 0)
2568 /* Go to the next instruction. */
2575 /* Return non-zero if IN contains a piece of rtl that has the address LOC */
2577 loc_mentioned_in_p (loc, in)
2580 enum rtx_code code = GET_CODE (in);
2581 const char *fmt = GET_RTX_FORMAT (code);
2584 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
2586 if (loc == &in->fld[i].rtx)
2590 if (loc_mentioned_in_p (loc, XEXP (in, i)))
2593 else if (fmt[i] == 'E')
2594 for (j = XVECLEN (in, i) - 1; j >= 0; j--)
2595 if (loc_mentioned_in_p (loc, XVECEXP (in, i, j)))