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 it is related specifically to operand 1)
167 during alias analysis. */
168 return (! for_alias && rtx_varies_p (XEXP (x, 0), for_alias))
169 || rtx_varies_p (XEXP (x, 1), for_alias);
172 if (MEM_VOLATILE_P (x))
181 fmt = GET_RTX_FORMAT (code);
182 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
185 if (rtx_varies_p (XEXP (x, i), for_alias))
188 else if (fmt[i] == 'E')
191 for (j = 0; j < XVECLEN (x, i); j++)
192 if (rtx_varies_p (XVECEXP (x, i, j), for_alias))
199 /* Return 0 if the use of X as an address in a MEM can cause a trap. */
202 rtx_addr_can_trap_p (x)
205 register enum rtx_code code = GET_CODE (x);
211 /* SYMBOL_REF is problematic due to the possible presence of
212 a #pragma weak, but to say that loads from symbols can trap is
213 *very* costly. It's not at all clear what's best here. For
214 now, we ignore the impact of #pragma weak. */
218 /* As in rtx_varies_p, we have to use the actual rtx, not reg number. */
219 if (x == frame_pointer_rtx || x == hard_frame_pointer_rtx
220 || x == stack_pointer_rtx
221 /* The arg pointer varies if it is not a fixed register. */
222 || (x == arg_pointer_rtx && fixed_regs[ARG_POINTER_REGNUM]))
224 /* All of the virtual frame registers are stack references. */
225 if (REGNO (x) >= FIRST_VIRTUAL_REGISTER
226 && REGNO (x) <= LAST_VIRTUAL_REGISTER)
231 return rtx_addr_can_trap_p (XEXP (x, 0));
234 /* An address is assumed not to trap if it is an address that can't
235 trap plus a constant integer or it is the pic register plus a
237 return ! ((! rtx_addr_can_trap_p (XEXP (x, 0))
238 && GET_CODE (XEXP (x, 1)) == CONST_INT)
239 || (XEXP (x, 0) == pic_offset_table_rtx
240 && CONSTANT_P (XEXP (x, 1))));
244 return rtx_addr_can_trap_p (XEXP (x, 1));
251 return rtx_addr_can_trap_p (XEXP (x, 0));
257 /* If it isn't one of the case above, it can cause a trap. */
261 /* Return 1 if X refers to a memory location whose address
262 cannot be compared reliably with constant addresses,
263 or if X refers to a BLKmode memory object.
264 FOR_ALIAS is nonzero if we are called from alias analysis; if it is
265 zero, we are slightly more conservative. */
268 rtx_addr_varies_p (x, for_alias)
272 register enum rtx_code code;
274 register const char *fmt;
281 return GET_MODE (x) == BLKmode || rtx_varies_p (XEXP (x, 0), for_alias);
283 fmt = GET_RTX_FORMAT (code);
284 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
287 if (rtx_addr_varies_p (XEXP (x, i), for_alias))
290 else if (fmt[i] == 'E')
293 for (j = 0; j < XVECLEN (x, i); j++)
294 if (rtx_addr_varies_p (XVECEXP (x, i, j), for_alias))
300 /* Return the value of the integer term in X, if one is apparent;
302 Only obvious integer terms are detected.
303 This is used in cse.c with the `related_value' field.*/
309 if (GET_CODE (x) == CONST)
312 if (GET_CODE (x) == MINUS
313 && GET_CODE (XEXP (x, 1)) == CONST_INT)
314 return - INTVAL (XEXP (x, 1));
315 if (GET_CODE (x) == PLUS
316 && GET_CODE (XEXP (x, 1)) == CONST_INT)
317 return INTVAL (XEXP (x, 1));
321 /* If X is a constant, return the value sans apparent integer term;
323 Only obvious integer terms are detected. */
326 get_related_value (x)
329 if (GET_CODE (x) != CONST)
332 if (GET_CODE (x) == PLUS
333 && GET_CODE (XEXP (x, 1)) == CONST_INT)
335 else if (GET_CODE (x) == MINUS
336 && GET_CODE (XEXP (x, 1)) == CONST_INT)
341 /* Return the number of places FIND appears within X. If COUNT_DEST is
342 zero, we do not count occurrences inside the destination of a SET. */
345 count_occurrences (x, find, count_dest)
351 const char *format_ptr;
371 if (GET_CODE (find) == MEM && rtx_equal_p (x, find))
376 if (SET_DEST (x) == find && ! count_dest)
377 return count_occurrences (SET_SRC (x), find, count_dest);
384 format_ptr = GET_RTX_FORMAT (code);
387 for (i = 0; i < GET_RTX_LENGTH (code); i++)
389 switch (*format_ptr++)
392 count += count_occurrences (XEXP (x, i), find, count_dest);
396 for (j = 0; j < XVECLEN (x, i); j++)
397 count += count_occurrences (XVECEXP (x, i, j), find, count_dest);
404 /* Nonzero if register REG appears somewhere within IN.
405 Also works if REG is not a register; in this case it checks
406 for a subexpression of IN that is Lisp "equal" to REG. */
409 reg_mentioned_p (reg, in)
410 register rtx reg, in;
412 register const char *fmt;
414 register enum rtx_code code;
422 if (GET_CODE (in) == LABEL_REF)
423 return reg == XEXP (in, 0);
425 code = GET_CODE (in);
429 /* Compare registers by number. */
431 return GET_CODE (reg) == REG && REGNO (in) == REGNO (reg);
433 /* These codes have no constituent expressions
441 return GET_CODE (reg) == CONST_INT && INTVAL (in) == INTVAL (reg);
444 /* These are kept unique for a given value. */
451 if (GET_CODE (reg) == code && rtx_equal_p (reg, in))
454 fmt = GET_RTX_FORMAT (code);
456 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
461 for (j = XVECLEN (in, i) - 1; j >= 0; j--)
462 if (reg_mentioned_p (reg, XVECEXP (in, i, j)))
465 else if (fmt[i] == 'e'
466 && reg_mentioned_p (reg, XEXP (in, i)))
472 /* Return 1 if in between BEG and END, exclusive of BEG and END, there is
473 no CODE_LABEL insn. */
476 no_labels_between_p (beg, end)
480 for (p = NEXT_INSN (beg); p != end; p = NEXT_INSN (p))
481 if (GET_CODE (p) == CODE_LABEL)
486 /* Return 1 if in between BEG and END, exclusive of BEG and END, there is
487 no JUMP_INSN insn. */
490 no_jumps_between_p (beg, end)
494 for (p = NEXT_INSN (beg); p != end; p = NEXT_INSN (p))
495 if (GET_CODE (p) == JUMP_INSN)
500 /* Nonzero if register REG is used in an insn between
501 FROM_INSN and TO_INSN (exclusive of those two). */
504 reg_used_between_p (reg, from_insn, to_insn)
505 rtx reg, from_insn, to_insn;
509 if (from_insn == to_insn)
512 for (insn = NEXT_INSN (from_insn); insn != to_insn; insn = NEXT_INSN (insn))
514 && (reg_overlap_mentioned_p (reg, PATTERN (insn))
515 || (GET_CODE (insn) == CALL_INSN
516 && (find_reg_fusage (insn, USE, reg)
517 || find_reg_fusage (insn, CLOBBER, reg)))))
522 /* Nonzero if the old value of X, a register, is referenced in BODY. If X
523 is entirely replaced by a new value and the only use is as a SET_DEST,
524 we do not consider it a reference. */
527 reg_referenced_p (x, body)
533 switch (GET_CODE (body))
536 if (reg_overlap_mentioned_p (x, SET_SRC (body)))
539 /* If the destination is anything other than CC0, PC, a REG or a SUBREG
540 of a REG that occupies all of the REG, the insn references X if
541 it is mentioned in the destination. */
542 if (GET_CODE (SET_DEST (body)) != CC0
543 && GET_CODE (SET_DEST (body)) != PC
544 && GET_CODE (SET_DEST (body)) != REG
545 && ! (GET_CODE (SET_DEST (body)) == SUBREG
546 && GET_CODE (SUBREG_REG (SET_DEST (body))) == REG
547 && (((GET_MODE_SIZE (GET_MODE (SUBREG_REG (SET_DEST (body))))
548 + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD)
549 == ((GET_MODE_SIZE (GET_MODE (SET_DEST (body)))
550 + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD)))
551 && reg_overlap_mentioned_p (x, SET_DEST (body)))
556 for (i = ASM_OPERANDS_INPUT_LENGTH (body) - 1; i >= 0; i--)
557 if (reg_overlap_mentioned_p (x, ASM_OPERANDS_INPUT (body, i)))
564 return reg_overlap_mentioned_p (x, body);
567 return reg_overlap_mentioned_p (x, TRAP_CONDITION (body));
570 case UNSPEC_VOLATILE:
571 for (i = XVECLEN (body, 0) - 1; i >= 0; i--)
572 if (reg_overlap_mentioned_p (x, XVECEXP (body, 0, i)))
577 for (i = XVECLEN (body, 0) - 1; i >= 0; i--)
578 if (reg_referenced_p (x, XVECEXP (body, 0, i)))
583 if (GET_CODE (XEXP (body, 0)) == MEM)
584 if (reg_overlap_mentioned_p (x, XEXP (XEXP (body, 0), 0)))
589 if (reg_overlap_mentioned_p (x, COND_EXEC_TEST (body)))
591 return reg_referenced_p (x, COND_EXEC_CODE (body));
598 /* Nonzero if register REG is referenced in an insn between
599 FROM_INSN and TO_INSN (exclusive of those two). Sets of REG do
603 reg_referenced_between_p (reg, from_insn, to_insn)
604 rtx reg, from_insn, to_insn;
608 if (from_insn == to_insn)
611 for (insn = NEXT_INSN (from_insn); insn != to_insn; insn = NEXT_INSN (insn))
613 && (reg_referenced_p (reg, PATTERN (insn))
614 || (GET_CODE (insn) == CALL_INSN
615 && find_reg_fusage (insn, USE, reg))))
620 /* Nonzero if register REG is set or clobbered in an insn between
621 FROM_INSN and TO_INSN (exclusive of those two). */
624 reg_set_between_p (reg, from_insn, to_insn)
625 rtx reg, from_insn, to_insn;
629 if (from_insn == to_insn)
632 for (insn = NEXT_INSN (from_insn); insn != to_insn; insn = NEXT_INSN (insn))
633 if (INSN_P (insn) && reg_set_p (reg, insn))
638 /* Internals of reg_set_between_p. */
640 reg_set_p (reg, insn)
645 /* We can be passed an insn or part of one. If we are passed an insn,
646 check if a side-effect of the insn clobbers REG. */
649 if (FIND_REG_INC_NOTE (insn, reg)
650 || (GET_CODE (insn) == CALL_INSN
651 /* We'd like to test call_used_regs here, but rtlanal.c can't
652 reference that variable due to its use in genattrtab. So
653 we'll just be more conservative.
655 ??? Unless we could ensure that the CALL_INSN_FUNCTION_USAGE
656 information holds all clobbered registers. */
657 && ((GET_CODE (reg) == REG
658 && REGNO (reg) < FIRST_PSEUDO_REGISTER)
659 || GET_CODE (reg) == MEM
660 || find_reg_fusage (insn, CLOBBER, reg))))
663 body = PATTERN (insn);
666 return set_of (reg, insn) != NULL_RTX;
669 /* Similar to reg_set_between_p, but check all registers in X. Return 0
670 only if none of them are modified between START and END. Do not
671 consider non-registers one way or the other. */
674 regs_set_between_p (x, start, end)
678 enum rtx_code code = GET_CODE (x);
694 return reg_set_between_p (x, start, end);
700 fmt = GET_RTX_FORMAT (code);
701 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
703 if (fmt[i] == 'e' && regs_set_between_p (XEXP (x, i), start, end))
706 else if (fmt[i] == 'E')
707 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
708 if (regs_set_between_p (XVECEXP (x, i, j), start, end))
715 /* Similar to reg_set_between_p, but check all registers in X. Return 0
716 only if none of them are modified between START and END. Return 1 if
717 X contains a MEM; this routine does not perform any memory aliasing. */
720 modified_between_p (x, start, end)
724 enum rtx_code code = GET_CODE (x);
742 /* If the memory is not constant, assume it is modified. If it is
743 constant, we still have to check the address. */
744 if (! RTX_UNCHANGING_P (x))
749 return reg_set_between_p (x, start, end);
755 fmt = GET_RTX_FORMAT (code);
756 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
758 if (fmt[i] == 'e' && modified_between_p (XEXP (x, i), start, end))
761 else if (fmt[i] == 'E')
762 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
763 if (modified_between_p (XVECEXP (x, i, j), start, end))
770 /* Similar to reg_set_p, but check all registers in X. Return 0 only if none
771 of them are modified in INSN. Return 1 if X contains a MEM; this routine
772 does not perform any memory aliasing. */
775 modified_in_p (x, insn)
779 enum rtx_code code = GET_CODE (x);
797 /* If the memory is not constant, assume it is modified. If it is
798 constant, we still have to check the address. */
799 if (! RTX_UNCHANGING_P (x))
804 return reg_set_p (x, insn);
810 fmt = GET_RTX_FORMAT (code);
811 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
813 if (fmt[i] == 'e' && modified_in_p (XEXP (x, i), insn))
816 else if (fmt[i] == 'E')
817 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
818 if (modified_in_p (XVECEXP (x, i, j), insn))
825 /* Return true if anything in insn X is (anti,output,true) dependent on
826 anything in insn Y. */
829 insn_dependent_p (x, y)
834 if (! INSN_P (x) || ! INSN_P (y))
838 note_stores (PATTERN (x), insn_dependent_p_1, &tmp);
843 note_stores (PATTERN (y), insn_dependent_p_1, &tmp);
850 /* A helper routine for insn_dependent_p called through note_stores. */
853 insn_dependent_p_1 (x, pat, data)
855 rtx pat ATTRIBUTE_UNUSED;
858 rtx * pinsn = (rtx *) data;
860 if (*pinsn && reg_mentioned_p (x, *pinsn))
864 /* Helper function for set_of. */
872 set_of_1 (x, pat, data1)
877 struct set_of_data *data = (struct set_of_data *) (data1);
878 if (rtx_equal_p (x, data->pat)
879 || (GET_CODE (x) != MEM && reg_overlap_mentioned_p (data->pat, x)))
883 /* Give an INSN, return a SET or CLOBBER expression that does modify PAT
884 (eighter directly or via STRICT_LOW_PART and similar modifiers). */
889 struct set_of_data data;
890 data.found = NULL_RTX;
892 note_stores (INSN_P (insn) ? PATTERN (insn) : insn, set_of_1, &data);
896 /* Given an INSN, return a SET expression if this insn has only a single SET.
897 It may also have CLOBBERs, USEs, or SET whose output
898 will not be used, which we ignore. */
901 single_set_2 (insn, pat)
905 int set_verified = 1;
908 if (GET_CODE (pat) == PARALLEL)
910 for (i = 0; i < XVECLEN (pat, 0); i++)
912 rtx sub = XVECEXP (pat, 0, i);
913 switch (GET_CODE (sub))
920 /* We can consider insns having multiple sets, where all
921 but one are dead as single set insns. In common case
922 only single set is present in the pattern so we want
923 to avoid checking for REG_UNUSED notes unless neccesary.
925 When we reach set first time, we just expect this is
926 the single set we are looking for and only when more
927 sets are found in the insn, we check them. */
930 if (find_reg_note (insn, REG_UNUSED, SET_DEST (set))
931 && !side_effects_p (set))
937 set = sub, set_verified = 0;
938 else if (!find_reg_note (insn, REG_UNUSED, SET_DEST (sub))
939 || side_effects_p (sub))
951 /* Given an INSN, return nonzero if it has more than one SET, else return
961 /* INSN must be an insn. */
965 /* Only a PARALLEL can have multiple SETs. */
966 if (GET_CODE (PATTERN (insn)) == PARALLEL)
968 for (i = 0, found = 0; i < XVECLEN (PATTERN (insn), 0); i++)
969 if (GET_CODE (XVECEXP (PATTERN (insn), 0, i)) == SET)
971 /* If we have already found a SET, then return now. */
979 /* Either zero or one SET. */
983 /* Return the last thing that X was assigned from before *PINSN. If VALID_TO
984 is not NULL_RTX then verify that the object is not modified up to VALID_TO.
985 If the object was modified, if we hit a partial assignment to X, or hit a
986 CODE_LABEL first, return X. If we found an assignment, update *PINSN to
987 point to it. ALLOW_HWREG is set to 1 if hardware registers are allowed to
991 find_last_value (x, pinsn, valid_to, allow_hwreg)
999 for (p = PREV_INSN (*pinsn); p && GET_CODE (p) != CODE_LABEL;
1003 rtx set = single_set (p);
1004 rtx note = find_reg_note (p, REG_EQUAL, NULL_RTX);
1006 if (set && rtx_equal_p (x, SET_DEST (set)))
1008 rtx src = SET_SRC (set);
1010 if (note && GET_CODE (XEXP (note, 0)) != EXPR_LIST)
1011 src = XEXP (note, 0);
1013 if ((valid_to == NULL_RTX
1014 || ! modified_between_p (src, PREV_INSN (p), valid_to))
1015 /* Reject hard registers because we don't usually want
1016 to use them; we'd rather use a pseudo. */
1017 && (! (GET_CODE (src) == REG
1018 && REGNO (src) < FIRST_PSEUDO_REGISTER) || allow_hwreg))
1025 /* If set in non-simple way, we don't have a value. */
1026 if (reg_set_p (x, p))
1033 /* Return nonzero if register in range [REGNO, ENDREGNO)
1034 appears either explicitly or implicitly in X
1035 other than being stored into.
1037 References contained within the substructure at LOC do not count.
1038 LOC may be zero, meaning don't ignore anything. */
1041 refers_to_regno_p (regno, endregno, x, loc)
1042 unsigned int regno, endregno;
1047 unsigned int x_regno;
1052 /* The contents of a REG_NONNEG note is always zero, so we must come here
1053 upon repeat in case the last REG_NOTE is a REG_NONNEG note. */
1057 code = GET_CODE (x);
1062 x_regno = REGNO (x);
1064 /* If we modifying the stack, frame, or argument pointer, it will
1065 clobber a virtual register. In fact, we could be more precise,
1066 but it isn't worth it. */
1067 if ((x_regno == STACK_POINTER_REGNUM
1068 #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
1069 || x_regno == ARG_POINTER_REGNUM
1071 || x_regno == FRAME_POINTER_REGNUM)
1072 && regno >= FIRST_VIRTUAL_REGISTER && regno <= LAST_VIRTUAL_REGISTER)
1075 return (endregno > x_regno
1076 && regno < x_regno + (x_regno < FIRST_PSEUDO_REGISTER
1077 ? HARD_REGNO_NREGS (x_regno, GET_MODE (x))
1081 /* If this is a SUBREG of a hard reg, we can see exactly which
1082 registers are being modified. Otherwise, handle normally. */
1083 if (GET_CODE (SUBREG_REG (x)) == REG
1084 && REGNO (SUBREG_REG (x)) < FIRST_PSEUDO_REGISTER)
1086 unsigned int inner_regno = REGNO (SUBREG_REG (x)) + SUBREG_WORD (x);
1087 unsigned int inner_endregno
1088 = inner_regno + (inner_regno < FIRST_PSEUDO_REGISTER
1089 ? HARD_REGNO_NREGS (regno, GET_MODE (x)) : 1);
1091 return endregno > inner_regno && regno < inner_endregno;
1097 if (&SET_DEST (x) != loc
1098 /* Note setting a SUBREG counts as referring to the REG it is in for
1099 a pseudo but not for hard registers since we can
1100 treat each word individually. */
1101 && ((GET_CODE (SET_DEST (x)) == SUBREG
1102 && loc != &SUBREG_REG (SET_DEST (x))
1103 && GET_CODE (SUBREG_REG (SET_DEST (x))) == REG
1104 && REGNO (SUBREG_REG (SET_DEST (x))) >= FIRST_PSEUDO_REGISTER
1105 && refers_to_regno_p (regno, endregno,
1106 SUBREG_REG (SET_DEST (x)), loc))
1107 || (GET_CODE (SET_DEST (x)) != REG
1108 && refers_to_regno_p (regno, endregno, SET_DEST (x), loc))))
1111 if (code == CLOBBER || loc == &SET_SRC (x))
1120 /* X does not match, so try its subexpressions. */
1122 fmt = GET_RTX_FORMAT (code);
1123 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
1125 if (fmt[i] == 'e' && loc != &XEXP (x, i))
1133 if (refers_to_regno_p (regno, endregno, XEXP (x, i), loc))
1136 else if (fmt[i] == 'E')
1139 for (j = XVECLEN (x, i) - 1; j >=0; j--)
1140 if (loc != &XVECEXP (x, i, j)
1141 && refers_to_regno_p (regno, endregno, XVECEXP (x, i, j), loc))
1148 /* Nonzero if modifying X will affect IN. If X is a register or a SUBREG,
1149 we check if any register number in X conflicts with the relevant register
1150 numbers. If X is a constant, return 0. If X is a MEM, return 1 iff IN
1151 contains a MEM (we don't bother checking for memory addresses that can't
1152 conflict because we expect this to be a rare case. */
1155 reg_overlap_mentioned_p (x, in)
1158 unsigned int regno, endregno;
1160 /* Overly conservative. */
1161 if (GET_CODE (x) == STRICT_LOW_PART)
1164 /* If either argument is a constant, then modifying X can not affect IN. */
1165 if (CONSTANT_P (x) || CONSTANT_P (in))
1168 switch (GET_CODE (x))
1171 regno = REGNO (SUBREG_REG (x));
1172 if (regno < FIRST_PSEUDO_REGISTER)
1173 regno += SUBREG_WORD (x);
1179 endregno = regno + (regno < FIRST_PSEUDO_REGISTER
1180 ? HARD_REGNO_NREGS (regno, GET_MODE (x)) : 1);
1181 return refers_to_regno_p (regno, endregno, in, NULL_PTR);
1188 if (GET_CODE (in) == MEM)
1191 fmt = GET_RTX_FORMAT (GET_CODE (in));
1192 for (i = GET_RTX_LENGTH (GET_CODE (in)) - 1; i >= 0; i--)
1193 if (fmt[i] == 'e' && reg_overlap_mentioned_p (x, XEXP (in, i)))
1202 return reg_mentioned_p (x, in);
1208 /* If any register in here refers to it we return true. */
1209 for (i = XVECLEN (x, 0) - 1; i >= 0; i--)
1210 if (XEXP (XVECEXP (x, 0, i), 0) != 0
1211 && reg_overlap_mentioned_p (XEXP (XVECEXP (x, 0, i), 0), in))
1223 /* Return the last value to which REG was set prior to INSN. If we can't
1224 find it easily, return 0.
1226 We only return a REG, SUBREG, or constant because it is too hard to
1227 check if a MEM remains unchanged. */
1230 reg_set_last (x, insn)
1234 rtx orig_insn = insn;
1236 /* Scan backwards until reg_set_last_1 changed one of the above flags.
1237 Stop when we reach a label or X is a hard reg and we reach a
1238 CALL_INSN (if reg_set_last_last_regno is a hard reg).
1240 If we find a set of X, ensure that its SET_SRC remains unchanged. */
1242 /* We compare with <= here, because reg_set_last_last_regno
1243 is actually the number of the first reg *not* in X. */
1245 insn && GET_CODE (insn) != CODE_LABEL
1246 && ! (GET_CODE (insn) == CALL_INSN
1247 && REGNO (x) <= FIRST_PSEUDO_REGISTER);
1248 insn = PREV_INSN (insn))
1251 rtx set = set_of (x, insn);
1252 /* OK, this function modify our register. See if we understand it. */
1256 if (GET_CODE (set) != SET || SET_DEST (set) != x)
1258 last_value = SET_SRC (x);
1259 if (CONSTANT_P (last_value)
1260 || ((GET_CODE (last_value) == REG
1261 || GET_CODE (last_value) == SUBREG)
1262 && ! reg_set_between_p (last_value,
1273 /* Call FUN on each register or MEM that is stored into or clobbered by X.
1274 (X would be the pattern of an insn).
1275 FUN receives two arguments:
1276 the REG, MEM, CC0 or PC being stored in or clobbered,
1277 the SET or CLOBBER rtx that does the store.
1279 If the item being stored in or clobbered is a SUBREG of a hard register,
1280 the SUBREG will be passed. */
1283 note_stores (x, fun, data)
1285 void (*fun) PARAMS ((rtx, rtx, void *));
1290 if (GET_CODE (x) == COND_EXEC)
1291 x = COND_EXEC_CODE (x);
1293 if (GET_CODE (x) == SET || GET_CODE (x) == CLOBBER)
1295 register rtx dest = SET_DEST (x);
1297 while ((GET_CODE (dest) == SUBREG
1298 && (GET_CODE (SUBREG_REG (dest)) != REG
1299 || REGNO (SUBREG_REG (dest)) >= FIRST_PSEUDO_REGISTER))
1300 || GET_CODE (dest) == ZERO_EXTRACT
1301 || GET_CODE (dest) == SIGN_EXTRACT
1302 || GET_CODE (dest) == STRICT_LOW_PART)
1303 dest = XEXP (dest, 0);
1305 /* If we have a PARALLEL, SET_DEST is a list of EXPR_LIST expressions,
1306 each of whose first operand is a register. We can't know what
1307 precisely is being set in these cases, so make up a CLOBBER to pass
1309 if (GET_CODE (dest) == PARALLEL)
1311 for (i = XVECLEN (dest, 0) - 1; i >= 0; i--)
1312 if (XEXP (XVECEXP (dest, 0, i), 0) != 0)
1313 (*fun) (XEXP (XVECEXP (dest, 0, i), 0),
1314 gen_rtx_CLOBBER (VOIDmode,
1315 XEXP (XVECEXP (dest, 0, i), 0)),
1319 (*fun) (dest, x, data);
1322 else if (GET_CODE (x) == PARALLEL)
1323 for (i = XVECLEN (x, 0) - 1; i >= 0; i--)
1324 note_stores (XVECEXP (x, 0, i), fun, data);
1327 /* Like notes_stores, but call FUN for each expression that is being
1328 referenced in PBODY, a pointer to the PATTERN of an insn. We only call
1329 FUN for each expression, not any interior subexpressions. FUN receives a
1330 pointer to the expression and the DATA passed to this function.
1332 Note that this is not quite the same test as that done in reg_referenced_p
1333 since that considers something as being referenced if it is being
1334 partially set, while we do not. */
1337 note_uses (pbody, fun, data)
1339 void (*fun) PARAMS ((rtx *, void *));
1345 switch (GET_CODE (body))
1348 (*fun) (&COND_EXEC_TEST (body), data);
1349 note_uses (&COND_EXEC_CODE (body), fun, data);
1353 for (i = XVECLEN (body, 0) - 1; i >= 0; i--)
1354 note_uses (&XVECEXP (body, 0, i), fun, data);
1358 (*fun) (&XEXP (body, 0), data);
1362 for (i = ASM_OPERANDS_INPUT_LENGTH (body) - 1; i >= 0; i--)
1363 (*fun) (&ASM_OPERANDS_INPUT (body, i), data);
1367 (*fun) (&TRAP_CONDITION (body), data);
1371 case UNSPEC_VOLATILE:
1372 for (i = XVECLEN (body, 0) - 1; i >= 0; i--)
1373 (*fun) (&XVECEXP (body, 0, i), data);
1377 if (GET_CODE (XEXP (body, 0)) == MEM)
1378 (*fun) (&XEXP (XEXP (body, 0), 0), data);
1383 rtx dest = SET_DEST (body);
1385 /* For sets we replace everything in source plus registers in memory
1386 expression in store and operands of a ZERO_EXTRACT. */
1387 (*fun) (&SET_SRC (body), data);
1389 if (GET_CODE (dest) == ZERO_EXTRACT)
1391 (*fun) (&XEXP (dest, 1), data);
1392 (*fun) (&XEXP (dest, 2), data);
1395 while (GET_CODE (dest) == SUBREG || GET_CODE (dest) == STRICT_LOW_PART)
1396 dest = XEXP (dest, 0);
1398 if (GET_CODE (dest) == MEM)
1399 (*fun) (&XEXP (dest, 0), data);
1404 /* All the other possibilities never store. */
1405 (*fun) (pbody, data);
1410 /* Return nonzero if X's old contents don't survive after INSN.
1411 This will be true if X is (cc0) or if X is a register and
1412 X dies in INSN or because INSN entirely sets X.
1414 "Entirely set" means set directly and not through a SUBREG,
1415 ZERO_EXTRACT or SIGN_EXTRACT, so no trace of the old contents remains.
1416 Likewise, REG_INC does not count.
1418 REG may be a hard or pseudo reg. Renumbering is not taken into account,
1419 but for this use that makes no difference, since regs don't overlap
1420 during their lifetimes. Therefore, this function may be used
1421 at any time after deaths have been computed (in flow.c).
1423 If REG is a hard reg that occupies multiple machine registers, this
1424 function will only return 1 if each of those registers will be replaced
1428 dead_or_set_p (insn, x)
1432 unsigned int regno, last_regno;
1435 /* Can't use cc0_rtx below since this file is used by genattrtab.c. */
1436 if (GET_CODE (x) == CC0)
1439 if (GET_CODE (x) != REG)
1443 last_regno = (regno >= FIRST_PSEUDO_REGISTER ? regno
1444 : regno + HARD_REGNO_NREGS (regno, GET_MODE (x)) - 1);
1446 for (i = regno; i <= last_regno; i++)
1447 if (! dead_or_set_regno_p (insn, i))
1453 /* Utility function for dead_or_set_p to check an individual register. Also
1454 called from flow.c. */
1457 dead_or_set_regno_p (insn, test_regno)
1459 unsigned int test_regno;
1461 unsigned int regno, endregno;
1464 /* See if there is a death note for something that includes TEST_REGNO. */
1465 if (find_regno_note (insn, REG_DEAD, test_regno))
1468 if (GET_CODE (insn) == CALL_INSN
1469 && find_regno_fusage (insn, CLOBBER, test_regno))
1472 pattern = PATTERN (insn);
1474 if (GET_CODE (pattern) == COND_EXEC)
1475 pattern = COND_EXEC_CODE (pattern);
1477 if (GET_CODE (pattern) == SET)
1479 rtx dest = SET_DEST (PATTERN (insn));
1481 /* A value is totally replaced if it is the destination or the
1482 destination is a SUBREG of REGNO that does not change the number of
1484 if (GET_CODE (dest) == SUBREG
1485 && (((GET_MODE_SIZE (GET_MODE (dest))
1486 + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
1487 == ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (dest)))
1488 + UNITS_PER_WORD - 1) / UNITS_PER_WORD)))
1489 dest = SUBREG_REG (dest);
1491 if (GET_CODE (dest) != REG)
1494 regno = REGNO (dest);
1495 endregno = (regno >= FIRST_PSEUDO_REGISTER ? regno + 1
1496 : regno + HARD_REGNO_NREGS (regno, GET_MODE (dest)));
1498 return (test_regno >= regno && test_regno < endregno);
1500 else if (GET_CODE (pattern) == PARALLEL)
1504 for (i = XVECLEN (pattern, 0) - 1; i >= 0; i--)
1506 rtx body = XVECEXP (pattern, 0, i);
1508 if (GET_CODE (body) == COND_EXEC)
1509 body = COND_EXEC_CODE (body);
1511 if (GET_CODE (body) == SET || GET_CODE (body) == CLOBBER)
1513 rtx dest = SET_DEST (body);
1515 if (GET_CODE (dest) == SUBREG
1516 && (((GET_MODE_SIZE (GET_MODE (dest))
1517 + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
1518 == ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (dest)))
1519 + UNITS_PER_WORD - 1) / UNITS_PER_WORD)))
1520 dest = SUBREG_REG (dest);
1522 if (GET_CODE (dest) != REG)
1525 regno = REGNO (dest);
1526 endregno = (regno >= FIRST_PSEUDO_REGISTER ? regno + 1
1527 : regno + HARD_REGNO_NREGS (regno, GET_MODE (dest)));
1529 if (test_regno >= regno && test_regno < endregno)
1538 /* Return the reg-note of kind KIND in insn INSN, if there is one.
1539 If DATUM is nonzero, look for one whose datum is DATUM. */
1542 find_reg_note (insn, kind, datum)
1549 /* Ignore anything that is not an INSN, JUMP_INSN or CALL_INSN. */
1550 if (! INSN_P (insn))
1553 for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
1554 if (REG_NOTE_KIND (link) == kind
1555 && (datum == 0 || datum == XEXP (link, 0)))
1560 /* Return the reg-note of kind KIND in insn INSN which applies to register
1561 number REGNO, if any. Return 0 if there is no such reg-note. Note that
1562 the REGNO of this NOTE need not be REGNO if REGNO is a hard register;
1563 it might be the case that the note overlaps REGNO. */
1566 find_regno_note (insn, kind, regno)
1573 /* Ignore anything that is not an INSN, JUMP_INSN or CALL_INSN. */
1574 if (! INSN_P (insn))
1577 for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
1578 if (REG_NOTE_KIND (link) == kind
1579 /* Verify that it is a register, so that scratch and MEM won't cause a
1581 && GET_CODE (XEXP (link, 0)) == REG
1582 && REGNO (XEXP (link, 0)) <= regno
1583 && ((REGNO (XEXP (link, 0))
1584 + (REGNO (XEXP (link, 0)) >= FIRST_PSEUDO_REGISTER ? 1
1585 : HARD_REGNO_NREGS (REGNO (XEXP (link, 0)),
1586 GET_MODE (XEXP (link, 0)))))
1592 /* Return a REG_EQUIV or REG_EQUAL note if insn has only a single set and
1596 find_reg_equal_equiv_note (insn)
1601 if (single_set (insn) == 0)
1603 else if ((note = find_reg_note (insn, REG_EQUIV, NULL_RTX)) != 0)
1606 return find_reg_note (insn, REG_EQUAL, NULL_RTX);
1609 /* Return true if DATUM, or any overlap of DATUM, of kind CODE is found
1610 in the CALL_INSN_FUNCTION_USAGE information of INSN. */
1613 find_reg_fusage (insn, code, datum)
1618 /* If it's not a CALL_INSN, it can't possibly have a
1619 CALL_INSN_FUNCTION_USAGE field, so don't bother checking. */
1620 if (GET_CODE (insn) != CALL_INSN)
1626 if (GET_CODE (datum) != REG)
1630 for (link = CALL_INSN_FUNCTION_USAGE (insn);
1632 link = XEXP (link, 1))
1633 if (GET_CODE (XEXP (link, 0)) == code
1634 && rtx_equal_p (datum, SET_DEST (XEXP (link, 0))))
1639 unsigned int regno = REGNO (datum);
1641 /* CALL_INSN_FUNCTION_USAGE information cannot contain references
1642 to pseudo registers, so don't bother checking. */
1644 if (regno < FIRST_PSEUDO_REGISTER)
1646 unsigned int end_regno
1647 = regno + HARD_REGNO_NREGS (regno, GET_MODE (datum));
1650 for (i = regno; i < end_regno; i++)
1651 if (find_regno_fusage (insn, code, i))
1659 /* Return true if REGNO, or any overlap of REGNO, of kind CODE is found
1660 in the CALL_INSN_FUNCTION_USAGE information of INSN. */
1663 find_regno_fusage (insn, code, regno)
1670 /* CALL_INSN_FUNCTION_USAGE information cannot contain references
1671 to pseudo registers, so don't bother checking. */
1673 if (regno >= FIRST_PSEUDO_REGISTER
1674 || GET_CODE (insn) != CALL_INSN )
1677 for (link = CALL_INSN_FUNCTION_USAGE (insn); link; link = XEXP (link, 1))
1679 unsigned int regnote;
1682 if (GET_CODE (op = XEXP (link, 0)) == code
1683 && GET_CODE (reg = XEXP (op, 0)) == REG
1684 && (regnote = REGNO (reg)) <= regno
1685 && regnote + HARD_REGNO_NREGS (regnote, GET_MODE (reg)) > regno)
1692 /* Remove register note NOTE from the REG_NOTES of INSN. */
1695 remove_note (insn, note)
1701 if (note == NULL_RTX)
1704 if (REG_NOTES (insn) == note)
1706 REG_NOTES (insn) = XEXP (note, 1);
1710 for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
1711 if (XEXP (link, 1) == note)
1713 XEXP (link, 1) = XEXP (note, 1);
1720 /* Search LISTP (an EXPR_LIST) for an entry whose first operand is NODE and
1721 remove that entry from the list if it is found.
1723 A simple equality test is used to determine if NODE matches. */
1726 remove_node_from_expr_list (node, listp)
1731 rtx prev = NULL_RTX;
1735 if (node == XEXP (temp, 0))
1737 /* Splice the node out of the list. */
1739 XEXP (prev, 1) = XEXP (temp, 1);
1741 *listp = XEXP (temp, 1);
1747 temp = XEXP (temp, 1);
1751 /* Nonzero if X contains any volatile instructions. These are instructions
1752 which may cause unpredictable machine state instructions, and thus no
1753 instructions should be moved or combined across them. This includes
1754 only volatile asms and UNSPEC_VOLATILE instructions. */
1760 register RTX_CODE code;
1762 code = GET_CODE (x);
1782 case UNSPEC_VOLATILE:
1783 /* case TRAP_IF: This isn't clear yet. */
1787 if (MEM_VOLATILE_P (x))
1794 /* Recursively scan the operands of this expression. */
1797 register const char *fmt = GET_RTX_FORMAT (code);
1800 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
1804 if (volatile_insn_p (XEXP (x, i)))
1807 else if (fmt[i] == 'E')
1810 for (j = 0; j < XVECLEN (x, i); j++)
1811 if (volatile_insn_p (XVECEXP (x, i, j)))
1819 /* Nonzero if X contains any volatile memory references
1820 UNSPEC_VOLATILE operations or volatile ASM_OPERANDS expressions. */
1826 register RTX_CODE code;
1828 code = GET_CODE (x);
1847 case UNSPEC_VOLATILE:
1848 /* case TRAP_IF: This isn't clear yet. */
1853 if (MEM_VOLATILE_P (x))
1860 /* Recursively scan the operands of this expression. */
1863 register const char *fmt = GET_RTX_FORMAT (code);
1866 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
1870 if (volatile_refs_p (XEXP (x, i)))
1873 else if (fmt[i] == 'E')
1876 for (j = 0; j < XVECLEN (x, i); j++)
1877 if (volatile_refs_p (XVECEXP (x, i, j)))
1885 /* Similar to above, except that it also rejects register pre- and post-
1892 register RTX_CODE code;
1894 code = GET_CODE (x);
1912 /* Reject CLOBBER with a non-VOID mode. These are made by combine.c
1913 when some combination can't be done. If we see one, don't think
1914 that we can simplify the expression. */
1915 return (GET_MODE (x) != VOIDmode);
1924 case UNSPEC_VOLATILE:
1925 /* case TRAP_IF: This isn't clear yet. */
1930 if (MEM_VOLATILE_P (x))
1937 /* Recursively scan the operands of this expression. */
1940 register const char *fmt = GET_RTX_FORMAT (code);
1943 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
1947 if (side_effects_p (XEXP (x, i)))
1950 else if (fmt[i] == 'E')
1953 for (j = 0; j < XVECLEN (x, i); j++)
1954 if (side_effects_p (XVECEXP (x, i, j)))
1962 /* Return nonzero if evaluating rtx X might cause a trap. */
1974 code = GET_CODE (x);
1977 /* Handle these cases quickly. */
1990 case UNSPEC_VOLATILE:
1995 return MEM_VOLATILE_P (x);
1997 /* Memory ref can trap unless it's a static var or a stack slot. */
1999 return rtx_addr_can_trap_p (XEXP (x, 0));
2001 /* Division by a non-constant might trap. */
2006 if (! CONSTANT_P (XEXP (x, 1))
2007 || GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT)
2009 /* This was const0_rtx, but by not using that,
2010 we can link this file into other programs. */
2011 if (GET_CODE (XEXP (x, 1)) == CONST_INT && INTVAL (XEXP (x, 1)) == 0)
2016 /* An EXPR_LIST is used to represent a function call. This
2017 certainly may trap. */
2025 /* Some floating point comparisons may trap. */
2026 /* ??? There is no machine independent way to check for tests that trap
2027 when COMPARE is used, though many targets do make this distinction.
2028 For instance, sparc uses CCFPE for compares which generate exceptions
2029 and CCFP for compares which do not generate exceptions. */
2030 if (GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT)
2032 /* But often the compare has some CC mode, so check operand
2034 if (GET_MODE_CLASS (GET_MODE (XEXP (x, 0))) == MODE_FLOAT
2035 || GET_MODE_CLASS (GET_MODE (XEXP (x, 1))) == MODE_FLOAT)
2041 /* These operations don't trap even with floating point. */
2045 /* Any floating arithmetic may trap. */
2046 if (GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT)
2050 fmt = GET_RTX_FORMAT (code);
2051 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
2055 if (may_trap_p (XEXP (x, i)))
2058 else if (fmt[i] == 'E')
2061 for (j = 0; j < XVECLEN (x, i); j++)
2062 if (may_trap_p (XVECEXP (x, i, j)))
2069 /* Return nonzero if X contains a comparison that is not either EQ or NE,
2070 i.e., an inequality. */
2073 inequality_comparisons_p (x)
2076 register const char *fmt;
2077 register int len, i;
2078 register enum rtx_code code = GET_CODE (x);
2107 len = GET_RTX_LENGTH (code);
2108 fmt = GET_RTX_FORMAT (code);
2110 for (i = 0; i < len; i++)
2114 if (inequality_comparisons_p (XEXP (x, i)))
2117 else if (fmt[i] == 'E')
2120 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
2121 if (inequality_comparisons_p (XVECEXP (x, i, j)))
2129 /* Replace any occurrence of FROM in X with TO. The function does
2130 not enter into CONST_DOUBLE for the replace.
2132 Note that copying is not done so X must not be shared unless all copies
2133 are to be modified. */
2136 replace_rtx (x, from, to)
2140 register const char *fmt;
2142 /* The following prevents loops occurrence when we change MEM in
2143 CONST_DOUBLE onto the same CONST_DOUBLE. */
2144 if (x != 0 && GET_CODE (x) == CONST_DOUBLE)
2150 /* Allow this function to make replacements in EXPR_LISTs. */
2154 fmt = GET_RTX_FORMAT (GET_CODE (x));
2155 for (i = GET_RTX_LENGTH (GET_CODE (x)) - 1; i >= 0; i--)
2158 XEXP (x, i) = replace_rtx (XEXP (x, i), from, to);
2159 else if (fmt[i] == 'E')
2160 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
2161 XVECEXP (x, i, j) = replace_rtx (XVECEXP (x, i, j), from, to);
2167 /* Throughout the rtx X, replace many registers according to REG_MAP.
2168 Return the replacement for X (which may be X with altered contents).
2169 REG_MAP[R] is the replacement for register R, or 0 for don't replace.
2170 NREGS is the length of REG_MAP; regs >= NREGS are not mapped.
2172 We only support REG_MAP entries of REG or SUBREG. Also, hard registers
2173 should not be mapped to pseudos or vice versa since validate_change
2176 If REPLACE_DEST is 1, replacements are also done in destinations;
2177 otherwise, only sources are replaced. */
2180 replace_regs (x, reg_map, nregs, replace_dest)
2186 register enum rtx_code code;
2188 register const char *fmt;
2193 code = GET_CODE (x);
2207 /* Verify that the register has an entry before trying to access it. */
2208 if (REGNO (x) < nregs && reg_map[REGNO (x)] != 0)
2210 /* SUBREGs can't be shared. Always return a copy to ensure that if
2211 this replacement occurs more than once then each instance will
2212 get distinct rtx. */
2213 if (GET_CODE (reg_map[REGNO (x)]) == SUBREG)
2214 return copy_rtx (reg_map[REGNO (x)]);
2215 return reg_map[REGNO (x)];
2220 /* Prevent making nested SUBREGs. */
2221 if (GET_CODE (SUBREG_REG (x)) == REG && REGNO (SUBREG_REG (x)) < nregs
2222 && reg_map[REGNO (SUBREG_REG (x))] != 0
2223 && GET_CODE (reg_map[REGNO (SUBREG_REG (x))]) == SUBREG)
2225 rtx map_val = reg_map[REGNO (SUBREG_REG (x))];
2226 rtx map_inner = SUBREG_REG (map_val);
2228 if (GET_MODE (x) == GET_MODE (map_inner))
2232 /* We cannot call gen_rtx here since we may be linked with
2234 /* Let's try clobbering the incoming SUBREG and see
2235 if this is really safe. */
2236 SUBREG_REG (x) = map_inner;
2237 SUBREG_WORD (x) += SUBREG_WORD (map_val);
2240 rtx new = rtx_alloc (SUBREG);
2241 PUT_MODE (new, GET_MODE (x));
2242 SUBREG_REG (new) = map_inner;
2243 SUBREG_WORD (new) = SUBREG_WORD (x) + SUBREG_WORD (map_val);
2251 SET_DEST (x) = replace_regs (SET_DEST (x), reg_map, nregs, 0);
2253 else if (GET_CODE (SET_DEST (x)) == MEM
2254 || GET_CODE (SET_DEST (x)) == STRICT_LOW_PART)
2255 /* Even if we are not to replace destinations, replace register if it
2256 is CONTAINED in destination (destination is memory or
2257 STRICT_LOW_PART). */
2258 XEXP (SET_DEST (x), 0) = replace_regs (XEXP (SET_DEST (x), 0),
2260 else if (GET_CODE (SET_DEST (x)) == ZERO_EXTRACT)
2261 /* Similarly, for ZERO_EXTRACT we replace all operands. */
2264 SET_SRC (x) = replace_regs (SET_SRC (x), reg_map, nregs, 0);
2271 fmt = GET_RTX_FORMAT (code);
2272 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
2275 XEXP (x, i) = replace_regs (XEXP (x, i), reg_map, nregs, replace_dest);
2276 else if (fmt[i] == 'E')
2279 for (j = 0; j < XVECLEN (x, i); j++)
2280 XVECEXP (x, i, j) = replace_regs (XVECEXP (x, i, j), reg_map,
2281 nregs, replace_dest);
2287 /* A subroutine of computed_jump_p, return 1 if X contains a REG or MEM or
2288 constant that is not in the constant pool and not in the condition
2289 of an IF_THEN_ELSE. */
2292 computed_jump_p_1 (x)
2295 enum rtx_code code = GET_CODE (x);
2313 return ! (GET_CODE (XEXP (x, 0)) == SYMBOL_REF
2314 && CONSTANT_POOL_ADDRESS_P (XEXP (x, 0)));
2317 return (computed_jump_p_1 (XEXP (x, 1))
2318 || computed_jump_p_1 (XEXP (x, 2)));
2324 fmt = GET_RTX_FORMAT (code);
2325 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
2328 && computed_jump_p_1 (XEXP (x, i)))
2331 else if (fmt[i] == 'E')
2332 for (j = 0; j < XVECLEN (x, i); j++)
2333 if (computed_jump_p_1 (XVECEXP (x, i, j)))
2340 /* Return nonzero if INSN is an indirect jump (aka computed jump).
2342 Tablejumps and casesi insns are not considered indirect jumps;
2343 we can recognize them by a (use (label_ref)). */
2346 computed_jump_p (insn)
2350 if (GET_CODE (insn) == JUMP_INSN)
2352 rtx pat = PATTERN (insn);
2354 if (find_reg_note (insn, REG_LABEL, NULL_RTX))
2356 else if (GET_CODE (pat) == PARALLEL)
2358 int len = XVECLEN (pat, 0);
2359 int has_use_labelref = 0;
2361 for (i = len - 1; i >= 0; i--)
2362 if (GET_CODE (XVECEXP (pat, 0, i)) == USE
2363 && (GET_CODE (XEXP (XVECEXP (pat, 0, i), 0))
2365 has_use_labelref = 1;
2367 if (! has_use_labelref)
2368 for (i = len - 1; i >= 0; i--)
2369 if (GET_CODE (XVECEXP (pat, 0, i)) == SET
2370 && SET_DEST (XVECEXP (pat, 0, i)) == pc_rtx
2371 && computed_jump_p_1 (SET_SRC (XVECEXP (pat, 0, i))))
2374 else if (GET_CODE (pat) == SET
2375 && SET_DEST (pat) == pc_rtx
2376 && computed_jump_p_1 (SET_SRC (pat)))
2382 /* Traverse X via depth-first search, calling F for each
2383 sub-expression (including X itself). F is also passed the DATA.
2384 If F returns -1, do not traverse sub-expressions, but continue
2385 traversing the rest of the tree. If F ever returns any other
2386 non-zero value, stop the traversal, and return the value returned
2387 by F. Otherwise, return 0. This function does not traverse inside
2388 tree structure that contains RTX_EXPRs, or into sub-expressions
2389 whose format code is `0' since it is not known whether or not those
2390 codes are actually RTL.
2392 This routine is very general, and could (should?) be used to
2393 implement many of the other routines in this file. */
2396 for_each_rtx (x, f, data)
2407 result = (*f)(x, data);
2409 /* Do not traverse sub-expressions. */
2411 else if (result != 0)
2412 /* Stop the traversal. */
2416 /* There are no sub-expressions. */
2419 length = GET_RTX_LENGTH (GET_CODE (*x));
2420 format = GET_RTX_FORMAT (GET_CODE (*x));
2422 for (i = 0; i < length; ++i)
2427 result = for_each_rtx (&XEXP (*x, i), f, data);
2434 if (XVEC (*x, i) != 0)
2437 for (j = 0; j < XVECLEN (*x, i); ++j)
2439 result = for_each_rtx (&XVECEXP (*x, i, j), f, data);
2447 /* Nothing to do. */
2456 /* Searches X for any reference to REGNO, returning the rtx of the
2457 reference found if any. Otherwise, returns NULL_RTX. */
2460 regno_use_in (regno, x)
2464 register const char *fmt;
2468 if (GET_CODE (x) == REG && REGNO (x) == regno)
2471 fmt = GET_RTX_FORMAT (GET_CODE (x));
2472 for (i = GET_RTX_LENGTH (GET_CODE (x)) - 1; i >= 0; i--)
2476 if ((tem = regno_use_in (regno, XEXP (x, i))))
2479 else if (fmt[i] == 'E')
2480 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
2481 if ((tem = regno_use_in (regno , XVECEXP (x, i, j))))
2489 /* Return 1 if X is an autoincrement side effect and the register is
2490 not the stack pointer. */
2495 switch (GET_CODE (x))
2503 /* There are no REG_INC notes for SP. */
2504 if (XEXP (x, 0) != stack_pointer_rtx)
2512 /* Return 1 if the sequence of instructions beginning with FROM and up
2513 to and including TO is safe to move. If NEW_TO is non-NULL, and
2514 the sequence is not already safe to move, but can be easily
2515 extended to a sequence which is safe, then NEW_TO will point to the
2516 end of the extended sequence.
2518 For now, this function only checks that the region contains whole
2519 exception regions, but it could be extended to check additional
2520 conditions as well. */
2523 insns_safe_to_move_p (from, to, new_to)
2528 int eh_region_count = 0;
2532 /* By default, assume the end of the region will be what was
2539 if (GET_CODE (r) == NOTE)
2541 switch (NOTE_LINE_NUMBER (r))
2543 case NOTE_INSN_EH_REGION_BEG:
2547 case NOTE_INSN_EH_REGION_END:
2548 if (eh_region_count == 0)
2549 /* This sequence of instructions contains the end of
2550 an exception region, but not he beginning. Moving
2551 it will cause chaos. */
2562 /* If we've passed TO, and we see a non-note instruction, we
2563 can't extend the sequence to a movable sequence. */
2569 /* It's OK to move the sequence if there were matched sets of
2570 exception region notes. */
2571 return eh_region_count == 0;
2576 /* It's OK to move the sequence if there were matched sets of
2577 exception region notes. */
2578 if (past_to_p && eh_region_count == 0)
2584 /* Go to the next instruction. */
2591 /* Return non-zero if IN contains a piece of rtl that has the address LOC */
2593 loc_mentioned_in_p (loc, in)
2596 enum rtx_code code = GET_CODE (in);
2597 const char *fmt = GET_RTX_FORMAT (code);
2600 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
2602 if (loc == &in->fld[i].rtx)
2606 if (loc_mentioned_in_p (loc, XEXP (in, i)))
2609 else if (fmt[i] == 'E')
2610 for (j = XVECLEN (in, i) - 1; j >= 0; j--)
2611 if (loc_mentioned_in_p (loc, XVECEXP (in, i, j)))