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 GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
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));
33 static int operand_preference PARAMS ((rtx));
34 static void parms_set PARAMS ((rtx, rtx, void *));
36 /* Bit flags that specify the machine subtype we are compiling for.
37 Bits are tested using macros TARGET_... defined in the tm.h file
38 and set by `-m...' switches. Must be defined in rtlanal.c. */
42 /* Return 1 if the value of X is unstable
43 (would be different at a different point in the program).
44 The frame pointer, arg pointer, etc. are considered stable
45 (within one function) and so is anything marked `unchanging'. */
51 register RTX_CODE code = GET_CODE (x);
53 register const char *fmt;
58 return ! RTX_UNCHANGING_P (x) || rtx_unstable_p (XEXP (x, 0));
72 /* As in rtx_varies_p, we have to use the actual rtx, not reg number. */
73 if (x == frame_pointer_rtx || x == hard_frame_pointer_rtx
74 /* The arg pointer varies if it is not a fixed register. */
75 || (x == arg_pointer_rtx && fixed_regs[ARG_POINTER_REGNUM])
76 || RTX_UNCHANGING_P (x))
78 #ifndef PIC_OFFSET_TABLE_REG_CALL_CLOBBERED
79 /* ??? When call-clobbered, the value is stable modulo the restore
80 that must happen after a call. This currently screws up local-alloc
81 into believing that the restore is not needed. */
82 if (x == pic_offset_table_rtx)
88 if (MEM_VOLATILE_P (x))
97 fmt = GET_RTX_FORMAT (code);
98 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
101 if (rtx_unstable_p (XEXP (x, i)))
104 else if (fmt[i] == 'E')
107 for (j = 0; j < XVECLEN (x, i); j++)
108 if (rtx_unstable_p (XVECEXP (x, i, j)))
115 /* Return 1 if X has a value that can vary even between two
116 executions of the program. 0 means X can be compared reliably
117 against certain constants or near-constants.
118 FOR_ALIAS is nonzero if we are called from alias analysis; if it is
119 zero, we are slightly more conservative.
120 The frame pointer and the arg pointer are considered constant. */
123 rtx_varies_p (x, for_alias)
127 register RTX_CODE code = GET_CODE (x);
129 register const char *fmt;
134 return ! RTX_UNCHANGING_P (x) || rtx_varies_p (XEXP (x, 0), for_alias);
147 /* Note that we have to test for the actual rtx used for the frame
148 and arg pointers and not just the register number in case we have
149 eliminated the frame and/or arg pointer and are using it
151 if (x == frame_pointer_rtx || x == hard_frame_pointer_rtx
152 /* The arg pointer varies if it is not a fixed register. */
153 || (x == arg_pointer_rtx && fixed_regs[ARG_POINTER_REGNUM]))
155 if (x == pic_offset_table_rtx
156 #ifdef PIC_OFFSET_TABLE_REG_CALL_CLOBBERED
157 /* ??? When call-clobbered, the value is stable modulo the restore
158 that must happen after a call. This currently screws up
159 local-alloc into believing that the restore is not needed, so we
160 must return 0 only if we are called from alias analysis. */
168 /* The operand 0 of a LO_SUM is considered constant
169 (in fact it is related specifically to operand 1)
170 during alias analysis. */
171 return (! for_alias && rtx_varies_p (XEXP (x, 0), for_alias))
172 || rtx_varies_p (XEXP (x, 1), for_alias);
175 if (MEM_VOLATILE_P (x))
184 fmt = GET_RTX_FORMAT (code);
185 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
188 if (rtx_varies_p (XEXP (x, i), for_alias))
191 else if (fmt[i] == 'E')
194 for (j = 0; j < XVECLEN (x, i); j++)
195 if (rtx_varies_p (XVECEXP (x, i, j), for_alias))
202 /* Return 0 if the use of X as an address in a MEM can cause a trap. */
205 rtx_addr_can_trap_p (x)
208 register enum rtx_code code = GET_CODE (x);
213 return SYMBOL_REF_WEAK (x);
219 /* As in rtx_varies_p, we have to use the actual rtx, not reg number. */
220 if (x == frame_pointer_rtx || x == hard_frame_pointer_rtx
221 || x == stack_pointer_rtx
222 /* The arg pointer varies if it is not a fixed register. */
223 || (x == arg_pointer_rtx && fixed_regs[ARG_POINTER_REGNUM]))
225 /* All of the virtual frame registers are stack references. */
226 if (REGNO (x) >= FIRST_VIRTUAL_REGISTER
227 && REGNO (x) <= LAST_VIRTUAL_REGISTER)
232 return rtx_addr_can_trap_p (XEXP (x, 0));
235 /* An address is assumed not to trap if it is an address that can't
236 trap plus a constant integer or it is the pic register plus a
238 return ! ((! rtx_addr_can_trap_p (XEXP (x, 0))
239 && GET_CODE (XEXP (x, 1)) == CONST_INT)
240 || (XEXP (x, 0) == pic_offset_table_rtx
241 && CONSTANT_P (XEXP (x, 1))));
245 return rtx_addr_can_trap_p (XEXP (x, 1));
252 return rtx_addr_can_trap_p (XEXP (x, 0));
258 /* If it isn't one of the case above, it can cause a trap. */
262 /* Return 1 if X refers to a memory location whose address
263 cannot be compared reliably with constant addresses,
264 or if X refers to a BLKmode memory object.
265 FOR_ALIAS is nonzero if we are called from alias analysis; if it is
266 zero, we are slightly more conservative. */
269 rtx_addr_varies_p (x, for_alias)
273 register enum rtx_code code;
275 register const char *fmt;
282 return GET_MODE (x) == BLKmode || rtx_varies_p (XEXP (x, 0), for_alias);
284 fmt = GET_RTX_FORMAT (code);
285 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
288 if (rtx_addr_varies_p (XEXP (x, i), for_alias))
291 else if (fmt[i] == 'E')
294 for (j = 0; j < XVECLEN (x, i); j++)
295 if (rtx_addr_varies_p (XVECEXP (x, i, j), for_alias))
301 /* Return the value of the integer term in X, if one is apparent;
303 Only obvious integer terms are detected.
304 This is used in cse.c with the `related_value' field.*/
310 if (GET_CODE (x) == CONST)
313 if (GET_CODE (x) == MINUS
314 && GET_CODE (XEXP (x, 1)) == CONST_INT)
315 return - INTVAL (XEXP (x, 1));
316 if (GET_CODE (x) == PLUS
317 && GET_CODE (XEXP (x, 1)) == CONST_INT)
318 return INTVAL (XEXP (x, 1));
322 /* If X is a constant, return the value sans apparent integer term;
324 Only obvious integer terms are detected. */
327 get_related_value (x)
330 if (GET_CODE (x) != CONST)
333 if (GET_CODE (x) == PLUS
334 && GET_CODE (XEXP (x, 1)) == CONST_INT)
336 else if (GET_CODE (x) == MINUS
337 && GET_CODE (XEXP (x, 1)) == CONST_INT)
342 /* Return the number of places FIND appears within X. If COUNT_DEST is
343 zero, we do not count occurrences inside the destination of a SET. */
346 count_occurrences (x, find, count_dest)
352 const char *format_ptr;
372 if (GET_CODE (find) == MEM && rtx_equal_p (x, find))
377 if (SET_DEST (x) == find && ! count_dest)
378 return count_occurrences (SET_SRC (x), find, count_dest);
385 format_ptr = GET_RTX_FORMAT (code);
388 for (i = 0; i < GET_RTX_LENGTH (code); i++)
390 switch (*format_ptr++)
393 count += count_occurrences (XEXP (x, i), find, count_dest);
397 for (j = 0; j < XVECLEN (x, i); j++)
398 count += count_occurrences (XVECEXP (x, i, j), find, count_dest);
405 /* Nonzero if register REG appears somewhere within IN.
406 Also works if REG is not a register; in this case it checks
407 for a subexpression of IN that is Lisp "equal" to REG. */
410 reg_mentioned_p (reg, in)
411 register rtx reg, in;
413 register const char *fmt;
415 register enum rtx_code code;
423 if (GET_CODE (in) == LABEL_REF)
424 return reg == XEXP (in, 0);
426 code = GET_CODE (in);
430 /* Compare registers by number. */
432 return GET_CODE (reg) == REG && REGNO (in) == REGNO (reg);
434 /* These codes have no constituent expressions
442 return GET_CODE (reg) == CONST_INT && INTVAL (in) == INTVAL (reg);
445 /* These are kept unique for a given value. */
452 if (GET_CODE (reg) == code && rtx_equal_p (reg, in))
455 fmt = GET_RTX_FORMAT (code);
457 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
462 for (j = XVECLEN (in, i) - 1; j >= 0; j--)
463 if (reg_mentioned_p (reg, XVECEXP (in, i, j)))
466 else if (fmt[i] == 'e'
467 && reg_mentioned_p (reg, XEXP (in, i)))
473 /* Return 1 if in between BEG and END, exclusive of BEG and END, there is
474 no CODE_LABEL insn. */
477 no_labels_between_p (beg, end)
483 for (p = NEXT_INSN (beg); p != end; p = NEXT_INSN (p))
484 if (GET_CODE (p) == CODE_LABEL)
489 /* Return 1 if in between BEG and END, exclusive of BEG and END, there is
490 no JUMP_INSN insn. */
493 no_jumps_between_p (beg, end)
497 for (p = NEXT_INSN (beg); p != end; p = NEXT_INSN (p))
498 if (GET_CODE (p) == JUMP_INSN)
503 /* Nonzero if register REG is used in an insn between
504 FROM_INSN and TO_INSN (exclusive of those two). */
507 reg_used_between_p (reg, from_insn, to_insn)
508 rtx reg, from_insn, to_insn;
512 if (from_insn == to_insn)
515 for (insn = NEXT_INSN (from_insn); insn != to_insn; insn = NEXT_INSN (insn))
517 && (reg_overlap_mentioned_p (reg, PATTERN (insn))
518 || (GET_CODE (insn) == CALL_INSN
519 && (find_reg_fusage (insn, USE, reg)
520 || find_reg_fusage (insn, CLOBBER, reg)))))
525 /* Nonzero if the old value of X, a register, is referenced in BODY. If X
526 is entirely replaced by a new value and the only use is as a SET_DEST,
527 we do not consider it a reference. */
530 reg_referenced_p (x, body)
536 switch (GET_CODE (body))
539 if (reg_overlap_mentioned_p (x, SET_SRC (body)))
542 /* If the destination is anything other than CC0, PC, a REG or a SUBREG
543 of a REG that occupies all of the REG, the insn references X if
544 it is mentioned in the destination. */
545 if (GET_CODE (SET_DEST (body)) != CC0
546 && GET_CODE (SET_DEST (body)) != PC
547 && GET_CODE (SET_DEST (body)) != REG
548 && ! (GET_CODE (SET_DEST (body)) == SUBREG
549 && GET_CODE (SUBREG_REG (SET_DEST (body))) == REG
550 && (((GET_MODE_SIZE (GET_MODE (SUBREG_REG (SET_DEST (body))))
551 + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD)
552 == ((GET_MODE_SIZE (GET_MODE (SET_DEST (body)))
553 + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD)))
554 && reg_overlap_mentioned_p (x, SET_DEST (body)))
559 for (i = ASM_OPERANDS_INPUT_LENGTH (body) - 1; i >= 0; i--)
560 if (reg_overlap_mentioned_p (x, ASM_OPERANDS_INPUT (body, i)))
567 return reg_overlap_mentioned_p (x, body);
570 return reg_overlap_mentioned_p (x, TRAP_CONDITION (body));
573 case UNSPEC_VOLATILE:
574 for (i = XVECLEN (body, 0) - 1; i >= 0; i--)
575 if (reg_overlap_mentioned_p (x, XVECEXP (body, 0, i)))
580 for (i = XVECLEN (body, 0) - 1; i >= 0; i--)
581 if (reg_referenced_p (x, XVECEXP (body, 0, i)))
586 if (GET_CODE (XEXP (body, 0)) == MEM)
587 if (reg_overlap_mentioned_p (x, XEXP (XEXP (body, 0), 0)))
592 if (reg_overlap_mentioned_p (x, COND_EXEC_TEST (body)))
594 return reg_referenced_p (x, COND_EXEC_CODE (body));
601 /* Nonzero if register REG is referenced in an insn between
602 FROM_INSN and TO_INSN (exclusive of those two). Sets of REG do
606 reg_referenced_between_p (reg, from_insn, to_insn)
607 rtx reg, from_insn, to_insn;
611 if (from_insn == to_insn)
614 for (insn = NEXT_INSN (from_insn); insn != to_insn; insn = NEXT_INSN (insn))
616 && (reg_referenced_p (reg, PATTERN (insn))
617 || (GET_CODE (insn) == CALL_INSN
618 && find_reg_fusage (insn, USE, reg))))
623 /* Nonzero if register REG is set or clobbered in an insn between
624 FROM_INSN and TO_INSN (exclusive of those two). */
627 reg_set_between_p (reg, from_insn, to_insn)
628 rtx reg, from_insn, to_insn;
632 if (from_insn == to_insn)
635 for (insn = NEXT_INSN (from_insn); insn != to_insn; insn = NEXT_INSN (insn))
636 if (INSN_P (insn) && reg_set_p (reg, insn))
641 /* Internals of reg_set_between_p. */
643 reg_set_p (reg, insn)
648 /* We can be passed an insn or part of one. If we are passed an insn,
649 check if a side-effect of the insn clobbers REG. */
652 if (FIND_REG_INC_NOTE (insn, reg)
653 || (GET_CODE (insn) == CALL_INSN
654 /* We'd like to test call_used_regs here, but rtlanal.c can't
655 reference that variable due to its use in genattrtab. So
656 we'll just be more conservative.
658 ??? Unless we could ensure that the CALL_INSN_FUNCTION_USAGE
659 information holds all clobbered registers. */
660 && ((GET_CODE (reg) == REG
661 && REGNO (reg) < FIRST_PSEUDO_REGISTER)
662 || GET_CODE (reg) == MEM
663 || find_reg_fusage (insn, CLOBBER, reg))))
666 body = PATTERN (insn);
669 return set_of (reg, insn) != NULL_RTX;
672 /* Similar to reg_set_between_p, but check all registers in X. Return 0
673 only if none of them are modified between START and END. Do not
674 consider non-registers one way or the other. */
677 regs_set_between_p (x, start, end)
681 enum rtx_code code = GET_CODE (x);
697 return reg_set_between_p (x, start, end);
703 fmt = GET_RTX_FORMAT (code);
704 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
706 if (fmt[i] == 'e' && regs_set_between_p (XEXP (x, i), start, end))
709 else if (fmt[i] == 'E')
710 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
711 if (regs_set_between_p (XVECEXP (x, i, j), start, end))
718 /* Similar to reg_set_between_p, but check all registers in X. Return 0
719 only if none of them are modified between START and END. Return 1 if
720 X contains a MEM; this routine does not perform any memory aliasing. */
723 modified_between_p (x, start, end)
727 enum rtx_code code = GET_CODE (x);
745 /* If the memory is not constant, assume it is modified. If it is
746 constant, we still have to check the address. */
747 if (! RTX_UNCHANGING_P (x))
752 return reg_set_between_p (x, start, end);
758 fmt = GET_RTX_FORMAT (code);
759 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
761 if (fmt[i] == 'e' && modified_between_p (XEXP (x, i), start, end))
764 else if (fmt[i] == 'E')
765 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
766 if (modified_between_p (XVECEXP (x, i, j), start, end))
773 /* Similar to reg_set_p, but check all registers in X. Return 0 only if none
774 of them are modified in INSN. Return 1 if X contains a MEM; this routine
775 does not perform any memory aliasing. */
778 modified_in_p (x, insn)
782 enum rtx_code code = GET_CODE (x);
800 /* If the memory is not constant, assume it is modified. If it is
801 constant, we still have to check the address. */
802 if (! RTX_UNCHANGING_P (x))
807 return reg_set_p (x, insn);
813 fmt = GET_RTX_FORMAT (code);
814 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
816 if (fmt[i] == 'e' && modified_in_p (XEXP (x, i), insn))
819 else if (fmt[i] == 'E')
820 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
821 if (modified_in_p (XVECEXP (x, i, j), insn))
828 /* Return true if anything in insn X is (anti,output,true) dependent on
829 anything in insn Y. */
832 insn_dependent_p (x, y)
837 if (! INSN_P (x) || ! INSN_P (y))
841 note_stores (PATTERN (x), insn_dependent_p_1, &tmp);
846 note_stores (PATTERN (y), insn_dependent_p_1, &tmp);
853 /* A helper routine for insn_dependent_p called through note_stores. */
856 insn_dependent_p_1 (x, pat, data)
858 rtx pat ATTRIBUTE_UNUSED;
861 rtx * pinsn = (rtx *) data;
863 if (*pinsn && reg_mentioned_p (x, *pinsn))
867 /* Helper function for set_of. */
875 set_of_1 (x, pat, data1)
880 struct set_of_data *data = (struct set_of_data *) (data1);
881 if (rtx_equal_p (x, data->pat)
882 || (GET_CODE (x) != MEM && reg_overlap_mentioned_p (data->pat, x)))
886 /* Give an INSN, return a SET or CLOBBER expression that does modify PAT
887 (eighter directly or via STRICT_LOW_PART and similar modifiers). */
892 struct set_of_data data;
893 data.found = NULL_RTX;
895 note_stores (INSN_P (insn) ? PATTERN (insn) : insn, set_of_1, &data);
899 /* Given an INSN, return a SET expression if this insn has only a single SET.
900 It may also have CLOBBERs, USEs, or SET whose output
901 will not be used, which we ignore. */
904 single_set_2 (insn, pat)
908 int set_verified = 1;
911 if (GET_CODE (pat) == PARALLEL)
913 for (i = 0; i < XVECLEN (pat, 0); i++)
915 rtx sub = XVECEXP (pat, 0, i);
916 switch (GET_CODE (sub))
923 /* We can consider insns having multiple sets, where all
924 but one are dead as single set insns. In common case
925 only single set is present in the pattern so we want
926 to avoid checking for REG_UNUSED notes unless neccesary.
928 When we reach set first time, we just expect this is
929 the single set we are looking for and only when more
930 sets are found in the insn, we check them. */
933 if (find_reg_note (insn, REG_UNUSED, SET_DEST (set))
934 && !side_effects_p (set))
940 set = sub, set_verified = 0;
941 else if (!find_reg_note (insn, REG_UNUSED, SET_DEST (sub))
942 || side_effects_p (sub))
954 /* Given an INSN, return nonzero if it has more than one SET, else return
964 /* INSN must be an insn. */
968 /* Only a PARALLEL can have multiple SETs. */
969 if (GET_CODE (PATTERN (insn)) == PARALLEL)
971 for (i = 0, found = 0; i < XVECLEN (PATTERN (insn), 0); i++)
972 if (GET_CODE (XVECEXP (PATTERN (insn), 0, i)) == SET)
974 /* If we have already found a SET, then return now. */
982 /* Either zero or one SET. */
986 /* Return nonzero if the destination of SET equals the source
987 and there are no side effects. */
993 rtx src = SET_SRC (set);
994 rtx dst = SET_DEST (set);
996 if (side_effects_p (src) || side_effects_p (dst))
999 if (GET_CODE (dst) == MEM && GET_CODE (src) == MEM)
1000 return rtx_equal_p (dst, src);
1002 if (dst == pc_rtx && src == pc_rtx)
1005 if (GET_CODE (dst) == SIGN_EXTRACT
1006 || GET_CODE (dst) == ZERO_EXTRACT)
1007 return rtx_equal_p (XEXP (dst, 0), src)
1008 && ! BYTES_BIG_ENDIAN && XEXP (dst, 2) == const0_rtx;
1010 if (GET_CODE (dst) == STRICT_LOW_PART)
1011 dst = XEXP (dst, 0);
1013 if (GET_CODE (src) == SUBREG && GET_CODE (dst) == SUBREG)
1015 if (SUBREG_BYTE (src) != SUBREG_BYTE (dst))
1017 src = SUBREG_REG (src);
1018 dst = SUBREG_REG (dst);
1021 return (GET_CODE (src) == REG && GET_CODE (dst) == REG
1022 && REGNO (src) == REGNO (dst));
1025 /* Return nonzero if an insn consists only of SETs, each of which only sets a
1032 rtx pat = PATTERN (insn);
1034 if (INSN_CODE (insn) == NOOP_MOVE_INSN_CODE)
1037 /* Insns carrying these notes are useful later on. */
1038 if (find_reg_note (insn, REG_EQUAL, NULL_RTX))
1041 if (GET_CODE (pat) == SET && set_noop_p (pat))
1044 if (GET_CODE (pat) == PARALLEL)
1047 /* If nothing but SETs of registers to themselves,
1048 this insn can also be deleted. */
1049 for (i = 0; i < XVECLEN (pat, 0); i++)
1051 rtx tem = XVECEXP (pat, 0, i);
1053 if (GET_CODE (tem) == USE
1054 || GET_CODE (tem) == CLOBBER)
1057 if (GET_CODE (tem) != SET || ! set_noop_p (tem))
1067 /* Return the last thing that X was assigned from before *PINSN. If VALID_TO
1068 is not NULL_RTX then verify that the object is not modified up to VALID_TO.
1069 If the object was modified, if we hit a partial assignment to X, or hit a
1070 CODE_LABEL first, return X. If we found an assignment, update *PINSN to
1071 point to it. ALLOW_HWREG is set to 1 if hardware registers are allowed to
1075 find_last_value (x, pinsn, valid_to, allow_hwreg)
1083 for (p = PREV_INSN (*pinsn); p && GET_CODE (p) != CODE_LABEL;
1087 rtx set = single_set (p);
1088 rtx note = find_reg_note (p, REG_EQUAL, NULL_RTX);
1090 if (set && rtx_equal_p (x, SET_DEST (set)))
1092 rtx src = SET_SRC (set);
1094 if (note && GET_CODE (XEXP (note, 0)) != EXPR_LIST)
1095 src = XEXP (note, 0);
1097 if ((valid_to == NULL_RTX
1098 || ! modified_between_p (src, PREV_INSN (p), valid_to))
1099 /* Reject hard registers because we don't usually want
1100 to use them; we'd rather use a pseudo. */
1101 && (! (GET_CODE (src) == REG
1102 && REGNO (src) < FIRST_PSEUDO_REGISTER) || allow_hwreg))
1109 /* If set in non-simple way, we don't have a value. */
1110 if (reg_set_p (x, p))
1117 /* Return nonzero if register in range [REGNO, ENDREGNO)
1118 appears either explicitly or implicitly in X
1119 other than being stored into.
1121 References contained within the substructure at LOC do not count.
1122 LOC may be zero, meaning don't ignore anything. */
1125 refers_to_regno_p (regno, endregno, x, loc)
1126 unsigned int regno, endregno;
1131 unsigned int x_regno;
1136 /* The contents of a REG_NONNEG note is always zero, so we must come here
1137 upon repeat in case the last REG_NOTE is a REG_NONNEG note. */
1141 code = GET_CODE (x);
1146 x_regno = REGNO (x);
1148 /* If we modifying the stack, frame, or argument pointer, it will
1149 clobber a virtual register. In fact, we could be more precise,
1150 but it isn't worth it. */
1151 if ((x_regno == STACK_POINTER_REGNUM
1152 #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
1153 || x_regno == ARG_POINTER_REGNUM
1155 || x_regno == FRAME_POINTER_REGNUM)
1156 && regno >= FIRST_VIRTUAL_REGISTER && regno <= LAST_VIRTUAL_REGISTER)
1159 return (endregno > x_regno
1160 && regno < x_regno + (x_regno < FIRST_PSEUDO_REGISTER
1161 ? HARD_REGNO_NREGS (x_regno, GET_MODE (x))
1165 /* If this is a SUBREG of a hard reg, we can see exactly which
1166 registers are being modified. Otherwise, handle normally. */
1167 if (GET_CODE (SUBREG_REG (x)) == REG
1168 && REGNO (SUBREG_REG (x)) < FIRST_PSEUDO_REGISTER)
1170 unsigned int inner_regno = subreg_regno (x);
1171 unsigned int inner_endregno
1172 = inner_regno + (inner_regno < FIRST_PSEUDO_REGISTER
1173 ? HARD_REGNO_NREGS (regno, GET_MODE (x)) : 1);
1175 return endregno > inner_regno && regno < inner_endregno;
1181 if (&SET_DEST (x) != loc
1182 /* Note setting a SUBREG counts as referring to the REG it is in for
1183 a pseudo but not for hard registers since we can
1184 treat each word individually. */
1185 && ((GET_CODE (SET_DEST (x)) == SUBREG
1186 && loc != &SUBREG_REG (SET_DEST (x))
1187 && GET_CODE (SUBREG_REG (SET_DEST (x))) == REG
1188 && REGNO (SUBREG_REG (SET_DEST (x))) >= FIRST_PSEUDO_REGISTER
1189 && refers_to_regno_p (regno, endregno,
1190 SUBREG_REG (SET_DEST (x)), loc))
1191 || (GET_CODE (SET_DEST (x)) != REG
1192 && refers_to_regno_p (regno, endregno, SET_DEST (x), loc))))
1195 if (code == CLOBBER || loc == &SET_SRC (x))
1204 /* X does not match, so try its subexpressions. */
1206 fmt = GET_RTX_FORMAT (code);
1207 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
1209 if (fmt[i] == 'e' && loc != &XEXP (x, i))
1217 if (refers_to_regno_p (regno, endregno, XEXP (x, i), loc))
1220 else if (fmt[i] == 'E')
1223 for (j = XVECLEN (x, i) - 1; j >=0; j--)
1224 if (loc != &XVECEXP (x, i, j)
1225 && refers_to_regno_p (regno, endregno, XVECEXP (x, i, j), loc))
1232 /* Nonzero if modifying X will affect IN. If X is a register or a SUBREG,
1233 we check if any register number in X conflicts with the relevant register
1234 numbers. If X is a constant, return 0. If X is a MEM, return 1 iff IN
1235 contains a MEM (we don't bother checking for memory addresses that can't
1236 conflict because we expect this to be a rare case. */
1239 reg_overlap_mentioned_p (x, in)
1242 unsigned int regno, endregno;
1244 /* Overly conservative. */
1245 if (GET_CODE (x) == STRICT_LOW_PART)
1248 /* If either argument is a constant, then modifying X can not affect IN. */
1249 if (CONSTANT_P (x) || CONSTANT_P (in))
1252 switch (GET_CODE (x))
1255 regno = REGNO (SUBREG_REG (x));
1256 if (regno < FIRST_PSEUDO_REGISTER)
1257 regno = subreg_regno (x);
1263 endregno = regno + (regno < FIRST_PSEUDO_REGISTER
1264 ? HARD_REGNO_NREGS (regno, GET_MODE (x)) : 1);
1265 return refers_to_regno_p (regno, endregno, in, (rtx*)0);
1272 if (GET_CODE (in) == MEM)
1275 fmt = GET_RTX_FORMAT (GET_CODE (in));
1276 for (i = GET_RTX_LENGTH (GET_CODE (in)) - 1; i >= 0; i--)
1277 if (fmt[i] == 'e' && reg_overlap_mentioned_p (x, XEXP (in, i)))
1286 return reg_mentioned_p (x, in);
1292 /* If any register in here refers to it we return true. */
1293 for (i = XVECLEN (x, 0) - 1; i >= 0; i--)
1294 if (XEXP (XVECEXP (x, 0, i), 0) != 0
1295 && reg_overlap_mentioned_p (XEXP (XVECEXP (x, 0, i), 0), in))
1307 /* Return the last value to which REG was set prior to INSN. If we can't
1308 find it easily, return 0.
1310 We only return a REG, SUBREG, or constant because it is too hard to
1311 check if a MEM remains unchanged. */
1314 reg_set_last (x, insn)
1318 rtx orig_insn = insn;
1320 /* Scan backwards until reg_set_last_1 changed one of the above flags.
1321 Stop when we reach a label or X is a hard reg and we reach a
1322 CALL_INSN (if reg_set_last_last_regno is a hard reg).
1324 If we find a set of X, ensure that its SET_SRC remains unchanged. */
1326 /* We compare with <= here, because reg_set_last_last_regno
1327 is actually the number of the first reg *not* in X. */
1329 insn && GET_CODE (insn) != CODE_LABEL
1330 && ! (GET_CODE (insn) == CALL_INSN
1331 && REGNO (x) <= FIRST_PSEUDO_REGISTER);
1332 insn = PREV_INSN (insn))
1335 rtx set = set_of (x, insn);
1336 /* OK, this function modify our register. See if we understand it. */
1340 if (GET_CODE (set) != SET || SET_DEST (set) != x)
1342 last_value = SET_SRC (x);
1343 if (CONSTANT_P (last_value)
1344 || ((GET_CODE (last_value) == REG
1345 || GET_CODE (last_value) == SUBREG)
1346 && ! reg_set_between_p (last_value,
1357 /* Call FUN on each register or MEM that is stored into or clobbered by X.
1358 (X would be the pattern of an insn).
1359 FUN receives two arguments:
1360 the REG, MEM, CC0 or PC being stored in or clobbered,
1361 the SET or CLOBBER rtx that does the store.
1363 If the item being stored in or clobbered is a SUBREG of a hard register,
1364 the SUBREG will be passed. */
1367 note_stores (x, fun, data)
1369 void (*fun) PARAMS ((rtx, rtx, void *));
1374 if (GET_CODE (x) == COND_EXEC)
1375 x = COND_EXEC_CODE (x);
1377 if (GET_CODE (x) == SET || GET_CODE (x) == CLOBBER)
1379 register rtx dest = SET_DEST (x);
1381 while ((GET_CODE (dest) == SUBREG
1382 && (GET_CODE (SUBREG_REG (dest)) != REG
1383 || REGNO (SUBREG_REG (dest)) >= FIRST_PSEUDO_REGISTER))
1384 || GET_CODE (dest) == ZERO_EXTRACT
1385 || GET_CODE (dest) == SIGN_EXTRACT
1386 || GET_CODE (dest) == STRICT_LOW_PART)
1387 dest = XEXP (dest, 0);
1389 /* If we have a PARALLEL, SET_DEST is a list of EXPR_LIST expressions,
1390 each of whose first operand is a register. We can't know what
1391 precisely is being set in these cases, so make up a CLOBBER to pass
1393 if (GET_CODE (dest) == PARALLEL)
1395 for (i = XVECLEN (dest, 0) - 1; i >= 0; i--)
1396 if (XEXP (XVECEXP (dest, 0, i), 0) != 0)
1397 (*fun) (XEXP (XVECEXP (dest, 0, i), 0),
1398 gen_rtx_CLOBBER (VOIDmode,
1399 XEXP (XVECEXP (dest, 0, i), 0)),
1403 (*fun) (dest, x, data);
1406 else if (GET_CODE (x) == PARALLEL)
1407 for (i = XVECLEN (x, 0) - 1; i >= 0; i--)
1408 note_stores (XVECEXP (x, 0, i), fun, data);
1411 /* Like notes_stores, but call FUN for each expression that is being
1412 referenced in PBODY, a pointer to the PATTERN of an insn. We only call
1413 FUN for each expression, not any interior subexpressions. FUN receives a
1414 pointer to the expression and the DATA passed to this function.
1416 Note that this is not quite the same test as that done in reg_referenced_p
1417 since that considers something as being referenced if it is being
1418 partially set, while we do not. */
1421 note_uses (pbody, fun, data)
1423 void (*fun) PARAMS ((rtx *, void *));
1429 switch (GET_CODE (body))
1432 (*fun) (&COND_EXEC_TEST (body), data);
1433 note_uses (&COND_EXEC_CODE (body), fun, data);
1437 for (i = XVECLEN (body, 0) - 1; i >= 0; i--)
1438 note_uses (&XVECEXP (body, 0, i), fun, data);
1442 (*fun) (&XEXP (body, 0), data);
1446 for (i = ASM_OPERANDS_INPUT_LENGTH (body) - 1; i >= 0; i--)
1447 (*fun) (&ASM_OPERANDS_INPUT (body, i), data);
1451 (*fun) (&TRAP_CONDITION (body), data);
1455 case UNSPEC_VOLATILE:
1456 for (i = XVECLEN (body, 0) - 1; i >= 0; i--)
1457 (*fun) (&XVECEXP (body, 0, i), data);
1461 if (GET_CODE (XEXP (body, 0)) == MEM)
1462 (*fun) (&XEXP (XEXP (body, 0), 0), data);
1467 rtx dest = SET_DEST (body);
1469 /* For sets we replace everything in source plus registers in memory
1470 expression in store and operands of a ZERO_EXTRACT. */
1471 (*fun) (&SET_SRC (body), data);
1473 if (GET_CODE (dest) == ZERO_EXTRACT)
1475 (*fun) (&XEXP (dest, 1), data);
1476 (*fun) (&XEXP (dest, 2), data);
1479 while (GET_CODE (dest) == SUBREG || GET_CODE (dest) == STRICT_LOW_PART)
1480 dest = XEXP (dest, 0);
1482 if (GET_CODE (dest) == MEM)
1483 (*fun) (&XEXP (dest, 0), data);
1488 /* All the other possibilities never store. */
1489 (*fun) (pbody, data);
1494 /* Return nonzero if X's old contents don't survive after INSN.
1495 This will be true if X is (cc0) or if X is a register and
1496 X dies in INSN or because INSN entirely sets X.
1498 "Entirely set" means set directly and not through a SUBREG,
1499 ZERO_EXTRACT or SIGN_EXTRACT, so no trace of the old contents remains.
1500 Likewise, REG_INC does not count.
1502 REG may be a hard or pseudo reg. Renumbering is not taken into account,
1503 but for this use that makes no difference, since regs don't overlap
1504 during their lifetimes. Therefore, this function may be used
1505 at any time after deaths have been computed (in flow.c).
1507 If REG is a hard reg that occupies multiple machine registers, this
1508 function will only return 1 if each of those registers will be replaced
1512 dead_or_set_p (insn, x)
1516 unsigned int regno, last_regno;
1519 /* Can't use cc0_rtx below since this file is used by genattrtab.c. */
1520 if (GET_CODE (x) == CC0)
1523 if (GET_CODE (x) != REG)
1527 last_regno = (regno >= FIRST_PSEUDO_REGISTER ? regno
1528 : regno + HARD_REGNO_NREGS (regno, GET_MODE (x)) - 1);
1530 for (i = regno; i <= last_regno; i++)
1531 if (! dead_or_set_regno_p (insn, i))
1537 /* Utility function for dead_or_set_p to check an individual register. Also
1538 called from flow.c. */
1541 dead_or_set_regno_p (insn, test_regno)
1543 unsigned int test_regno;
1545 unsigned int regno, endregno;
1548 /* See if there is a death note for something that includes TEST_REGNO. */
1549 if (find_regno_note (insn, REG_DEAD, test_regno))
1552 if (GET_CODE (insn) == CALL_INSN
1553 && find_regno_fusage (insn, CLOBBER, test_regno))
1556 pattern = PATTERN (insn);
1558 if (GET_CODE (pattern) == COND_EXEC)
1559 pattern = COND_EXEC_CODE (pattern);
1561 if (GET_CODE (pattern) == SET)
1563 rtx dest = SET_DEST (PATTERN (insn));
1565 /* A value is totally replaced if it is the destination or the
1566 destination is a SUBREG of REGNO that does not change the number of
1568 if (GET_CODE (dest) == SUBREG
1569 && (((GET_MODE_SIZE (GET_MODE (dest))
1570 + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
1571 == ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (dest)))
1572 + UNITS_PER_WORD - 1) / UNITS_PER_WORD)))
1573 dest = SUBREG_REG (dest);
1575 if (GET_CODE (dest) != REG)
1578 regno = REGNO (dest);
1579 endregno = (regno >= FIRST_PSEUDO_REGISTER ? regno + 1
1580 : regno + HARD_REGNO_NREGS (regno, GET_MODE (dest)));
1582 return (test_regno >= regno && test_regno < endregno);
1584 else if (GET_CODE (pattern) == PARALLEL)
1588 for (i = XVECLEN (pattern, 0) - 1; i >= 0; i--)
1590 rtx body = XVECEXP (pattern, 0, i);
1592 if (GET_CODE (body) == COND_EXEC)
1593 body = COND_EXEC_CODE (body);
1595 if (GET_CODE (body) == SET || GET_CODE (body) == CLOBBER)
1597 rtx dest = SET_DEST (body);
1599 if (GET_CODE (dest) == SUBREG
1600 && (((GET_MODE_SIZE (GET_MODE (dest))
1601 + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
1602 == ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (dest)))
1603 + UNITS_PER_WORD - 1) / UNITS_PER_WORD)))
1604 dest = SUBREG_REG (dest);
1606 if (GET_CODE (dest) != REG)
1609 regno = REGNO (dest);
1610 endregno = (regno >= FIRST_PSEUDO_REGISTER ? regno + 1
1611 : regno + HARD_REGNO_NREGS (regno, GET_MODE (dest)));
1613 if (test_regno >= regno && test_regno < endregno)
1622 /* Return the reg-note of kind KIND in insn INSN, if there is one.
1623 If DATUM is nonzero, look for one whose datum is DATUM. */
1626 find_reg_note (insn, kind, datum)
1633 /* Ignore anything that is not an INSN, JUMP_INSN or CALL_INSN. */
1634 if (! INSN_P (insn))
1637 for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
1638 if (REG_NOTE_KIND (link) == kind
1639 && (datum == 0 || datum == XEXP (link, 0)))
1644 /* Return the reg-note of kind KIND in insn INSN which applies to register
1645 number REGNO, if any. Return 0 if there is no such reg-note. Note that
1646 the REGNO of this NOTE need not be REGNO if REGNO is a hard register;
1647 it might be the case that the note overlaps REGNO. */
1650 find_regno_note (insn, kind, regno)
1657 /* Ignore anything that is not an INSN, JUMP_INSN or CALL_INSN. */
1658 if (! INSN_P (insn))
1661 for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
1662 if (REG_NOTE_KIND (link) == kind
1663 /* Verify that it is a register, so that scratch and MEM won't cause a
1665 && GET_CODE (XEXP (link, 0)) == REG
1666 && REGNO (XEXP (link, 0)) <= regno
1667 && ((REGNO (XEXP (link, 0))
1668 + (REGNO (XEXP (link, 0)) >= FIRST_PSEUDO_REGISTER ? 1
1669 : HARD_REGNO_NREGS (REGNO (XEXP (link, 0)),
1670 GET_MODE (XEXP (link, 0)))))
1676 /* Return a REG_EQUIV or REG_EQUAL note if insn has only a single set and
1680 find_reg_equal_equiv_note (insn)
1685 if (single_set (insn) == 0)
1687 else if ((note = find_reg_note (insn, REG_EQUIV, NULL_RTX)) != 0)
1690 return find_reg_note (insn, REG_EQUAL, NULL_RTX);
1693 /* Return true if DATUM, or any overlap of DATUM, of kind CODE is found
1694 in the CALL_INSN_FUNCTION_USAGE information of INSN. */
1697 find_reg_fusage (insn, code, datum)
1702 /* If it's not a CALL_INSN, it can't possibly have a
1703 CALL_INSN_FUNCTION_USAGE field, so don't bother checking. */
1704 if (GET_CODE (insn) != CALL_INSN)
1710 if (GET_CODE (datum) != REG)
1714 for (link = CALL_INSN_FUNCTION_USAGE (insn);
1716 link = XEXP (link, 1))
1717 if (GET_CODE (XEXP (link, 0)) == code
1718 && rtx_equal_p (datum, SET_DEST (XEXP (link, 0))))
1723 unsigned int regno = REGNO (datum);
1725 /* CALL_INSN_FUNCTION_USAGE information cannot contain references
1726 to pseudo registers, so don't bother checking. */
1728 if (regno < FIRST_PSEUDO_REGISTER)
1730 unsigned int end_regno
1731 = regno + HARD_REGNO_NREGS (regno, GET_MODE (datum));
1734 for (i = regno; i < end_regno; i++)
1735 if (find_regno_fusage (insn, code, i))
1743 /* Return true if REGNO, or any overlap of REGNO, of kind CODE is found
1744 in the CALL_INSN_FUNCTION_USAGE information of INSN. */
1747 find_regno_fusage (insn, code, regno)
1754 /* CALL_INSN_FUNCTION_USAGE information cannot contain references
1755 to pseudo registers, so don't bother checking. */
1757 if (regno >= FIRST_PSEUDO_REGISTER
1758 || GET_CODE (insn) != CALL_INSN )
1761 for (link = CALL_INSN_FUNCTION_USAGE (insn); link; link = XEXP (link, 1))
1763 unsigned int regnote;
1766 if (GET_CODE (op = XEXP (link, 0)) == code
1767 && GET_CODE (reg = XEXP (op, 0)) == REG
1768 && (regnote = REGNO (reg)) <= regno
1769 && regnote + HARD_REGNO_NREGS (regnote, GET_MODE (reg)) > regno)
1776 /* Remove register note NOTE from the REG_NOTES of INSN. */
1779 remove_note (insn, note)
1785 if (note == NULL_RTX)
1788 if (REG_NOTES (insn) == note)
1790 REG_NOTES (insn) = XEXP (note, 1);
1794 for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
1795 if (XEXP (link, 1) == note)
1797 XEXP (link, 1) = XEXP (note, 1);
1804 /* Search LISTP (an EXPR_LIST) for an entry whose first operand is NODE and
1805 remove that entry from the list if it is found.
1807 A simple equality test is used to determine if NODE matches. */
1810 remove_node_from_expr_list (node, listp)
1815 rtx prev = NULL_RTX;
1819 if (node == XEXP (temp, 0))
1821 /* Splice the node out of the list. */
1823 XEXP (prev, 1) = XEXP (temp, 1);
1825 *listp = XEXP (temp, 1);
1831 temp = XEXP (temp, 1);
1835 /* Nonzero if X contains any volatile instructions. These are instructions
1836 which may cause unpredictable machine state instructions, and thus no
1837 instructions should be moved or combined across them. This includes
1838 only volatile asms and UNSPEC_VOLATILE instructions. */
1844 register RTX_CODE code;
1846 code = GET_CODE (x);
1866 case UNSPEC_VOLATILE:
1867 /* case TRAP_IF: This isn't clear yet. */
1871 if (MEM_VOLATILE_P (x))
1878 /* Recursively scan the operands of this expression. */
1881 register const char *fmt = GET_RTX_FORMAT (code);
1884 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
1888 if (volatile_insn_p (XEXP (x, i)))
1891 else if (fmt[i] == 'E')
1894 for (j = 0; j < XVECLEN (x, i); j++)
1895 if (volatile_insn_p (XVECEXP (x, i, j)))
1903 /* Nonzero if X contains any volatile memory references
1904 UNSPEC_VOLATILE operations or volatile ASM_OPERANDS expressions. */
1910 register RTX_CODE code;
1912 code = GET_CODE (x);
1931 case UNSPEC_VOLATILE:
1932 /* case TRAP_IF: This isn't clear yet. */
1937 if (MEM_VOLATILE_P (x))
1944 /* Recursively scan the operands of this expression. */
1947 register const char *fmt = GET_RTX_FORMAT (code);
1950 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
1954 if (volatile_refs_p (XEXP (x, i)))
1957 else if (fmt[i] == 'E')
1960 for (j = 0; j < XVECLEN (x, i); j++)
1961 if (volatile_refs_p (XVECEXP (x, i, j)))
1969 /* Similar to above, except that it also rejects register pre- and post-
1976 register RTX_CODE code;
1978 code = GET_CODE (x);
1996 /* Reject CLOBBER with a non-VOID mode. These are made by combine.c
1997 when some combination can't be done. If we see one, don't think
1998 that we can simplify the expression. */
1999 return (GET_MODE (x) != VOIDmode);
2008 case UNSPEC_VOLATILE:
2009 /* case TRAP_IF: This isn't clear yet. */
2014 if (MEM_VOLATILE_P (x))
2021 /* Recursively scan the operands of this expression. */
2024 register const char *fmt = GET_RTX_FORMAT (code);
2027 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
2031 if (side_effects_p (XEXP (x, i)))
2034 else if (fmt[i] == 'E')
2037 for (j = 0; j < XVECLEN (x, i); j++)
2038 if (side_effects_p (XVECEXP (x, i, j)))
2046 /* Return nonzero if evaluating rtx X might cause a trap. */
2058 code = GET_CODE (x);
2061 /* Handle these cases quickly. */
2074 case UNSPEC_VOLATILE:
2079 return MEM_VOLATILE_P (x);
2081 /* Memory ref can trap unless it's a static var or a stack slot. */
2083 return rtx_addr_can_trap_p (XEXP (x, 0));
2085 /* Division by a non-constant might trap. */
2090 if (! CONSTANT_P (XEXP (x, 1))
2091 || GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT)
2093 /* This was const0_rtx, but by not using that,
2094 we can link this file into other programs. */
2095 if (GET_CODE (XEXP (x, 1)) == CONST_INT && INTVAL (XEXP (x, 1)) == 0)
2100 /* An EXPR_LIST is used to represent a function call. This
2101 certainly may trap. */
2109 /* Some floating point comparisons may trap. */
2110 /* ??? There is no machine independent way to check for tests that trap
2111 when COMPARE is used, though many targets do make this distinction.
2112 For instance, sparc uses CCFPE for compares which generate exceptions
2113 and CCFP for compares which do not generate exceptions. */
2114 if (GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT)
2116 /* But often the compare has some CC mode, so check operand
2118 if (GET_MODE_CLASS (GET_MODE (XEXP (x, 0))) == MODE_FLOAT
2119 || GET_MODE_CLASS (GET_MODE (XEXP (x, 1))) == MODE_FLOAT)
2125 /* These operations don't trap even with floating point. */
2129 /* Any floating arithmetic may trap. */
2130 if (GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT)
2134 fmt = GET_RTX_FORMAT (code);
2135 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
2139 if (may_trap_p (XEXP (x, i)))
2142 else if (fmt[i] == 'E')
2145 for (j = 0; j < XVECLEN (x, i); j++)
2146 if (may_trap_p (XVECEXP (x, i, j)))
2153 /* Return nonzero if X contains a comparison that is not either EQ or NE,
2154 i.e., an inequality. */
2157 inequality_comparisons_p (x)
2160 register const char *fmt;
2161 register int len, i;
2162 register enum rtx_code code = GET_CODE (x);
2191 len = GET_RTX_LENGTH (code);
2192 fmt = GET_RTX_FORMAT (code);
2194 for (i = 0; i < len; i++)
2198 if (inequality_comparisons_p (XEXP (x, i)))
2201 else if (fmt[i] == 'E')
2204 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
2205 if (inequality_comparisons_p (XVECEXP (x, i, j)))
2213 /* Replace any occurrence of FROM in X with TO. The function does
2214 not enter into CONST_DOUBLE for the replace.
2216 Note that copying is not done so X must not be shared unless all copies
2217 are to be modified. */
2220 replace_rtx (x, from, to)
2224 register const char *fmt;
2226 /* The following prevents loops occurrence when we change MEM in
2227 CONST_DOUBLE onto the same CONST_DOUBLE. */
2228 if (x != 0 && GET_CODE (x) == CONST_DOUBLE)
2234 /* Allow this function to make replacements in EXPR_LISTs. */
2238 fmt = GET_RTX_FORMAT (GET_CODE (x));
2239 for (i = GET_RTX_LENGTH (GET_CODE (x)) - 1; i >= 0; i--)
2242 XEXP (x, i) = replace_rtx (XEXP (x, i), from, to);
2243 else if (fmt[i] == 'E')
2244 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
2245 XVECEXP (x, i, j) = replace_rtx (XVECEXP (x, i, j), from, to);
2251 /* Throughout the rtx X, replace many registers according to REG_MAP.
2252 Return the replacement for X (which may be X with altered contents).
2253 REG_MAP[R] is the replacement for register R, or 0 for don't replace.
2254 NREGS is the length of REG_MAP; regs >= NREGS are not mapped.
2256 We only support REG_MAP entries of REG or SUBREG. Also, hard registers
2257 should not be mapped to pseudos or vice versa since validate_change
2260 If REPLACE_DEST is 1, replacements are also done in destinations;
2261 otherwise, only sources are replaced. */
2264 replace_regs (x, reg_map, nregs, replace_dest)
2270 register enum rtx_code code;
2272 register const char *fmt;
2277 code = GET_CODE (x);
2291 /* Verify that the register has an entry before trying to access it. */
2292 if (REGNO (x) < nregs && reg_map[REGNO (x)] != 0)
2294 /* SUBREGs can't be shared. Always return a copy to ensure that if
2295 this replacement occurs more than once then each instance will
2296 get distinct rtx. */
2297 if (GET_CODE (reg_map[REGNO (x)]) == SUBREG)
2298 return copy_rtx (reg_map[REGNO (x)]);
2299 return reg_map[REGNO (x)];
2304 /* Prevent making nested SUBREGs. */
2305 if (GET_CODE (SUBREG_REG (x)) == REG && REGNO (SUBREG_REG (x)) < nregs
2306 && reg_map[REGNO (SUBREG_REG (x))] != 0
2307 && GET_CODE (reg_map[REGNO (SUBREG_REG (x))]) == SUBREG)
2309 rtx map_val = reg_map[REGNO (SUBREG_REG (x))];
2310 return simplify_gen_subreg (GET_MODE (x), map_val,
2311 GET_MODE (SUBREG_REG (x)),
2318 SET_DEST (x) = replace_regs (SET_DEST (x), reg_map, nregs, 0);
2320 else if (GET_CODE (SET_DEST (x)) == MEM
2321 || GET_CODE (SET_DEST (x)) == STRICT_LOW_PART)
2322 /* Even if we are not to replace destinations, replace register if it
2323 is CONTAINED in destination (destination is memory or
2324 STRICT_LOW_PART). */
2325 XEXP (SET_DEST (x), 0) = replace_regs (XEXP (SET_DEST (x), 0),
2327 else if (GET_CODE (SET_DEST (x)) == ZERO_EXTRACT)
2328 /* Similarly, for ZERO_EXTRACT we replace all operands. */
2331 SET_SRC (x) = replace_regs (SET_SRC (x), reg_map, nregs, 0);
2338 fmt = GET_RTX_FORMAT (code);
2339 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
2342 XEXP (x, i) = replace_regs (XEXP (x, i), reg_map, nregs, replace_dest);
2343 else if (fmt[i] == 'E')
2346 for (j = 0; j < XVECLEN (x, i); j++)
2347 XVECEXP (x, i, j) = replace_regs (XVECEXP (x, i, j), reg_map,
2348 nregs, replace_dest);
2354 /* A subroutine of computed_jump_p, return 1 if X contains a REG or MEM or
2355 constant that is not in the constant pool and not in the condition
2356 of an IF_THEN_ELSE. */
2359 computed_jump_p_1 (x)
2362 enum rtx_code code = GET_CODE (x);
2380 return ! (GET_CODE (XEXP (x, 0)) == SYMBOL_REF
2381 && CONSTANT_POOL_ADDRESS_P (XEXP (x, 0)));
2384 return (computed_jump_p_1 (XEXP (x, 1))
2385 || computed_jump_p_1 (XEXP (x, 2)));
2391 fmt = GET_RTX_FORMAT (code);
2392 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
2395 && computed_jump_p_1 (XEXP (x, i)))
2398 else if (fmt[i] == 'E')
2399 for (j = 0; j < XVECLEN (x, i); j++)
2400 if (computed_jump_p_1 (XVECEXP (x, i, j)))
2407 /* Return nonzero if INSN is an indirect jump (aka computed jump).
2409 Tablejumps and casesi insns are not considered indirect jumps;
2410 we can recognize them by a (use (label_ref)). */
2413 computed_jump_p (insn)
2417 if (GET_CODE (insn) == JUMP_INSN)
2419 rtx pat = PATTERN (insn);
2421 if (find_reg_note (insn, REG_LABEL, NULL_RTX))
2423 else if (GET_CODE (pat) == PARALLEL)
2425 int len = XVECLEN (pat, 0);
2426 int has_use_labelref = 0;
2428 for (i = len - 1; i >= 0; i--)
2429 if (GET_CODE (XVECEXP (pat, 0, i)) == USE
2430 && (GET_CODE (XEXP (XVECEXP (pat, 0, i), 0))
2432 has_use_labelref = 1;
2434 if (! has_use_labelref)
2435 for (i = len - 1; i >= 0; i--)
2436 if (GET_CODE (XVECEXP (pat, 0, i)) == SET
2437 && SET_DEST (XVECEXP (pat, 0, i)) == pc_rtx
2438 && computed_jump_p_1 (SET_SRC (XVECEXP (pat, 0, i))))
2441 else if (GET_CODE (pat) == SET
2442 && SET_DEST (pat) == pc_rtx
2443 && computed_jump_p_1 (SET_SRC (pat)))
2449 /* Traverse X via depth-first search, calling F for each
2450 sub-expression (including X itself). F is also passed the DATA.
2451 If F returns -1, do not traverse sub-expressions, but continue
2452 traversing the rest of the tree. If F ever returns any other
2453 non-zero value, stop the traversal, and return the value returned
2454 by F. Otherwise, return 0. This function does not traverse inside
2455 tree structure that contains RTX_EXPRs, or into sub-expressions
2456 whose format code is `0' since it is not known whether or not those
2457 codes are actually RTL.
2459 This routine is very general, and could (should?) be used to
2460 implement many of the other routines in this file. */
2463 for_each_rtx (x, f, data)
2474 result = (*f) (x, data);
2476 /* Do not traverse sub-expressions. */
2478 else if (result != 0)
2479 /* Stop the traversal. */
2483 /* There are no sub-expressions. */
2486 length = GET_RTX_LENGTH (GET_CODE (*x));
2487 format = GET_RTX_FORMAT (GET_CODE (*x));
2489 for (i = 0; i < length; ++i)
2494 result = for_each_rtx (&XEXP (*x, i), f, data);
2501 if (XVEC (*x, i) != 0)
2504 for (j = 0; j < XVECLEN (*x, i); ++j)
2506 result = for_each_rtx (&XVECEXP (*x, i, j), f, data);
2514 /* Nothing to do. */
2523 /* Searches X for any reference to REGNO, returning the rtx of the
2524 reference found if any. Otherwise, returns NULL_RTX. */
2527 regno_use_in (regno, x)
2531 register const char *fmt;
2535 if (GET_CODE (x) == REG && REGNO (x) == regno)
2538 fmt = GET_RTX_FORMAT (GET_CODE (x));
2539 for (i = GET_RTX_LENGTH (GET_CODE (x)) - 1; i >= 0; i--)
2543 if ((tem = regno_use_in (regno, XEXP (x, i))))
2546 else if (fmt[i] == 'E')
2547 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
2548 if ((tem = regno_use_in (regno , XVECEXP (x, i, j))))
2555 /* Return a value indicating whether OP, an operand of a commutative
2556 operation, is preferred as the first or second operand. The higher
2557 the value, the stronger the preference for being the first operand.
2558 We use negative values to indicate a preference for the first operand
2559 and positive values for the second operand. */
2562 operand_preference (op)
2565 /* Constants always come the second operand. Prefer "nice" constants. */
2566 if (GET_CODE (op) == CONST_INT)
2568 if (GET_CODE (op) == CONST_DOUBLE)
2570 if (CONSTANT_P (op))
2573 /* SUBREGs of objects should come second. */
2574 if (GET_CODE (op) == SUBREG
2575 && GET_RTX_CLASS (GET_CODE (SUBREG_REG (op))) == 'o')
2578 /* If only one operand is a `neg', `not',
2579 `mult', `plus', or `minus' expression, it will be the first
2581 if (GET_CODE (op) == NEG || GET_CODE (op) == NOT
2582 || GET_CODE (op) == MULT || GET_CODE (op) == PLUS
2583 || GET_CODE (op) == MINUS)
2586 /* Complex expressions should be the first, so decrease priority
2588 if (GET_RTX_CLASS (GET_CODE (op)) == 'o')
2593 /* Return 1 iff it is neccesary to swap operands of commutative operation
2594 in order to canonicalize expression. */
2597 swap_commutative_operands_p (x, y)
2600 return operand_preference (x) < operand_preference (y);
2603 /* Return 1 if X is an autoincrement side effect and the register is
2604 not the stack pointer. */
2609 switch (GET_CODE (x))
2617 /* There are no REG_INC notes for SP. */
2618 if (XEXP (x, 0) != stack_pointer_rtx)
2626 /* Return 1 if the sequence of instructions beginning with FROM and up
2627 to and including TO is safe to move. If NEW_TO is non-NULL, and
2628 the sequence is not already safe to move, but can be easily
2629 extended to a sequence which is safe, then NEW_TO will point to the
2630 end of the extended sequence.
2632 For now, this function only checks that the region contains whole
2633 exception regions, but it could be extended to check additional
2634 conditions as well. */
2637 insns_safe_to_move_p (from, to, new_to)
2642 int eh_region_count = 0;
2646 /* By default, assume the end of the region will be what was
2653 if (GET_CODE (r) == NOTE)
2655 switch (NOTE_LINE_NUMBER (r))
2657 case NOTE_INSN_EH_REGION_BEG:
2661 case NOTE_INSN_EH_REGION_END:
2662 if (eh_region_count == 0)
2663 /* This sequence of instructions contains the end of
2664 an exception region, but not he beginning. Moving
2665 it will cause chaos. */
2676 /* If we've passed TO, and we see a non-note instruction, we
2677 can't extend the sequence to a movable sequence. */
2683 /* It's OK to move the sequence if there were matched sets of
2684 exception region notes. */
2685 return eh_region_count == 0;
2690 /* It's OK to move the sequence if there were matched sets of
2691 exception region notes. */
2692 if (past_to_p && eh_region_count == 0)
2698 /* Go to the next instruction. */
2705 /* Return non-zero if IN contains a piece of rtl that has the address LOC */
2707 loc_mentioned_in_p (loc, in)
2710 enum rtx_code code = GET_CODE (in);
2711 const char *fmt = GET_RTX_FORMAT (code);
2714 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
2716 if (loc == &in->fld[i].rtx)
2720 if (loc_mentioned_in_p (loc, XEXP (in, i)))
2723 else if (fmt[i] == 'E')
2724 for (j = XVECLEN (in, i) - 1; j >= 0; j--)
2725 if (loc_mentioned_in_p (loc, XVECEXP (in, i, j)))
2731 /* This function returns the regno offset of a subreg expression.
2732 xregno - A regno of an inner hard subreg_reg (or what will become one).
2733 xmode - The mode of xregno.
2734 offset - The byte offset.
2735 ymode - The mode of a top level SUBREG (or what may become one).
2736 RETURN - The regno offset which would be used.
2737 This function can be overridden by defining SUBREG_REGNO_OFFSET,
2738 taking the same parameters. */
2740 subreg_regno_offset (xregno, xmode, offset, ymode)
2741 unsigned int xregno;
2742 enum machine_mode xmode;
2743 unsigned int offset;
2744 enum machine_mode ymode;
2747 int nregs_xmode, nregs_ymode;
2748 int mode_multiple, nregs_multiple;
2751 /* Check for an override, and use it instead. */
2752 #ifdef SUBREG_REGNO_OFFSET
2753 ret = SUBREG_REGNO_OFFSET (xregno, xmode, offset, ymode)
2755 if (xregno >= FIRST_PSEUDO_REGISTER)
2758 nregs_xmode = HARD_REGNO_NREGS (xregno, xmode);
2759 nregs_ymode = HARD_REGNO_NREGS (xregno, ymode);
2760 if (offset == 0 || nregs_xmode == nregs_ymode)
2763 /* size of ymode must not be greater than the size of xmode. */
2764 mode_multiple = GET_MODE_SIZE (xmode) / GET_MODE_SIZE (ymode);
2765 if (mode_multiple == 0)
2768 y_offset = offset / GET_MODE_SIZE (ymode);
2769 nregs_multiple = nregs_xmode / nregs_ymode;
2770 ret = (y_offset / (mode_multiple / nregs_multiple)) * nregs_ymode;
2776 /* Return the final regno that a subreg expression refers to. */
2782 rtx subreg = SUBREG_REG (x);
2783 int regno = REGNO (subreg);
2785 ret = regno + subreg_regno_offset (regno,
2792 struct parms_set_data
2798 /* Helper function for noticing stores to parameter registers. */
2800 parms_set (x, pat, data)
2801 rtx x, pat ATTRIBUTE_UNUSED;
2804 struct parms_set_data *d = data;
2805 if (REG_P (x) && REGNO (x) < FIRST_PSEUDO_REGISTER
2806 && TEST_HARD_REG_BIT (d->regs, REGNO (x)))
2808 CLEAR_HARD_REG_BIT (d->regs, REGNO (x));
2813 /* Look backward for first parameter to be loaded.
2814 Do not skip BOUNDARY. */
2816 find_first_parameter_load (call_insn, boundary)
2817 rtx call_insn, boundary;
2819 struct parms_set_data parm;
2822 /* Since different machines initialize their parameter registers
2823 in different orders, assume nothing. Collect the set of all
2824 parameter registers. */
2825 CLEAR_HARD_REG_SET (parm.regs);
2827 for (p = CALL_INSN_FUNCTION_USAGE (call_insn); p; p = XEXP (p, 1))
2828 if (GET_CODE (XEXP (p, 0)) == USE
2829 && GET_CODE (XEXP (XEXP (p, 0), 0)) == REG)
2831 if (REGNO (XEXP (XEXP (p, 0), 0)) >= FIRST_PSEUDO_REGISTER)
2834 /* We only care about registers which can hold function
2836 if (!FUNCTION_ARG_REGNO_P (REGNO (XEXP (XEXP (p, 0), 0))))
2839 SET_HARD_REG_BIT (parm.regs, REGNO (XEXP (XEXP (p, 0), 0)));
2844 /* Search backward for the first set of a register in this set. */
2845 while (parm.nregs && before != boundary)
2847 before = PREV_INSN (before);
2849 /* It is possible that some loads got CSEed from one call to
2850 another. Stop in that case. */
2851 if (GET_CODE (before) == CALL_INSN)
2854 /* Our caller needs either ensure that we will find all sets
2855 (in case code has not been optimized yet), or take care
2856 for possible labels in a way by setting boundary to preceeding
2858 if (GET_CODE (before) == CODE_LABEL)
2860 if (before != boundary)
2865 if (INSN_P (before))
2866 note_stores (PATTERN (before), parms_set, &parm);