1 /* Analyze RTL for C-Compiler
2 Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001 Free Software Foundation, Inc.
5 This file is part of GNU CC.
7 GNU CC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU CC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU CC; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
27 #include "hard-reg-set.h"
29 /* Forward declarations */
30 static void set_of_1 PARAMS ((rtx, rtx, void *));
31 static void insn_dependent_p_1 PARAMS ((rtx, rtx, void *));
32 static int computed_jump_p_1 PARAMS ((rtx));
33 static int operand_preference PARAMS ((rtx));
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 register RTX_CODE code = GET_CODE (x);
52 register const char *fmt;
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 register RTX_CODE code = GET_CODE (x);
128 register const char *fmt;
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 register 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)
272 register enum rtx_code code;
274 register const char *fmt;
281 return GET_MODE (x) == BLKmode || rtx_varies_p (XEXP (x, 0), for_alias);
283 fmt = GET_RTX_FORMAT (code);
284 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
287 if (rtx_addr_varies_p (XEXP (x, i), for_alias))
290 else if (fmt[i] == 'E')
293 for (j = 0; j < XVECLEN (x, i); j++)
294 if (rtx_addr_varies_p (XVECEXP (x, i, j), for_alias))
300 /* Return the value of the integer term in X, if one is apparent;
302 Only obvious integer terms are detected.
303 This is used in cse.c with the `related_value' field.*/
309 if (GET_CODE (x) == CONST)
312 if (GET_CODE (x) == MINUS
313 && GET_CODE (XEXP (x, 1)) == CONST_INT)
314 return - INTVAL (XEXP (x, 1));
315 if (GET_CODE (x) == PLUS
316 && GET_CODE (XEXP (x, 1)) == CONST_INT)
317 return INTVAL (XEXP (x, 1));
321 /* If X is a constant, return the value sans apparent integer term;
323 Only obvious integer terms are detected. */
326 get_related_value (x)
329 if (GET_CODE (x) != CONST)
332 if (GET_CODE (x) == PLUS
333 && GET_CODE (XEXP (x, 1)) == CONST_INT)
335 else if (GET_CODE (x) == MINUS
336 && GET_CODE (XEXP (x, 1)) == CONST_INT)
341 /* Return the number of places FIND appears within X. If COUNT_DEST is
342 zero, we do not count occurrences inside the destination of a SET. */
345 count_occurrences (x, find, count_dest)
351 const char *format_ptr;
371 if (GET_CODE (find) == MEM && rtx_equal_p (x, find))
376 if (SET_DEST (x) == find && ! count_dest)
377 return count_occurrences (SET_SRC (x), find, count_dest);
384 format_ptr = GET_RTX_FORMAT (code);
387 for (i = 0; i < GET_RTX_LENGTH (code); i++)
389 switch (*format_ptr++)
392 count += count_occurrences (XEXP (x, i), find, count_dest);
396 for (j = 0; j < XVECLEN (x, i); j++)
397 count += count_occurrences (XVECEXP (x, i, j), find, count_dest);
404 /* Nonzero if register REG appears somewhere within IN.
405 Also works if REG is not a register; in this case it checks
406 for a subexpression of IN that is Lisp "equal" to REG. */
409 reg_mentioned_p (reg, in)
410 register rtx reg, in;
412 register const char *fmt;
414 register enum rtx_code code;
422 if (GET_CODE (in) == LABEL_REF)
423 return reg == XEXP (in, 0);
425 code = GET_CODE (in);
429 /* Compare registers by number. */
431 return GET_CODE (reg) == REG && REGNO (in) == REGNO (reg);
433 /* These codes have no constituent expressions
441 return GET_CODE (reg) == CONST_INT && INTVAL (in) == INTVAL (reg);
444 /* These are kept unique for a given value. */
451 if (GET_CODE (reg) == code && rtx_equal_p (reg, in))
454 fmt = GET_RTX_FORMAT (code);
456 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
461 for (j = XVECLEN (in, i) - 1; j >= 0; j--)
462 if (reg_mentioned_p (reg, XVECEXP (in, i, j)))
465 else if (fmt[i] == 'e'
466 && reg_mentioned_p (reg, XEXP (in, i)))
472 /* Return 1 if in between BEG and END, exclusive of BEG and END, there is
473 no CODE_LABEL insn. */
476 no_labels_between_p (beg, end)
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 (GET_CODE (dst) == SIGN_EXTRACT
1002 || GET_CODE (dst) == ZERO_EXTRACT)
1003 return rtx_equal_p (XEXP (dst, 0), src)
1004 && ! BYTES_BIG_ENDIAN && XEXP (dst, 2) == const0_rtx;
1006 if (GET_CODE (dst) == STRICT_LOW_PART)
1007 dst = XEXP (dst, 0);
1009 if (GET_CODE (src) == SUBREG && GET_CODE (dst) == SUBREG)
1011 if (SUBREG_BYTE (src) != SUBREG_BYTE (dst))
1013 src = SUBREG_REG (src);
1014 dst = SUBREG_REG (dst);
1017 return (GET_CODE (src) == REG && GET_CODE (dst) == REG
1018 && REGNO (src) == REGNO (dst));
1021 /* Return the last thing that X was assigned from before *PINSN. If VALID_TO
1022 is not NULL_RTX then verify that the object is not modified up to VALID_TO.
1023 If the object was modified, if we hit a partial assignment to X, or hit a
1024 CODE_LABEL first, return X. If we found an assignment, update *PINSN to
1025 point to it. ALLOW_HWREG is set to 1 if hardware registers are allowed to
1029 find_last_value (x, pinsn, valid_to, allow_hwreg)
1037 for (p = PREV_INSN (*pinsn); p && GET_CODE (p) != CODE_LABEL;
1041 rtx set = single_set (p);
1042 rtx note = find_reg_note (p, REG_EQUAL, NULL_RTX);
1044 if (set && rtx_equal_p (x, SET_DEST (set)))
1046 rtx src = SET_SRC (set);
1048 if (note && GET_CODE (XEXP (note, 0)) != EXPR_LIST)
1049 src = XEXP (note, 0);
1051 if ((valid_to == NULL_RTX
1052 || ! modified_between_p (src, PREV_INSN (p), valid_to))
1053 /* Reject hard registers because we don't usually want
1054 to use them; we'd rather use a pseudo. */
1055 && (! (GET_CODE (src) == REG
1056 && REGNO (src) < FIRST_PSEUDO_REGISTER) || allow_hwreg))
1063 /* If set in non-simple way, we don't have a value. */
1064 if (reg_set_p (x, p))
1071 /* Return nonzero if register in range [REGNO, ENDREGNO)
1072 appears either explicitly or implicitly in X
1073 other than being stored into.
1075 References contained within the substructure at LOC do not count.
1076 LOC may be zero, meaning don't ignore anything. */
1079 refers_to_regno_p (regno, endregno, x, loc)
1080 unsigned int regno, endregno;
1085 unsigned int x_regno;
1090 /* The contents of a REG_NONNEG note is always zero, so we must come here
1091 upon repeat in case the last REG_NOTE is a REG_NONNEG note. */
1095 code = GET_CODE (x);
1100 x_regno = REGNO (x);
1102 /* If we modifying the stack, frame, or argument pointer, it will
1103 clobber a virtual register. In fact, we could be more precise,
1104 but it isn't worth it. */
1105 if ((x_regno == STACK_POINTER_REGNUM
1106 #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
1107 || x_regno == ARG_POINTER_REGNUM
1109 || x_regno == FRAME_POINTER_REGNUM)
1110 && regno >= FIRST_VIRTUAL_REGISTER && regno <= LAST_VIRTUAL_REGISTER)
1113 return (endregno > x_regno
1114 && regno < x_regno + (x_regno < FIRST_PSEUDO_REGISTER
1115 ? HARD_REGNO_NREGS (x_regno, GET_MODE (x))
1119 /* If this is a SUBREG of a hard reg, we can see exactly which
1120 registers are being modified. Otherwise, handle normally. */
1121 if (GET_CODE (SUBREG_REG (x)) == REG
1122 && REGNO (SUBREG_REG (x)) < FIRST_PSEUDO_REGISTER)
1124 unsigned int inner_regno = subreg_regno (x);
1125 unsigned int inner_endregno
1126 = inner_regno + (inner_regno < FIRST_PSEUDO_REGISTER
1127 ? HARD_REGNO_NREGS (regno, GET_MODE (x)) : 1);
1129 return endregno > inner_regno && regno < inner_endregno;
1135 if (&SET_DEST (x) != loc
1136 /* Note setting a SUBREG counts as referring to the REG it is in for
1137 a pseudo but not for hard registers since we can
1138 treat each word individually. */
1139 && ((GET_CODE (SET_DEST (x)) == SUBREG
1140 && loc != &SUBREG_REG (SET_DEST (x))
1141 && GET_CODE (SUBREG_REG (SET_DEST (x))) == REG
1142 && REGNO (SUBREG_REG (SET_DEST (x))) >= FIRST_PSEUDO_REGISTER
1143 && refers_to_regno_p (regno, endregno,
1144 SUBREG_REG (SET_DEST (x)), loc))
1145 || (GET_CODE (SET_DEST (x)) != REG
1146 && refers_to_regno_p (regno, endregno, SET_DEST (x), loc))))
1149 if (code == CLOBBER || loc == &SET_SRC (x))
1158 /* X does not match, so try its subexpressions. */
1160 fmt = GET_RTX_FORMAT (code);
1161 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
1163 if (fmt[i] == 'e' && loc != &XEXP (x, i))
1171 if (refers_to_regno_p (regno, endregno, XEXP (x, i), loc))
1174 else if (fmt[i] == 'E')
1177 for (j = XVECLEN (x, i) - 1; j >=0; j--)
1178 if (loc != &XVECEXP (x, i, j)
1179 && refers_to_regno_p (regno, endregno, XVECEXP (x, i, j), loc))
1186 /* Nonzero if modifying X will affect IN. If X is a register or a SUBREG,
1187 we check if any register number in X conflicts with the relevant register
1188 numbers. If X is a constant, return 0. If X is a MEM, return 1 iff IN
1189 contains a MEM (we don't bother checking for memory addresses that can't
1190 conflict because we expect this to be a rare case. */
1193 reg_overlap_mentioned_p (x, in)
1196 unsigned int regno, endregno;
1198 /* Overly conservative. */
1199 if (GET_CODE (x) == STRICT_LOW_PART)
1202 /* If either argument is a constant, then modifying X can not affect IN. */
1203 if (CONSTANT_P (x) || CONSTANT_P (in))
1206 switch (GET_CODE (x))
1209 regno = REGNO (SUBREG_REG (x));
1210 if (regno < FIRST_PSEUDO_REGISTER)
1211 regno = subreg_regno (x);
1217 endregno = regno + (regno < FIRST_PSEUDO_REGISTER
1218 ? HARD_REGNO_NREGS (regno, GET_MODE (x)) : 1);
1219 return refers_to_regno_p (regno, endregno, in, (rtx*)0);
1226 if (GET_CODE (in) == MEM)
1229 fmt = GET_RTX_FORMAT (GET_CODE (in));
1230 for (i = GET_RTX_LENGTH (GET_CODE (in)) - 1; i >= 0; i--)
1231 if (fmt[i] == 'e' && reg_overlap_mentioned_p (x, XEXP (in, i)))
1240 return reg_mentioned_p (x, in);
1246 /* If any register in here refers to it we return true. */
1247 for (i = XVECLEN (x, 0) - 1; i >= 0; i--)
1248 if (XEXP (XVECEXP (x, 0, i), 0) != 0
1249 && reg_overlap_mentioned_p (XEXP (XVECEXP (x, 0, i), 0), in))
1261 /* Return the last value to which REG was set prior to INSN. If we can't
1262 find it easily, return 0.
1264 We only return a REG, SUBREG, or constant because it is too hard to
1265 check if a MEM remains unchanged. */
1268 reg_set_last (x, insn)
1272 rtx orig_insn = insn;
1274 /* Scan backwards until reg_set_last_1 changed one of the above flags.
1275 Stop when we reach a label or X is a hard reg and we reach a
1276 CALL_INSN (if reg_set_last_last_regno is a hard reg).
1278 If we find a set of X, ensure that its SET_SRC remains unchanged. */
1280 /* We compare with <= here, because reg_set_last_last_regno
1281 is actually the number of the first reg *not* in X. */
1283 insn && GET_CODE (insn) != CODE_LABEL
1284 && ! (GET_CODE (insn) == CALL_INSN
1285 && REGNO (x) <= FIRST_PSEUDO_REGISTER);
1286 insn = PREV_INSN (insn))
1289 rtx set = set_of (x, insn);
1290 /* OK, this function modify our register. See if we understand it. */
1294 if (GET_CODE (set) != SET || SET_DEST (set) != x)
1296 last_value = SET_SRC (x);
1297 if (CONSTANT_P (last_value)
1298 || ((GET_CODE (last_value) == REG
1299 || GET_CODE (last_value) == SUBREG)
1300 && ! reg_set_between_p (last_value,
1311 /* Call FUN on each register or MEM that is stored into or clobbered by X.
1312 (X would be the pattern of an insn).
1313 FUN receives two arguments:
1314 the REG, MEM, CC0 or PC being stored in or clobbered,
1315 the SET or CLOBBER rtx that does the store.
1317 If the item being stored in or clobbered is a SUBREG of a hard register,
1318 the SUBREG will be passed. */
1321 note_stores (x, fun, data)
1323 void (*fun) PARAMS ((rtx, rtx, void *));
1328 if (GET_CODE (x) == COND_EXEC)
1329 x = COND_EXEC_CODE (x);
1331 if (GET_CODE (x) == SET || GET_CODE (x) == CLOBBER)
1333 register rtx dest = SET_DEST (x);
1335 while ((GET_CODE (dest) == SUBREG
1336 && (GET_CODE (SUBREG_REG (dest)) != REG
1337 || REGNO (SUBREG_REG (dest)) >= FIRST_PSEUDO_REGISTER))
1338 || GET_CODE (dest) == ZERO_EXTRACT
1339 || GET_CODE (dest) == SIGN_EXTRACT
1340 || GET_CODE (dest) == STRICT_LOW_PART)
1341 dest = XEXP (dest, 0);
1343 /* If we have a PARALLEL, SET_DEST is a list of EXPR_LIST expressions,
1344 each of whose first operand is a register. We can't know what
1345 precisely is being set in these cases, so make up a CLOBBER to pass
1347 if (GET_CODE (dest) == PARALLEL)
1349 for (i = XVECLEN (dest, 0) - 1; i >= 0; i--)
1350 if (XEXP (XVECEXP (dest, 0, i), 0) != 0)
1351 (*fun) (XEXP (XVECEXP (dest, 0, i), 0),
1352 gen_rtx_CLOBBER (VOIDmode,
1353 XEXP (XVECEXP (dest, 0, i), 0)),
1357 (*fun) (dest, x, data);
1360 else if (GET_CODE (x) == PARALLEL)
1361 for (i = XVECLEN (x, 0) - 1; i >= 0; i--)
1362 note_stores (XVECEXP (x, 0, i), fun, data);
1365 /* Like notes_stores, but call FUN for each expression that is being
1366 referenced in PBODY, a pointer to the PATTERN of an insn. We only call
1367 FUN for each expression, not any interior subexpressions. FUN receives a
1368 pointer to the expression and the DATA passed to this function.
1370 Note that this is not quite the same test as that done in reg_referenced_p
1371 since that considers something as being referenced if it is being
1372 partially set, while we do not. */
1375 note_uses (pbody, fun, data)
1377 void (*fun) PARAMS ((rtx *, void *));
1383 switch (GET_CODE (body))
1386 (*fun) (&COND_EXEC_TEST (body), data);
1387 note_uses (&COND_EXEC_CODE (body), fun, data);
1391 for (i = XVECLEN (body, 0) - 1; i >= 0; i--)
1392 note_uses (&XVECEXP (body, 0, i), fun, data);
1396 (*fun) (&XEXP (body, 0), data);
1400 for (i = ASM_OPERANDS_INPUT_LENGTH (body) - 1; i >= 0; i--)
1401 (*fun) (&ASM_OPERANDS_INPUT (body, i), data);
1405 (*fun) (&TRAP_CONDITION (body), data);
1409 case UNSPEC_VOLATILE:
1410 for (i = XVECLEN (body, 0) - 1; i >= 0; i--)
1411 (*fun) (&XVECEXP (body, 0, i), data);
1415 if (GET_CODE (XEXP (body, 0)) == MEM)
1416 (*fun) (&XEXP (XEXP (body, 0), 0), data);
1421 rtx dest = SET_DEST (body);
1423 /* For sets we replace everything in source plus registers in memory
1424 expression in store and operands of a ZERO_EXTRACT. */
1425 (*fun) (&SET_SRC (body), data);
1427 if (GET_CODE (dest) == ZERO_EXTRACT)
1429 (*fun) (&XEXP (dest, 1), data);
1430 (*fun) (&XEXP (dest, 2), data);
1433 while (GET_CODE (dest) == SUBREG || GET_CODE (dest) == STRICT_LOW_PART)
1434 dest = XEXP (dest, 0);
1436 if (GET_CODE (dest) == MEM)
1437 (*fun) (&XEXP (dest, 0), data);
1442 /* All the other possibilities never store. */
1443 (*fun) (pbody, data);
1448 /* Return nonzero if X's old contents don't survive after INSN.
1449 This will be true if X is (cc0) or if X is a register and
1450 X dies in INSN or because INSN entirely sets X.
1452 "Entirely set" means set directly and not through a SUBREG,
1453 ZERO_EXTRACT or SIGN_EXTRACT, so no trace of the old contents remains.
1454 Likewise, REG_INC does not count.
1456 REG may be a hard or pseudo reg. Renumbering is not taken into account,
1457 but for this use that makes no difference, since regs don't overlap
1458 during their lifetimes. Therefore, this function may be used
1459 at any time after deaths have been computed (in flow.c).
1461 If REG is a hard reg that occupies multiple machine registers, this
1462 function will only return 1 if each of those registers will be replaced
1466 dead_or_set_p (insn, x)
1470 unsigned int regno, last_regno;
1473 /* Can't use cc0_rtx below since this file is used by genattrtab.c. */
1474 if (GET_CODE (x) == CC0)
1477 if (GET_CODE (x) != REG)
1481 last_regno = (regno >= FIRST_PSEUDO_REGISTER ? regno
1482 : regno + HARD_REGNO_NREGS (regno, GET_MODE (x)) - 1);
1484 for (i = regno; i <= last_regno; i++)
1485 if (! dead_or_set_regno_p (insn, i))
1491 /* Utility function for dead_or_set_p to check an individual register. Also
1492 called from flow.c. */
1495 dead_or_set_regno_p (insn, test_regno)
1497 unsigned int test_regno;
1499 unsigned int regno, endregno;
1502 /* See if there is a death note for something that includes TEST_REGNO. */
1503 if (find_regno_note (insn, REG_DEAD, test_regno))
1506 if (GET_CODE (insn) == CALL_INSN
1507 && find_regno_fusage (insn, CLOBBER, test_regno))
1510 pattern = PATTERN (insn);
1512 if (GET_CODE (pattern) == COND_EXEC)
1513 pattern = COND_EXEC_CODE (pattern);
1515 if (GET_CODE (pattern) == SET)
1517 rtx dest = SET_DEST (PATTERN (insn));
1519 /* A value is totally replaced if it is the destination or the
1520 destination is a SUBREG of REGNO that does not change the number of
1522 if (GET_CODE (dest) == SUBREG
1523 && (((GET_MODE_SIZE (GET_MODE (dest))
1524 + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
1525 == ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (dest)))
1526 + UNITS_PER_WORD - 1) / UNITS_PER_WORD)))
1527 dest = SUBREG_REG (dest);
1529 if (GET_CODE (dest) != REG)
1532 regno = REGNO (dest);
1533 endregno = (regno >= FIRST_PSEUDO_REGISTER ? regno + 1
1534 : regno + HARD_REGNO_NREGS (regno, GET_MODE (dest)));
1536 return (test_regno >= regno && test_regno < endregno);
1538 else if (GET_CODE (pattern) == PARALLEL)
1542 for (i = XVECLEN (pattern, 0) - 1; i >= 0; i--)
1544 rtx body = XVECEXP (pattern, 0, i);
1546 if (GET_CODE (body) == COND_EXEC)
1547 body = COND_EXEC_CODE (body);
1549 if (GET_CODE (body) == SET || GET_CODE (body) == CLOBBER)
1551 rtx dest = SET_DEST (body);
1553 if (GET_CODE (dest) == SUBREG
1554 && (((GET_MODE_SIZE (GET_MODE (dest))
1555 + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
1556 == ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (dest)))
1557 + UNITS_PER_WORD - 1) / UNITS_PER_WORD)))
1558 dest = SUBREG_REG (dest);
1560 if (GET_CODE (dest) != REG)
1563 regno = REGNO (dest);
1564 endregno = (regno >= FIRST_PSEUDO_REGISTER ? regno + 1
1565 : regno + HARD_REGNO_NREGS (regno, GET_MODE (dest)));
1567 if (test_regno >= regno && test_regno < endregno)
1576 /* Return the reg-note of kind KIND in insn INSN, if there is one.
1577 If DATUM is nonzero, look for one whose datum is DATUM. */
1580 find_reg_note (insn, kind, datum)
1587 /* Ignore anything that is not an INSN, JUMP_INSN or CALL_INSN. */
1588 if (! INSN_P (insn))
1591 for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
1592 if (REG_NOTE_KIND (link) == kind
1593 && (datum == 0 || datum == XEXP (link, 0)))
1598 /* Return the reg-note of kind KIND in insn INSN which applies to register
1599 number REGNO, if any. Return 0 if there is no such reg-note. Note that
1600 the REGNO of this NOTE need not be REGNO if REGNO is a hard register;
1601 it might be the case that the note overlaps REGNO. */
1604 find_regno_note (insn, kind, regno)
1611 /* Ignore anything that is not an INSN, JUMP_INSN or CALL_INSN. */
1612 if (! INSN_P (insn))
1615 for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
1616 if (REG_NOTE_KIND (link) == kind
1617 /* Verify that it is a register, so that scratch and MEM won't cause a
1619 && GET_CODE (XEXP (link, 0)) == REG
1620 && REGNO (XEXP (link, 0)) <= regno
1621 && ((REGNO (XEXP (link, 0))
1622 + (REGNO (XEXP (link, 0)) >= FIRST_PSEUDO_REGISTER ? 1
1623 : HARD_REGNO_NREGS (REGNO (XEXP (link, 0)),
1624 GET_MODE (XEXP (link, 0)))))
1630 /* Return a REG_EQUIV or REG_EQUAL note if insn has only a single set and
1634 find_reg_equal_equiv_note (insn)
1639 if (single_set (insn) == 0)
1641 else if ((note = find_reg_note (insn, REG_EQUIV, NULL_RTX)) != 0)
1644 return find_reg_note (insn, REG_EQUAL, NULL_RTX);
1647 /* Return true if DATUM, or any overlap of DATUM, of kind CODE is found
1648 in the CALL_INSN_FUNCTION_USAGE information of INSN. */
1651 find_reg_fusage (insn, code, datum)
1656 /* If it's not a CALL_INSN, it can't possibly have a
1657 CALL_INSN_FUNCTION_USAGE field, so don't bother checking. */
1658 if (GET_CODE (insn) != CALL_INSN)
1664 if (GET_CODE (datum) != REG)
1668 for (link = CALL_INSN_FUNCTION_USAGE (insn);
1670 link = XEXP (link, 1))
1671 if (GET_CODE (XEXP (link, 0)) == code
1672 && rtx_equal_p (datum, SET_DEST (XEXP (link, 0))))
1677 unsigned int regno = REGNO (datum);
1679 /* CALL_INSN_FUNCTION_USAGE information cannot contain references
1680 to pseudo registers, so don't bother checking. */
1682 if (regno < FIRST_PSEUDO_REGISTER)
1684 unsigned int end_regno
1685 = regno + HARD_REGNO_NREGS (regno, GET_MODE (datum));
1688 for (i = regno; i < end_regno; i++)
1689 if (find_regno_fusage (insn, code, i))
1697 /* Return true if REGNO, or any overlap of REGNO, of kind CODE is found
1698 in the CALL_INSN_FUNCTION_USAGE information of INSN. */
1701 find_regno_fusage (insn, code, regno)
1708 /* CALL_INSN_FUNCTION_USAGE information cannot contain references
1709 to pseudo registers, so don't bother checking. */
1711 if (regno >= FIRST_PSEUDO_REGISTER
1712 || GET_CODE (insn) != CALL_INSN )
1715 for (link = CALL_INSN_FUNCTION_USAGE (insn); link; link = XEXP (link, 1))
1717 unsigned int regnote;
1720 if (GET_CODE (op = XEXP (link, 0)) == code
1721 && GET_CODE (reg = XEXP (op, 0)) == REG
1722 && (regnote = REGNO (reg)) <= regno
1723 && regnote + HARD_REGNO_NREGS (regnote, GET_MODE (reg)) > regno)
1730 /* Remove register note NOTE from the REG_NOTES of INSN. */
1733 remove_note (insn, note)
1739 if (note == NULL_RTX)
1742 if (REG_NOTES (insn) == note)
1744 REG_NOTES (insn) = XEXP (note, 1);
1748 for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
1749 if (XEXP (link, 1) == note)
1751 XEXP (link, 1) = XEXP (note, 1);
1758 /* Search LISTP (an EXPR_LIST) for an entry whose first operand is NODE and
1759 remove that entry from the list if it is found.
1761 A simple equality test is used to determine if NODE matches. */
1764 remove_node_from_expr_list (node, listp)
1769 rtx prev = NULL_RTX;
1773 if (node == XEXP (temp, 0))
1775 /* Splice the node out of the list. */
1777 XEXP (prev, 1) = XEXP (temp, 1);
1779 *listp = XEXP (temp, 1);
1785 temp = XEXP (temp, 1);
1789 /* Nonzero if X contains any volatile instructions. These are instructions
1790 which may cause unpredictable machine state instructions, and thus no
1791 instructions should be moved or combined across them. This includes
1792 only volatile asms and UNSPEC_VOLATILE instructions. */
1798 register RTX_CODE code;
1800 code = GET_CODE (x);
1820 case UNSPEC_VOLATILE:
1821 /* case TRAP_IF: This isn't clear yet. */
1825 if (MEM_VOLATILE_P (x))
1832 /* Recursively scan the operands of this expression. */
1835 register const char *fmt = GET_RTX_FORMAT (code);
1838 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
1842 if (volatile_insn_p (XEXP (x, i)))
1845 else if (fmt[i] == 'E')
1848 for (j = 0; j < XVECLEN (x, i); j++)
1849 if (volatile_insn_p (XVECEXP (x, i, j)))
1857 /* Nonzero if X contains any volatile memory references
1858 UNSPEC_VOLATILE operations or volatile ASM_OPERANDS expressions. */
1864 register RTX_CODE code;
1866 code = GET_CODE (x);
1885 case UNSPEC_VOLATILE:
1886 /* case TRAP_IF: This isn't clear yet. */
1891 if (MEM_VOLATILE_P (x))
1898 /* Recursively scan the operands of this expression. */
1901 register const char *fmt = GET_RTX_FORMAT (code);
1904 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
1908 if (volatile_refs_p (XEXP (x, i)))
1911 else if (fmt[i] == 'E')
1914 for (j = 0; j < XVECLEN (x, i); j++)
1915 if (volatile_refs_p (XVECEXP (x, i, j)))
1923 /* Similar to above, except that it also rejects register pre- and post-
1930 register RTX_CODE code;
1932 code = GET_CODE (x);
1950 /* Reject CLOBBER with a non-VOID mode. These are made by combine.c
1951 when some combination can't be done. If we see one, don't think
1952 that we can simplify the expression. */
1953 return (GET_MODE (x) != VOIDmode);
1962 case UNSPEC_VOLATILE:
1963 /* case TRAP_IF: This isn't clear yet. */
1968 if (MEM_VOLATILE_P (x))
1975 /* Recursively scan the operands of this expression. */
1978 register const char *fmt = GET_RTX_FORMAT (code);
1981 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
1985 if (side_effects_p (XEXP (x, i)))
1988 else if (fmt[i] == 'E')
1991 for (j = 0; j < XVECLEN (x, i); j++)
1992 if (side_effects_p (XVECEXP (x, i, j)))
2000 /* Return nonzero if evaluating rtx X might cause a trap. */
2012 code = GET_CODE (x);
2015 /* Handle these cases quickly. */
2028 case UNSPEC_VOLATILE:
2033 return MEM_VOLATILE_P (x);
2035 /* Memory ref can trap unless it's a static var or a stack slot. */
2037 return rtx_addr_can_trap_p (XEXP (x, 0));
2039 /* Division by a non-constant might trap. */
2044 if (! CONSTANT_P (XEXP (x, 1))
2045 || GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT)
2047 /* This was const0_rtx, but by not using that,
2048 we can link this file into other programs. */
2049 if (GET_CODE (XEXP (x, 1)) == CONST_INT && INTVAL (XEXP (x, 1)) == 0)
2054 /* An EXPR_LIST is used to represent a function call. This
2055 certainly may trap. */
2063 /* Some floating point comparisons may trap. */
2064 /* ??? There is no machine independent way to check for tests that trap
2065 when COMPARE is used, though many targets do make this distinction.
2066 For instance, sparc uses CCFPE for compares which generate exceptions
2067 and CCFP for compares which do not generate exceptions. */
2068 if (GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT)
2070 /* But often the compare has some CC mode, so check operand
2072 if (GET_MODE_CLASS (GET_MODE (XEXP (x, 0))) == MODE_FLOAT
2073 || GET_MODE_CLASS (GET_MODE (XEXP (x, 1))) == MODE_FLOAT)
2079 /* These operations don't trap even with floating point. */
2083 /* Any floating arithmetic may trap. */
2084 if (GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT)
2088 fmt = GET_RTX_FORMAT (code);
2089 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
2093 if (may_trap_p (XEXP (x, i)))
2096 else if (fmt[i] == 'E')
2099 for (j = 0; j < XVECLEN (x, i); j++)
2100 if (may_trap_p (XVECEXP (x, i, j)))
2107 /* Return nonzero if X contains a comparison that is not either EQ or NE,
2108 i.e., an inequality. */
2111 inequality_comparisons_p (x)
2114 register const char *fmt;
2115 register int len, i;
2116 register enum rtx_code code = GET_CODE (x);
2145 len = GET_RTX_LENGTH (code);
2146 fmt = GET_RTX_FORMAT (code);
2148 for (i = 0; i < len; i++)
2152 if (inequality_comparisons_p (XEXP (x, i)))
2155 else if (fmt[i] == 'E')
2158 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
2159 if (inequality_comparisons_p (XVECEXP (x, i, j)))
2167 /* Replace any occurrence of FROM in X with TO. The function does
2168 not enter into CONST_DOUBLE for the replace.
2170 Note that copying is not done so X must not be shared unless all copies
2171 are to be modified. */
2174 replace_rtx (x, from, to)
2178 register const char *fmt;
2180 /* The following prevents loops occurrence when we change MEM in
2181 CONST_DOUBLE onto the same CONST_DOUBLE. */
2182 if (x != 0 && GET_CODE (x) == CONST_DOUBLE)
2188 /* Allow this function to make replacements in EXPR_LISTs. */
2192 fmt = GET_RTX_FORMAT (GET_CODE (x));
2193 for (i = GET_RTX_LENGTH (GET_CODE (x)) - 1; i >= 0; i--)
2196 XEXP (x, i) = replace_rtx (XEXP (x, i), from, to);
2197 else if (fmt[i] == 'E')
2198 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
2199 XVECEXP (x, i, j) = replace_rtx (XVECEXP (x, i, j), from, to);
2205 /* Throughout the rtx X, replace many registers according to REG_MAP.
2206 Return the replacement for X (which may be X with altered contents).
2207 REG_MAP[R] is the replacement for register R, or 0 for don't replace.
2208 NREGS is the length of REG_MAP; regs >= NREGS are not mapped.
2210 We only support REG_MAP entries of REG or SUBREG. Also, hard registers
2211 should not be mapped to pseudos or vice versa since validate_change
2214 If REPLACE_DEST is 1, replacements are also done in destinations;
2215 otherwise, only sources are replaced. */
2218 replace_regs (x, reg_map, nregs, replace_dest)
2224 register enum rtx_code code;
2226 register const char *fmt;
2231 code = GET_CODE (x);
2245 /* Verify that the register has an entry before trying to access it. */
2246 if (REGNO (x) < nregs && reg_map[REGNO (x)] != 0)
2248 /* SUBREGs can't be shared. Always return a copy to ensure that if
2249 this replacement occurs more than once then each instance will
2250 get distinct rtx. */
2251 if (GET_CODE (reg_map[REGNO (x)]) == SUBREG)
2252 return copy_rtx (reg_map[REGNO (x)]);
2253 return reg_map[REGNO (x)];
2258 /* Prevent making nested SUBREGs. */
2259 if (GET_CODE (SUBREG_REG (x)) == REG && REGNO (SUBREG_REG (x)) < nregs
2260 && reg_map[REGNO (SUBREG_REG (x))] != 0
2261 && GET_CODE (reg_map[REGNO (SUBREG_REG (x))]) == SUBREG)
2263 rtx map_val = reg_map[REGNO (SUBREG_REG (x))];
2264 return simplify_gen_subreg (GET_MODE (x), map_val,
2265 GET_MODE (SUBREG_REG (x)),
2272 SET_DEST (x) = replace_regs (SET_DEST (x), reg_map, nregs, 0);
2274 else if (GET_CODE (SET_DEST (x)) == MEM
2275 || GET_CODE (SET_DEST (x)) == STRICT_LOW_PART)
2276 /* Even if we are not to replace destinations, replace register if it
2277 is CONTAINED in destination (destination is memory or
2278 STRICT_LOW_PART). */
2279 XEXP (SET_DEST (x), 0) = replace_regs (XEXP (SET_DEST (x), 0),
2281 else if (GET_CODE (SET_DEST (x)) == ZERO_EXTRACT)
2282 /* Similarly, for ZERO_EXTRACT we replace all operands. */
2285 SET_SRC (x) = replace_regs (SET_SRC (x), reg_map, nregs, 0);
2292 fmt = GET_RTX_FORMAT (code);
2293 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
2296 XEXP (x, i) = replace_regs (XEXP (x, i), reg_map, nregs, replace_dest);
2297 else if (fmt[i] == 'E')
2300 for (j = 0; j < XVECLEN (x, i); j++)
2301 XVECEXP (x, i, j) = replace_regs (XVECEXP (x, i, j), reg_map,
2302 nregs, replace_dest);
2308 /* A subroutine of computed_jump_p, return 1 if X contains a REG or MEM or
2309 constant that is not in the constant pool and not in the condition
2310 of an IF_THEN_ELSE. */
2313 computed_jump_p_1 (x)
2316 enum rtx_code code = GET_CODE (x);
2334 return ! (GET_CODE (XEXP (x, 0)) == SYMBOL_REF
2335 && CONSTANT_POOL_ADDRESS_P (XEXP (x, 0)));
2338 return (computed_jump_p_1 (XEXP (x, 1))
2339 || computed_jump_p_1 (XEXP (x, 2)));
2345 fmt = GET_RTX_FORMAT (code);
2346 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
2349 && computed_jump_p_1 (XEXP (x, i)))
2352 else if (fmt[i] == 'E')
2353 for (j = 0; j < XVECLEN (x, i); j++)
2354 if (computed_jump_p_1 (XVECEXP (x, i, j)))
2361 /* Return nonzero if INSN is an indirect jump (aka computed jump).
2363 Tablejumps and casesi insns are not considered indirect jumps;
2364 we can recognize them by a (use (label_ref)). */
2367 computed_jump_p (insn)
2371 if (GET_CODE (insn) == JUMP_INSN)
2373 rtx pat = PATTERN (insn);
2375 if (find_reg_note (insn, REG_LABEL, NULL_RTX))
2377 else if (GET_CODE (pat) == PARALLEL)
2379 int len = XVECLEN (pat, 0);
2380 int has_use_labelref = 0;
2382 for (i = len - 1; i >= 0; i--)
2383 if (GET_CODE (XVECEXP (pat, 0, i)) == USE
2384 && (GET_CODE (XEXP (XVECEXP (pat, 0, i), 0))
2386 has_use_labelref = 1;
2388 if (! has_use_labelref)
2389 for (i = len - 1; i >= 0; i--)
2390 if (GET_CODE (XVECEXP (pat, 0, i)) == SET
2391 && SET_DEST (XVECEXP (pat, 0, i)) == pc_rtx
2392 && computed_jump_p_1 (SET_SRC (XVECEXP (pat, 0, i))))
2395 else if (GET_CODE (pat) == SET
2396 && SET_DEST (pat) == pc_rtx
2397 && computed_jump_p_1 (SET_SRC (pat)))
2403 /* Traverse X via depth-first search, calling F for each
2404 sub-expression (including X itself). F is also passed the DATA.
2405 If F returns -1, do not traverse sub-expressions, but continue
2406 traversing the rest of the tree. If F ever returns any other
2407 non-zero value, stop the traversal, and return the value returned
2408 by F. Otherwise, return 0. This function does not traverse inside
2409 tree structure that contains RTX_EXPRs, or into sub-expressions
2410 whose format code is `0' since it is not known whether or not those
2411 codes are actually RTL.
2413 This routine is very general, and could (should?) be used to
2414 implement many of the other routines in this file. */
2417 for_each_rtx (x, f, data)
2428 result = (*f)(x, data);
2430 /* Do not traverse sub-expressions. */
2432 else if (result != 0)
2433 /* Stop the traversal. */
2437 /* There are no sub-expressions. */
2440 length = GET_RTX_LENGTH (GET_CODE (*x));
2441 format = GET_RTX_FORMAT (GET_CODE (*x));
2443 for (i = 0; i < length; ++i)
2448 result = for_each_rtx (&XEXP (*x, i), f, data);
2455 if (XVEC (*x, i) != 0)
2458 for (j = 0; j < XVECLEN (*x, i); ++j)
2460 result = for_each_rtx (&XVECEXP (*x, i, j), f, data);
2468 /* Nothing to do. */
2477 /* Searches X for any reference to REGNO, returning the rtx of the
2478 reference found if any. Otherwise, returns NULL_RTX. */
2481 regno_use_in (regno, x)
2485 register const char *fmt;
2489 if (GET_CODE (x) == REG && REGNO (x) == regno)
2492 fmt = GET_RTX_FORMAT (GET_CODE (x));
2493 for (i = GET_RTX_LENGTH (GET_CODE (x)) - 1; i >= 0; i--)
2497 if ((tem = regno_use_in (regno, XEXP (x, i))))
2500 else if (fmt[i] == 'E')
2501 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
2502 if ((tem = regno_use_in (regno , XVECEXP (x, i, j))))
2509 /* Return a value indicating whether OP, an operand of a commutative
2510 operation, is preferred as the first or second operand. The higher
2511 the value, the stronger the preference for being the first operand.
2512 We use negative values to indicate a preference for the first operand
2513 and positive values for the second operand. */
2516 operand_preference (op)
2519 /* Constants always come the second operand. Prefer "nice" constants. */
2520 if (GET_CODE (op) == CONST_INT)
2522 if (GET_CODE (op) == CONST_DOUBLE)
2524 if (CONSTANT_P (op))
2527 /* SUBREGs of objects should come second. */
2528 if (GET_CODE (op) == SUBREG
2529 && GET_RTX_CLASS (GET_CODE (SUBREG_REG (op))) == 'o')
2532 /* If only one operand is a `neg', `not',
2533 `mult', `plus', or `minus' expression, it will be the first
2535 if (GET_CODE (op) == NEG || GET_CODE (op) == NOT
2536 || GET_CODE (op) == MULT || GET_CODE (op) == PLUS
2537 || GET_CODE (op) == MINUS)
2540 /* Complex expressions should be the first, so decrease priority
2542 if (GET_RTX_CLASS (GET_CODE (op)) == 'o')
2547 /* Return 1 iff it is neccesary to swap operands of commutative operation
2548 in order to canonicalize expression. */
2551 swap_commutative_operands_p (x, y)
2554 return operand_preference (x) < operand_preference (y);
2557 /* Return 1 if X is an autoincrement side effect and the register is
2558 not the stack pointer. */
2563 switch (GET_CODE (x))
2571 /* There are no REG_INC notes for SP. */
2572 if (XEXP (x, 0) != stack_pointer_rtx)
2580 /* Return 1 if the sequence of instructions beginning with FROM and up
2581 to and including TO is safe to move. If NEW_TO is non-NULL, and
2582 the sequence is not already safe to move, but can be easily
2583 extended to a sequence which is safe, then NEW_TO will point to the
2584 end of the extended sequence.
2586 For now, this function only checks that the region contains whole
2587 exception regions, but it could be extended to check additional
2588 conditions as well. */
2591 insns_safe_to_move_p (from, to, new_to)
2596 int eh_region_count = 0;
2600 /* By default, assume the end of the region will be what was
2607 if (GET_CODE (r) == NOTE)
2609 switch (NOTE_LINE_NUMBER (r))
2611 case NOTE_INSN_EH_REGION_BEG:
2615 case NOTE_INSN_EH_REGION_END:
2616 if (eh_region_count == 0)
2617 /* This sequence of instructions contains the end of
2618 an exception region, but not he beginning. Moving
2619 it will cause chaos. */
2630 /* If we've passed TO, and we see a non-note instruction, we
2631 can't extend the sequence to a movable sequence. */
2637 /* It's OK to move the sequence if there were matched sets of
2638 exception region notes. */
2639 return eh_region_count == 0;
2644 /* It's OK to move the sequence if there were matched sets of
2645 exception region notes. */
2646 if (past_to_p && eh_region_count == 0)
2652 /* Go to the next instruction. */
2659 /* Return non-zero if IN contains a piece of rtl that has the address LOC */
2661 loc_mentioned_in_p (loc, in)
2664 enum rtx_code code = GET_CODE (in);
2665 const char *fmt = GET_RTX_FORMAT (code);
2668 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
2670 if (loc == &in->fld[i].rtx)
2674 if (loc_mentioned_in_p (loc, XEXP (in, i)))
2677 else if (fmt[i] == 'E')
2678 for (j = XVECLEN (in, i) - 1; j >= 0; j--)
2679 if (loc_mentioned_in_p (loc, XVECEXP (in, i, j)))
2685 /* This function returns the regno offset of a subreg expression.
2686 xregno - A regno of an inner hard subreg_reg (or what will become one).
2687 xmode - The mode of xregno.
2688 offset - The byte offset.
2689 ymode - The mode of a top level SUBREG (or what may become one).
2690 RETURN - The regno offset which would be used.
2691 This function can be overridden by defining SUBREG_REGNO_OFFSET,
2692 taking the same parameters. */
2694 subreg_regno_offset (xregno, xmode, offset, ymode)
2695 unsigned int xregno;
2696 enum machine_mode xmode;
2697 unsigned int offset;
2698 enum machine_mode ymode;
2701 int nregs_xmode, nregs_ymode;
2702 int mode_multiple, nregs_multiple;
2705 /* Check for an override, and use it instead. */
2706 #ifdef SUBREG_REGNO_OFFSET
2707 ret = SUBREG_REGNO_OFFSET (xregno, xmode, offset, ymode)
2709 if (xregno >= FIRST_PSEUDO_REGISTER)
2712 nregs_xmode = HARD_REGNO_NREGS (xregno, xmode);
2713 nregs_ymode = HARD_REGNO_NREGS (xregno, ymode);
2714 if (offset == 0 || nregs_xmode == nregs_ymode)
2717 /* size of ymode must not be greater than the size of xmode. */
2718 mode_multiple = GET_MODE_SIZE (xmode) / GET_MODE_SIZE (ymode);
2719 if (mode_multiple == 0)
2722 y_offset = offset / GET_MODE_SIZE (ymode);
2723 nregs_multiple = nregs_xmode / nregs_ymode;
2724 ret = (y_offset / (mode_multiple / nregs_multiple)) * nregs_ymode;
2730 /* Return the final regno that a subreg expression refers to. */
2736 rtx subreg = SUBREG_REG (x);
2737 int regno = REGNO (subreg);
2739 ret = regno + subreg_regno_offset (regno,