gcc/gcc/regmove.c

36 #include "hard-reg-set.h"
139 		     is set, but the value is dead.  Failure to do so will
175   /* If we get something that isn't a simple set, or a
176      [(set ..) (clobber ..)], this whole function will go wrong.  */
299 		 as the destination of a set.  */
582       /* If SRC is a hard register which is set or killed in some other
599    ending with the set of SRC to DEST, with SRC.  We do not do this
613   rtx set;
626       set = single_set (p);
627       if (set && SET_SRC (set) == dest && SET_DEST (set) == src
662    Look if SRC dies there, and if it is only set once, by loading
676   rtx p, set, subreg;
694   if (! (set = single_set (p))
695       || GET_CODE (SET_SRC (set)) != MEM
699       || SET_DEST (set) != src_reg)
704   if (MEM_VOLATILE_P (SET_SRC (set)))
716   XEXP (src, 0) = SET_SRC (set);
720   validate_change (p, &SET_SRC (set), src, 1);
766   rtx set;
786       && (set = single_set (insn)) != NULL_RTX
787       && !reg_mentioned_p (dest, SET_SRC (set))
868 /* Return whether REG is set in only one location, and is set to a
869    constant, but is set in a different basic block from INSN (an
873    set in the same basic block as INSN, we don't worry about it,
889   /* Look for the set.  */
901 	  /* The register is set in the same basic block.  */
934      (set (reg100) (plus reg1 offset1))
936      (set (reg100) (plus reg1 offset2))
938      (set (reg100) (plus reg1 offset1))
940      (set (reg100) (plus reg100 offset2-offset1))  */
1115 	  rtx set;
1118 	  set = single_set (insn);
1119 	  if (! set)
1123 	      && (GET_CODE (SET_SRC (set)) == SIGN_EXTEND
1124 		  || GET_CODE (SET_SRC (set)) == ZERO_EXTEND)
1125 	      && GET_CODE (XEXP (SET_SRC (set), 0)) == REG
1126 	      && GET_CODE (SET_DEST (set)) == REG)
1127 	    optimize_reg_copy_3 (insn, SET_DEST (set), SET_SRC (set));
1130 	      && GET_CODE (SET_SRC (set)) == REG
1131 	      && GET_CODE (SET_DEST (set)) == REG)
1136 	      if ((find_reg_note (insn, REG_DEAD, SET_SRC (set))
1137 		   || optimize_reg_copy_1 (insn, SET_DEST (set), SET_SRC (set)))
1138 		  && REGNO (SET_DEST (set)) >= FIRST_PSEUDO_REGISTER)
1141 		  if (REGNO (SET_SRC (set)) >= FIRST_PSEUDO_REGISTER)
1142 		    optimize_reg_copy_2 (insn, SET_DEST (set), SET_SRC (set));
1143 		  if (regno_src_regno[REGNO (SET_DEST (set))] < 0
1144 		      && SET_SRC (set) != SET_DEST (set))
1146 		      int srcregno = REGNO (SET_SRC (set));
1149 		      regno_src_regno[REGNO (SET_DEST (set))] = srcregno;
1218 	      if (recog_data.operand[match_no] != SET_DEST (set))
1243 	      if (fixup_match_1 (insn, set, src, src_subreg, dst, pass,
1276 	      rtx set, p, src, dst;
1311 	      set = single_set (insn);
1312 	      if (! set)
1315 	      /* Note that single_set ignores parts of a parallel set for
1318 		 such that a single register is set twice within a single
1334 	      if (recog_data.operand[match_no] != SET_DEST (set))
1339 		  if (GET_CODE (SET_SRC (set)) == PLUS
1340 		      && GET_CODE (XEXP (SET_SRC (set), 1)) == CONST_INT
1341 		      && XEXP (SET_SRC (set), 0) == src
1343 					XEXP (SET_SRC (set), 1),
1375 	      /* Can not modify an earlier insn to set dst if this insn
1377 	      if (reg_overlap_mentioned_p (dst, SET_SRC (set)))
1387 	      /* If src is set once in a different basic block,
1388 		 and is set equal to a constant, then do not use
1409 		 the input operand.  If the operand is set here, then
1426 		  /* ??? See if all of SRC is set in P.  This test is much
1483 		     it, because DST is now set there.  */
1563      the commutative case may set matches for operands other than
1673    the only set in INSN.  INSN has just been recognized and constrained.
1680 fixup_match_1 (insn, set, src, src_subreg, dst, backward, operand_number,
1682      rtx insn, set, src, src_subreg, dst;
1704       /* Look for (set (regX) (op regA constX))
1705 		  (set (regY) (op regA constY))
1707 		  (set (regA) (op regA constX)).
1708 		  (set (regY) (op regA constY-constX)).
1710 	 regA is dead after or set by the second insn.  */
1712       code = GET_CODE (SET_SRC (set));
1715 	  && XEXP (SET_SRC (set), 0) == src
1716 	  && GET_CODE (XEXP (SET_SRC (set), 1)) == CONST_INT)
1717 	insn_const = INTVAL (XEXP (SET_SRC (set), 1));
1718       else if (! stable_and_no_regs_but_for_p (SET_SRC (set), src, dst))
1730   /* If SRC is equivalent to a constant set in a different basic block,
1830 		      set2 = set;
1906       validate_change (insn, &XEXP (SET_SRC (set), 1), GEN_INT (insn_const), 0);
1937      if so, replace the instruction that set src
1976 	      && validate_change (insn, &SET_SRC (set), XEXP (note, 0), 0))
2079    stable if it has the RTX_UNCHANGING_P bit set, but that would still
2211       /* The special case is allowing a no-op set.  */
2271   rtx set;
2273   set = single_set_for_csa (insn);
2274   validate_change (insn, &XEXP (SET_SRC (set), 1), GEN_INT (new_adjust), 1);
2354   rtx insn, next, set;
2366       set = single_set_for_csa (insn);
2367       if (set)
2369 	  rtx dest = SET_DEST (set);
2370 	  rtx src = SET_SRC (set);
2473 	      && validate_change (insn, &SET_DEST (set),