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 void parms_set PARAMS ((rtx, rtx, void *));
35 /* Bit flags that specify the machine subtype we are compiling for.
36 Bits are tested using macros TARGET_... defined in the tm.h file
37 and set by `-m...' switches. Must be defined in rtlanal.c. */
41 /* Return 1 if the value of X is unstable
42 (would be different at a different point in the program).
43 The frame pointer, arg pointer, etc. are considered stable
44 (within one function) and so is anything marked `unchanging'. */
50 RTX_CODE code = GET_CODE (x);
57 return ! RTX_UNCHANGING_P (x) || rtx_unstable_p (XEXP (x, 0));
71 /* As in rtx_varies_p, we have to use the actual rtx, not reg number. */
72 if (x == frame_pointer_rtx || x == hard_frame_pointer_rtx
73 /* The arg pointer varies if it is not a fixed register. */
74 || (x == arg_pointer_rtx && fixed_regs[ARG_POINTER_REGNUM])
75 || RTX_UNCHANGING_P (x))
77 #ifndef PIC_OFFSET_TABLE_REG_CALL_CLOBBERED
78 /* ??? When call-clobbered, the value is stable modulo the restore
79 that must happen after a call. This currently screws up local-alloc
80 into believing that the restore is not needed. */
81 if (x == pic_offset_table_rtx)
87 if (MEM_VOLATILE_P (x))
96 fmt = GET_RTX_FORMAT (code);
97 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
100 if (rtx_unstable_p (XEXP (x, i)))
103 else if (fmt[i] == 'E')
106 for (j = 0; j < XVECLEN (x, i); j++)
107 if (rtx_unstable_p (XVECEXP (x, i, j)))
114 /* Return 1 if X has a value that can vary even between two
115 executions of the program. 0 means X can be compared reliably
116 against certain constants or near-constants.
117 FOR_ALIAS is nonzero if we are called from alias analysis; if it is
118 zero, we are slightly more conservative.
119 The frame pointer and the arg pointer are considered constant. */
122 rtx_varies_p (x, for_alias)
126 RTX_CODE code = GET_CODE (x);
133 return ! RTX_UNCHANGING_P (x) || rtx_varies_p (XEXP (x, 0), for_alias);
146 /* Note that we have to test for the actual rtx used for the frame
147 and arg pointers and not just the register number in case we have
148 eliminated the frame and/or arg pointer and are using it
150 if (x == frame_pointer_rtx || x == hard_frame_pointer_rtx
151 /* The arg pointer varies if it is not a fixed register. */
152 || (x == arg_pointer_rtx && fixed_regs[ARG_POINTER_REGNUM]))
154 if (x == pic_offset_table_rtx
155 #ifdef PIC_OFFSET_TABLE_REG_CALL_CLOBBERED
156 /* ??? When call-clobbered, the value is stable modulo the restore
157 that must happen after a call. This currently screws up
158 local-alloc into believing that the restore is not needed, so we
159 must return 0 only if we are called from alias analysis. */
167 /* The operand 0 of a LO_SUM is considered constant
168 (in fact it is related specifically to operand 1)
169 during alias analysis. */
170 return (! for_alias && rtx_varies_p (XEXP (x, 0), for_alias))
171 || rtx_varies_p (XEXP (x, 1), for_alias);
174 if (MEM_VOLATILE_P (x))
183 fmt = GET_RTX_FORMAT (code);
184 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
187 if (rtx_varies_p (XEXP (x, i), for_alias))
190 else if (fmt[i] == 'E')
193 for (j = 0; j < XVECLEN (x, i); j++)
194 if (rtx_varies_p (XVECEXP (x, i, j), for_alias))
201 /* Return 0 if the use of X as an address in a MEM can cause a trap. */
204 rtx_addr_can_trap_p (x)
207 enum rtx_code code = GET_CODE (x);
212 return SYMBOL_REF_WEAK (x);
218 /* As in rtx_varies_p, we have to use the actual rtx, not reg number. */
219 if (x == frame_pointer_rtx || x == hard_frame_pointer_rtx
220 || x == stack_pointer_rtx
221 /* The arg pointer varies if it is not a fixed register. */
222 || (x == arg_pointer_rtx && fixed_regs[ARG_POINTER_REGNUM]))
224 /* All of the virtual frame registers are stack references. */
225 if (REGNO (x) >= FIRST_VIRTUAL_REGISTER
226 && REGNO (x) <= LAST_VIRTUAL_REGISTER)
231 return rtx_addr_can_trap_p (XEXP (x, 0));
234 /* An address is assumed not to trap if it is an address that can't
235 trap plus a constant integer or it is the pic register plus a
237 return ! ((! rtx_addr_can_trap_p (XEXP (x, 0))
238 && GET_CODE (XEXP (x, 1)) == CONST_INT)
239 || (XEXP (x, 0) == pic_offset_table_rtx
240 && CONSTANT_P (XEXP (x, 1))));
244 return rtx_addr_can_trap_p (XEXP (x, 1));
251 return rtx_addr_can_trap_p (XEXP (x, 0));
257 /* If it isn't one of the case above, it can cause a trap. */
261 /* Return 1 if X refers to a memory location whose address
262 cannot be compared reliably with constant addresses,
263 or if X refers to a BLKmode memory object.
264 FOR_ALIAS is nonzero if we are called from alias analysis; if it is
265 zero, we are slightly more conservative. */
268 rtx_addr_varies_p (x, for_alias)
281 return GET_MODE (x) == BLKmode || rtx_varies_p (XEXP (x, 0), for_alias);
283 fmt = GET_RTX_FORMAT (code);
284 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
287 if (rtx_addr_varies_p (XEXP (x, i), for_alias))
290 else if (fmt[i] == 'E')
293 for (j = 0; j < XVECLEN (x, i); j++)
294 if (rtx_addr_varies_p (XVECEXP (x, i, j), for_alias))
300 /* Return the value of the integer term in X, if one is apparent;
302 Only obvious integer terms are detected.
303 This is used in cse.c with the `related_value' field.*/
309 if (GET_CODE (x) == CONST)
312 if (GET_CODE (x) == MINUS
313 && GET_CODE (XEXP (x, 1)) == CONST_INT)
314 return - INTVAL (XEXP (x, 1));
315 if (GET_CODE (x) == PLUS
316 && GET_CODE (XEXP (x, 1)) == CONST_INT)
317 return INTVAL (XEXP (x, 1));
321 /* If X is a constant, return the value sans apparent integer term;
323 Only obvious integer terms are detected. */
326 get_related_value (x)
329 if (GET_CODE (x) != CONST)
332 if (GET_CODE (x) == PLUS
333 && GET_CODE (XEXP (x, 1)) == CONST_INT)
335 else if (GET_CODE (x) == MINUS
336 && GET_CODE (XEXP (x, 1)) == CONST_INT)
341 /* Return the number of places FIND appears within X. If COUNT_DEST is
342 zero, we do not count occurrences inside the destination of a SET. */
345 count_occurrences (x, find, count_dest)
351 const char *format_ptr;
371 if (GET_CODE (find) == MEM && rtx_equal_p (x, find))
376 if (SET_DEST (x) == find && ! count_dest)
377 return count_occurrences (SET_SRC (x), find, count_dest);
384 format_ptr = GET_RTX_FORMAT (code);
387 for (i = 0; i < GET_RTX_LENGTH (code); i++)
389 switch (*format_ptr++)
392 count += count_occurrences (XEXP (x, i), find, count_dest);
396 for (j = 0; j < XVECLEN (x, i); j++)
397 count += count_occurrences (XVECEXP (x, i, j), find, count_dest);
404 /* Nonzero if register REG appears somewhere within IN.
405 Also works if REG is not a register; in this case it checks
406 for a subexpression of IN that is Lisp "equal" to REG. */
409 reg_mentioned_p (reg, in)
422 if (GET_CODE (in) == LABEL_REF)
423 return reg == XEXP (in, 0);
425 code = GET_CODE (in);
429 /* Compare registers by number. */
431 return GET_CODE (reg) == REG && REGNO (in) == REGNO (reg);
433 /* These codes have no constituent expressions
441 return GET_CODE (reg) == CONST_INT && INTVAL (in) == INTVAL (reg);
444 /* These are kept unique for a given value. */
451 if (GET_CODE (reg) == code && rtx_equal_p (reg, in))
454 fmt = GET_RTX_FORMAT (code);
456 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
461 for (j = XVECLEN (in, i) - 1; j >= 0; j--)
462 if (reg_mentioned_p (reg, XVECEXP (in, i, j)))
465 else if (fmt[i] == 'e'
466 && reg_mentioned_p (reg, XEXP (in, i)))
472 /* Return 1 if in between BEG and END, exclusive of BEG and END, there is
473 no CODE_LABEL insn. */
476 no_labels_between_p (beg, end)
482 for (p = NEXT_INSN (beg); p != end; p = NEXT_INSN (p))
483 if (GET_CODE (p) == CODE_LABEL)
488 /* Return 1 if in between BEG and END, exclusive of BEG and END, there is
489 no JUMP_INSN insn. */
492 no_jumps_between_p (beg, end)
496 for (p = NEXT_INSN (beg); p != end; p = NEXT_INSN (p))
497 if (GET_CODE (p) == JUMP_INSN)
502 /* Nonzero if register REG is used in an insn between
503 FROM_INSN and TO_INSN (exclusive of those two). */
506 reg_used_between_p (reg, from_insn, to_insn)
507 rtx reg, from_insn, to_insn;
511 if (from_insn == to_insn)
514 for (insn = NEXT_INSN (from_insn); insn != to_insn; insn = NEXT_INSN (insn))
516 && (reg_overlap_mentioned_p (reg, PATTERN (insn))
517 || (GET_CODE (insn) == CALL_INSN
518 && (find_reg_fusage (insn, USE, reg)
519 || find_reg_fusage (insn, CLOBBER, reg)))))
524 /* Nonzero if the old value of X, a register, is referenced in BODY. If X
525 is entirely replaced by a new value and the only use is as a SET_DEST,
526 we do not consider it a reference. */
529 reg_referenced_p (x, body)
535 switch (GET_CODE (body))
538 if (reg_overlap_mentioned_p (x, SET_SRC (body)))
541 /* If the destination is anything other than CC0, PC, a REG or a SUBREG
542 of a REG that occupies all of the REG, the insn references X if
543 it is mentioned in the destination. */
544 if (GET_CODE (SET_DEST (body)) != CC0
545 && GET_CODE (SET_DEST (body)) != PC
546 && GET_CODE (SET_DEST (body)) != REG
547 && ! (GET_CODE (SET_DEST (body)) == SUBREG
548 && GET_CODE (SUBREG_REG (SET_DEST (body))) == REG
549 && (((GET_MODE_SIZE (GET_MODE (SUBREG_REG (SET_DEST (body))))
550 + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD)
551 == ((GET_MODE_SIZE (GET_MODE (SET_DEST (body)))
552 + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD)))
553 && reg_overlap_mentioned_p (x, SET_DEST (body)))
558 for (i = ASM_OPERANDS_INPUT_LENGTH (body) - 1; i >= 0; i--)
559 if (reg_overlap_mentioned_p (x, ASM_OPERANDS_INPUT (body, i)))
566 return reg_overlap_mentioned_p (x, body);
569 return reg_overlap_mentioned_p (x, TRAP_CONDITION (body));
572 case UNSPEC_VOLATILE:
573 for (i = XVECLEN (body, 0) - 1; i >= 0; i--)
574 if (reg_overlap_mentioned_p (x, XVECEXP (body, 0, i)))
579 for (i = XVECLEN (body, 0) - 1; i >= 0; i--)
580 if (reg_referenced_p (x, XVECEXP (body, 0, i)))
585 if (GET_CODE (XEXP (body, 0)) == MEM)
586 if (reg_overlap_mentioned_p (x, XEXP (XEXP (body, 0), 0)))
591 if (reg_overlap_mentioned_p (x, COND_EXEC_TEST (body)))
593 return reg_referenced_p (x, COND_EXEC_CODE (body));
600 /* Nonzero if register REG is referenced in an insn between
601 FROM_INSN and TO_INSN (exclusive of those two). Sets of REG do
605 reg_referenced_between_p (reg, from_insn, to_insn)
606 rtx reg, from_insn, to_insn;
610 if (from_insn == to_insn)
613 for (insn = NEXT_INSN (from_insn); insn != to_insn; insn = NEXT_INSN (insn))
615 && (reg_referenced_p (reg, PATTERN (insn))
616 || (GET_CODE (insn) == CALL_INSN
617 && find_reg_fusage (insn, USE, reg))))
622 /* Nonzero if register REG is set or clobbered in an insn between
623 FROM_INSN and TO_INSN (exclusive of those two). */
626 reg_set_between_p (reg, from_insn, to_insn)
627 rtx reg, from_insn, to_insn;
631 if (from_insn == to_insn)
634 for (insn = NEXT_INSN (from_insn); insn != to_insn; insn = NEXT_INSN (insn))
635 if (INSN_P (insn) && reg_set_p (reg, insn))
640 /* Internals of reg_set_between_p. */
642 reg_set_p (reg, insn)
647 /* We can be passed an insn or part of one. If we are passed an insn,
648 check if a side-effect of the insn clobbers REG. */
651 if (FIND_REG_INC_NOTE (insn, reg)
652 || (GET_CODE (insn) == CALL_INSN
653 /* We'd like to test call_used_regs here, but rtlanal.c can't
654 reference that variable due to its use in genattrtab. So
655 we'll just be more conservative.
657 ??? Unless we could ensure that the CALL_INSN_FUNCTION_USAGE
658 information holds all clobbered registers. */
659 && ((GET_CODE (reg) == REG
660 && REGNO (reg) < FIRST_PSEUDO_REGISTER)
661 || GET_CODE (reg) == MEM
662 || find_reg_fusage (insn, CLOBBER, reg))))
665 body = PATTERN (insn);
668 return set_of (reg, insn) != NULL_RTX;
671 /* Similar to reg_set_between_p, but check all registers in X. Return 0
672 only if none of them are modified between START and END. Do not
673 consider non-registers one way or the other. */
676 regs_set_between_p (x, start, end)
680 enum rtx_code code = GET_CODE (x);
696 return reg_set_between_p (x, start, end);
702 fmt = GET_RTX_FORMAT (code);
703 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
705 if (fmt[i] == 'e' && regs_set_between_p (XEXP (x, i), start, end))
708 else if (fmt[i] == 'E')
709 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
710 if (regs_set_between_p (XVECEXP (x, i, j), start, end))
717 /* Similar to reg_set_between_p, but check all registers in X. Return 0
718 only if none of them are modified between START and END. Return 1 if
719 X contains a MEM; this routine does not perform any memory aliasing. */
722 modified_between_p (x, start, end)
726 enum rtx_code code = GET_CODE (x);
744 /* If the memory is not constant, assume it is modified. If it is
745 constant, we still have to check the address. */
746 if (! RTX_UNCHANGING_P (x))
751 return reg_set_between_p (x, start, end);
757 fmt = GET_RTX_FORMAT (code);
758 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
760 if (fmt[i] == 'e' && modified_between_p (XEXP (x, i), start, end))
763 else if (fmt[i] == 'E')
764 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
765 if (modified_between_p (XVECEXP (x, i, j), start, end))
772 /* Similar to reg_set_p, but check all registers in X. Return 0 only if none
773 of them are modified in INSN. Return 1 if X contains a MEM; this routine
774 does not perform any memory aliasing. */
777 modified_in_p (x, insn)
781 enum rtx_code code = GET_CODE (x);
799 /* If the memory is not constant, assume it is modified. If it is
800 constant, we still have to check the address. */
801 if (! RTX_UNCHANGING_P (x))
806 return reg_set_p (x, insn);
812 fmt = GET_RTX_FORMAT (code);
813 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
815 if (fmt[i] == 'e' && modified_in_p (XEXP (x, i), insn))
818 else if (fmt[i] == 'E')
819 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
820 if (modified_in_p (XVECEXP (x, i, j), insn))
827 /* Return true if anything in insn X is (anti,output,true) dependent on
828 anything in insn Y. */
831 insn_dependent_p (x, y)
836 if (! INSN_P (x) || ! INSN_P (y))
840 note_stores (PATTERN (x), insn_dependent_p_1, &tmp);
845 note_stores (PATTERN (y), insn_dependent_p_1, &tmp);
852 /* A helper routine for insn_dependent_p called through note_stores. */
855 insn_dependent_p_1 (x, pat, data)
857 rtx pat ATTRIBUTE_UNUSED;
860 rtx * pinsn = (rtx *) data;
862 if (*pinsn && reg_mentioned_p (x, *pinsn))
866 /* Helper function for set_of. */
874 set_of_1 (x, pat, data1)
879 struct set_of_data *data = (struct set_of_data *) (data1);
880 if (rtx_equal_p (x, data->pat)
881 || (GET_CODE (x) != MEM && reg_overlap_mentioned_p (data->pat, x)))
885 /* Give an INSN, return a SET or CLOBBER expression that does modify PAT
886 (eighter directly or via STRICT_LOW_PART and similar modifiers). */
891 struct set_of_data data;
892 data.found = NULL_RTX;
894 note_stores (INSN_P (insn) ? PATTERN (insn) : insn, set_of_1, &data);
898 /* Given an INSN, return a SET expression if this insn has only a single SET.
899 It may also have CLOBBERs, USEs, or SET whose output
900 will not be used, which we ignore. */
903 single_set_2 (insn, pat)
907 int set_verified = 1;
910 if (GET_CODE (pat) == PARALLEL)
912 for (i = 0; i < XVECLEN (pat, 0); i++)
914 rtx sub = XVECEXP (pat, 0, i);
915 switch (GET_CODE (sub))
922 /* We can consider insns having multiple sets, where all
923 but one are dead as single set insns. In common case
924 only single set is present in the pattern so we want
925 to avoid checking for REG_UNUSED notes unless neccesary.
927 When we reach set first time, we just expect this is
928 the single set we are looking for and only when more
929 sets are found in the insn, we check them. */
932 if (find_reg_note (insn, REG_UNUSED, SET_DEST (set))
933 && !side_effects_p (set))
939 set = sub, set_verified = 0;
940 else if (!find_reg_note (insn, REG_UNUSED, SET_DEST (sub))
941 || side_effects_p (sub))
953 /* Given an INSN, return nonzero if it has more than one SET, else return
963 /* INSN must be an insn. */
967 /* Only a PARALLEL can have multiple SETs. */
968 if (GET_CODE (PATTERN (insn)) == PARALLEL)
970 for (i = 0, found = 0; i < XVECLEN (PATTERN (insn), 0); i++)
971 if (GET_CODE (XVECEXP (PATTERN (insn), 0, i)) == SET)
973 /* If we have already found a SET, then return now. */
981 /* Either zero or one SET. */
985 /* Return nonzero if the destination of SET equals the source
986 and there are no side effects. */
992 rtx src = SET_SRC (set);
993 rtx dst = SET_DEST (set);
995 if (side_effects_p (src) || side_effects_p (dst))
998 if (GET_CODE (dst) == MEM && GET_CODE (src) == MEM)
999 return rtx_equal_p (dst, src);
1001 if (dst == pc_rtx && src == pc_rtx)
1004 if (GET_CODE (dst) == SIGN_EXTRACT
1005 || GET_CODE (dst) == ZERO_EXTRACT)
1006 return rtx_equal_p (XEXP (dst, 0), src)
1007 && ! BYTES_BIG_ENDIAN && XEXP (dst, 2) == const0_rtx;
1009 if (GET_CODE (dst) == STRICT_LOW_PART)
1010 dst = XEXP (dst, 0);
1012 if (GET_CODE (src) == SUBREG && GET_CODE (dst) == SUBREG)
1014 if (SUBREG_BYTE (src) != SUBREG_BYTE (dst))
1016 src = SUBREG_REG (src);
1017 dst = SUBREG_REG (dst);
1020 return (GET_CODE (src) == REG && GET_CODE (dst) == REG
1021 && REGNO (src) == REGNO (dst));
1024 /* Return nonzero if an insn consists only of SETs, each of which only sets a
1031 rtx pat = PATTERN (insn);
1033 if (INSN_CODE (insn) == NOOP_MOVE_INSN_CODE)
1036 /* Insns carrying these notes are useful later on. */
1037 if (find_reg_note (insn, REG_EQUAL, NULL_RTX))
1040 /* For now treat an insn with a REG_RETVAL note as a
1041 a special insn which should not be considered a no-op. */
1042 if (find_reg_note (insn, REG_RETVAL, NULL_RTX))
1045 if (GET_CODE (pat) == SET && set_noop_p (pat))
1048 if (GET_CODE (pat) == PARALLEL)
1051 /* If nothing but SETs of registers to themselves,
1052 this insn can also be deleted. */
1053 for (i = 0; i < XVECLEN (pat, 0); i++)
1055 rtx tem = XVECEXP (pat, 0, i);
1057 if (GET_CODE (tem) == USE
1058 || GET_CODE (tem) == CLOBBER)
1061 if (GET_CODE (tem) != SET || ! set_noop_p (tem))
1071 /* Return the last thing that X was assigned from before *PINSN. If VALID_TO
1072 is not NULL_RTX then verify that the object is not modified up to VALID_TO.
1073 If the object was modified, if we hit a partial assignment to X, or hit a
1074 CODE_LABEL first, return X. If we found an assignment, update *PINSN to
1075 point to it. ALLOW_HWREG is set to 1 if hardware registers are allowed to
1079 find_last_value (x, pinsn, valid_to, allow_hwreg)
1087 for (p = PREV_INSN (*pinsn); p && GET_CODE (p) != CODE_LABEL;
1091 rtx set = single_set (p);
1092 rtx note = find_reg_note (p, REG_EQUAL, NULL_RTX);
1094 if (set && rtx_equal_p (x, SET_DEST (set)))
1096 rtx src = SET_SRC (set);
1098 if (note && GET_CODE (XEXP (note, 0)) != EXPR_LIST)
1099 src = XEXP (note, 0);
1101 if ((valid_to == NULL_RTX
1102 || ! modified_between_p (src, PREV_INSN (p), valid_to))
1103 /* Reject hard registers because we don't usually want
1104 to use them; we'd rather use a pseudo. */
1105 && (! (GET_CODE (src) == REG
1106 && REGNO (src) < FIRST_PSEUDO_REGISTER) || allow_hwreg))
1113 /* If set in non-simple way, we don't have a value. */
1114 if (reg_set_p (x, p))
1121 /* Return nonzero if register in range [REGNO, ENDREGNO)
1122 appears either explicitly or implicitly in X
1123 other than being stored into.
1125 References contained within the substructure at LOC do not count.
1126 LOC may be zero, meaning don't ignore anything. */
1129 refers_to_regno_p (regno, endregno, x, loc)
1130 unsigned int regno, endregno;
1135 unsigned int x_regno;
1140 /* The contents of a REG_NONNEG note is always zero, so we must come here
1141 upon repeat in case the last REG_NOTE is a REG_NONNEG note. */
1145 code = GET_CODE (x);
1150 x_regno = REGNO (x);
1152 /* If we modifying the stack, frame, or argument pointer, it will
1153 clobber a virtual register. In fact, we could be more precise,
1154 but it isn't worth it. */
1155 if ((x_regno == STACK_POINTER_REGNUM
1156 #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
1157 || x_regno == ARG_POINTER_REGNUM
1159 || x_regno == FRAME_POINTER_REGNUM)
1160 && regno >= FIRST_VIRTUAL_REGISTER && regno <= LAST_VIRTUAL_REGISTER)
1163 return (endregno > x_regno
1164 && regno < x_regno + (x_regno < FIRST_PSEUDO_REGISTER
1165 ? HARD_REGNO_NREGS (x_regno, GET_MODE (x))
1169 /* If this is a SUBREG of a hard reg, we can see exactly which
1170 registers are being modified. Otherwise, handle normally. */
1171 if (GET_CODE (SUBREG_REG (x)) == REG
1172 && REGNO (SUBREG_REG (x)) < FIRST_PSEUDO_REGISTER)
1174 unsigned int inner_regno = subreg_regno (x);
1175 unsigned int inner_endregno
1176 = inner_regno + (inner_regno < FIRST_PSEUDO_REGISTER
1177 ? HARD_REGNO_NREGS (regno, GET_MODE (x)) : 1);
1179 return endregno > inner_regno && regno < inner_endregno;
1185 if (&SET_DEST (x) != loc
1186 /* Note setting a SUBREG counts as referring to the REG it is in for
1187 a pseudo but not for hard registers since we can
1188 treat each word individually. */
1189 && ((GET_CODE (SET_DEST (x)) == SUBREG
1190 && loc != &SUBREG_REG (SET_DEST (x))
1191 && GET_CODE (SUBREG_REG (SET_DEST (x))) == REG
1192 && REGNO (SUBREG_REG (SET_DEST (x))) >= FIRST_PSEUDO_REGISTER
1193 && refers_to_regno_p (regno, endregno,
1194 SUBREG_REG (SET_DEST (x)), loc))
1195 || (GET_CODE (SET_DEST (x)) != REG
1196 && refers_to_regno_p (regno, endregno, SET_DEST (x), loc))))
1199 if (code == CLOBBER || loc == &SET_SRC (x))
1208 /* X does not match, so try its subexpressions. */
1210 fmt = GET_RTX_FORMAT (code);
1211 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
1213 if (fmt[i] == 'e' && loc != &XEXP (x, i))
1221 if (refers_to_regno_p (regno, endregno, XEXP (x, i), loc))
1224 else if (fmt[i] == 'E')
1227 for (j = XVECLEN (x, i) - 1; j >=0; j--)
1228 if (loc != &XVECEXP (x, i, j)
1229 && refers_to_regno_p (regno, endregno, XVECEXP (x, i, j), loc))
1236 /* Nonzero if modifying X will affect IN. If X is a register or a SUBREG,
1237 we check if any register number in X conflicts with the relevant register
1238 numbers. If X is a constant, return 0. If X is a MEM, return 1 iff IN
1239 contains a MEM (we don't bother checking for memory addresses that can't
1240 conflict because we expect this to be a rare case. */
1243 reg_overlap_mentioned_p (x, in)
1246 unsigned int regno, endregno;
1248 /* Overly conservative. */
1249 if (GET_CODE (x) == STRICT_LOW_PART)
1252 /* If either argument is a constant, then modifying X can not affect IN. */
1253 if (CONSTANT_P (x) || CONSTANT_P (in))
1256 switch (GET_CODE (x))
1259 regno = REGNO (SUBREG_REG (x));
1260 if (regno < FIRST_PSEUDO_REGISTER)
1261 regno = subreg_regno (x);
1267 endregno = regno + (regno < FIRST_PSEUDO_REGISTER
1268 ? HARD_REGNO_NREGS (regno, GET_MODE (x)) : 1);
1269 return refers_to_regno_p (regno, endregno, in, (rtx*)0);
1276 if (GET_CODE (in) == MEM)
1279 fmt = GET_RTX_FORMAT (GET_CODE (in));
1280 for (i = GET_RTX_LENGTH (GET_CODE (in)) - 1; i >= 0; i--)
1281 if (fmt[i] == 'e' && reg_overlap_mentioned_p (x, XEXP (in, i)))
1290 return reg_mentioned_p (x, in);
1296 /* If any register in here refers to it we return true. */
1297 for (i = XVECLEN (x, 0) - 1; i >= 0; i--)
1298 if (XEXP (XVECEXP (x, 0, i), 0) != 0
1299 && reg_overlap_mentioned_p (XEXP (XVECEXP (x, 0, i), 0), in))
1311 /* Return the last value to which REG was set prior to INSN. If we can't
1312 find it easily, return 0.
1314 We only return a REG, SUBREG, or constant because it is too hard to
1315 check if a MEM remains unchanged. */
1318 reg_set_last (x, insn)
1322 rtx orig_insn = insn;
1324 /* Scan backwards until reg_set_last_1 changed one of the above flags.
1325 Stop when we reach a label or X is a hard reg and we reach a
1326 CALL_INSN (if reg_set_last_last_regno is a hard reg).
1328 If we find a set of X, ensure that its SET_SRC remains unchanged. */
1330 /* We compare with <= here, because reg_set_last_last_regno
1331 is actually the number of the first reg *not* in X. */
1333 insn && GET_CODE (insn) != CODE_LABEL
1334 && ! (GET_CODE (insn) == CALL_INSN
1335 && REGNO (x) <= FIRST_PSEUDO_REGISTER);
1336 insn = PREV_INSN (insn))
1339 rtx set = set_of (x, insn);
1340 /* OK, this function modify our register. See if we understand it. */
1344 if (GET_CODE (set) != SET || SET_DEST (set) != x)
1346 last_value = SET_SRC (x);
1347 if (CONSTANT_P (last_value)
1348 || ((GET_CODE (last_value) == REG
1349 || GET_CODE (last_value) == SUBREG)
1350 && ! reg_set_between_p (last_value,
1361 /* Call FUN on each register or MEM that is stored into or clobbered by X.
1362 (X would be the pattern of an insn).
1363 FUN receives two arguments:
1364 the REG, MEM, CC0 or PC being stored in or clobbered,
1365 the SET or CLOBBER rtx that does the store.
1367 If the item being stored in or clobbered is a SUBREG of a hard register,
1368 the SUBREG will be passed. */
1371 note_stores (x, fun, data)
1373 void (*fun) PARAMS ((rtx, rtx, void *));
1378 if (GET_CODE (x) == COND_EXEC)
1379 x = COND_EXEC_CODE (x);
1381 if (GET_CODE (x) == SET || GET_CODE (x) == CLOBBER)
1383 rtx dest = SET_DEST (x);
1385 while ((GET_CODE (dest) == SUBREG
1386 && (GET_CODE (SUBREG_REG (dest)) != REG
1387 || REGNO (SUBREG_REG (dest)) >= FIRST_PSEUDO_REGISTER))
1388 || GET_CODE (dest) == ZERO_EXTRACT
1389 || GET_CODE (dest) == SIGN_EXTRACT
1390 || GET_CODE (dest) == STRICT_LOW_PART)
1391 dest = XEXP (dest, 0);
1393 /* If we have a PARALLEL, SET_DEST is a list of EXPR_LIST expressions,
1394 each of whose first operand is a register. We can't know what
1395 precisely is being set in these cases, so make up a CLOBBER to pass
1397 if (GET_CODE (dest) == PARALLEL)
1399 for (i = XVECLEN (dest, 0) - 1; i >= 0; i--)
1400 if (XEXP (XVECEXP (dest, 0, i), 0) != 0)
1401 (*fun) (XEXP (XVECEXP (dest, 0, i), 0),
1402 gen_rtx_CLOBBER (VOIDmode,
1403 XEXP (XVECEXP (dest, 0, i), 0)),
1407 (*fun) (dest, x, data);
1410 else if (GET_CODE (x) == PARALLEL)
1411 for (i = XVECLEN (x, 0) - 1; i >= 0; i--)
1412 note_stores (XVECEXP (x, 0, i), fun, data);
1415 /* Like notes_stores, but call FUN for each expression that is being
1416 referenced in PBODY, a pointer to the PATTERN of an insn. We only call
1417 FUN for each expression, not any interior subexpressions. FUN receives a
1418 pointer to the expression and the DATA passed to this function.
1420 Note that this is not quite the same test as that done in reg_referenced_p
1421 since that considers something as being referenced if it is being
1422 partially set, while we do not. */
1425 note_uses (pbody, fun, data)
1427 void (*fun) PARAMS ((rtx *, void *));
1433 switch (GET_CODE (body))
1436 (*fun) (&COND_EXEC_TEST (body), data);
1437 note_uses (&COND_EXEC_CODE (body), fun, data);
1441 for (i = XVECLEN (body, 0) - 1; i >= 0; i--)
1442 note_uses (&XVECEXP (body, 0, i), fun, data);
1446 (*fun) (&XEXP (body, 0), data);
1450 for (i = ASM_OPERANDS_INPUT_LENGTH (body) - 1; i >= 0; i--)
1451 (*fun) (&ASM_OPERANDS_INPUT (body, i), data);
1455 (*fun) (&TRAP_CONDITION (body), data);
1459 case UNSPEC_VOLATILE:
1460 for (i = XVECLEN (body, 0) - 1; i >= 0; i--)
1461 (*fun) (&XVECEXP (body, 0, i), data);
1465 if (GET_CODE (XEXP (body, 0)) == MEM)
1466 (*fun) (&XEXP (XEXP (body, 0), 0), data);
1471 rtx dest = SET_DEST (body);
1473 /* For sets we replace everything in source plus registers in memory
1474 expression in store and operands of a ZERO_EXTRACT. */
1475 (*fun) (&SET_SRC (body), data);
1477 if (GET_CODE (dest) == ZERO_EXTRACT)
1479 (*fun) (&XEXP (dest, 1), data);
1480 (*fun) (&XEXP (dest, 2), data);
1483 while (GET_CODE (dest) == SUBREG || GET_CODE (dest) == STRICT_LOW_PART)
1484 dest = XEXP (dest, 0);
1486 if (GET_CODE (dest) == MEM)
1487 (*fun) (&XEXP (dest, 0), data);
1492 /* All the other possibilities never store. */
1493 (*fun) (pbody, data);
1498 /* Return nonzero if X's old contents don't survive after INSN.
1499 This will be true if X is (cc0) or if X is a register and
1500 X dies in INSN or because INSN entirely sets X.
1502 "Entirely set" means set directly and not through a SUBREG,
1503 ZERO_EXTRACT or SIGN_EXTRACT, so no trace of the old contents remains.
1504 Likewise, REG_INC does not count.
1506 REG may be a hard or pseudo reg. Renumbering is not taken into account,
1507 but for this use that makes no difference, since regs don't overlap
1508 during their lifetimes. Therefore, this function may be used
1509 at any time after deaths have been computed (in flow.c).
1511 If REG is a hard reg that occupies multiple machine registers, this
1512 function will only return 1 if each of those registers will be replaced
1516 dead_or_set_p (insn, x)
1520 unsigned int regno, last_regno;
1523 /* Can't use cc0_rtx below since this file is used by genattrtab.c. */
1524 if (GET_CODE (x) == CC0)
1527 if (GET_CODE (x) != REG)
1531 last_regno = (regno >= FIRST_PSEUDO_REGISTER ? regno
1532 : regno + HARD_REGNO_NREGS (regno, GET_MODE (x)) - 1);
1534 for (i = regno; i <= last_regno; i++)
1535 if (! dead_or_set_regno_p (insn, i))
1541 /* Utility function for dead_or_set_p to check an individual register. Also
1542 called from flow.c. */
1545 dead_or_set_regno_p (insn, test_regno)
1547 unsigned int test_regno;
1549 unsigned int regno, endregno;
1552 /* See if there is a death note for something that includes TEST_REGNO. */
1553 if (find_regno_note (insn, REG_DEAD, test_regno))
1556 if (GET_CODE (insn) == CALL_INSN
1557 && find_regno_fusage (insn, CLOBBER, test_regno))
1560 pattern = PATTERN (insn);
1562 if (GET_CODE (pattern) == COND_EXEC)
1563 pattern = COND_EXEC_CODE (pattern);
1565 if (GET_CODE (pattern) == SET)
1567 rtx dest = SET_DEST (PATTERN (insn));
1569 /* A value is totally replaced if it is the destination or the
1570 destination is a SUBREG of REGNO that does not change the number of
1572 if (GET_CODE (dest) == SUBREG
1573 && (((GET_MODE_SIZE (GET_MODE (dest))
1574 + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
1575 == ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (dest)))
1576 + UNITS_PER_WORD - 1) / UNITS_PER_WORD)))
1577 dest = SUBREG_REG (dest);
1579 if (GET_CODE (dest) != REG)
1582 regno = REGNO (dest);
1583 endregno = (regno >= FIRST_PSEUDO_REGISTER ? regno + 1
1584 : regno + HARD_REGNO_NREGS (regno, GET_MODE (dest)));
1586 return (test_regno >= regno && test_regno < endregno);
1588 else if (GET_CODE (pattern) == PARALLEL)
1592 for (i = XVECLEN (pattern, 0) - 1; i >= 0; i--)
1594 rtx body = XVECEXP (pattern, 0, i);
1596 if (GET_CODE (body) == COND_EXEC)
1597 body = COND_EXEC_CODE (body);
1599 if (GET_CODE (body) == SET || GET_CODE (body) == CLOBBER)
1601 rtx dest = SET_DEST (body);
1603 if (GET_CODE (dest) == SUBREG
1604 && (((GET_MODE_SIZE (GET_MODE (dest))
1605 + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
1606 == ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (dest)))
1607 + UNITS_PER_WORD - 1) / UNITS_PER_WORD)))
1608 dest = SUBREG_REG (dest);
1610 if (GET_CODE (dest) != REG)
1613 regno = REGNO (dest);
1614 endregno = (regno >= FIRST_PSEUDO_REGISTER ? regno + 1
1615 : regno + HARD_REGNO_NREGS (regno, GET_MODE (dest)));
1617 if (test_regno >= regno && test_regno < endregno)
1626 /* Return the reg-note of kind KIND in insn INSN, if there is one.
1627 If DATUM is nonzero, look for one whose datum is DATUM. */
1630 find_reg_note (insn, kind, datum)
1637 /* Ignore anything that is not an INSN, JUMP_INSN or CALL_INSN. */
1638 if (! INSN_P (insn))
1641 for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
1642 if (REG_NOTE_KIND (link) == kind
1643 && (datum == 0 || datum == XEXP (link, 0)))
1648 /* Return the reg-note of kind KIND in insn INSN which applies to register
1649 number REGNO, if any. Return 0 if there is no such reg-note. Note that
1650 the REGNO of this NOTE need not be REGNO if REGNO is a hard register;
1651 it might be the case that the note overlaps REGNO. */
1654 find_regno_note (insn, kind, regno)
1661 /* Ignore anything that is not an INSN, JUMP_INSN or CALL_INSN. */
1662 if (! INSN_P (insn))
1665 for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
1666 if (REG_NOTE_KIND (link) == kind
1667 /* Verify that it is a register, so that scratch and MEM won't cause a
1669 && GET_CODE (XEXP (link, 0)) == REG
1670 && REGNO (XEXP (link, 0)) <= regno
1671 && ((REGNO (XEXP (link, 0))
1672 + (REGNO (XEXP (link, 0)) >= FIRST_PSEUDO_REGISTER ? 1
1673 : HARD_REGNO_NREGS (REGNO (XEXP (link, 0)),
1674 GET_MODE (XEXP (link, 0)))))
1680 /* Return a REG_EQUIV or REG_EQUAL note if insn has only a single set and
1684 find_reg_equal_equiv_note (insn)
1689 if (single_set (insn) == 0)
1691 else if ((note = find_reg_note (insn, REG_EQUIV, NULL_RTX)) != 0)
1694 return find_reg_note (insn, REG_EQUAL, NULL_RTX);
1697 /* Return true if DATUM, or any overlap of DATUM, of kind CODE is found
1698 in the CALL_INSN_FUNCTION_USAGE information of INSN. */
1701 find_reg_fusage (insn, code, datum)
1706 /* If it's not a CALL_INSN, it can't possibly have a
1707 CALL_INSN_FUNCTION_USAGE field, so don't bother checking. */
1708 if (GET_CODE (insn) != CALL_INSN)
1714 if (GET_CODE (datum) != REG)
1718 for (link = CALL_INSN_FUNCTION_USAGE (insn);
1720 link = XEXP (link, 1))
1721 if (GET_CODE (XEXP (link, 0)) == code
1722 && rtx_equal_p (datum, SET_DEST (XEXP (link, 0))))
1727 unsigned int regno = REGNO (datum);
1729 /* CALL_INSN_FUNCTION_USAGE information cannot contain references
1730 to pseudo registers, so don't bother checking. */
1732 if (regno < FIRST_PSEUDO_REGISTER)
1734 unsigned int end_regno
1735 = regno + HARD_REGNO_NREGS (regno, GET_MODE (datum));
1738 for (i = regno; i < end_regno; i++)
1739 if (find_regno_fusage (insn, code, i))
1747 /* Return true if REGNO, or any overlap of REGNO, of kind CODE is found
1748 in the CALL_INSN_FUNCTION_USAGE information of INSN. */
1751 find_regno_fusage (insn, code, regno)
1758 /* CALL_INSN_FUNCTION_USAGE information cannot contain references
1759 to pseudo registers, so don't bother checking. */
1761 if (regno >= FIRST_PSEUDO_REGISTER
1762 || GET_CODE (insn) != CALL_INSN )
1765 for (link = CALL_INSN_FUNCTION_USAGE (insn); link; link = XEXP (link, 1))
1767 unsigned int regnote;
1770 if (GET_CODE (op = XEXP (link, 0)) == code
1771 && GET_CODE (reg = XEXP (op, 0)) == REG
1772 && (regnote = REGNO (reg)) <= regno
1773 && regnote + HARD_REGNO_NREGS (regnote, GET_MODE (reg)) > regno)
1780 /* Remove register note NOTE from the REG_NOTES of INSN. */
1783 remove_note (insn, note)
1789 if (note == NULL_RTX)
1792 if (REG_NOTES (insn) == note)
1794 REG_NOTES (insn) = XEXP (note, 1);
1798 for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
1799 if (XEXP (link, 1) == note)
1801 XEXP (link, 1) = XEXP (note, 1);
1808 /* Search LISTP (an EXPR_LIST) for an entry whose first operand is NODE and
1809 remove that entry from the list if it is found.
1811 A simple equality test is used to determine if NODE matches. */
1814 remove_node_from_expr_list (node, listp)
1819 rtx prev = NULL_RTX;
1823 if (node == XEXP (temp, 0))
1825 /* Splice the node out of the list. */
1827 XEXP (prev, 1) = XEXP (temp, 1);
1829 *listp = XEXP (temp, 1);
1835 temp = XEXP (temp, 1);
1839 /* Nonzero if X contains any volatile instructions. These are instructions
1840 which may cause unpredictable machine state instructions, and thus no
1841 instructions should be moved or combined across them. This includes
1842 only volatile asms and UNSPEC_VOLATILE instructions. */
1850 code = GET_CODE (x);
1870 case UNSPEC_VOLATILE:
1871 /* case TRAP_IF: This isn't clear yet. */
1875 if (MEM_VOLATILE_P (x))
1882 /* Recursively scan the operands of this expression. */
1885 const char *fmt = GET_RTX_FORMAT (code);
1888 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
1892 if (volatile_insn_p (XEXP (x, i)))
1895 else if (fmt[i] == 'E')
1898 for (j = 0; j < XVECLEN (x, i); j++)
1899 if (volatile_insn_p (XVECEXP (x, i, j)))
1907 /* Nonzero if X contains any volatile memory references
1908 UNSPEC_VOLATILE operations or volatile ASM_OPERANDS expressions. */
1916 code = GET_CODE (x);
1935 case UNSPEC_VOLATILE:
1936 /* case TRAP_IF: This isn't clear yet. */
1941 if (MEM_VOLATILE_P (x))
1948 /* Recursively scan the operands of this expression. */
1951 const char *fmt = GET_RTX_FORMAT (code);
1954 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
1958 if (volatile_refs_p (XEXP (x, i)))
1961 else if (fmt[i] == 'E')
1964 for (j = 0; j < XVECLEN (x, i); j++)
1965 if (volatile_refs_p (XVECEXP (x, i, j)))
1973 /* Similar to above, except that it also rejects register pre- and post-
1982 code = GET_CODE (x);
2000 /* Reject CLOBBER with a non-VOID mode. These are made by combine.c
2001 when some combination can't be done. If we see one, don't think
2002 that we can simplify the expression. */
2003 return (GET_MODE (x) != VOIDmode);
2012 case UNSPEC_VOLATILE:
2013 /* case TRAP_IF: This isn't clear yet. */
2018 if (MEM_VOLATILE_P (x))
2025 /* Recursively scan the operands of this expression. */
2028 const char *fmt = GET_RTX_FORMAT (code);
2031 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
2035 if (side_effects_p (XEXP (x, i)))
2038 else if (fmt[i] == 'E')
2041 for (j = 0; j < XVECLEN (x, i); j++)
2042 if (side_effects_p (XVECEXP (x, i, j)))
2050 /* Return nonzero if evaluating rtx X might cause a trap. */
2062 code = GET_CODE (x);
2065 /* Handle these cases quickly. */
2078 case UNSPEC_VOLATILE:
2083 return MEM_VOLATILE_P (x);
2085 /* Memory ref can trap unless it's a static var or a stack slot. */
2087 return rtx_addr_can_trap_p (XEXP (x, 0));
2089 /* Division by a non-constant might trap. */
2094 if (! CONSTANT_P (XEXP (x, 1))
2095 || GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT)
2097 /* This was const0_rtx, but by not using that,
2098 we can link this file into other programs. */
2099 if (GET_CODE (XEXP (x, 1)) == CONST_INT && INTVAL (XEXP (x, 1)) == 0)
2104 /* An EXPR_LIST is used to represent a function call. This
2105 certainly may trap. */
2113 /* Some floating point comparisons may trap. */
2114 /* ??? There is no machine independent way to check for tests that trap
2115 when COMPARE is used, though many targets do make this distinction.
2116 For instance, sparc uses CCFPE for compares which generate exceptions
2117 and CCFP for compares which do not generate exceptions. */
2118 if (GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT)
2120 /* But often the compare has some CC mode, so check operand
2122 if (GET_MODE_CLASS (GET_MODE (XEXP (x, 0))) == MODE_FLOAT
2123 || GET_MODE_CLASS (GET_MODE (XEXP (x, 1))) == MODE_FLOAT)
2129 /* These operations don't trap even with floating point. */
2133 /* Any floating arithmetic may trap. */
2134 if (GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT)
2138 fmt = GET_RTX_FORMAT (code);
2139 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
2143 if (may_trap_p (XEXP (x, i)))
2146 else if (fmt[i] == 'E')
2149 for (j = 0; j < XVECLEN (x, i); j++)
2150 if (may_trap_p (XVECEXP (x, i, j)))
2157 /* Return nonzero if X contains a comparison that is not either EQ or NE,
2158 i.e., an inequality. */
2161 inequality_comparisons_p (x)
2166 enum rtx_code code = GET_CODE (x);
2195 len = GET_RTX_LENGTH (code);
2196 fmt = GET_RTX_FORMAT (code);
2198 for (i = 0; i < len; i++)
2202 if (inequality_comparisons_p (XEXP (x, i)))
2205 else if (fmt[i] == 'E')
2208 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
2209 if (inequality_comparisons_p (XVECEXP (x, i, j)))
2217 /* Replace any occurrence of FROM in X with TO. The function does
2218 not enter into CONST_DOUBLE for the replace.
2220 Note that copying is not done so X must not be shared unless all copies
2221 are to be modified. */
2224 replace_rtx (x, from, to)
2230 /* The following prevents loops occurrence when we change MEM in
2231 CONST_DOUBLE onto the same CONST_DOUBLE. */
2232 if (x != 0 && GET_CODE (x) == CONST_DOUBLE)
2238 /* Allow this function to make replacements in EXPR_LISTs. */
2242 fmt = GET_RTX_FORMAT (GET_CODE (x));
2243 for (i = GET_RTX_LENGTH (GET_CODE (x)) - 1; i >= 0; i--)
2246 XEXP (x, i) = replace_rtx (XEXP (x, i), from, to);
2247 else if (fmt[i] == 'E')
2248 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
2249 XVECEXP (x, i, j) = replace_rtx (XVECEXP (x, i, j), from, to);
2255 /* Throughout the rtx X, replace many registers according to REG_MAP.
2256 Return the replacement for X (which may be X with altered contents).
2257 REG_MAP[R] is the replacement for register R, or 0 for don't replace.
2258 NREGS is the length of REG_MAP; regs >= NREGS are not mapped.
2260 We only support REG_MAP entries of REG or SUBREG. Also, hard registers
2261 should not be mapped to pseudos or vice versa since validate_change
2264 If REPLACE_DEST is 1, replacements are also done in destinations;
2265 otherwise, only sources are replaced. */
2268 replace_regs (x, reg_map, nregs, replace_dest)
2281 code = GET_CODE (x);
2295 /* Verify that the register has an entry before trying to access it. */
2296 if (REGNO (x) < nregs && reg_map[REGNO (x)] != 0)
2298 /* SUBREGs can't be shared. Always return a copy to ensure that if
2299 this replacement occurs more than once then each instance will
2300 get distinct rtx. */
2301 if (GET_CODE (reg_map[REGNO (x)]) == SUBREG)
2302 return copy_rtx (reg_map[REGNO (x)]);
2303 return reg_map[REGNO (x)];
2308 /* Prevent making nested SUBREGs. */
2309 if (GET_CODE (SUBREG_REG (x)) == REG && REGNO (SUBREG_REG (x)) < nregs
2310 && reg_map[REGNO (SUBREG_REG (x))] != 0
2311 && GET_CODE (reg_map[REGNO (SUBREG_REG (x))]) == SUBREG)
2313 rtx map_val = reg_map[REGNO (SUBREG_REG (x))];
2314 return simplify_gen_subreg (GET_MODE (x), map_val,
2315 GET_MODE (SUBREG_REG (x)),
2322 SET_DEST (x) = replace_regs (SET_DEST (x), reg_map, nregs, 0);
2324 else if (GET_CODE (SET_DEST (x)) == MEM
2325 || GET_CODE (SET_DEST (x)) == STRICT_LOW_PART)
2326 /* Even if we are not to replace destinations, replace register if it
2327 is CONTAINED in destination (destination is memory or
2328 STRICT_LOW_PART). */
2329 XEXP (SET_DEST (x), 0) = replace_regs (XEXP (SET_DEST (x), 0),
2331 else if (GET_CODE (SET_DEST (x)) == ZERO_EXTRACT)
2332 /* Similarly, for ZERO_EXTRACT we replace all operands. */
2335 SET_SRC (x) = replace_regs (SET_SRC (x), reg_map, nregs, 0);
2342 fmt = GET_RTX_FORMAT (code);
2343 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
2346 XEXP (x, i) = replace_regs (XEXP (x, i), reg_map, nregs, replace_dest);
2347 else if (fmt[i] == 'E')
2350 for (j = 0; j < XVECLEN (x, i); j++)
2351 XVECEXP (x, i, j) = replace_regs (XVECEXP (x, i, j), reg_map,
2352 nregs, replace_dest);
2358 /* A subroutine of computed_jump_p, return 1 if X contains a REG or MEM or
2359 constant that is not in the constant pool and not in the condition
2360 of an IF_THEN_ELSE. */
2363 computed_jump_p_1 (x)
2366 enum rtx_code code = GET_CODE (x);
2384 return ! (GET_CODE (XEXP (x, 0)) == SYMBOL_REF
2385 && CONSTANT_POOL_ADDRESS_P (XEXP (x, 0)));
2388 return (computed_jump_p_1 (XEXP (x, 1))
2389 || computed_jump_p_1 (XEXP (x, 2)));
2395 fmt = GET_RTX_FORMAT (code);
2396 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
2399 && computed_jump_p_1 (XEXP (x, i)))
2402 else if (fmt[i] == 'E')
2403 for (j = 0; j < XVECLEN (x, i); j++)
2404 if (computed_jump_p_1 (XVECEXP (x, i, j)))
2411 /* Return nonzero if INSN is an indirect jump (aka computed jump).
2413 Tablejumps and casesi insns are not considered indirect jumps;
2414 we can recognize them by a (use (label_ref)). */
2417 computed_jump_p (insn)
2421 if (GET_CODE (insn) == JUMP_INSN)
2423 rtx pat = PATTERN (insn);
2425 if (find_reg_note (insn, REG_LABEL, NULL_RTX))
2427 else if (GET_CODE (pat) == PARALLEL)
2429 int len = XVECLEN (pat, 0);
2430 int has_use_labelref = 0;
2432 for (i = len - 1; i >= 0; i--)
2433 if (GET_CODE (XVECEXP (pat, 0, i)) == USE
2434 && (GET_CODE (XEXP (XVECEXP (pat, 0, i), 0))
2436 has_use_labelref = 1;
2438 if (! has_use_labelref)
2439 for (i = len - 1; i >= 0; i--)
2440 if (GET_CODE (XVECEXP (pat, 0, i)) == SET
2441 && SET_DEST (XVECEXP (pat, 0, i)) == pc_rtx
2442 && computed_jump_p_1 (SET_SRC (XVECEXP (pat, 0, i))))
2445 else if (GET_CODE (pat) == SET
2446 && SET_DEST (pat) == pc_rtx
2447 && computed_jump_p_1 (SET_SRC (pat)))
2453 /* Traverse X via depth-first search, calling F for each
2454 sub-expression (including X itself). F is also passed the DATA.
2455 If F returns -1, do not traverse sub-expressions, but continue
2456 traversing the rest of the tree. If F ever returns any other
2457 non-zero value, stop the traversal, and return the value returned
2458 by F. Otherwise, return 0. This function does not traverse inside
2459 tree structure that contains RTX_EXPRs, or into sub-expressions
2460 whose format code is `0' since it is not known whether or not those
2461 codes are actually RTL.
2463 This routine is very general, and could (should?) be used to
2464 implement many of the other routines in this file. */
2467 for_each_rtx (x, f, data)
2478 result = (*f) (x, data);
2480 /* Do not traverse sub-expressions. */
2482 else if (result != 0)
2483 /* Stop the traversal. */
2487 /* There are no sub-expressions. */
2490 length = GET_RTX_LENGTH (GET_CODE (*x));
2491 format = GET_RTX_FORMAT (GET_CODE (*x));
2493 for (i = 0; i < length; ++i)
2498 result = for_each_rtx (&XEXP (*x, i), f, data);
2505 if (XVEC (*x, i) != 0)
2508 for (j = 0; j < XVECLEN (*x, i); ++j)
2510 result = for_each_rtx (&XVECEXP (*x, i, j), f, data);
2518 /* Nothing to do. */
2527 /* Searches X for any reference to REGNO, returning the rtx of the
2528 reference found if any. Otherwise, returns NULL_RTX. */
2531 regno_use_in (regno, x)
2539 if (GET_CODE (x) == REG && REGNO (x) == regno)
2542 fmt = GET_RTX_FORMAT (GET_CODE (x));
2543 for (i = GET_RTX_LENGTH (GET_CODE (x)) - 1; i >= 0; i--)
2547 if ((tem = regno_use_in (regno, XEXP (x, i))))
2550 else if (fmt[i] == 'E')
2551 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
2552 if ((tem = regno_use_in (regno , XVECEXP (x, i, j))))
2559 /* Return a value indicating whether OP, an operand of a commutative
2560 operation, is preferred as the first or second operand. The higher
2561 the value, the stronger the preference for being the first operand.
2562 We use negative values to indicate a preference for the first operand
2563 and positive values for the second operand. */
2566 commutative_operand_precedence (op)
2569 /* Constants always come the second operand. Prefer "nice" constants. */
2570 if (GET_CODE (op) == CONST_INT)
2572 if (GET_CODE (op) == CONST_DOUBLE)
2574 if (CONSTANT_P (op))
2577 /* SUBREGs of objects should come second. */
2578 if (GET_CODE (op) == SUBREG
2579 && GET_RTX_CLASS (GET_CODE (SUBREG_REG (op))) == 'o')
2582 /* If only one operand is a `neg', `not',
2583 `mult', `plus', or `minus' expression, it will be the first
2585 if (GET_CODE (op) == NEG || GET_CODE (op) == NOT
2586 || GET_CODE (op) == MULT || GET_CODE (op) == PLUS
2587 || GET_CODE (op) == MINUS)
2590 /* Complex expressions should be the first, so decrease priority
2592 if (GET_RTX_CLASS (GET_CODE (op)) == 'o')
2597 /* Return 1 iff it is neccesary to swap operands of commutative operation
2598 in order to canonicalize expression. */
2601 swap_commutative_operands_p (x, y)
2604 return (commutative_operand_precedence (x)
2605 < commutative_operand_precedence (y));
2608 /* Return 1 if X is an autoincrement side effect and the register is
2609 not the stack pointer. */
2614 switch (GET_CODE (x))
2622 /* There are no REG_INC notes for SP. */
2623 if (XEXP (x, 0) != stack_pointer_rtx)
2631 /* Return 1 if the sequence of instructions beginning with FROM and up
2632 to and including TO is safe to move. If NEW_TO is non-NULL, and
2633 the sequence is not already safe to move, but can be easily
2634 extended to a sequence which is safe, then NEW_TO will point to the
2635 end of the extended sequence.
2637 For now, this function only checks that the region contains whole
2638 exception regions, but it could be extended to check additional
2639 conditions as well. */
2642 insns_safe_to_move_p (from, to, new_to)
2647 int eh_region_count = 0;
2651 /* By default, assume the end of the region will be what was
2658 if (GET_CODE (r) == NOTE)
2660 switch (NOTE_LINE_NUMBER (r))
2662 case NOTE_INSN_EH_REGION_BEG:
2666 case NOTE_INSN_EH_REGION_END:
2667 if (eh_region_count == 0)
2668 /* This sequence of instructions contains the end of
2669 an exception region, but not he beginning. Moving
2670 it will cause chaos. */
2681 /* If we've passed TO, and we see a non-note instruction, we
2682 can't extend the sequence to a movable sequence. */
2688 /* It's OK to move the sequence if there were matched sets of
2689 exception region notes. */
2690 return eh_region_count == 0;
2695 /* It's OK to move the sequence if there were matched sets of
2696 exception region notes. */
2697 if (past_to_p && eh_region_count == 0)
2703 /* Go to the next instruction. */
2710 /* Return non-zero if IN contains a piece of rtl that has the address LOC */
2712 loc_mentioned_in_p (loc, in)
2715 enum rtx_code code = GET_CODE (in);
2716 const char *fmt = GET_RTX_FORMAT (code);
2719 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
2721 if (loc == &in->fld[i].rtx)
2725 if (loc_mentioned_in_p (loc, XEXP (in, i)))
2728 else if (fmt[i] == 'E')
2729 for (j = XVECLEN (in, i) - 1; j >= 0; j--)
2730 if (loc_mentioned_in_p (loc, XVECEXP (in, i, j)))
2736 /* This function returns the regno offset of a subreg expression.
2737 xregno - A regno of an inner hard subreg_reg (or what will become one).
2738 xmode - The mode of xregno.
2739 offset - The byte offset.
2740 ymode - The mode of a top level SUBREG (or what may become one).
2741 RETURN - The regno offset which would be used.
2742 This function can be overridden by defining SUBREG_REGNO_OFFSET,
2743 taking the same parameters. */
2745 subreg_regno_offset (xregno, xmode, offset, ymode)
2746 unsigned int xregno;
2747 enum machine_mode xmode;
2748 unsigned int offset;
2749 enum machine_mode ymode;
2752 int nregs_xmode, nregs_ymode;
2753 int mode_multiple, nregs_multiple;
2756 /* Check for an override, and use it instead. */
2757 #ifdef SUBREG_REGNO_OFFSET
2758 ret = SUBREG_REGNO_OFFSET (xregno, xmode, offset, ymode);
2760 if (xregno >= FIRST_PSEUDO_REGISTER)
2763 nregs_xmode = HARD_REGNO_NREGS (xregno, xmode);
2764 nregs_ymode = HARD_REGNO_NREGS (xregno, ymode);
2765 if (offset == 0 || nregs_xmode == nregs_ymode)
2768 /* size of ymode must not be greater than the size of xmode. */
2769 mode_multiple = GET_MODE_SIZE (xmode) / GET_MODE_SIZE (ymode);
2770 if (mode_multiple == 0)
2773 y_offset = offset / GET_MODE_SIZE (ymode);
2774 nregs_multiple = nregs_xmode / nregs_ymode;
2775 ret = (y_offset / (mode_multiple / nregs_multiple)) * nregs_ymode;
2781 /* Return the final regno that a subreg expression refers to. */
2787 rtx subreg = SUBREG_REG (x);
2788 int regno = REGNO (subreg);
2790 ret = regno + subreg_regno_offset (regno,
2797 struct parms_set_data
2803 /* Helper function for noticing stores to parameter registers. */
2805 parms_set (x, pat, data)
2806 rtx x, pat ATTRIBUTE_UNUSED;
2809 struct parms_set_data *d = data;
2810 if (REG_P (x) && REGNO (x) < FIRST_PSEUDO_REGISTER
2811 && TEST_HARD_REG_BIT (d->regs, REGNO (x)))
2813 CLEAR_HARD_REG_BIT (d->regs, REGNO (x));
2818 /* Look backward for first parameter to be loaded.
2819 Do not skip BOUNDARY. */
2821 find_first_parameter_load (call_insn, boundary)
2822 rtx call_insn, boundary;
2824 struct parms_set_data parm;
2827 /* Since different machines initialize their parameter registers
2828 in different orders, assume nothing. Collect the set of all
2829 parameter registers. */
2830 CLEAR_HARD_REG_SET (parm.regs);
2832 for (p = CALL_INSN_FUNCTION_USAGE (call_insn); p; p = XEXP (p, 1))
2833 if (GET_CODE (XEXP (p, 0)) == USE
2834 && GET_CODE (XEXP (XEXP (p, 0), 0)) == REG)
2836 if (REGNO (XEXP (XEXP (p, 0), 0)) >= FIRST_PSEUDO_REGISTER)
2839 /* We only care about registers which can hold function
2841 if (!FUNCTION_ARG_REGNO_P (REGNO (XEXP (XEXP (p, 0), 0))))
2844 SET_HARD_REG_BIT (parm.regs, REGNO (XEXP (XEXP (p, 0), 0)));
2849 /* Search backward for the first set of a register in this set. */
2850 while (parm.nregs && before != boundary)
2852 before = PREV_INSN (before);
2854 /* It is possible that some loads got CSEed from one call to
2855 another. Stop in that case. */
2856 if (GET_CODE (before) == CALL_INSN)
2859 /* Our caller needs either ensure that we will find all sets
2860 (in case code has not been optimized yet), or take care
2861 for possible labels in a way by setting boundary to preceeding
2863 if (GET_CODE (before) == CODE_LABEL)
2865 if (before != boundary)
2870 if (INSN_P (before))
2871 note_stores (PATTERN (before), parms_set, &parm);