gcc/gcc/reload1.c

1 /* Reload pseudo regs into hard regs for insns that require hard regs.
55    reg_renumber; the insns still contain pseudo regs, but reg_renumber
56    can be used to find which hard reg, if any, a pseudo reg is in.
59    called ``reload regs'', and for each place where a pseudo reg
99 /* Element N is the constant value to which pseudo reg N is equivalent,
100    or zero if pseudo reg N is not equivalent to a constant.
101    find_reloads looks at this in order to replace pseudo reg N
105 /* Element N is a memory location to which pseudo reg N is equivalent,
111 /* Element N is the address of stack slot to which pseudo reg N is equivalent.
116 /* Element N is the memory slot to which pseudo reg N is equivalent,
117    or zero if pseudo reg N is not equivalent to a memory slot.  */
120 /* Widest width in which each pseudo reg is referred to (via subreg).  */
130 /* During reload_as_needed, element N contains the last pseudo regno reloaded
131    into hard register N.  If that pseudo reg occupied more than one register,
132    reg_reloaded_contents points to that pseudo for each spill register in
187    of spilled pseudo-registers.  `n_spills' is the number of
197 /* This vector of reg sets indicates, for each pseudo, which hard registers
199    formerly spilled from one of them.  If we allowed reallocating a pseudo to
204 /* This vector of reg sets indicates, for each pseudo, which hard
207    pseudo is live.  */
320 				   register corresponding to a pseudo
592    so any pseudo reg that is spilled must go to the stack.
596    which registers are seized as reload regs, which pseudo regs
597    are spilled from them, and where the pseudo regs are reallocated to.
645      as homes for pseudo registers.
660   /* Find all the pseudo registers that didn't get hard regs
692   /* Look for REG_EQUIV notes; record what each pseudo is equivalent to.
693      Also find all paradoxical subregs and find largest such for each pseudo.
802   /* Alter each pseudo-reg rtx to contain its hard reg number.
821   /* If all the pseudo regs have hard regs,
896       /* For each pseudo register that has an equivalent location defined,
914 	 a pseudo that didn't get a hard register and has an equivalent memory
915 	 location that also involves a pseudo that didn't get a hard register.
943 		   will be set up for this pseudo on the next pass around
1026   /* If a pseudo has no hard reg, delete the insns that made the equivalence.
1075      virtue of being in a pseudo, that pseudo will be marked live
1077      pseudo.  */
1090   /* Now eliminate all pseudo regs by modifying them into
1859 /* If pseudo REG conflicts with one of our reload registers, mark it as
2387 /* Modify the home of pseudo-reg I.
2390    FROM_REG may be the hard reg that the pseudo-reg is being spilled from;
2411      number or else to contain its pseudo reg number.  */
2415   /* If we have a pseudo that is needed but has no hard reg or equivalent,
2428       /* Each pseudo reg has an inherent size which comes from its own mode,
2430 	 which refer to the pseudo reg in wider modes.
2519    used by pseudo-reg number REGNO.  */
2702    CLOBBER of the pseudo after INSN so find_equiv_regs will know that
2715    they are not, or if REG_EQUIV_ADDRESS is nonzero for a pseudo we
2845 	    /* If one side is a PLUS and the other side is a pseudo that
2992 	 Also, if we have a non-paradoxical (subreg (pseudo)) and the
2993 	 pseudo didn't get a hard reg, we must replace this with the
3006 	  /* If we didn't change anything, we must retain the pseudo.  */
3011 	      /* In this case, we must show that the pseudo is used in this
3831   /* Spill every pseudo reg that was allocated to this reg
3855    spill pseudo registers and try to reallocate them.  It also sets up the
3895 	/* Record the current hard register the pseudo is allocated to in
3912 	 regs in pseudo_forbidden_regs for every pseudo live across the
4089    Used to avoid counting one pseudo twice.  */
4092 /* Update the costs in N_USES, considering that pseudo REG is live.  */
4128   /* Count number of uses of each hard reg by pseudo regs allocated to it
4217 /* Reload pseudo-registers into hard regs around each insn as needed.
4219    and perhaps store insns after insns that modify the reloaded pseudo reg.
4293 	  /* First find the pseudo regs that must be reloaded for this insn.
4296 	     rtx's for those pseudo regs.  */
4356 	  /* Any previously reloaded spilled pseudo reg, stored in this insn,
4389 		      /* Make sure it is the inc/dec pseudo, and not
4390 			 some other (e.g. output operand) pseudo.  */
4455 			   /* Make sure it is the inc/dec pseudo, and not
4456 			      some other (e.g. output operand) pseudo.  */
4466 	  /* If a pseudo that got a hard register is auto-incremented,
4472 		/* See if this pseudo reg was reloaded in this insn.
4514    or it may be a pseudo reg that was reloaded from.  */
4544 	 This can happen if a block-local pseudo is allocated to that reg
4649    by being allocated to a pseudo during any point of the current insn.  */
5247   /* We use some pseudo 'time' value to check if the lifetimes of the
5700 /* Assign hard reg targets for the pseudo-registers we must reload
5910 	     Try also when reload_in is a pseudo without a hard reg.  */
5934 	  /* First see if this pseudo is already available as reloaded
5988 	      /* This won't work, since REGNO can be a pseudo reg number.
6070 			      /* Don't use it if we'd clobber a pseudo reg.  */
6709 	     If foo is in memory due to spilling a pseudo reg, this is safe,
6802 	     the original pseudo register.  Since this is replaced with a
6804 	     find the pseudo in RELOAD_IN_REG.  */
6915 	  /* If we are reloading a pseudo-register that was set by the previous
6916 	     insn, see if we can get rid of that pseudo-register entirely
6947 		  /* Store into the reload register instead of the pseudo.  */
6961 		  /* If these are the only uses of the pseudo reg,
6999 		  /* If OLDEQUIV is a pseudo with a MEM, get the real MEM
7002 		  /* If it is a pseudo that cannot be replaced with its
7005 		     Likewise for a pseudo that can't be replaced with its
7204 		original pseudo.  */
7222 	rtx pseudo = reload_out_reg[j];
7224 	if (pseudo
7225 	    && GET_CODE (pseudo) == REG
7226 	    && ! rtx_equal_p (reload_in_reg[j], pseudo)
7227 	    && REGNO (pseudo) >= FIRST_PSEUDO_REGISTER
7228 	    && reg_last_reload_reg[REGNO (pseudo)])
7230 	    int pseudo_no = REGNO (pseudo);
7235 	       matches the pseudo.  */
7239 		&& rtx_equal_p (pseudo, spill_reg_stored_to[last_regno]))
7425 		   clear any memory of reloaded copies of the pseudo reg.
7453 			       has and where the actual store to the pseudo is
7560       /* If this is a non-inherited input reload from a pseudo, we must
7561          clear any memory of a previous store to the same pseudo.  Only do
7562          something if there will not be an output reload for the pseudo
7862      asked to reload a simple operand, such as a MEM, a constant, or a pseudo
7945 	 use move to copy constant, MEM, or pseudo register to the reload
8069   /* Get the raw pseudo-register referred to.  */
8115   /* If the pseudo-reg we are reloading is no longer referenced
8147      See if the pseudo reg has been completely replaced
8149      and forget we had a stack slot for the pseudo.  */
8167 	  /* Uses which just store in the pseudo don't count,
8187       /* Delete the now-dead stores into this pseudo.  */
8207 	 say the pseudo lives in this reload reg.  */
8352 		 allocated to a pseudo in this block if no reload in this
8630      pseudo-register here from a CLOBBER or the like.  We probably
8631      won't ever see a pseudo-register that has a real register number,
8816    different pseudo-registers to the same hard register, and then
10045 	/* Some spurious USEs of pseudo registers might remain.