contrib/gcc/reload1.c

1 /* Reload pseudo regs into hard regs for insns that require hard regs.
58    reg_renumber; the insns still contain pseudo regs, but reg_renumber
59    can be used to find which hard reg, if any, a pseudo reg is in.
62    called ``reload regs'', and for each place where a pseudo reg
97 /* Element N is the constant value to which pseudo reg N is equivalent,
98    or zero if pseudo reg N is not equivalent to a constant.
99    find_reloads looks at this in order to replace pseudo reg N
103 /* Element N is an invariant value to which pseudo reg N is equivalent.
108 /* Element N is a memory location to which pseudo reg N is equivalent,
118 /* Element N is the address of stack slot to which pseudo reg N is equivalent.
123 /* Element N is the memory slot to which pseudo reg N is equivalent,
124    or zero if pseudo reg N is not equivalent to a memory slot.  */
128    alternate representations of the location of pseudo reg N.  */
131 /* Widest width in which each pseudo reg is referred to (via subreg).  */
142 /* During reload_as_needed, element N contains the last pseudo regno reloaded
143    into hard register N.  If that pseudo reg occupied more than one register,
144    reg_reloaded_contents points to that pseudo for each spill register in
204    of spilled pseudo-registers.  `n_spills' is the number of
214 /* This vector of reg sets indicates, for each pseudo, which hard registers
216    formerly spilled from one of them.  If we allowed reallocating a pseudo to
221 /* This vector of reg sets indicates, for each pseudo, which hard
224    pseudo is live.  */
261    Used to avoid counting one pseudo twice.  */
326 				   register corresponding to a pseudo
649    so any pseudo reg that is spilled must go to the stack.
690      as homes for pseudo registers.
703   /* Find all the pseudo registers that didn't get hard regs
726   /* Look for REG_EQUIV notes; record what each pseudo is equivalent
728      each pseudo.  */
835   /* Alter each pseudo-reg rtx to contain its hard reg number.
911       /* For each pseudo register that has an equivalent location defined,
929 	 a pseudo that didn't get a hard register and has an equivalent memory
930 	 location that also involves a pseudo that didn't get a hard register.
958 		   will be set up for this pseudo on the next pass around
1047   /* If a pseudo has no hard reg, delete the insns that made the equivalence.
1097      virtue of being in a pseudo, that pseudo will be marked live
1099      pseudo.  */
1113   /* Now eliminate all pseudo regs by modifying them into
1616    only the first hard reg for a multi-reg pseudo.  */
1619 /* Update the spill cost arrays, considering that pseudo REG is live.  */
1659   /* Count number of uses of each hard reg by pseudo regs allocated to it
1694    SPILLED_NREGS.  Determine how pseudo REG, which is live during the insn,
1975 /* Modify the home of pseudo-reg I.
1978    FROM_REG may be the hard reg that the pseudo-reg is being spilled from;
1997      number or else to contain its pseudo reg number.  */
2001   /* If we have a pseudo that is needed but has no hard reg or equivalent,
2018       /* Each pseudo reg has an inherent size which comes from its own mode,
2020 	 which refer to the pseudo reg in wider modes.
2039 	  /* Nothing can alias this slot except this pseudo.  */
2116 	  /* We can do this only for the DECLs home pseudo, not for
2135    used by pseudo-reg number REGNO.  */
2311    CLOBBER of the pseudo after INSN so find_equiv_regs will know that
2321    they are not, or if REG_EQUIV_ADDRESS is nonzero for a pseudo we
2444 	    /* If one side is a PLUS and the other side is a pseudo that
2581 	 Also, if we have a non-paradoxical (subreg (pseudo)) and the
2582 	 pseudo didn't get a hard reg, we must replace this with the
3661   /* Spill every pseudo reg that was allocated to this reg
3676    spill pseudo registers and try to reallocate them.  It also sets up the
3714       /* Record the current hard register the pseudo is allocated to in
3731 	 regs in pseudo_forbidden_regs for every pseudo live across the
3906 /* Reload pseudo-registers into hard regs around each insn as needed.
3908    and perhaps store insns after insns that modify the reloaded pseudo reg.
3984 	  /* First find the pseudo regs that must be reloaded for this insn.
3987 	     rtx's for those pseudo regs.  */
4050 	  /* Any previously reloaded spilled pseudo reg, stored in this insn,
4084 		      /* Make sure it is the inc/dec pseudo, and not
4085 			 some other (e.g. output operand) pseudo.  */
4154 			   /* Make sure it is the inc/dec pseudo, and not
4155 			      some other (e.g. output operand) pseudo.  */
4166 	  /* If a pseudo that got a hard register is auto-incremented,
4172 		/* See if this pseudo reg was reloaded in this insn.
4208    or it may be a pseudo reg that was reloaded from.
4244 	 This can happen if a block-local pseudo is allocated to that reg
4338    by being allocated to a pseudo during any point of the current insn.  */
4929   /* We use some pseudo 'time' value to check if the lifetimes of the
5449 /* Assign hard reg targets for the pseudo-registers we must reload
5543 	     Try also when reload_in is a pseudo without a hard reg.  */
5567 	  /* First see if this pseudo is already available as reloaded
5618 	      /* This won't work, since REGNO can be a pseudo reg number.
5720 			      /* Don't use it if we'd clobber a pseudo reg.  */
6413      If foo is in memory due to spilling a pseudo reg, this is safe,
6439      the original pseudo register.  Since this is replaced with a
6441      find the pseudo in RELOAD_IN_REG.  */
6549   /* If we are reloading a pseudo-register that was set by the previous
6550      insn, see if we can get rid of that pseudo-register entirely
6576 	  /* Store into the reload register instead of the pseudo.  */
6594 	      /* If these are the only uses of the pseudo reg,
6635       /* If OLDEQUIV is a pseudo with a MEM, get the real MEM
6638       /* If it is a pseudo that cannot be replaced with its
6641 	 Likewise for a pseudo that can't be replaced with its
7005 	   clear any memory of reloaded copies of the pseudo reg.
7033 		     has and where the actual store to the pseudo is
7126 	 original pseudo.  */
7146   rtx pseudo = rl->out_reg;
7148   if (pseudo
7150       && REG_P (pseudo)
7151       && ! rtx_equal_p (rl->in_reg, pseudo)
7152       && REGNO (pseudo) >= FIRST_PSEUDO_REGISTER
7153       && reg_last_reload_reg[REGNO (pseudo)])
7155       int pseudo_no = REGNO (pseudo);
7160 	 matches the pseudo.  */
7164 	  && rtx_equal_p (pseudo, spill_reg_stored_to[last_regno]))
7326       /* If this is a non-inherited input reload from a pseudo, we must
7327 	 clear any memory of a previous store to the same pseudo.  Only do
7328 	 something if there will not be an output reload for the pseudo
7682      asked to reload a simple operand, such as a MEM, a constant, or a pseudo
7762 	 to reload a constant, MEM or pseudo since the move patterns can
7764 	 pseudo and OP1 is not a valid operand for an add instruction, then
7926   /* Get the raw pseudo-register referred to.  */
7977   /* If the pseudo-reg we are reloading is no longer referenced
8015      optimization - maybe even improving the code: See if the pseudo
8017      the store insn and forget we had a stack slot for the pseudo.  */
8034 	  /* Uses which just store in the pseudo don't count,
8052       /* Delete the now-dead stores into this pseudo.  Note that this
8068       /* For the debugging info, say the pseudo lives in this reload reg.  */
8211 		 allocated to a pseudo in this block if no reload in this