1 /* Analyze RTL for C-Compiler
2 Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002 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"
28 #include "insn-config.h"
32 /* Forward declarations */
33 static void set_of_1 PARAMS ((rtx, rtx, void *));
34 static void insn_dependent_p_1 PARAMS ((rtx, rtx, void *));
35 static int computed_jump_p_1 PARAMS ((rtx));
36 static void parms_set PARAMS ((rtx, rtx, void *));
38 /* Bit flags that specify the machine subtype we are compiling for.
39 Bits are tested using macros TARGET_... defined in the tm.h file
40 and set by `-m...' switches. Must be defined in rtlanal.c. */
44 /* Return 1 if the value of X is unstable
45 (would be different at a different point in the program).
46 The frame pointer, arg pointer, etc. are considered stable
47 (within one function) and so is anything marked `unchanging'. */
53 RTX_CODE code = GET_CODE (x);
60 return ! RTX_UNCHANGING_P (x) || rtx_unstable_p (XEXP (x, 0));
75 /* As in rtx_varies_p, we have to use the actual rtx, not reg number. */
76 if (x == frame_pointer_rtx || x == hard_frame_pointer_rtx
77 /* The arg pointer varies if it is not a fixed register. */
78 || (x == arg_pointer_rtx && fixed_regs[ARG_POINTER_REGNUM])
79 || RTX_UNCHANGING_P (x))
81 #ifndef PIC_OFFSET_TABLE_REG_CALL_CLOBBERED
82 /* ??? When call-clobbered, the value is stable modulo the restore
83 that must happen after a call. This currently screws up local-alloc
84 into believing that the restore is not needed. */
85 if (x == pic_offset_table_rtx)
91 if (MEM_VOLATILE_P (x))
100 fmt = GET_RTX_FORMAT (code);
101 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
104 if (rtx_unstable_p (XEXP (x, i)))
107 else if (fmt[i] == 'E')
110 for (j = 0; j < XVECLEN (x, i); j++)
111 if (rtx_unstable_p (XVECEXP (x, i, j)))
118 /* Return 1 if X has a value that can vary even between two
119 executions of the program. 0 means X can be compared reliably
120 against certain constants or near-constants.
121 FOR_ALIAS is nonzero if we are called from alias analysis; if it is
122 zero, we are slightly more conservative.
123 The frame pointer and the arg pointer are considered constant. */
126 rtx_varies_p (x, for_alias)
130 RTX_CODE code = GET_CODE (x);
137 return ! RTX_UNCHANGING_P (x) || rtx_varies_p (XEXP (x, 0), for_alias);
151 /* Note that we have to test for the actual rtx used for the frame
152 and arg pointers and not just the register number in case we have
153 eliminated the frame and/or arg pointer and are using it
155 if (x == frame_pointer_rtx || x == hard_frame_pointer_rtx
156 /* The arg pointer varies if it is not a fixed register. */
157 || (x == arg_pointer_rtx && fixed_regs[ARG_POINTER_REGNUM]))
159 if (x == pic_offset_table_rtx
160 #ifdef PIC_OFFSET_TABLE_REG_CALL_CLOBBERED
161 /* ??? When call-clobbered, the value is stable modulo the restore
162 that must happen after a call. This currently screws up
163 local-alloc into believing that the restore is not needed, so we
164 must return 0 only if we are called from alias analysis. */
172 /* The operand 0 of a LO_SUM is considered constant
173 (in fact it is related specifically to operand 1)
174 during alias analysis. */
175 return (! for_alias && rtx_varies_p (XEXP (x, 0), for_alias))
176 || rtx_varies_p (XEXP (x, 1), for_alias);
179 if (MEM_VOLATILE_P (x))
188 fmt = GET_RTX_FORMAT (code);
189 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
192 if (rtx_varies_p (XEXP (x, i), for_alias))
195 else if (fmt[i] == 'E')
198 for (j = 0; j < XVECLEN (x, i); j++)
199 if (rtx_varies_p (XVECEXP (x, i, j), for_alias))
206 /* Return 0 if the use of X as an address in a MEM can cause a trap. */
209 rtx_addr_can_trap_p (x)
212 enum rtx_code code = GET_CODE (x);
217 return SYMBOL_REF_WEAK (x);
223 /* As in rtx_varies_p, we have to use the actual rtx, not reg number. */
224 if (x == frame_pointer_rtx || x == hard_frame_pointer_rtx
225 || x == stack_pointer_rtx
226 /* The arg pointer varies if it is not a fixed register. */
227 || (x == arg_pointer_rtx && fixed_regs[ARG_POINTER_REGNUM]))
229 /* All of the virtual frame registers are stack references. */
230 if (REGNO (x) >= FIRST_VIRTUAL_REGISTER
231 && REGNO (x) <= LAST_VIRTUAL_REGISTER)
236 return rtx_addr_can_trap_p (XEXP (x, 0));
239 /* An address is assumed not to trap if it is an address that can't
240 trap plus a constant integer or it is the pic register plus a
242 return ! ((! rtx_addr_can_trap_p (XEXP (x, 0))
243 && GET_CODE (XEXP (x, 1)) == CONST_INT)
244 || (XEXP (x, 0) == pic_offset_table_rtx
245 && CONSTANT_P (XEXP (x, 1))));
249 return rtx_addr_can_trap_p (XEXP (x, 1));
256 return rtx_addr_can_trap_p (XEXP (x, 0));
262 /* If it isn't one of the case above, it can cause a trap. */
266 /* Return 1 if X refers to a memory location whose address
267 cannot be compared reliably with constant addresses,
268 or if X refers to a BLKmode memory object.
269 FOR_ALIAS is nonzero if we are called from alias analysis; if it is
270 zero, we are slightly more conservative. */
273 rtx_addr_varies_p (x, for_alias)
286 return GET_MODE (x) == BLKmode || rtx_varies_p (XEXP (x, 0), for_alias);
288 fmt = GET_RTX_FORMAT (code);
289 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
292 if (rtx_addr_varies_p (XEXP (x, i), for_alias))
295 else if (fmt[i] == 'E')
298 for (j = 0; j < XVECLEN (x, i); j++)
299 if (rtx_addr_varies_p (XVECEXP (x, i, j), for_alias))
305 /* Return the value of the integer term in X, if one is apparent;
307 Only obvious integer terms are detected.
308 This is used in cse.c with the `related_value' field. */
314 if (GET_CODE (x) == CONST)
317 if (GET_CODE (x) == MINUS
318 && GET_CODE (XEXP (x, 1)) == CONST_INT)
319 return - INTVAL (XEXP (x, 1));
320 if (GET_CODE (x) == PLUS
321 && GET_CODE (XEXP (x, 1)) == CONST_INT)
322 return INTVAL (XEXP (x, 1));
326 /* If X is a constant, return the value sans apparent integer term;
328 Only obvious integer terms are detected. */
331 get_related_value (x)
334 if (GET_CODE (x) != CONST)
337 if (GET_CODE (x) == PLUS
338 && GET_CODE (XEXP (x, 1)) == CONST_INT)
340 else if (GET_CODE (x) == MINUS
341 && GET_CODE (XEXP (x, 1)) == CONST_INT)
346 /* Given a tablejump insn INSN, return the RTL expression for the offset
347 into the jump table. If the offset cannot be determined, then return
350 If EARLIEST is non-zero, it is a pointer to a place where the earliest
351 insn used in locating the offset was found. */
354 get_jump_table_offset (insn, earliest)
368 if (GET_CODE (insn) != JUMP_INSN
369 || ! (label = JUMP_LABEL (insn))
370 || ! (table = NEXT_INSN (label))
371 || GET_CODE (table) != JUMP_INSN
372 || (GET_CODE (PATTERN (table)) != ADDR_VEC
373 && GET_CODE (PATTERN (table)) != ADDR_DIFF_VEC)
374 || ! (set = single_set (insn)))
379 /* Some targets (eg, ARM) emit a tablejump that also
380 contains the out-of-range target. */
381 if (GET_CODE (x) == IF_THEN_ELSE
382 && GET_CODE (XEXP (x, 2)) == LABEL_REF)
385 /* Search backwards and locate the expression stored in X. */
386 for (old_x = NULL_RTX; GET_CODE (x) == REG && x != old_x;
387 old_x = x, x = find_last_value (x, &insn, NULL_RTX, 0))
390 /* If X is an expression using a relative address then strip
391 off the addition / subtraction of PC, PIC_OFFSET_TABLE_REGNUM,
392 or the jump table label. */
393 if (GET_CODE (PATTERN (table)) == ADDR_DIFF_VEC
394 && (GET_CODE (x) == PLUS || GET_CODE (x) == MINUS))
396 for (i = 0; i < 2; i++)
401 if (y == pc_rtx || y == pic_offset_table_rtx)
404 for (old_y = NULL_RTX; GET_CODE (y) == REG && y != old_y;
405 old_y = y, y = find_last_value (y, &old_insn, NULL_RTX, 0))
408 if ((GET_CODE (y) == LABEL_REF && XEXP (y, 0) == label))
417 for (old_x = NULL_RTX; GET_CODE (x) == REG && x != old_x;
418 old_x = x, x = find_last_value (x, &insn, NULL_RTX, 0))
422 /* Strip off any sign or zero extension. */
423 if (GET_CODE (x) == SIGN_EXTEND || GET_CODE (x) == ZERO_EXTEND)
427 for (old_x = NULL_RTX; GET_CODE (x) == REG && x != old_x;
428 old_x = x, x = find_last_value (x, &insn, NULL_RTX, 0))
432 /* If X isn't a MEM then this isn't a tablejump we understand. */
433 if (GET_CODE (x) != MEM)
436 /* Strip off the MEM. */
439 for (old_x = NULL_RTX; GET_CODE (x) == REG && x != old_x;
440 old_x = x, x = find_last_value (x, &insn, NULL_RTX, 0))
443 /* If X isn't a PLUS than this isn't a tablejump we understand. */
444 if (GET_CODE (x) != PLUS)
447 /* At this point we should have an expression representing the jump table
448 plus an offset. Examine each operand in order to determine which one
449 represents the jump table. Knowing that tells us that the other operand
450 must represent the offset. */
451 for (i = 0; i < 2; i++)
456 for (old_y = NULL_RTX; GET_CODE (y) == REG && y != old_y;
457 old_y = y, y = find_last_value (y, &old_insn, NULL_RTX, 0))
460 if ((GET_CODE (y) == CONST || GET_CODE (y) == LABEL_REF)
461 && reg_mentioned_p (label, y))
470 /* Strip off the addition / subtraction of PIC_OFFSET_TABLE_REGNUM. */
471 if (GET_CODE (x) == PLUS || GET_CODE (x) == MINUS)
472 for (i = 0; i < 2; i++)
473 if (XEXP (x, i) == pic_offset_table_rtx)
482 /* Return the RTL expression representing the offset. */
486 /* Return the number of places FIND appears within X. If COUNT_DEST is
487 zero, we do not count occurrences inside the destination of a SET. */
490 count_occurrences (x, find, count_dest)
496 const char *format_ptr;
517 if (GET_CODE (find) == MEM && rtx_equal_p (x, find))
522 if (SET_DEST (x) == find && ! count_dest)
523 return count_occurrences (SET_SRC (x), find, count_dest);
530 format_ptr = GET_RTX_FORMAT (code);
533 for (i = 0; i < GET_RTX_LENGTH (code); i++)
535 switch (*format_ptr++)
538 count += count_occurrences (XEXP (x, i), find, count_dest);
542 for (j = 0; j < XVECLEN (x, i); j++)
543 count += count_occurrences (XVECEXP (x, i, j), find, count_dest);
550 /* Nonzero if register REG appears somewhere within IN.
551 Also works if REG is not a register; in this case it checks
552 for a subexpression of IN that is Lisp "equal" to REG. */
555 reg_mentioned_p (reg, in)
568 if (GET_CODE (in) == LABEL_REF)
569 return reg == XEXP (in, 0);
571 code = GET_CODE (in);
575 /* Compare registers by number. */
577 return GET_CODE (reg) == REG && REGNO (in) == REGNO (reg);
579 /* These codes have no constituent expressions
587 return GET_CODE (reg) == CONST_INT && INTVAL (in) == INTVAL (reg);
591 /* These are kept unique for a given value. */
598 if (GET_CODE (reg) == code && rtx_equal_p (reg, in))
601 fmt = GET_RTX_FORMAT (code);
603 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
608 for (j = XVECLEN (in, i) - 1; j >= 0; j--)
609 if (reg_mentioned_p (reg, XVECEXP (in, i, j)))
612 else if (fmt[i] == 'e'
613 && reg_mentioned_p (reg, XEXP (in, i)))
619 /* Return 1 if in between BEG and END, exclusive of BEG and END, there is
620 no CODE_LABEL insn. */
623 no_labels_between_p (beg, end)
629 for (p = NEXT_INSN (beg); p != end; p = NEXT_INSN (p))
630 if (GET_CODE (p) == CODE_LABEL)
635 /* Return 1 if in between BEG and END, exclusive of BEG and END, there is
636 no JUMP_INSN insn. */
639 no_jumps_between_p (beg, end)
643 for (p = NEXT_INSN (beg); p != end; p = NEXT_INSN (p))
644 if (GET_CODE (p) == JUMP_INSN)
649 /* Nonzero if register REG is used in an insn between
650 FROM_INSN and TO_INSN (exclusive of those two). */
653 reg_used_between_p (reg, from_insn, to_insn)
654 rtx reg, from_insn, to_insn;
658 if (from_insn == to_insn)
661 for (insn = NEXT_INSN (from_insn); insn != to_insn; insn = NEXT_INSN (insn))
663 && (reg_overlap_mentioned_p (reg, PATTERN (insn))
664 || (GET_CODE (insn) == CALL_INSN
665 && (find_reg_fusage (insn, USE, reg)
666 || find_reg_fusage (insn, CLOBBER, reg)))))
671 /* Nonzero if the old value of X, a register, is referenced in BODY. If X
672 is entirely replaced by a new value and the only use is as a SET_DEST,
673 we do not consider it a reference. */
676 reg_referenced_p (x, body)
682 switch (GET_CODE (body))
685 if (reg_overlap_mentioned_p (x, SET_SRC (body)))
688 /* If the destination is anything other than CC0, PC, a REG or a SUBREG
689 of a REG that occupies all of the REG, the insn references X if
690 it is mentioned in the destination. */
691 if (GET_CODE (SET_DEST (body)) != CC0
692 && GET_CODE (SET_DEST (body)) != PC
693 && GET_CODE (SET_DEST (body)) != REG
694 && ! (GET_CODE (SET_DEST (body)) == SUBREG
695 && GET_CODE (SUBREG_REG (SET_DEST (body))) == REG
696 && (((GET_MODE_SIZE (GET_MODE (SUBREG_REG (SET_DEST (body))))
697 + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD)
698 == ((GET_MODE_SIZE (GET_MODE (SET_DEST (body)))
699 + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD)))
700 && reg_overlap_mentioned_p (x, SET_DEST (body)))
705 for (i = ASM_OPERANDS_INPUT_LENGTH (body) - 1; i >= 0; i--)
706 if (reg_overlap_mentioned_p (x, ASM_OPERANDS_INPUT (body, i)))
713 return reg_overlap_mentioned_p (x, body);
716 return reg_overlap_mentioned_p (x, TRAP_CONDITION (body));
719 return reg_overlap_mentioned_p (x, XEXP (body, 0));
722 case UNSPEC_VOLATILE:
723 for (i = XVECLEN (body, 0) - 1; i >= 0; i--)
724 if (reg_overlap_mentioned_p (x, XVECEXP (body, 0, i)))
729 for (i = XVECLEN (body, 0) - 1; i >= 0; i--)
730 if (reg_referenced_p (x, XVECEXP (body, 0, i)))
735 if (GET_CODE (XEXP (body, 0)) == MEM)
736 if (reg_overlap_mentioned_p (x, XEXP (XEXP (body, 0), 0)))
741 if (reg_overlap_mentioned_p (x, COND_EXEC_TEST (body)))
743 return reg_referenced_p (x, COND_EXEC_CODE (body));
750 /* Nonzero if register REG is referenced in an insn between
751 FROM_INSN and TO_INSN (exclusive of those two). Sets of REG do
755 reg_referenced_between_p (reg, from_insn, to_insn)
756 rtx reg, from_insn, to_insn;
760 if (from_insn == to_insn)
763 for (insn = NEXT_INSN (from_insn); insn != to_insn; insn = NEXT_INSN (insn))
765 && (reg_referenced_p (reg, PATTERN (insn))
766 || (GET_CODE (insn) == CALL_INSN
767 && find_reg_fusage (insn, USE, reg))))
772 /* Nonzero if register REG is set or clobbered in an insn between
773 FROM_INSN and TO_INSN (exclusive of those two). */
776 reg_set_between_p (reg, from_insn, to_insn)
777 rtx reg, from_insn, to_insn;
781 if (from_insn == to_insn)
784 for (insn = NEXT_INSN (from_insn); insn != to_insn; insn = NEXT_INSN (insn))
785 if (INSN_P (insn) && reg_set_p (reg, insn))
790 /* Internals of reg_set_between_p. */
792 reg_set_p (reg, insn)
797 /* We can be passed an insn or part of one. If we are passed an insn,
798 check if a side-effect of the insn clobbers REG. */
801 if (FIND_REG_INC_NOTE (insn, reg)
802 || (GET_CODE (insn) == CALL_INSN
803 /* We'd like to test call_used_regs here, but rtlanal.c can't
804 reference that variable due to its use in genattrtab. So
805 we'll just be more conservative.
807 ??? Unless we could ensure that the CALL_INSN_FUNCTION_USAGE
808 information holds all clobbered registers. */
809 && ((GET_CODE (reg) == REG
810 && REGNO (reg) < FIRST_PSEUDO_REGISTER)
811 || GET_CODE (reg) == MEM
812 || find_reg_fusage (insn, CLOBBER, reg))))
815 body = PATTERN (insn);
818 return set_of (reg, insn) != NULL_RTX;
821 /* Similar to reg_set_between_p, but check all registers in X. Return 0
822 only if none of them are modified between START and END. Do not
823 consider non-registers one way or the other. */
826 regs_set_between_p (x, start, end)
830 enum rtx_code code = GET_CODE (x);
847 return reg_set_between_p (x, start, end);
853 fmt = GET_RTX_FORMAT (code);
854 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
856 if (fmt[i] == 'e' && regs_set_between_p (XEXP (x, i), start, end))
859 else if (fmt[i] == 'E')
860 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
861 if (regs_set_between_p (XVECEXP (x, i, j), start, end))
868 /* Similar to reg_set_between_p, but check all registers in X. Return 0
869 only if none of them are modified between START and END. Return 1 if
870 X contains a MEM; this routine does not perform any memory aliasing. */
873 modified_between_p (x, start, end)
877 enum rtx_code code = GET_CODE (x);
896 /* If the memory is not constant, assume it is modified. If it is
897 constant, we still have to check the address. */
898 if (! RTX_UNCHANGING_P (x))
903 return reg_set_between_p (x, start, end);
909 fmt = GET_RTX_FORMAT (code);
910 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
912 if (fmt[i] == 'e' && modified_between_p (XEXP (x, i), start, end))
915 else if (fmt[i] == 'E')
916 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
917 if (modified_between_p (XVECEXP (x, i, j), start, end))
924 /* Similar to reg_set_p, but check all registers in X. Return 0 only if none
925 of them are modified in INSN. Return 1 if X contains a MEM; this routine
926 does not perform any memory aliasing. */
929 modified_in_p (x, insn)
933 enum rtx_code code = GET_CODE (x);
952 /* If the memory is not constant, assume it is modified. If it is
953 constant, we still have to check the address. */
954 if (! RTX_UNCHANGING_P (x))
959 return reg_set_p (x, insn);
965 fmt = GET_RTX_FORMAT (code);
966 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
968 if (fmt[i] == 'e' && modified_in_p (XEXP (x, i), insn))
971 else if (fmt[i] == 'E')
972 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
973 if (modified_in_p (XVECEXP (x, i, j), insn))
980 /* Return true if anything in insn X is (anti,output,true) dependent on
981 anything in insn Y. */
984 insn_dependent_p (x, y)
989 if (! INSN_P (x) || ! INSN_P (y))
993 note_stores (PATTERN (x), insn_dependent_p_1, &tmp);
998 note_stores (PATTERN (y), insn_dependent_p_1, &tmp);
1005 /* A helper routine for insn_dependent_p called through note_stores. */
1008 insn_dependent_p_1 (x, pat, data)
1010 rtx pat ATTRIBUTE_UNUSED;
1013 rtx * pinsn = (rtx *) data;
1015 if (*pinsn && reg_mentioned_p (x, *pinsn))
1019 /* Helper function for set_of. */
1027 set_of_1 (x, pat, data1)
1032 struct set_of_data *data = (struct set_of_data *) (data1);
1033 if (rtx_equal_p (x, data->pat)
1034 || (GET_CODE (x) != MEM && reg_overlap_mentioned_p (data->pat, x)))
1038 /* Give an INSN, return a SET or CLOBBER expression that does modify PAT
1039 (either directly or via STRICT_LOW_PART and similar modifiers). */
1044 struct set_of_data data;
1045 data.found = NULL_RTX;
1047 note_stores (INSN_P (insn) ? PATTERN (insn) : insn, set_of_1, &data);
1051 /* Given an INSN, return a SET expression if this insn has only a single SET.
1052 It may also have CLOBBERs, USEs, or SET whose output
1053 will not be used, which we ignore. */
1056 single_set_2 (insn, pat)
1060 int set_verified = 1;
1063 if (GET_CODE (pat) == PARALLEL)
1065 for (i = 0; i < XVECLEN (pat, 0); i++)
1067 rtx sub = XVECEXP (pat, 0, i);
1068 switch (GET_CODE (sub))
1075 /* We can consider insns having multiple sets, where all
1076 but one are dead as single set insns. In common case
1077 only single set is present in the pattern so we want
1078 to avoid checking for REG_UNUSED notes unless necessary.
1080 When we reach set first time, we just expect this is
1081 the single set we are looking for and only when more
1082 sets are found in the insn, we check them. */
1085 if (find_reg_note (insn, REG_UNUSED, SET_DEST (set))
1086 && !side_effects_p (set))
1092 set = sub, set_verified = 0;
1093 else if (!find_reg_note (insn, REG_UNUSED, SET_DEST (sub))
1094 || side_effects_p (sub))
1106 /* Given an INSN, return nonzero if it has more than one SET, else return
1110 multiple_sets (insn)
1116 /* INSN must be an insn. */
1117 if (! INSN_P (insn))
1120 /* Only a PARALLEL can have multiple SETs. */
1121 if (GET_CODE (PATTERN (insn)) == PARALLEL)
1123 for (i = 0, found = 0; i < XVECLEN (PATTERN (insn), 0); i++)
1124 if (GET_CODE (XVECEXP (PATTERN (insn), 0, i)) == SET)
1126 /* If we have already found a SET, then return now. */
1134 /* Either zero or one SET. */
1138 /* Return nonzero if the destination of SET equals the source
1139 and there are no side effects. */
1145 rtx src = SET_SRC (set);
1146 rtx dst = SET_DEST (set);
1148 if (side_effects_p (src) || side_effects_p (dst))
1151 if (GET_CODE (dst) == MEM && GET_CODE (src) == MEM)
1152 return rtx_equal_p (dst, src);
1154 if (dst == pc_rtx && src == pc_rtx)
1157 if (GET_CODE (dst) == SIGN_EXTRACT
1158 || GET_CODE (dst) == ZERO_EXTRACT)
1159 return rtx_equal_p (XEXP (dst, 0), src)
1160 && ! BYTES_BIG_ENDIAN && XEXP (dst, 2) == const0_rtx;
1162 if (GET_CODE (dst) == STRICT_LOW_PART)
1163 dst = XEXP (dst, 0);
1165 if (GET_CODE (src) == SUBREG && GET_CODE (dst) == SUBREG)
1167 if (SUBREG_BYTE (src) != SUBREG_BYTE (dst))
1169 src = SUBREG_REG (src);
1170 dst = SUBREG_REG (dst);
1173 return (GET_CODE (src) == REG && GET_CODE (dst) == REG
1174 && REGNO (src) == REGNO (dst));
1177 /* Return nonzero if an insn consists only of SETs, each of which only sets a
1184 rtx pat = PATTERN (insn);
1186 if (INSN_CODE (insn) == NOOP_MOVE_INSN_CODE)
1189 /* Insns carrying these notes are useful later on. */
1190 if (find_reg_note (insn, REG_EQUAL, NULL_RTX))
1193 /* For now treat an insn with a REG_RETVAL note as a
1194 a special insn which should not be considered a no-op. */
1195 if (find_reg_note (insn, REG_RETVAL, NULL_RTX))
1198 if (GET_CODE (pat) == SET && set_noop_p (pat))
1201 if (GET_CODE (pat) == PARALLEL)
1204 /* If nothing but SETs of registers to themselves,
1205 this insn can also be deleted. */
1206 for (i = 0; i < XVECLEN (pat, 0); i++)
1208 rtx tem = XVECEXP (pat, 0, i);
1210 if (GET_CODE (tem) == USE
1211 || GET_CODE (tem) == CLOBBER)
1214 if (GET_CODE (tem) != SET || ! set_noop_p (tem))
1224 /* Return the last thing that X was assigned from before *PINSN. If VALID_TO
1225 is not NULL_RTX then verify that the object is not modified up to VALID_TO.
1226 If the object was modified, if we hit a partial assignment to X, or hit a
1227 CODE_LABEL first, return X. If we found an assignment, update *PINSN to
1228 point to it. ALLOW_HWREG is set to 1 if hardware registers are allowed to
1232 find_last_value (x, pinsn, valid_to, allow_hwreg)
1240 for (p = PREV_INSN (*pinsn); p && GET_CODE (p) != CODE_LABEL;
1244 rtx set = single_set (p);
1245 rtx note = find_reg_note (p, REG_EQUAL, NULL_RTX);
1247 if (set && rtx_equal_p (x, SET_DEST (set)))
1249 rtx src = SET_SRC (set);
1251 if (note && GET_CODE (XEXP (note, 0)) != EXPR_LIST)
1252 src = XEXP (note, 0);
1254 if ((valid_to == NULL_RTX
1255 || ! modified_between_p (src, PREV_INSN (p), valid_to))
1256 /* Reject hard registers because we don't usually want
1257 to use them; we'd rather use a pseudo. */
1258 && (! (GET_CODE (src) == REG
1259 && REGNO (src) < FIRST_PSEUDO_REGISTER) || allow_hwreg))
1266 /* If set in non-simple way, we don't have a value. */
1267 if (reg_set_p (x, p))
1274 /* Return nonzero if register in range [REGNO, ENDREGNO)
1275 appears either explicitly or implicitly in X
1276 other than being stored into.
1278 References contained within the substructure at LOC do not count.
1279 LOC may be zero, meaning don't ignore anything. */
1282 refers_to_regno_p (regno, endregno, x, loc)
1283 unsigned int regno, endregno;
1288 unsigned int x_regno;
1293 /* The contents of a REG_NONNEG note is always zero, so we must come here
1294 upon repeat in case the last REG_NOTE is a REG_NONNEG note. */
1298 code = GET_CODE (x);
1303 x_regno = REGNO (x);
1305 /* If we modifying the stack, frame, or argument pointer, it will
1306 clobber a virtual register. In fact, we could be more precise,
1307 but it isn't worth it. */
1308 if ((x_regno == STACK_POINTER_REGNUM
1309 #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
1310 || x_regno == ARG_POINTER_REGNUM
1312 || x_regno == FRAME_POINTER_REGNUM)
1313 && regno >= FIRST_VIRTUAL_REGISTER && regno <= LAST_VIRTUAL_REGISTER)
1316 return (endregno > x_regno
1317 && regno < x_regno + (x_regno < FIRST_PSEUDO_REGISTER
1318 ? HARD_REGNO_NREGS (x_regno, GET_MODE (x))
1322 /* If this is a SUBREG of a hard reg, we can see exactly which
1323 registers are being modified. Otherwise, handle normally. */
1324 if (GET_CODE (SUBREG_REG (x)) == REG
1325 && REGNO (SUBREG_REG (x)) < FIRST_PSEUDO_REGISTER)
1327 unsigned int inner_regno = subreg_regno (x);
1328 unsigned int inner_endregno
1329 = inner_regno + (inner_regno < FIRST_PSEUDO_REGISTER
1330 ? HARD_REGNO_NREGS (regno, GET_MODE (x)) : 1);
1332 return endregno > inner_regno && regno < inner_endregno;
1338 if (&SET_DEST (x) != loc
1339 /* Note setting a SUBREG counts as referring to the REG it is in for
1340 a pseudo but not for hard registers since we can
1341 treat each word individually. */
1342 && ((GET_CODE (SET_DEST (x)) == SUBREG
1343 && loc != &SUBREG_REG (SET_DEST (x))
1344 && GET_CODE (SUBREG_REG (SET_DEST (x))) == REG
1345 && REGNO (SUBREG_REG (SET_DEST (x))) >= FIRST_PSEUDO_REGISTER
1346 && refers_to_regno_p (regno, endregno,
1347 SUBREG_REG (SET_DEST (x)), loc))
1348 || (GET_CODE (SET_DEST (x)) != REG
1349 && refers_to_regno_p (regno, endregno, SET_DEST (x), loc))))
1352 if (code == CLOBBER || loc == &SET_SRC (x))
1361 /* X does not match, so try its subexpressions. */
1363 fmt = GET_RTX_FORMAT (code);
1364 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
1366 if (fmt[i] == 'e' && loc != &XEXP (x, i))
1374 if (refers_to_regno_p (regno, endregno, XEXP (x, i), loc))
1377 else if (fmt[i] == 'E')
1380 for (j = XVECLEN (x, i) - 1; j >=0; j--)
1381 if (loc != &XVECEXP (x, i, j)
1382 && refers_to_regno_p (regno, endregno, XVECEXP (x, i, j), loc))
1389 /* Nonzero if modifying X will affect IN. If X is a register or a SUBREG,
1390 we check if any register number in X conflicts with the relevant register
1391 numbers. If X is a constant, return 0. If X is a MEM, return 1 iff IN
1392 contains a MEM (we don't bother checking for memory addresses that can't
1393 conflict because we expect this to be a rare case. */
1396 reg_overlap_mentioned_p (x, in)
1399 unsigned int regno, endregno;
1401 /* Overly conservative. */
1402 if (GET_CODE (x) == STRICT_LOW_PART)
1405 /* If either argument is a constant, then modifying X can not affect IN. */
1406 if (CONSTANT_P (x) || CONSTANT_P (in))
1409 switch (GET_CODE (x))
1412 regno = REGNO (SUBREG_REG (x));
1413 if (regno < FIRST_PSEUDO_REGISTER)
1414 regno = subreg_regno (x);
1420 endregno = regno + (regno < FIRST_PSEUDO_REGISTER
1421 ? HARD_REGNO_NREGS (regno, GET_MODE (x)) : 1);
1422 return refers_to_regno_p (regno, endregno, in, (rtx*) 0);
1429 if (GET_CODE (in) == MEM)
1432 fmt = GET_RTX_FORMAT (GET_CODE (in));
1433 for (i = GET_RTX_LENGTH (GET_CODE (in)) - 1; i >= 0; i--)
1434 if (fmt[i] == 'e' && reg_overlap_mentioned_p (x, XEXP (in, i)))
1443 return reg_mentioned_p (x, in);
1449 /* If any register in here refers to it we return true. */
1450 for (i = XVECLEN (x, 0) - 1; i >= 0; i--)
1451 if (XEXP (XVECEXP (x, 0, i), 0) != 0
1452 && reg_overlap_mentioned_p (XEXP (XVECEXP (x, 0, i), 0), in))
1464 /* Return the last value to which REG was set prior to INSN. If we can't
1465 find it easily, return 0.
1467 We only return a REG, SUBREG, or constant because it is too hard to
1468 check if a MEM remains unchanged. */
1471 reg_set_last (x, insn)
1475 rtx orig_insn = insn;
1477 /* Scan backwards until reg_set_last_1 changed one of the above flags.
1478 Stop when we reach a label or X is a hard reg and we reach a
1479 CALL_INSN (if reg_set_last_last_regno is a hard reg).
1481 If we find a set of X, ensure that its SET_SRC remains unchanged. */
1483 /* We compare with <= here, because reg_set_last_last_regno
1484 is actually the number of the first reg *not* in X. */
1486 insn && GET_CODE (insn) != CODE_LABEL
1487 && ! (GET_CODE (insn) == CALL_INSN
1488 && REGNO (x) <= FIRST_PSEUDO_REGISTER);
1489 insn = PREV_INSN (insn))
1492 rtx set = set_of (x, insn);
1493 /* OK, this function modify our register. See if we understand it. */
1497 if (GET_CODE (set) != SET || SET_DEST (set) != x)
1499 last_value = SET_SRC (x);
1500 if (CONSTANT_P (last_value)
1501 || ((GET_CODE (last_value) == REG
1502 || GET_CODE (last_value) == SUBREG)
1503 && ! reg_set_between_p (last_value,
1514 /* Call FUN on each register or MEM that is stored into or clobbered by X.
1515 (X would be the pattern of an insn).
1516 FUN receives two arguments:
1517 the REG, MEM, CC0 or PC being stored in or clobbered,
1518 the SET or CLOBBER rtx that does the store.
1520 If the item being stored in or clobbered is a SUBREG of a hard register,
1521 the SUBREG will be passed. */
1524 note_stores (x, fun, data)
1526 void (*fun) PARAMS ((rtx, rtx, void *));
1531 if (GET_CODE (x) == COND_EXEC)
1532 x = COND_EXEC_CODE (x);
1534 if (GET_CODE (x) == SET || GET_CODE (x) == CLOBBER)
1536 rtx dest = SET_DEST (x);
1538 while ((GET_CODE (dest) == SUBREG
1539 && (GET_CODE (SUBREG_REG (dest)) != REG
1540 || REGNO (SUBREG_REG (dest)) >= FIRST_PSEUDO_REGISTER))
1541 || GET_CODE (dest) == ZERO_EXTRACT
1542 || GET_CODE (dest) == SIGN_EXTRACT
1543 || GET_CODE (dest) == STRICT_LOW_PART)
1544 dest = XEXP (dest, 0);
1546 /* If we have a PARALLEL, SET_DEST is a list of EXPR_LIST expressions,
1547 each of whose first operand is a register. We can't know what
1548 precisely is being set in these cases, so make up a CLOBBER to pass
1550 if (GET_CODE (dest) == PARALLEL)
1552 for (i = XVECLEN (dest, 0) - 1; i >= 0; i--)
1553 if (XEXP (XVECEXP (dest, 0, i), 0) != 0)
1554 (*fun) (XEXP (XVECEXP (dest, 0, i), 0),
1555 gen_rtx_CLOBBER (VOIDmode,
1556 XEXP (XVECEXP (dest, 0, i), 0)),
1560 (*fun) (dest, x, data);
1563 else if (GET_CODE (x) == PARALLEL)
1564 for (i = XVECLEN (x, 0) - 1; i >= 0; i--)
1565 note_stores (XVECEXP (x, 0, i), fun, data);
1568 /* Like notes_stores, but call FUN for each expression that is being
1569 referenced in PBODY, a pointer to the PATTERN of an insn. We only call
1570 FUN for each expression, not any interior subexpressions. FUN receives a
1571 pointer to the expression and the DATA passed to this function.
1573 Note that this is not quite the same test as that done in reg_referenced_p
1574 since that considers something as being referenced if it is being
1575 partially set, while we do not. */
1578 note_uses (pbody, fun, data)
1580 void (*fun) PARAMS ((rtx *, void *));
1586 switch (GET_CODE (body))
1589 (*fun) (&COND_EXEC_TEST (body), data);
1590 note_uses (&COND_EXEC_CODE (body), fun, data);
1594 for (i = XVECLEN (body, 0) - 1; i >= 0; i--)
1595 note_uses (&XVECEXP (body, 0, i), fun, data);
1599 (*fun) (&XEXP (body, 0), data);
1603 for (i = ASM_OPERANDS_INPUT_LENGTH (body) - 1; i >= 0; i--)
1604 (*fun) (&ASM_OPERANDS_INPUT (body, i), data);
1608 (*fun) (&TRAP_CONDITION (body), data);
1612 (*fun) (&XEXP (body, 0), data);
1616 case UNSPEC_VOLATILE:
1617 for (i = XVECLEN (body, 0) - 1; i >= 0; i--)
1618 (*fun) (&XVECEXP (body, 0, i), data);
1622 if (GET_CODE (XEXP (body, 0)) == MEM)
1623 (*fun) (&XEXP (XEXP (body, 0), 0), data);
1628 rtx dest = SET_DEST (body);
1630 /* For sets we replace everything in source plus registers in memory
1631 expression in store and operands of a ZERO_EXTRACT. */
1632 (*fun) (&SET_SRC (body), data);
1634 if (GET_CODE (dest) == ZERO_EXTRACT)
1636 (*fun) (&XEXP (dest, 1), data);
1637 (*fun) (&XEXP (dest, 2), data);
1640 while (GET_CODE (dest) == SUBREG || GET_CODE (dest) == STRICT_LOW_PART)
1641 dest = XEXP (dest, 0);
1643 if (GET_CODE (dest) == MEM)
1644 (*fun) (&XEXP (dest, 0), data);
1649 /* All the other possibilities never store. */
1650 (*fun) (pbody, data);
1655 /* Return nonzero if X's old contents don't survive after INSN.
1656 This will be true if X is (cc0) or if X is a register and
1657 X dies in INSN or because INSN entirely sets X.
1659 "Entirely set" means set directly and not through a SUBREG,
1660 ZERO_EXTRACT or SIGN_EXTRACT, so no trace of the old contents remains.
1661 Likewise, REG_INC does not count.
1663 REG may be a hard or pseudo reg. Renumbering is not taken into account,
1664 but for this use that makes no difference, since regs don't overlap
1665 during their lifetimes. Therefore, this function may be used
1666 at any time after deaths have been computed (in flow.c).
1668 If REG is a hard reg that occupies multiple machine registers, this
1669 function will only return 1 if each of those registers will be replaced
1673 dead_or_set_p (insn, x)
1677 unsigned int regno, last_regno;
1680 /* Can't use cc0_rtx below since this file is used by genattrtab.c. */
1681 if (GET_CODE (x) == CC0)
1684 if (GET_CODE (x) != REG)
1688 last_regno = (regno >= FIRST_PSEUDO_REGISTER ? regno
1689 : regno + HARD_REGNO_NREGS (regno, GET_MODE (x)) - 1);
1691 for (i = regno; i <= last_regno; i++)
1692 if (! dead_or_set_regno_p (insn, i))
1698 /* Utility function for dead_or_set_p to check an individual register. Also
1699 called from flow.c. */
1702 dead_or_set_regno_p (insn, test_regno)
1704 unsigned int test_regno;
1706 unsigned int regno, endregno;
1709 /* See if there is a death note for something that includes TEST_REGNO. */
1710 if (find_regno_note (insn, REG_DEAD, test_regno))
1713 if (GET_CODE (insn) == CALL_INSN
1714 && find_regno_fusage (insn, CLOBBER, test_regno))
1717 pattern = PATTERN (insn);
1719 if (GET_CODE (pattern) == COND_EXEC)
1720 pattern = COND_EXEC_CODE (pattern);
1722 if (GET_CODE (pattern) == SET)
1724 rtx dest = SET_DEST (PATTERN (insn));
1726 /* A value is totally replaced if it is the destination or the
1727 destination is a SUBREG of REGNO that does not change the number of
1729 if (GET_CODE (dest) == SUBREG
1730 && (((GET_MODE_SIZE (GET_MODE (dest))
1731 + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
1732 == ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (dest)))
1733 + UNITS_PER_WORD - 1) / UNITS_PER_WORD)))
1734 dest = SUBREG_REG (dest);
1736 if (GET_CODE (dest) != REG)
1739 regno = REGNO (dest);
1740 endregno = (regno >= FIRST_PSEUDO_REGISTER ? regno + 1
1741 : regno + HARD_REGNO_NREGS (regno, GET_MODE (dest)));
1743 return (test_regno >= regno && test_regno < endregno);
1745 else if (GET_CODE (pattern) == PARALLEL)
1749 for (i = XVECLEN (pattern, 0) - 1; i >= 0; i--)
1751 rtx body = XVECEXP (pattern, 0, i);
1753 if (GET_CODE (body) == COND_EXEC)
1754 body = COND_EXEC_CODE (body);
1756 if (GET_CODE (body) == SET || GET_CODE (body) == CLOBBER)
1758 rtx dest = SET_DEST (body);
1760 if (GET_CODE (dest) == SUBREG
1761 && (((GET_MODE_SIZE (GET_MODE (dest))
1762 + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
1763 == ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (dest)))
1764 + UNITS_PER_WORD - 1) / UNITS_PER_WORD)))
1765 dest = SUBREG_REG (dest);
1767 if (GET_CODE (dest) != REG)
1770 regno = REGNO (dest);
1771 endregno = (regno >= FIRST_PSEUDO_REGISTER ? regno + 1
1772 : regno + HARD_REGNO_NREGS (regno, GET_MODE (dest)));
1774 if (test_regno >= regno && test_regno < endregno)
1783 /* Return the reg-note of kind KIND in insn INSN, if there is one.
1784 If DATUM is nonzero, look for one whose datum is DATUM. */
1787 find_reg_note (insn, kind, datum)
1794 /* Ignore anything that is not an INSN, JUMP_INSN or CALL_INSN. */
1795 if (! INSN_P (insn))
1798 for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
1799 if (REG_NOTE_KIND (link) == kind
1800 && (datum == 0 || datum == XEXP (link, 0)))
1805 /* Return the reg-note of kind KIND in insn INSN which applies to register
1806 number REGNO, if any. Return 0 if there is no such reg-note. Note that
1807 the REGNO of this NOTE need not be REGNO if REGNO is a hard register;
1808 it might be the case that the note overlaps REGNO. */
1811 find_regno_note (insn, kind, regno)
1818 /* Ignore anything that is not an INSN, JUMP_INSN or CALL_INSN. */
1819 if (! INSN_P (insn))
1822 for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
1823 if (REG_NOTE_KIND (link) == kind
1824 /* Verify that it is a register, so that scratch and MEM won't cause a
1826 && GET_CODE (XEXP (link, 0)) == REG
1827 && REGNO (XEXP (link, 0)) <= regno
1828 && ((REGNO (XEXP (link, 0))
1829 + (REGNO (XEXP (link, 0)) >= FIRST_PSEUDO_REGISTER ? 1
1830 : HARD_REGNO_NREGS (REGNO (XEXP (link, 0)),
1831 GET_MODE (XEXP (link, 0)))))
1837 /* Return a REG_EQUIV or REG_EQUAL note if insn has only a single set and
1841 find_reg_equal_equiv_note (insn)
1846 if (single_set (insn) == 0)
1848 else if ((note = find_reg_note (insn, REG_EQUIV, NULL_RTX)) != 0)
1851 return find_reg_note (insn, REG_EQUAL, NULL_RTX);
1854 /* Return true if DATUM, or any overlap of DATUM, of kind CODE is found
1855 in the CALL_INSN_FUNCTION_USAGE information of INSN. */
1858 find_reg_fusage (insn, code, datum)
1863 /* If it's not a CALL_INSN, it can't possibly have a
1864 CALL_INSN_FUNCTION_USAGE field, so don't bother checking. */
1865 if (GET_CODE (insn) != CALL_INSN)
1871 if (GET_CODE (datum) != REG)
1875 for (link = CALL_INSN_FUNCTION_USAGE (insn);
1877 link = XEXP (link, 1))
1878 if (GET_CODE (XEXP (link, 0)) == code
1879 && rtx_equal_p (datum, XEXP (XEXP (link, 0), 0)))
1884 unsigned int regno = REGNO (datum);
1886 /* CALL_INSN_FUNCTION_USAGE information cannot contain references
1887 to pseudo registers, so don't bother checking. */
1889 if (regno < FIRST_PSEUDO_REGISTER)
1891 unsigned int end_regno
1892 = regno + HARD_REGNO_NREGS (regno, GET_MODE (datum));
1895 for (i = regno; i < end_regno; i++)
1896 if (find_regno_fusage (insn, code, i))
1904 /* Return true if REGNO, or any overlap of REGNO, of kind CODE is found
1905 in the CALL_INSN_FUNCTION_USAGE information of INSN. */
1908 find_regno_fusage (insn, code, regno)
1915 /* CALL_INSN_FUNCTION_USAGE information cannot contain references
1916 to pseudo registers, so don't bother checking. */
1918 if (regno >= FIRST_PSEUDO_REGISTER
1919 || GET_CODE (insn) != CALL_INSN )
1922 for (link = CALL_INSN_FUNCTION_USAGE (insn); link; link = XEXP (link, 1))
1924 unsigned int regnote;
1927 if (GET_CODE (op = XEXP (link, 0)) == code
1928 && GET_CODE (reg = XEXP (op, 0)) == REG
1929 && (regnote = REGNO (reg)) <= regno
1930 && regnote + HARD_REGNO_NREGS (regnote, GET_MODE (reg)) > regno)
1937 /* Remove register note NOTE from the REG_NOTES of INSN. */
1940 remove_note (insn, note)
1946 if (note == NULL_RTX)
1949 if (REG_NOTES (insn) == note)
1951 REG_NOTES (insn) = XEXP (note, 1);
1955 for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
1956 if (XEXP (link, 1) == note)
1958 XEXP (link, 1) = XEXP (note, 1);
1965 /* Search LISTP (an EXPR_LIST) for an entry whose first operand is NODE and
1966 return 1 if it is found. A simple equality test is used to determine if
1970 in_expr_list_p (listp, node)
1976 for (x = listp; x; x = XEXP (x, 1))
1977 if (node == XEXP (x, 0))
1983 /* Search LISTP (an EXPR_LIST) for an entry whose first operand is NODE and
1984 remove that entry from the list if it is found.
1986 A simple equality test is used to determine if NODE matches. */
1989 remove_node_from_expr_list (node, listp)
1994 rtx prev = NULL_RTX;
1998 if (node == XEXP (temp, 0))
2000 /* Splice the node out of the list. */
2002 XEXP (prev, 1) = XEXP (temp, 1);
2004 *listp = XEXP (temp, 1);
2010 temp = XEXP (temp, 1);
2014 /* Nonzero if X contains any volatile instructions. These are instructions
2015 which may cause unpredictable machine state instructions, and thus no
2016 instructions should be moved or combined across them. This includes
2017 only volatile asms and UNSPEC_VOLATILE instructions. */
2025 code = GET_CODE (x);
2046 case UNSPEC_VOLATILE:
2047 /* case TRAP_IF: This isn't clear yet. */
2051 if (MEM_VOLATILE_P (x))
2058 /* Recursively scan the operands of this expression. */
2061 const char *fmt = GET_RTX_FORMAT (code);
2064 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
2068 if (volatile_insn_p (XEXP (x, i)))
2071 else if (fmt[i] == 'E')
2074 for (j = 0; j < XVECLEN (x, i); j++)
2075 if (volatile_insn_p (XVECEXP (x, i, j)))
2083 /* Nonzero if X contains any volatile memory references
2084 UNSPEC_VOLATILE operations or volatile ASM_OPERANDS expressions. */
2092 code = GET_CODE (x);
2112 case UNSPEC_VOLATILE:
2113 /* case TRAP_IF: This isn't clear yet. */
2118 if (MEM_VOLATILE_P (x))
2125 /* Recursively scan the operands of this expression. */
2128 const char *fmt = GET_RTX_FORMAT (code);
2131 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
2135 if (volatile_refs_p (XEXP (x, i)))
2138 else if (fmt[i] == 'E')
2141 for (j = 0; j < XVECLEN (x, i); j++)
2142 if (volatile_refs_p (XVECEXP (x, i, j)))
2150 /* Similar to above, except that it also rejects register pre- and post-
2159 code = GET_CODE (x);
2178 /* Reject CLOBBER with a non-VOID mode. These are made by combine.c
2179 when some combination can't be done. If we see one, don't think
2180 that we can simplify the expression. */
2181 return (GET_MODE (x) != VOIDmode);
2190 case UNSPEC_VOLATILE:
2191 /* case TRAP_IF: This isn't clear yet. */
2196 if (MEM_VOLATILE_P (x))
2203 /* Recursively scan the operands of this expression. */
2206 const char *fmt = GET_RTX_FORMAT (code);
2209 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
2213 if (side_effects_p (XEXP (x, i)))
2216 else if (fmt[i] == 'E')
2219 for (j = 0; j < XVECLEN (x, i); j++)
2220 if (side_effects_p (XVECEXP (x, i, j)))
2228 /* Return nonzero if evaluating rtx X might cause a trap. */
2240 code = GET_CODE (x);
2243 /* Handle these cases quickly. */
2257 case UNSPEC_VOLATILE:
2262 return MEM_VOLATILE_P (x);
2264 /* Memory ref can trap unless it's a static var or a stack slot. */
2266 return rtx_addr_can_trap_p (XEXP (x, 0));
2268 /* Division by a non-constant might trap. */
2273 if (! CONSTANT_P (XEXP (x, 1))
2274 || GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT)
2276 /* This was const0_rtx, but by not using that,
2277 we can link this file into other programs. */
2278 if (GET_CODE (XEXP (x, 1)) == CONST_INT && INTVAL (XEXP (x, 1)) == 0)
2283 /* An EXPR_LIST is used to represent a function call. This
2284 certainly may trap. */
2292 /* Some floating point comparisons may trap. */
2293 /* ??? There is no machine independent way to check for tests that trap
2294 when COMPARE is used, though many targets do make this distinction.
2295 For instance, sparc uses CCFPE for compares which generate exceptions
2296 and CCFP for compares which do not generate exceptions. */
2297 if (GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT)
2299 /* But often the compare has some CC mode, so check operand
2301 if (GET_MODE_CLASS (GET_MODE (XEXP (x, 0))) == MODE_FLOAT
2302 || GET_MODE_CLASS (GET_MODE (XEXP (x, 1))) == MODE_FLOAT)
2308 /* These operations don't trap even with floating point. */
2312 /* Any floating arithmetic may trap. */
2313 if (GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT)
2317 fmt = GET_RTX_FORMAT (code);
2318 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
2322 if (may_trap_p (XEXP (x, i)))
2325 else if (fmt[i] == 'E')
2328 for (j = 0; j < XVECLEN (x, i); j++)
2329 if (may_trap_p (XVECEXP (x, i, j)))
2336 /* Return nonzero if X contains a comparison that is not either EQ or NE,
2337 i.e., an inequality. */
2340 inequality_comparisons_p (x)
2345 enum rtx_code code = GET_CODE (x);
2375 len = GET_RTX_LENGTH (code);
2376 fmt = GET_RTX_FORMAT (code);
2378 for (i = 0; i < len; i++)
2382 if (inequality_comparisons_p (XEXP (x, i)))
2385 else if (fmt[i] == 'E')
2388 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
2389 if (inequality_comparisons_p (XVECEXP (x, i, j)))
2397 /* Replace any occurrence of FROM in X with TO. The function does
2398 not enter into CONST_DOUBLE for the replace.
2400 Note that copying is not done so X must not be shared unless all copies
2401 are to be modified. */
2404 replace_rtx (x, from, to)
2410 /* The following prevents loops occurrence when we change MEM in
2411 CONST_DOUBLE onto the same CONST_DOUBLE. */
2412 if (x != 0 && GET_CODE (x) == CONST_DOUBLE)
2418 /* Allow this function to make replacements in EXPR_LISTs. */
2422 if (GET_CODE (x) == SUBREG)
2424 rtx new = replace_rtx (SUBREG_REG (x), from, to);
2426 if (GET_CODE (new) == CONST_INT)
2428 x = simplify_subreg (GET_MODE (x), new,
2429 GET_MODE (SUBREG_REG (x)),
2435 SUBREG_REG (x) = new;
2439 else if (GET_CODE (x) == ZERO_EXTEND)
2441 rtx new = replace_rtx (XEXP (x, 0), from, to);
2443 if (GET_CODE (new) == CONST_INT)
2445 x = simplify_unary_operation (ZERO_EXTEND, GET_MODE (x),
2446 new, GET_MODE (XEXP (x, 0)));
2456 fmt = GET_RTX_FORMAT (GET_CODE (x));
2457 for (i = GET_RTX_LENGTH (GET_CODE (x)) - 1; i >= 0; i--)
2460 XEXP (x, i) = replace_rtx (XEXP (x, i), from, to);
2461 else if (fmt[i] == 'E')
2462 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
2463 XVECEXP (x, i, j) = replace_rtx (XVECEXP (x, i, j), from, to);
2469 /* Throughout the rtx X, replace many registers according to REG_MAP.
2470 Return the replacement for X (which may be X with altered contents).
2471 REG_MAP[R] is the replacement for register R, or 0 for don't replace.
2472 NREGS is the length of REG_MAP; regs >= NREGS are not mapped.
2474 We only support REG_MAP entries of REG or SUBREG. Also, hard registers
2475 should not be mapped to pseudos or vice versa since validate_change
2478 If REPLACE_DEST is 1, replacements are also done in destinations;
2479 otherwise, only sources are replaced. */
2482 replace_regs (x, reg_map, nregs, replace_dest)
2495 code = GET_CODE (x);
2510 /* Verify that the register has an entry before trying to access it. */
2511 if (REGNO (x) < nregs && reg_map[REGNO (x)] != 0)
2513 /* SUBREGs can't be shared. Always return a copy to ensure that if
2514 this replacement occurs more than once then each instance will
2515 get distinct rtx. */
2516 if (GET_CODE (reg_map[REGNO (x)]) == SUBREG)
2517 return copy_rtx (reg_map[REGNO (x)]);
2518 return reg_map[REGNO (x)];
2523 /* Prevent making nested SUBREGs. */
2524 if (GET_CODE (SUBREG_REG (x)) == REG && REGNO (SUBREG_REG (x)) < nregs
2525 && reg_map[REGNO (SUBREG_REG (x))] != 0
2526 && GET_CODE (reg_map[REGNO (SUBREG_REG (x))]) == SUBREG)
2528 rtx map_val = reg_map[REGNO (SUBREG_REG (x))];
2529 return simplify_gen_subreg (GET_MODE (x), map_val,
2530 GET_MODE (SUBREG_REG (x)),
2537 SET_DEST (x) = replace_regs (SET_DEST (x), reg_map, nregs, 0);
2539 else if (GET_CODE (SET_DEST (x)) == MEM
2540 || GET_CODE (SET_DEST (x)) == STRICT_LOW_PART)
2541 /* Even if we are not to replace destinations, replace register if it
2542 is CONTAINED in destination (destination is memory or
2543 STRICT_LOW_PART). */
2544 XEXP (SET_DEST (x), 0) = replace_regs (XEXP (SET_DEST (x), 0),
2546 else if (GET_CODE (SET_DEST (x)) == ZERO_EXTRACT)
2547 /* Similarly, for ZERO_EXTRACT we replace all operands. */
2550 SET_SRC (x) = replace_regs (SET_SRC (x), reg_map, nregs, 0);
2557 fmt = GET_RTX_FORMAT (code);
2558 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
2561 XEXP (x, i) = replace_regs (XEXP (x, i), reg_map, nregs, replace_dest);
2562 else if (fmt[i] == 'E')
2565 for (j = 0; j < XVECLEN (x, i); j++)
2566 XVECEXP (x, i, j) = replace_regs (XVECEXP (x, i, j), reg_map,
2567 nregs, replace_dest);
2573 /* A subroutine of computed_jump_p, return 1 if X contains a REG or MEM or
2574 constant that is not in the constant pool and not in the condition
2575 of an IF_THEN_ELSE. */
2578 computed_jump_p_1 (x)
2581 enum rtx_code code = GET_CODE (x);
2600 return ! (GET_CODE (XEXP (x, 0)) == SYMBOL_REF
2601 && CONSTANT_POOL_ADDRESS_P (XEXP (x, 0)));
2604 return (computed_jump_p_1 (XEXP (x, 1))
2605 || computed_jump_p_1 (XEXP (x, 2)));
2611 fmt = GET_RTX_FORMAT (code);
2612 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
2615 && computed_jump_p_1 (XEXP (x, i)))
2618 else if (fmt[i] == 'E')
2619 for (j = 0; j < XVECLEN (x, i); j++)
2620 if (computed_jump_p_1 (XVECEXP (x, i, j)))
2627 /* Return nonzero if INSN is an indirect jump (aka computed jump).
2629 Tablejumps and casesi insns are not considered indirect jumps;
2630 we can recognize them by a (use (label_ref)). */
2633 computed_jump_p (insn)
2637 if (GET_CODE (insn) == JUMP_INSN)
2639 rtx pat = PATTERN (insn);
2641 if (find_reg_note (insn, REG_LABEL, NULL_RTX))
2643 else if (GET_CODE (pat) == PARALLEL)
2645 int len = XVECLEN (pat, 0);
2646 int has_use_labelref = 0;
2648 for (i = len - 1; i >= 0; i--)
2649 if (GET_CODE (XVECEXP (pat, 0, i)) == USE
2650 && (GET_CODE (XEXP (XVECEXP (pat, 0, i), 0))
2652 has_use_labelref = 1;
2654 if (! has_use_labelref)
2655 for (i = len - 1; i >= 0; i--)
2656 if (GET_CODE (XVECEXP (pat, 0, i)) == SET
2657 && SET_DEST (XVECEXP (pat, 0, i)) == pc_rtx
2658 && computed_jump_p_1 (SET_SRC (XVECEXP (pat, 0, i))))
2661 else if (GET_CODE (pat) == SET
2662 && SET_DEST (pat) == pc_rtx
2663 && computed_jump_p_1 (SET_SRC (pat)))
2669 /* Traverse X via depth-first search, calling F for each
2670 sub-expression (including X itself). F is also passed the DATA.
2671 If F returns -1, do not traverse sub-expressions, but continue
2672 traversing the rest of the tree. If F ever returns any other
2673 non-zero value, stop the traversal, and return the value returned
2674 by F. Otherwise, return 0. This function does not traverse inside
2675 tree structure that contains RTX_EXPRs, or into sub-expressions
2676 whose format code is `0' since it is not known whether or not those
2677 codes are actually RTL.
2679 This routine is very general, and could (should?) be used to
2680 implement many of the other routines in this file. */
2683 for_each_rtx (x, f, data)
2694 result = (*f) (x, data);
2696 /* Do not traverse sub-expressions. */
2698 else if (result != 0)
2699 /* Stop the traversal. */
2703 /* There are no sub-expressions. */
2706 length = GET_RTX_LENGTH (GET_CODE (*x));
2707 format = GET_RTX_FORMAT (GET_CODE (*x));
2709 for (i = 0; i < length; ++i)
2714 result = for_each_rtx (&XEXP (*x, i), f, data);
2721 if (XVEC (*x, i) != 0)
2724 for (j = 0; j < XVECLEN (*x, i); ++j)
2726 result = for_each_rtx (&XVECEXP (*x, i, j), f, data);
2734 /* Nothing to do. */
2743 /* Searches X for any reference to REGNO, returning the rtx of the
2744 reference found if any. Otherwise, returns NULL_RTX. */
2747 regno_use_in (regno, x)
2755 if (GET_CODE (x) == REG && REGNO (x) == regno)
2758 fmt = GET_RTX_FORMAT (GET_CODE (x));
2759 for (i = GET_RTX_LENGTH (GET_CODE (x)) - 1; i >= 0; i--)
2763 if ((tem = regno_use_in (regno, XEXP (x, i))))
2766 else if (fmt[i] == 'E')
2767 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
2768 if ((tem = regno_use_in (regno , XVECEXP (x, i, j))))
2775 /* Return a value indicating whether OP, an operand of a commutative
2776 operation, is preferred as the first or second operand. The higher
2777 the value, the stronger the preference for being the first operand.
2778 We use negative values to indicate a preference for the first operand
2779 and positive values for the second operand. */
2782 commutative_operand_precedence (op)
2785 /* Constants always come the second operand. Prefer "nice" constants. */
2786 if (GET_CODE (op) == CONST_INT)
2788 if (GET_CODE (op) == CONST_DOUBLE)
2790 if (CONSTANT_P (op))
2793 /* SUBREGs of objects should come second. */
2794 if (GET_CODE (op) == SUBREG
2795 && GET_RTX_CLASS (GET_CODE (SUBREG_REG (op))) == 'o')
2798 /* If only one operand is a `neg', `not',
2799 `mult', `plus', or `minus' expression, it will be the first
2801 if (GET_CODE (op) == NEG || GET_CODE (op) == NOT
2802 || GET_CODE (op) == MULT || GET_CODE (op) == PLUS
2803 || GET_CODE (op) == MINUS)
2806 /* Complex expressions should be the first, so decrease priority
2808 if (GET_RTX_CLASS (GET_CODE (op)) == 'o')
2813 /* Return 1 iff it is necessary to swap operands of commutative operation
2814 in order to canonicalize expression. */
2817 swap_commutative_operands_p (x, y)
2820 return (commutative_operand_precedence (x)
2821 < commutative_operand_precedence (y));
2824 /* Return 1 if X is an autoincrement side effect and the register is
2825 not the stack pointer. */
2830 switch (GET_CODE (x))
2838 /* There are no REG_INC notes for SP. */
2839 if (XEXP (x, 0) != stack_pointer_rtx)
2847 /* Return 1 if the sequence of instructions beginning with FROM and up
2848 to and including TO is safe to move. If NEW_TO is non-NULL, and
2849 the sequence is not already safe to move, but can be easily
2850 extended to a sequence which is safe, then NEW_TO will point to the
2851 end of the extended sequence.
2853 For now, this function only checks that the region contains whole
2854 exception regions, but it could be extended to check additional
2855 conditions as well. */
2858 insns_safe_to_move_p (from, to, new_to)
2863 int eh_region_count = 0;
2867 /* By default, assume the end of the region will be what was
2874 if (GET_CODE (r) == NOTE)
2876 switch (NOTE_LINE_NUMBER (r))
2878 case NOTE_INSN_EH_REGION_BEG:
2882 case NOTE_INSN_EH_REGION_END:
2883 if (eh_region_count == 0)
2884 /* This sequence of instructions contains the end of
2885 an exception region, but not he beginning. Moving
2886 it will cause chaos. */
2897 /* If we've passed TO, and we see a non-note instruction, we
2898 can't extend the sequence to a movable sequence. */
2904 /* It's OK to move the sequence if there were matched sets of
2905 exception region notes. */
2906 return eh_region_count == 0;
2911 /* It's OK to move the sequence if there were matched sets of
2912 exception region notes. */
2913 if (past_to_p && eh_region_count == 0)
2919 /* Go to the next instruction. */
2926 /* Return non-zero if IN contains a piece of rtl that has the address LOC */
2928 loc_mentioned_in_p (loc, in)
2931 enum rtx_code code = GET_CODE (in);
2932 const char *fmt = GET_RTX_FORMAT (code);
2935 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
2937 if (loc == &in->fld[i].rtx)
2941 if (loc_mentioned_in_p (loc, XEXP (in, i)))
2944 else if (fmt[i] == 'E')
2945 for (j = XVECLEN (in, i) - 1; j >= 0; j--)
2946 if (loc_mentioned_in_p (loc, XVECEXP (in, i, j)))
2952 /* Given a subreg X, return the bit offset where the subreg begins
2953 (counting from the least significant bit of the reg). */
2959 enum machine_mode inner_mode = GET_MODE (SUBREG_REG (x));
2960 enum machine_mode mode = GET_MODE (x);
2961 unsigned int bitpos;
2965 /* A paradoxical subreg begins at bit position 0. */
2966 if (GET_MODE_BITSIZE (mode) > GET_MODE_BITSIZE (inner_mode))
2969 if (WORDS_BIG_ENDIAN != BYTES_BIG_ENDIAN)
2970 /* If the subreg crosses a word boundary ensure that
2971 it also begins and ends on a word boundary. */
2972 if ((SUBREG_BYTE (x) % UNITS_PER_WORD
2973 + GET_MODE_SIZE (mode)) > UNITS_PER_WORD
2974 && (SUBREG_BYTE (x) % UNITS_PER_WORD
2975 || GET_MODE_SIZE (mode) % UNITS_PER_WORD))
2978 if (WORDS_BIG_ENDIAN)
2979 word = (GET_MODE_SIZE (inner_mode)
2980 - (SUBREG_BYTE (x) + GET_MODE_SIZE (mode))) / UNITS_PER_WORD;
2982 word = SUBREG_BYTE (x) / UNITS_PER_WORD;
2983 bitpos = word * BITS_PER_WORD;
2985 if (BYTES_BIG_ENDIAN)
2986 byte = (GET_MODE_SIZE (inner_mode)
2987 - (SUBREG_BYTE (x) + GET_MODE_SIZE (mode))) % UNITS_PER_WORD;
2989 byte = SUBREG_BYTE (x) % UNITS_PER_WORD;
2990 bitpos += byte * BITS_PER_UNIT;
2995 /* This function returns the regno offset of a subreg expression.
2996 xregno - A regno of an inner hard subreg_reg (or what will become one).
2997 xmode - The mode of xregno.
2998 offset - The byte offset.
2999 ymode - The mode of a top level SUBREG (or what may become one).
3000 RETURN - The regno offset which would be used. */
3002 subreg_regno_offset (xregno, xmode, offset, ymode)
3003 unsigned int xregno;
3004 enum machine_mode xmode;
3005 unsigned int offset;
3006 enum machine_mode ymode;
3008 int nregs_xmode, nregs_ymode;
3009 int mode_multiple, nregs_multiple;
3012 if (xregno >= FIRST_PSEUDO_REGISTER)
3015 nregs_xmode = HARD_REGNO_NREGS (xregno, xmode);
3016 nregs_ymode = HARD_REGNO_NREGS (xregno, ymode);
3017 if (offset == 0 || nregs_xmode == nregs_ymode)
3020 /* size of ymode must not be greater than the size of xmode. */
3021 mode_multiple = GET_MODE_SIZE (xmode) / GET_MODE_SIZE (ymode);
3022 if (mode_multiple == 0)
3025 y_offset = offset / GET_MODE_SIZE (ymode);
3026 nregs_multiple = nregs_xmode / nregs_ymode;
3027 return (y_offset / (mode_multiple / nregs_multiple)) * nregs_ymode;
3030 /* Return the final regno that a subreg expression refers to. */
3036 rtx subreg = SUBREG_REG (x);
3037 int regno = REGNO (subreg);
3039 ret = regno + subreg_regno_offset (regno,
3046 struct parms_set_data
3052 /* Helper function for noticing stores to parameter registers. */
3054 parms_set (x, pat, data)
3055 rtx x, pat ATTRIBUTE_UNUSED;
3058 struct parms_set_data *d = data;
3059 if (REG_P (x) && REGNO (x) < FIRST_PSEUDO_REGISTER
3060 && TEST_HARD_REG_BIT (d->regs, REGNO (x)))
3062 CLEAR_HARD_REG_BIT (d->regs, REGNO (x));
3067 /* Look backward for first parameter to be loaded.
3068 Do not skip BOUNDARY. */
3070 find_first_parameter_load (call_insn, boundary)
3071 rtx call_insn, boundary;
3073 struct parms_set_data parm;
3076 /* Since different machines initialize their parameter registers
3077 in different orders, assume nothing. Collect the set of all
3078 parameter registers. */
3079 CLEAR_HARD_REG_SET (parm.regs);
3081 for (p = CALL_INSN_FUNCTION_USAGE (call_insn); p; p = XEXP (p, 1))
3082 if (GET_CODE (XEXP (p, 0)) == USE
3083 && GET_CODE (XEXP (XEXP (p, 0), 0)) == REG)
3085 if (REGNO (XEXP (XEXP (p, 0), 0)) >= FIRST_PSEUDO_REGISTER)
3088 /* We only care about registers which can hold function
3090 if (!FUNCTION_ARG_REGNO_P (REGNO (XEXP (XEXP (p, 0), 0))))
3093 SET_HARD_REG_BIT (parm.regs, REGNO (XEXP (XEXP (p, 0), 0)));
3098 /* Search backward for the first set of a register in this set. */
3099 while (parm.nregs && before != boundary)
3101 before = PREV_INSN (before);
3103 /* It is possible that some loads got CSEed from one call to
3104 another. Stop in that case. */
3105 if (GET_CODE (before) == CALL_INSN)
3108 /* Our caller needs either ensure that we will find all sets
3109 (in case code has not been optimized yet), or take care
3110 for possible labels in a way by setting boundary to preceding
3112 if (GET_CODE (before) == CODE_LABEL)
3114 if (before != boundary)
3119 if (INSN_P (before))
3120 note_stores (PATTERN (before), parms_set, &parm);
3125 /* Return true if we should avoid inserting code between INSN and preceeding
3126 call instruction. */
3129 keep_with_call_p (insn)
3134 if (INSN_P (insn) && (set = single_set (insn)) != NULL)
3136 if (GET_CODE (SET_DEST (set)) == REG
3137 && fixed_regs[REGNO (SET_DEST (set))]
3138 && general_operand (SET_SRC (set), VOIDmode))
3140 if (GET_CODE (SET_SRC (set)) == REG
3141 && FUNCTION_VALUE_REGNO_P (REGNO (SET_SRC (set)))
3142 && GET_CODE (SET_DEST (set)) == REG
3143 && REGNO (SET_DEST (set)) >= FIRST_PSEUDO_REGISTER)
3145 /* There may be a stack pop just after the call and before the store
3146 of the return register. Search for the actual store when deciding
3147 if we can break or not. */
3148 if (SET_DEST (set) == stack_pointer_rtx)
3150 rtx i2 = next_nonnote_insn (insn);
3151 if (i2 && keep_with_call_p (i2))