1 /* Analyze RTL for C-Compiler
2 Copyright (C) 1987, 88, 92-97, 1998 Free Software Foundation, Inc.
4 This file is part of GNU CC.
6 GNU CC is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GNU CC is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU CC; see the file COPYING. If not, write to
18 the Free Software Foundation, 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
26 static int rtx_addr_can_trap_p PROTO((rtx));
27 static void reg_set_p_1 PROTO((rtx, rtx));
28 static void reg_set_last_1 PROTO((rtx, rtx));
31 /* Forward declarations */
32 static int jmp_uses_reg_or_mem PROTO((rtx));
34 /* Bit flags that specify the machine subtype we are compiling for.
35 Bits are tested using macros TARGET_... defined in the tm.h file
36 and set by `-m...' switches. Must be defined in rtlanal.c. */
40 /* Return 1 if the value of X is unstable
41 (would be different at a different point in the program).
42 The frame pointer, arg pointer, etc. are considered stable
43 (within one function) and so is anything marked `unchanging'. */
49 register RTX_CODE code = GET_CODE (x);
54 return ! RTX_UNCHANGING_P (x);
59 if (code == CONST || code == CONST_INT)
63 return ! (REGNO (x) == FRAME_POINTER_REGNUM
64 || REGNO (x) == HARD_FRAME_POINTER_REGNUM
65 || REGNO (x) == ARG_POINTER_REGNUM
66 || RTX_UNCHANGING_P (x));
68 fmt = GET_RTX_FORMAT (code);
69 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
71 if (rtx_unstable_p (XEXP (x, i)))
76 /* Return 1 if X has a value that can vary even between two
77 executions of the program. 0 means X can be compared reliably
78 against certain constants or near-constants.
79 The frame pointer and the arg pointer are considered constant. */
85 register RTX_CODE code = GET_CODE (x);
103 /* Note that we have to test for the actual rtx used for the frame
104 and arg pointers and not just the register number in case we have
105 eliminated the frame and/or arg pointer and are using it
107 return ! (x == frame_pointer_rtx || x == hard_frame_pointer_rtx
108 || x == arg_pointer_rtx || x == pic_offset_table_rtx);
111 /* The operand 0 of a LO_SUM is considered constant
112 (in fact is it related specifically to operand 1). */
113 return rtx_varies_p (XEXP (x, 1));
119 fmt = GET_RTX_FORMAT (code);
120 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
122 if (rtx_varies_p (XEXP (x, i)))
127 /* Return 0 if the use of X as an address in a MEM can cause a trap. */
130 rtx_addr_can_trap_p (x)
133 register enum rtx_code code = GET_CODE (x);
139 /* SYMBOL_REF is problematic due to the possible presence of
140 a #pragma weak, but to say that loads from symbols can trap is
141 *very* costly. It's not at all clear what's best here. For
142 now, we ignore the impact of #pragma weak. */
146 /* As in rtx_varies_p, we have to use the actual rtx, not reg number. */
147 return ! (x == frame_pointer_rtx || x == hard_frame_pointer_rtx
148 || x == stack_pointer_rtx || x == arg_pointer_rtx);
151 return rtx_addr_can_trap_p (XEXP (x, 0));
154 /* An address is assumed not to trap if it is an address that can't
155 trap plus a constant integer. */
156 return (rtx_addr_can_trap_p (XEXP (x, 0))
157 || GET_CODE (XEXP (x, 1)) != CONST_INT);
160 return rtx_addr_can_trap_p (XEXP (x, 1));
166 /* If it isn't one of the case above, it can cause a trap. */
170 /* Return 1 if X refers to a memory location whose address
171 cannot be compared reliably with constant addresses,
172 or if X refers to a BLKmode memory object. */
175 rtx_addr_varies_p (x)
178 register enum rtx_code code;
187 return GET_MODE (x) == BLKmode || rtx_varies_p (XEXP (x, 0));
189 fmt = GET_RTX_FORMAT (code);
190 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
193 if (rtx_addr_varies_p (XEXP (x, i)))
196 else if (fmt[i] == 'E')
199 for (j = 0; j < XVECLEN (x, i); j++)
200 if (rtx_addr_varies_p (XVECEXP (x, i, j)))
206 /* Return the value of the integer term in X, if one is apparent;
208 Only obvious integer terms are detected.
209 This is used in cse.c with the `related_value' field.*/
215 if (GET_CODE (x) == CONST)
218 if (GET_CODE (x) == MINUS
219 && GET_CODE (XEXP (x, 1)) == CONST_INT)
220 return - INTVAL (XEXP (x, 1));
221 if (GET_CODE (x) == PLUS
222 && GET_CODE (XEXP (x, 1)) == CONST_INT)
223 return INTVAL (XEXP (x, 1));
227 /* If X is a constant, return the value sans apparent integer term;
229 Only obvious integer terms are detected. */
232 get_related_value (x)
235 if (GET_CODE (x) != CONST)
238 if (GET_CODE (x) == PLUS
239 && GET_CODE (XEXP (x, 1)) == CONST_INT)
241 else if (GET_CODE (x) == MINUS
242 && GET_CODE (XEXP (x, 1)) == CONST_INT)
247 /* Nonzero if register REG appears somewhere within IN.
248 Also works if REG is not a register; in this case it checks
249 for a subexpression of IN that is Lisp "equal" to REG. */
252 reg_mentioned_p (reg, in)
253 register rtx reg, in;
257 register enum rtx_code code;
265 if (GET_CODE (in) == LABEL_REF)
266 return reg == XEXP (in, 0);
268 code = GET_CODE (in);
272 /* Compare registers by number. */
274 return GET_CODE (reg) == REG && REGNO (in) == REGNO (reg);
276 /* These codes have no constituent expressions
284 return GET_CODE (reg) == CONST_INT && INTVAL (in) == INTVAL (reg);
287 /* These are kept unique for a given value. */
294 if (GET_CODE (reg) == code && rtx_equal_p (reg, in))
297 fmt = GET_RTX_FORMAT (code);
299 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
304 for (j = XVECLEN (in, i) - 1; j >= 0; j--)
305 if (reg_mentioned_p (reg, XVECEXP (in, i, j)))
308 else if (fmt[i] == 'e'
309 && reg_mentioned_p (reg, XEXP (in, i)))
315 /* Return 1 if in between BEG and END, exclusive of BEG and END, there is
316 no CODE_LABEL insn. */
319 no_labels_between_p (beg, end)
323 for (p = NEXT_INSN (beg); p != end; p = NEXT_INSN (p))
324 if (GET_CODE (p) == CODE_LABEL)
329 /* Nonzero if register REG is used in an insn between
330 FROM_INSN and TO_INSN (exclusive of those two). */
333 reg_used_between_p (reg, from_insn, to_insn)
334 rtx reg, from_insn, to_insn;
338 if (from_insn == to_insn)
341 for (insn = NEXT_INSN (from_insn); insn != to_insn; insn = NEXT_INSN (insn))
342 if (GET_RTX_CLASS (GET_CODE (insn)) == 'i'
343 && (reg_overlap_mentioned_p (reg, PATTERN (insn))
344 || (GET_CODE (insn) == CALL_INSN
345 && (find_reg_fusage (insn, USE, reg)
346 || find_reg_fusage (insn, CLOBBER, reg)))))
351 /* Nonzero if the old value of X, a register, is referenced in BODY. If X
352 is entirely replaced by a new value and the only use is as a SET_DEST,
353 we do not consider it a reference. */
356 reg_referenced_p (x, body)
362 switch (GET_CODE (body))
365 if (reg_overlap_mentioned_p (x, SET_SRC (body)))
368 /* If the destination is anything other than CC0, PC, a REG or a SUBREG
369 of a REG that occupies all of the REG, the insn references X if
370 it is mentioned in the destination. */
371 if (GET_CODE (SET_DEST (body)) != CC0
372 && GET_CODE (SET_DEST (body)) != PC
373 && GET_CODE (SET_DEST (body)) != REG
374 && ! (GET_CODE (SET_DEST (body)) == SUBREG
375 && GET_CODE (SUBREG_REG (SET_DEST (body))) == REG
376 && (((GET_MODE_SIZE (GET_MODE (SUBREG_REG (SET_DEST (body))))
377 + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD)
378 == ((GET_MODE_SIZE (GET_MODE (SET_DEST (body)))
379 + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD)))
380 && reg_overlap_mentioned_p (x, SET_DEST (body)))
385 for (i = ASM_OPERANDS_INPUT_LENGTH (body) - 1; i >= 0; i--)
386 if (reg_overlap_mentioned_p (x, ASM_OPERANDS_INPUT (body, i)))
392 return reg_overlap_mentioned_p (x, body);
395 return reg_overlap_mentioned_p (x, TRAP_CONDITION (body));
398 case UNSPEC_VOLATILE:
400 for (i = XVECLEN (body, 0) - 1; i >= 0; i--)
401 if (reg_referenced_p (x, XVECEXP (body, 0, i)))
410 /* Nonzero if register REG is referenced in an insn between
411 FROM_INSN and TO_INSN (exclusive of those two). Sets of REG do
415 reg_referenced_between_p (reg, from_insn, to_insn)
416 rtx reg, from_insn, to_insn;
420 if (from_insn == to_insn)
423 for (insn = NEXT_INSN (from_insn); insn != to_insn; insn = NEXT_INSN (insn))
424 if (GET_RTX_CLASS (GET_CODE (insn)) == 'i'
425 && (reg_referenced_p (reg, PATTERN (insn))
426 || (GET_CODE (insn) == CALL_INSN
427 && find_reg_fusage (insn, USE, reg))))
432 /* Nonzero if register REG is set or clobbered in an insn between
433 FROM_INSN and TO_INSN (exclusive of those two). */
436 reg_set_between_p (reg, from_insn, to_insn)
437 rtx reg, from_insn, to_insn;
441 if (from_insn == to_insn)
444 for (insn = NEXT_INSN (from_insn); insn != to_insn; insn = NEXT_INSN (insn))
445 if (GET_RTX_CLASS (GET_CODE (insn)) == 'i'
446 && reg_set_p (reg, insn))
451 /* Internals of reg_set_between_p. */
453 static rtx reg_set_reg;
454 static int reg_set_flag;
459 rtx pat ATTRIBUTE_UNUSED;
461 /* We don't want to return 1 if X is a MEM that contains a register
462 within REG_SET_REG. */
464 if ((GET_CODE (x) != MEM)
465 && reg_overlap_mentioned_p (reg_set_reg, x))
470 reg_set_p (reg, insn)
475 /* We can be passed an insn or part of one. If we are passed an insn,
476 check if a side-effect of the insn clobbers REG. */
477 if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
479 if (FIND_REG_INC_NOTE (insn, reg)
480 || (GET_CODE (insn) == CALL_INSN
481 /* We'd like to test call_used_regs here, but rtlanal.c can't
482 reference that variable due to its use in genattrtab. So
483 we'll just be more conservative.
485 ??? Unless we could ensure that the CALL_INSN_FUNCTION_USAGE
486 information holds all clobbered registers. */
487 && ((GET_CODE (reg) == REG
488 && REGNO (reg) < FIRST_PSEUDO_REGISTER)
489 || GET_CODE (reg) == MEM
490 || find_reg_fusage (insn, CLOBBER, reg))))
493 body = PATTERN (insn);
498 note_stores (body, reg_set_p_1);
502 /* Similar to reg_set_between_p, but check all registers in X. Return 0
503 only if none of them are modified between START and END. Do not
504 consider non-registers one way or the other. */
507 regs_set_between_p (x, start, end)
511 enum rtx_code code = GET_CODE (x);
527 return reg_set_between_p (x, start, end);
533 fmt = GET_RTX_FORMAT (code);
534 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
536 if (fmt[i] == 'e' && regs_set_between_p (XEXP (x, i), start, end))
539 else if (fmt[i] == 'E')
540 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
541 if (regs_set_between_p (XVECEXP (x, i, j), start, end))
548 /* Similar to reg_set_between_p, but check all registers in X. Return 0
549 only if none of them are modified between START and END. Return 1 if
550 X contains a MEM; this routine does not perform any memory aliasing. */
553 modified_between_p (x, start, end)
557 enum rtx_code code = GET_CODE (x);
575 /* If the memory is not constant, assume it is modified. If it is
576 constant, we still have to check the address. */
577 if (! RTX_UNCHANGING_P (x))
582 return reg_set_between_p (x, start, end);
588 fmt = GET_RTX_FORMAT (code);
589 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
591 if (fmt[i] == 'e' && modified_between_p (XEXP (x, i), start, end))
595 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
596 if (modified_between_p (XVECEXP (x, i, j), start, end))
603 /* Similar to reg_set_p, but check all registers in X. Return 0 only if none
604 of them are modified in INSN. Return 1 if X contains a MEM; this routine
605 does not perform any memory aliasing. */
608 modified_in_p (x, insn)
612 enum rtx_code code = GET_CODE (x);
630 /* If the memory is not constant, assume it is modified. If it is
631 constant, we still have to check the address. */
632 if (! RTX_UNCHANGING_P (x))
637 return reg_set_p (x, insn);
643 fmt = GET_RTX_FORMAT (code);
644 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
646 if (fmt[i] == 'e' && modified_in_p (XEXP (x, i), insn))
650 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
651 if (modified_in_p (XVECEXP (x, i, j), insn))
658 /* Given an INSN, return a SET expression if this insn has only a single SET.
659 It may also have CLOBBERs, USEs, or SET whose output
660 will not be used, which we ignore. */
669 if (GET_RTX_CLASS (GET_CODE (insn)) != 'i')
672 if (GET_CODE (PATTERN (insn)) == SET)
673 return PATTERN (insn);
675 else if (GET_CODE (PATTERN (insn)) == PARALLEL)
677 for (i = 0, set = 0; i < XVECLEN (PATTERN (insn), 0); i++)
678 if (GET_CODE (XVECEXP (PATTERN (insn), 0, i)) == SET
679 && (! find_reg_note (insn, REG_UNUSED,
680 SET_DEST (XVECEXP (PATTERN (insn), 0, i)))
681 || side_effects_p (XVECEXP (PATTERN (insn), 0, i))))
686 set = XVECEXP (PATTERN (insn), 0, i);
694 /* Return the last thing that X was assigned from before *PINSN. Verify that
695 the object is not modified up to VALID_TO. If it was, if we hit
696 a partial assignment to X, or hit a CODE_LABEL first, return X. If we
697 found an assignment, update *PINSN to point to it. */
700 find_last_value (x, pinsn, valid_to)
707 for (p = PREV_INSN (*pinsn); p && GET_CODE (p) != CODE_LABEL;
709 if (GET_RTX_CLASS (GET_CODE (p)) == 'i')
711 rtx set = single_set (p);
712 rtx note = find_reg_note (p, REG_EQUAL, NULL_RTX);
714 if (set && rtx_equal_p (x, SET_DEST (set)))
716 rtx src = SET_SRC (set);
718 if (note && GET_CODE (XEXP (note, 0)) != EXPR_LIST)
719 src = XEXP (note, 0);
721 if (! modified_between_p (src, PREV_INSN (p), valid_to)
722 /* Reject hard registers because we don't usually want
723 to use them; we'd rather use a pseudo. */
724 && ! (GET_CODE (src) == REG
725 && REGNO (src) < FIRST_PSEUDO_REGISTER))
732 /* If set in non-simple way, we don't have a value. */
733 if (reg_set_p (x, p))
740 /* Return nonzero if register in range [REGNO, ENDREGNO)
741 appears either explicitly or implicitly in X
742 other than being stored into.
744 References contained within the substructure at LOC do not count.
745 LOC may be zero, meaning don't ignore anything. */
748 refers_to_regno_p (regno, endregno, x, loc)
754 register RTX_CODE code;
758 /* The contents of a REG_NONNEG note is always zero, so we must come here
759 upon repeat in case the last REG_NOTE is a REG_NONNEG note. */
770 /* If we modifying the stack, frame, or argument pointer, it will
771 clobber a virtual register. In fact, we could be more precise,
772 but it isn't worth it. */
773 if ((i == STACK_POINTER_REGNUM
774 #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
775 || i == ARG_POINTER_REGNUM
777 || i == FRAME_POINTER_REGNUM)
778 && regno >= FIRST_VIRTUAL_REGISTER && regno <= LAST_VIRTUAL_REGISTER)
782 && regno < i + (i < FIRST_PSEUDO_REGISTER
783 ? HARD_REGNO_NREGS (i, GET_MODE (x))
787 /* If this is a SUBREG of a hard reg, we can see exactly which
788 registers are being modified. Otherwise, handle normally. */
789 if (GET_CODE (SUBREG_REG (x)) == REG
790 && REGNO (SUBREG_REG (x)) < FIRST_PSEUDO_REGISTER)
792 int inner_regno = REGNO (SUBREG_REG (x)) + SUBREG_WORD (x);
794 = inner_regno + (inner_regno < FIRST_PSEUDO_REGISTER
795 ? HARD_REGNO_NREGS (regno, GET_MODE (x)) : 1);
797 return endregno > inner_regno && regno < inner_endregno;
803 if (&SET_DEST (x) != loc
804 /* Note setting a SUBREG counts as referring to the REG it is in for
805 a pseudo but not for hard registers since we can
806 treat each word individually. */
807 && ((GET_CODE (SET_DEST (x)) == SUBREG
808 && loc != &SUBREG_REG (SET_DEST (x))
809 && GET_CODE (SUBREG_REG (SET_DEST (x))) == REG
810 && REGNO (SUBREG_REG (SET_DEST (x))) >= FIRST_PSEUDO_REGISTER
811 && refers_to_regno_p (regno, endregno,
812 SUBREG_REG (SET_DEST (x)), loc))
813 || (GET_CODE (SET_DEST (x)) != REG
814 && refers_to_regno_p (regno, endregno, SET_DEST (x), loc))))
817 if (code == CLOBBER || loc == &SET_SRC (x))
826 /* X does not match, so try its subexpressions. */
828 fmt = GET_RTX_FORMAT (code);
829 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
831 if (fmt[i] == 'e' && loc != &XEXP (x, i))
839 if (refers_to_regno_p (regno, endregno, XEXP (x, i), loc))
842 else if (fmt[i] == 'E')
845 for (j = XVECLEN (x, i) - 1; j >=0; j--)
846 if (loc != &XVECEXP (x, i, j)
847 && refers_to_regno_p (regno, endregno, XVECEXP (x, i, j), loc))
854 /* Nonzero if modifying X will affect IN. If X is a register or a SUBREG,
855 we check if any register number in X conflicts with the relevant register
856 numbers. If X is a constant, return 0. If X is a MEM, return 1 iff IN
857 contains a MEM (we don't bother checking for memory addresses that can't
858 conflict because we expect this to be a rare case. */
861 reg_overlap_mentioned_p (x, in)
866 /* Overly conservative. */
867 if (GET_CODE (x) == STRICT_LOW_PART)
870 /* If either argument is a constant, then modifying X can not affect IN. */
871 if (CONSTANT_P (x) || CONSTANT_P (in))
873 else if (GET_CODE (x) == SUBREG)
875 regno = REGNO (SUBREG_REG (x));
876 if (regno < FIRST_PSEUDO_REGISTER)
877 regno += SUBREG_WORD (x);
879 else if (GET_CODE (x) == REG)
881 else if (GET_CODE (x) == MEM)
886 if (GET_CODE (in) == MEM)
889 fmt = GET_RTX_FORMAT (GET_CODE (in));
891 for (i = GET_RTX_LENGTH (GET_CODE (in)) - 1; i >= 0; i--)
892 if (fmt[i] == 'e' && reg_overlap_mentioned_p (x, XEXP (in, i)))
897 else if (GET_CODE (x) == SCRATCH || GET_CODE (x) == PC
898 || GET_CODE (x) == CC0)
899 return reg_mentioned_p (x, in);
900 else if (GET_CODE (x) == PARALLEL
901 && GET_MODE (x) == BLKmode)
905 /* If any register in here refers to it
907 for (i = XVECLEN (x, 0) - 1; i >= 0; i--)
908 if (reg_overlap_mentioned_p (SET_DEST (XVECEXP (x, 0, i)), in))
915 endregno = regno + (regno < FIRST_PSEUDO_REGISTER
916 ? HARD_REGNO_NREGS (regno, GET_MODE (x)) : 1);
918 return refers_to_regno_p (regno, endregno, in, NULL_PTR);
921 /* Used for communications between the next few functions. */
923 static int reg_set_last_unknown;
924 static rtx reg_set_last_value;
925 static int reg_set_last_first_regno, reg_set_last_last_regno;
927 /* Called via note_stores from reg_set_last. */
930 reg_set_last_1 (x, pat)
936 /* If X is not a register, or is not one in the range we care
938 if (GET_CODE (x) != REG)
942 last = first + (first < FIRST_PSEUDO_REGISTER
943 ? HARD_REGNO_NREGS (first, GET_MODE (x)) : 1);
945 if (first >= reg_set_last_last_regno
946 || last <= reg_set_last_first_regno)
949 /* If this is a CLOBBER or is some complex LHS, or doesn't modify
950 exactly the registers we care about, show we don't know the value. */
951 if (GET_CODE (pat) == CLOBBER || SET_DEST (pat) != x
952 || first != reg_set_last_first_regno
953 || last != reg_set_last_last_regno)
954 reg_set_last_unknown = 1;
956 reg_set_last_value = SET_SRC (pat);
959 /* Return the last value to which REG was set prior to INSN. If we can't
960 find it easily, return 0.
962 We only return a REG, SUBREG, or constant because it is too hard to
963 check if a MEM remains unchanged. */
966 reg_set_last (x, insn)
970 rtx orig_insn = insn;
972 reg_set_last_first_regno = REGNO (x);
974 reg_set_last_last_regno
975 = reg_set_last_first_regno
976 + (reg_set_last_first_regno < FIRST_PSEUDO_REGISTER
977 ? HARD_REGNO_NREGS (reg_set_last_first_regno, GET_MODE (x)) : 1);
979 reg_set_last_unknown = 0;
980 reg_set_last_value = 0;
982 /* Scan backwards until reg_set_last_1 changed one of the above flags.
983 Stop when we reach a label or X is a hard reg and we reach a
984 CALL_INSN (if reg_set_last_last_regno is a hard reg).
986 If we find a set of X, ensure that its SET_SRC remains unchanged. */
988 /* We compare with <= here, because reg_set_last_last_regno
989 is actually the number of the first reg *not* in X. */
991 insn && GET_CODE (insn) != CODE_LABEL
992 && ! (GET_CODE (insn) == CALL_INSN
993 && reg_set_last_last_regno <= FIRST_PSEUDO_REGISTER);
994 insn = PREV_INSN (insn))
995 if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
997 note_stores (PATTERN (insn), reg_set_last_1);
998 if (reg_set_last_unknown)
1000 else if (reg_set_last_value)
1002 if (CONSTANT_P (reg_set_last_value)
1003 || ((GET_CODE (reg_set_last_value) == REG
1004 || GET_CODE (reg_set_last_value) == SUBREG)
1005 && ! reg_set_between_p (reg_set_last_value,
1007 return reg_set_last_value;
1016 /* This is 1 until after the rtl generation pass. */
1017 int rtx_equal_function_value_matters;
1019 /* Return 1 if X and Y are identical-looking rtx's.
1020 This is the Lisp function EQUAL for rtx arguments. */
1028 register enum rtx_code code;
1033 if (x == 0 || y == 0)
1036 code = GET_CODE (x);
1037 /* Rtx's of different codes cannot be equal. */
1038 if (code != GET_CODE (y))
1041 /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent.
1042 (REG:SI x) and (REG:HI x) are NOT equivalent. */
1044 if (GET_MODE (x) != GET_MODE (y))
1047 /* REG, LABEL_REF, and SYMBOL_REF can be compared nonrecursively. */
1050 /* Until rtl generation is complete, don't consider a reference to the
1051 return register of the current function the same as the return from a
1052 called function. This eases the job of function integration. Once the
1053 distinction is no longer needed, they can be considered equivalent. */
1054 return (REGNO (x) == REGNO (y)
1055 && (! rtx_equal_function_value_matters
1056 || REG_FUNCTION_VALUE_P (x) == REG_FUNCTION_VALUE_P (y)));
1057 else if (code == LABEL_REF)
1058 return XEXP (x, 0) == XEXP (y, 0);
1059 else if (code == SYMBOL_REF)
1060 return XSTR (x, 0) == XSTR (y, 0);
1061 else if (code == SCRATCH || code == CONST_DOUBLE)
1064 /* Compare the elements. If any pair of corresponding elements
1065 fail to match, return 0 for the whole things. */
1067 fmt = GET_RTX_FORMAT (code);
1068 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
1073 if (XWINT (x, i) != XWINT (y, i))
1079 if (XINT (x, i) != XINT (y, i))
1085 /* Two vectors must have the same length. */
1086 if (XVECLEN (x, i) != XVECLEN (y, i))
1089 /* And the corresponding elements must match. */
1090 for (j = 0; j < XVECLEN (x, i); j++)
1091 if (rtx_equal_p (XVECEXP (x, i, j), XVECEXP (y, i, j)) == 0)
1096 if (rtx_equal_p (XEXP (x, i), XEXP (y, i)) == 0)
1102 if (strcmp (XSTR (x, i), XSTR (y, i)))
1107 /* These are just backpointers, so they don't matter. */
1113 /* It is believed that rtx's at this level will never
1114 contain anything but integers and other rtx's,
1115 except for within LABEL_REFs and SYMBOL_REFs. */
1123 /* Call FUN on each register or MEM that is stored into or clobbered by X.
1124 (X would be the pattern of an insn).
1125 FUN receives two arguments:
1126 the REG, MEM, CC0 or PC being stored in or clobbered,
1127 the SET or CLOBBER rtx that does the store.
1129 If the item being stored in or clobbered is a SUBREG of a hard register,
1130 the SUBREG will be passed. */
1133 note_stores (x, fun)
1137 if ((GET_CODE (x) == SET || GET_CODE (x) == CLOBBER))
1139 register rtx dest = SET_DEST (x);
1140 while ((GET_CODE (dest) == SUBREG
1141 && (GET_CODE (SUBREG_REG (dest)) != REG
1142 || REGNO (SUBREG_REG (dest)) >= FIRST_PSEUDO_REGISTER))
1143 || GET_CODE (dest) == ZERO_EXTRACT
1144 || GET_CODE (dest) == SIGN_EXTRACT
1145 || GET_CODE (dest) == STRICT_LOW_PART)
1146 dest = XEXP (dest, 0);
1148 if (GET_CODE (dest) == PARALLEL
1149 && GET_MODE (dest) == BLKmode)
1152 for (i = XVECLEN (dest, 0) - 1; i >= 0; i--)
1153 (*fun) (SET_DEST (XVECEXP (dest, 0, i)), x);
1158 else if (GET_CODE (x) == PARALLEL)
1161 for (i = XVECLEN (x, 0) - 1; i >= 0; i--)
1163 register rtx y = XVECEXP (x, 0, i);
1164 if (GET_CODE (y) == SET || GET_CODE (y) == CLOBBER)
1166 register rtx dest = SET_DEST (y);
1167 while ((GET_CODE (dest) == SUBREG
1168 && (GET_CODE (SUBREG_REG (dest)) != REG
1169 || (REGNO (SUBREG_REG (dest))
1170 >= FIRST_PSEUDO_REGISTER)))
1171 || GET_CODE (dest) == ZERO_EXTRACT
1172 || GET_CODE (dest) == SIGN_EXTRACT
1173 || GET_CODE (dest) == STRICT_LOW_PART)
1174 dest = XEXP (dest, 0);
1175 if (GET_CODE (dest) == PARALLEL
1176 && GET_MODE (dest) == BLKmode)
1179 for (i = XVECLEN (dest, 0) - 1; i >= 0; i--)
1180 (*fun) (SET_DEST (XVECEXP (dest, 0, i)), y);
1189 /* Return nonzero if X's old contents don't survive after INSN.
1190 This will be true if X is (cc0) or if X is a register and
1191 X dies in INSN or because INSN entirely sets X.
1193 "Entirely set" means set directly and not through a SUBREG,
1194 ZERO_EXTRACT or SIGN_EXTRACT, so no trace of the old contents remains.
1195 Likewise, REG_INC does not count.
1197 REG may be a hard or pseudo reg. Renumbering is not taken into account,
1198 but for this use that makes no difference, since regs don't overlap
1199 during their lifetimes. Therefore, this function may be used
1200 at any time after deaths have been computed (in flow.c).
1202 If REG is a hard reg that occupies multiple machine registers, this
1203 function will only return 1 if each of those registers will be replaced
1207 dead_or_set_p (insn, x)
1211 register int regno, last_regno;
1214 /* Can't use cc0_rtx below since this file is used by genattrtab.c. */
1215 if (GET_CODE (x) == CC0)
1218 if (GET_CODE (x) != REG)
1222 last_regno = (regno >= FIRST_PSEUDO_REGISTER ? regno
1223 : regno + HARD_REGNO_NREGS (regno, GET_MODE (x)) - 1);
1225 for (i = regno; i <= last_regno; i++)
1226 if (! dead_or_set_regno_p (insn, i))
1232 /* Utility function for dead_or_set_p to check an individual register. Also
1233 called from flow.c. */
1236 dead_or_set_regno_p (insn, test_regno)
1240 int regno, endregno;
1243 /* See if there is a death note for something that includes
1245 for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
1247 if (REG_NOTE_KIND (link) != REG_DEAD
1248 || GET_CODE (XEXP (link, 0)) != REG)
1251 regno = REGNO (XEXP (link, 0));
1252 endregno = (regno >= FIRST_PSEUDO_REGISTER ? regno + 1
1253 : regno + HARD_REGNO_NREGS (regno,
1254 GET_MODE (XEXP (link, 0))));
1256 if (test_regno >= regno && test_regno < endregno)
1260 if (GET_CODE (insn) == CALL_INSN
1261 && find_regno_fusage (insn, CLOBBER, test_regno))
1264 if (GET_CODE (PATTERN (insn)) == SET)
1266 rtx dest = SET_DEST (PATTERN (insn));
1268 /* A value is totally replaced if it is the destination or the
1269 destination is a SUBREG of REGNO that does not change the number of
1271 if (GET_CODE (dest) == SUBREG
1272 && (((GET_MODE_SIZE (GET_MODE (dest))
1273 + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
1274 == ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (dest)))
1275 + UNITS_PER_WORD - 1) / UNITS_PER_WORD)))
1276 dest = SUBREG_REG (dest);
1278 if (GET_CODE (dest) != REG)
1281 regno = REGNO (dest);
1282 endregno = (regno >= FIRST_PSEUDO_REGISTER ? regno + 1
1283 : regno + HARD_REGNO_NREGS (regno, GET_MODE (dest)));
1285 return (test_regno >= regno && test_regno < endregno);
1287 else if (GET_CODE (PATTERN (insn)) == PARALLEL)
1291 for (i = XVECLEN (PATTERN (insn), 0) - 1; i >= 0; i--)
1293 rtx body = XVECEXP (PATTERN (insn), 0, i);
1295 if (GET_CODE (body) == SET || GET_CODE (body) == CLOBBER)
1297 rtx dest = SET_DEST (body);
1299 if (GET_CODE (dest) == SUBREG
1300 && (((GET_MODE_SIZE (GET_MODE (dest))
1301 + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
1302 == ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (dest)))
1303 + UNITS_PER_WORD - 1) / UNITS_PER_WORD)))
1304 dest = SUBREG_REG (dest);
1306 if (GET_CODE (dest) != REG)
1309 regno = REGNO (dest);
1310 endregno = (regno >= FIRST_PSEUDO_REGISTER ? regno + 1
1311 : regno + HARD_REGNO_NREGS (regno, GET_MODE (dest)));
1313 if (test_regno >= regno && test_regno < endregno)
1322 /* Return the reg-note of kind KIND in insn INSN, if there is one.
1323 If DATUM is nonzero, look for one whose datum is DATUM. */
1326 find_reg_note (insn, kind, datum)
1333 /* Ignore anything that is not an INSN, JUMP_INSN or CALL_INSN. */
1334 if (GET_RTX_CLASS (GET_CODE (insn)) != 'i')
1337 for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
1338 if (REG_NOTE_KIND (link) == kind
1339 && (datum == 0 || datum == XEXP (link, 0)))
1344 /* Return the reg-note of kind KIND in insn INSN which applies to register
1345 number REGNO, if any. Return 0 if there is no such reg-note. Note that
1346 the REGNO of this NOTE need not be REGNO if REGNO is a hard register;
1347 it might be the case that the note overlaps REGNO. */
1350 find_regno_note (insn, kind, regno)
1357 /* Ignore anything that is not an INSN, JUMP_INSN or CALL_INSN. */
1358 if (GET_RTX_CLASS (GET_CODE (insn)) != 'i')
1361 for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
1362 if (REG_NOTE_KIND (link) == kind
1363 /* Verify that it is a register, so that scratch and MEM won't cause a
1365 && GET_CODE (XEXP (link, 0)) == REG
1366 && REGNO (XEXP (link, 0)) <= regno
1367 && ((REGNO (XEXP (link, 0))
1368 + (REGNO (XEXP (link, 0)) >= FIRST_PSEUDO_REGISTER ? 1
1369 : HARD_REGNO_NREGS (REGNO (XEXP (link, 0)),
1370 GET_MODE (XEXP (link, 0)))))
1376 /* Return true if DATUM, or any overlap of DATUM, of kind CODE is found
1377 in the CALL_INSN_FUNCTION_USAGE information of INSN. */
1380 find_reg_fusage (insn, code, datum)
1385 /* If it's not a CALL_INSN, it can't possibly have a
1386 CALL_INSN_FUNCTION_USAGE field, so don't bother checking. */
1387 if (GET_CODE (insn) != CALL_INSN)
1393 if (GET_CODE (datum) != REG)
1397 for (link = CALL_INSN_FUNCTION_USAGE (insn);
1399 link = XEXP (link, 1))
1400 if (GET_CODE (XEXP (link, 0)) == code
1401 && rtx_equal_p (datum, SET_DEST (XEXP (link, 0))))
1406 register int regno = REGNO (datum);
1408 /* CALL_INSN_FUNCTION_USAGE information cannot contain references
1409 to pseudo registers, so don't bother checking. */
1411 if (regno < FIRST_PSEUDO_REGISTER)
1413 int end_regno = regno + HARD_REGNO_NREGS (regno, GET_MODE (datum));
1416 for (i = regno; i < end_regno; i++)
1417 if (find_regno_fusage (insn, code, i))
1425 /* Return true if REGNO, or any overlap of REGNO, of kind CODE is found
1426 in the CALL_INSN_FUNCTION_USAGE information of INSN. */
1429 find_regno_fusage (insn, code, regno)
1436 /* CALL_INSN_FUNCTION_USAGE information cannot contain references
1437 to pseudo registers, so don't bother checking. */
1439 if (regno >= FIRST_PSEUDO_REGISTER
1440 || GET_CODE (insn) != CALL_INSN )
1443 for (link = CALL_INSN_FUNCTION_USAGE (insn); link; link = XEXP (link, 1))
1445 register int regnote;
1448 if (GET_CODE (op = XEXP (link, 0)) == code
1449 && GET_CODE (SET_DEST (op)) == REG
1450 && (regnote = REGNO (SET_DEST (op))) <= regno
1452 + HARD_REGNO_NREGS (regnote, GET_MODE (SET_DEST (op)))
1460 /* Remove register note NOTE from the REG_NOTES of INSN. */
1463 remove_note (insn, note)
1469 if (REG_NOTES (insn) == note)
1471 REG_NOTES (insn) = XEXP (note, 1);
1475 for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
1476 if (XEXP (link, 1) == note)
1478 XEXP (link, 1) = XEXP (note, 1);
1485 /* Nonzero if X contains any volatile instructions. These are instructions
1486 which may cause unpredictable machine state instructions, and thus no
1487 instructions should be moved or combined across them. This includes
1488 only volatile asms and UNSPEC_VOLATILE instructions. */
1494 register RTX_CODE code;
1496 code = GET_CODE (x);
1516 case UNSPEC_VOLATILE:
1517 /* case TRAP_IF: This isn't clear yet. */
1521 if (MEM_VOLATILE_P (x))
1528 /* Recursively scan the operands of this expression. */
1531 register char *fmt = GET_RTX_FORMAT (code);
1534 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
1538 if (volatile_insn_p (XEXP (x, i)))
1544 for (j = 0; j < XVECLEN (x, i); j++)
1545 if (volatile_insn_p (XVECEXP (x, i, j)))
1553 /* Nonzero if X contains any volatile memory references
1554 UNSPEC_VOLATILE operations or volatile ASM_OPERANDS expressions. */
1560 register RTX_CODE code;
1562 code = GET_CODE (x);
1581 case UNSPEC_VOLATILE:
1582 /* case TRAP_IF: This isn't clear yet. */
1587 if (MEM_VOLATILE_P (x))
1594 /* Recursively scan the operands of this expression. */
1597 register char *fmt = GET_RTX_FORMAT (code);
1600 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
1604 if (volatile_refs_p (XEXP (x, i)))
1610 for (j = 0; j < XVECLEN (x, i); j++)
1611 if (volatile_refs_p (XVECEXP (x, i, j)))
1619 /* Similar to above, except that it also rejects register pre- and post-
1626 register RTX_CODE code;
1628 code = GET_CODE (x);
1646 /* Reject CLOBBER with a non-VOID mode. These are made by combine.c
1647 when some combination can't be done. If we see one, don't think
1648 that we can simplify the expression. */
1649 return (GET_MODE (x) != VOIDmode);
1656 case UNSPEC_VOLATILE:
1657 /* case TRAP_IF: This isn't clear yet. */
1662 if (MEM_VOLATILE_P (x))
1669 /* Recursively scan the operands of this expression. */
1672 register char *fmt = GET_RTX_FORMAT (code);
1675 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
1679 if (side_effects_p (XEXP (x, i)))
1685 for (j = 0; j < XVECLEN (x, i); j++)
1686 if (side_effects_p (XVECEXP (x, i, j)))
1694 /* Return nonzero if evaluating rtx X might cause a trap. */
1706 code = GET_CODE (x);
1709 /* Handle these cases quickly. */
1721 /* Conditional trap can trap! */
1722 case UNSPEC_VOLATILE:
1726 /* Memory ref can trap unless it's a static var or a stack slot. */
1728 return rtx_addr_can_trap_p (XEXP (x, 0));
1730 /* Division by a non-constant might trap. */
1735 if (! CONSTANT_P (XEXP (x, 1))
1736 || GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT)
1738 /* This was const0_rtx, but by not using that,
1739 we can link this file into other programs. */
1740 if (GET_CODE (XEXP (x, 1)) == CONST_INT && INTVAL (XEXP (x, 1)) == 0)
1745 /* An EXPR_LIST is used to represent a function call. This
1746 certainly may trap. */
1750 /* Any floating arithmetic may trap. */
1751 if (GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT)
1755 fmt = GET_RTX_FORMAT (code);
1756 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
1760 if (may_trap_p (XEXP (x, i)))
1763 else if (fmt[i] == 'E')
1766 for (j = 0; j < XVECLEN (x, i); j++)
1767 if (may_trap_p (XVECEXP (x, i, j)))
1774 /* Return nonzero if X contains a comparison that is not either EQ or NE,
1775 i.e., an inequality. */
1778 inequality_comparisons_p (x)
1782 register int len, i;
1783 register enum rtx_code code = GET_CODE (x);
1812 len = GET_RTX_LENGTH (code);
1813 fmt = GET_RTX_FORMAT (code);
1815 for (i = 0; i < len; i++)
1819 if (inequality_comparisons_p (XEXP (x, i)))
1822 else if (fmt[i] == 'E')
1825 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
1826 if (inequality_comparisons_p (XVECEXP (x, i, j)))
1834 /* Replace any occurrence of FROM in X with TO. The function does
1835 not enter into CONST_DOUBLE for the replace.
1837 Note that copying is not done so X must not be shared unless all copies
1838 are to be modified. */
1841 replace_rtx (x, from, to)
1847 /* The following prevents loops occurrence when we change MEM in
1848 CONST_DOUBLE onto the same CONST_DOUBLE. */
1849 if (x != 0 && GET_CODE (x) == CONST_DOUBLE)
1855 /* Allow this function to make replacements in EXPR_LISTs. */
1859 fmt = GET_RTX_FORMAT (GET_CODE (x));
1860 for (i = GET_RTX_LENGTH (GET_CODE (x)) - 1; i >= 0; i--)
1863 XEXP (x, i) = replace_rtx (XEXP (x, i), from, to);
1864 else if (fmt[i] == 'E')
1865 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
1866 XVECEXP (x, i, j) = replace_rtx (XVECEXP (x, i, j), from, to);
1872 /* Throughout the rtx X, replace many registers according to REG_MAP.
1873 Return the replacement for X (which may be X with altered contents).
1874 REG_MAP[R] is the replacement for register R, or 0 for don't replace.
1875 NREGS is the length of REG_MAP; regs >= NREGS are not mapped.
1877 We only support REG_MAP entries of REG or SUBREG. Also, hard registers
1878 should not be mapped to pseudos or vice versa since validate_change
1881 If REPLACE_DEST is 1, replacements are also done in destinations;
1882 otherwise, only sources are replaced. */
1885 replace_regs (x, reg_map, nregs, replace_dest)
1891 register enum rtx_code code;
1898 code = GET_CODE (x);
1912 /* Verify that the register has an entry before trying to access it. */
1913 if (REGNO (x) < nregs && reg_map[REGNO (x)] != 0)
1915 /* SUBREGs can't be shared. Always return a copy to ensure that if
1916 this replacement occurs more than once then each instance will
1917 get distinct rtx. */
1918 if (GET_CODE (reg_map[REGNO (x)]) == SUBREG)
1919 return copy_rtx (reg_map[REGNO (x)]);
1920 return reg_map[REGNO (x)];
1925 /* Prevent making nested SUBREGs. */
1926 if (GET_CODE (SUBREG_REG (x)) == REG && REGNO (SUBREG_REG (x)) < nregs
1927 && reg_map[REGNO (SUBREG_REG (x))] != 0
1928 && GET_CODE (reg_map[REGNO (SUBREG_REG (x))]) == SUBREG)
1930 rtx map_val = reg_map[REGNO (SUBREG_REG (x))];
1931 rtx map_inner = SUBREG_REG (map_val);
1933 if (GET_MODE (x) == GET_MODE (map_inner))
1937 /* We cannot call gen_rtx here since we may be linked with
1939 /* Let's try clobbering the incoming SUBREG and see
1940 if this is really safe. */
1941 SUBREG_REG (x) = map_inner;
1942 SUBREG_WORD (x) += SUBREG_WORD (map_val);
1945 rtx new = rtx_alloc (SUBREG);
1946 PUT_MODE (new, GET_MODE (x));
1947 SUBREG_REG (new) = map_inner;
1948 SUBREG_WORD (new) = SUBREG_WORD (x) + SUBREG_WORD (map_val);
1956 SET_DEST (x) = replace_regs (SET_DEST (x), reg_map, nregs, 0);
1958 else if (GET_CODE (SET_DEST (x)) == MEM
1959 || GET_CODE (SET_DEST (x)) == STRICT_LOW_PART)
1960 /* Even if we are not to replace destinations, replace register if it
1961 is CONTAINED in destination (destination is memory or
1962 STRICT_LOW_PART). */
1963 XEXP (SET_DEST (x), 0) = replace_regs (XEXP (SET_DEST (x), 0),
1965 else if (GET_CODE (SET_DEST (x)) == ZERO_EXTRACT)
1966 /* Similarly, for ZERO_EXTRACT we replace all operands. */
1969 SET_SRC (x) = replace_regs (SET_SRC (x), reg_map, nregs, 0);
1976 fmt = GET_RTX_FORMAT (code);
1977 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
1980 XEXP (x, i) = replace_regs (XEXP (x, i), reg_map, nregs, replace_dest);
1984 for (j = 0; j < XVECLEN (x, i); j++)
1985 XVECEXP (x, i, j) = replace_regs (XVECEXP (x, i, j), reg_map,
1986 nregs, replace_dest);
1992 /* Return 1 if X, the SRC_SRC of SET of (pc) contain a REG or MEM that is
1993 not in the constant pool and not in the condition of an IF_THEN_ELSE. */
1996 jmp_uses_reg_or_mem (x)
1999 enum rtx_code code = GET_CODE (x);
2014 return ! (GET_CODE (XEXP (x, 0)) == SYMBOL_REF
2015 && CONSTANT_POOL_ADDRESS_P (XEXP (x, 0)));
2018 return (jmp_uses_reg_or_mem (XEXP (x, 1))
2019 || jmp_uses_reg_or_mem (XEXP (x, 2)));
2021 case PLUS: case MINUS: case MULT:
2022 return (jmp_uses_reg_or_mem (XEXP (x, 0))
2023 || jmp_uses_reg_or_mem (XEXP (x, 1)));
2029 fmt = GET_RTX_FORMAT (code);
2030 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
2033 && jmp_uses_reg_or_mem (XEXP (x, i)))
2037 for (j = 0; j < XVECLEN (x, i); j++)
2038 if (jmp_uses_reg_or_mem (XVECEXP (x, i, j)))
2045 /* Return nonzero if INSN is an indirect jump (aka computed jump).
2047 Tablejumps and casesi insns are not considered indirect jumps;
2048 we can recognize them by a (use (lael_ref)). */
2051 computed_jump_p (insn)
2055 if (GET_CODE (insn) == JUMP_INSN)
2057 rtx pat = PATTERN (insn);
2059 if (GET_CODE (pat) == PARALLEL)
2061 int len = XVECLEN (pat, 0);
2062 int has_use_labelref = 0;
2064 for (i = len - 1; i >= 0; i--)
2065 if (GET_CODE (XVECEXP (pat, 0, i)) == USE
2066 && (GET_CODE (XEXP (XVECEXP (pat, 0, i), 0))
2068 has_use_labelref = 1;
2070 if (! has_use_labelref)
2071 for (i = len - 1; i >= 0; i--)
2072 if (GET_CODE (XVECEXP (pat, 0, i)) == SET
2073 && SET_DEST (XVECEXP (pat, 0, i)) == pc_rtx
2074 && jmp_uses_reg_or_mem (SET_SRC (XVECEXP (pat, 0, i))))
2077 else if (GET_CODE (pat) == SET
2078 && SET_DEST (pat) == pc_rtx
2079 && jmp_uses_reg_or_mem (SET_SRC (pat)))
2085 /* Traverse X via depth-first search, calling F for each
2086 sub-expression (including X itself). F is also passed the DATA.
2087 If F returns -1, do not traverse sub-expressions, but continue
2088 traversing the rest of the tree. If F ever returns any other
2089 non-zero value, stop the traversal, and return the value returned
2090 by F. Otherwise, return 0. This function does not traverse inside
2091 tree structure that contains RTX_EXPRs, or into sub-expressions
2092 whose format code is `0' since it is not known whether or not those
2093 codes are actually RTL.
2095 This routine is very general, and could (should?) be used to
2096 implement many of the other routines in this file. */
2099 for_each_rtx (x, f, data)
2110 result = (*f)(x, data);
2112 /* Do not traverse sub-expressions. */
2114 else if (result != 0)
2115 /* Stop the traversal. */
2119 /* There are no sub-expressions. */
2122 length = GET_RTX_LENGTH (GET_CODE (*x));
2123 format = GET_RTX_FORMAT (GET_CODE (*x));
2125 for (i = 0; i < length; ++i)
2130 result = for_each_rtx (&XEXP (*x, i), f, data);
2137 if (XVEC (*x, i) != 0)
2140 for (j = 0; j < XVECLEN (*x, i); ++j)
2142 result = for_each_rtx (&XVECEXP (*x, i, j), f, data);
2150 /* Nothing to do. */