gcc/gcc/reload1.c

1 /* Reload pseudo regs into hard regs for insns that require hard regs.
83    reg_renumber; the insns still contain pseudo regs, but reg_renumber
84    can be used to find which hard reg, if any, a pseudo reg is in.
87    called ``reload regs'', and for each place where a pseudo reg
130 /* Widest width in which each pseudo reg is referred to (via subreg).  */
136 /* During reload_as_needed, element N contains the last pseudo regno reloaded
137    into hard register N.  If that pseudo reg occupied more than one register,
138    reg_reloaded_contents points to that pseudo for each spill register in
198    of spilled pseudo-registers.  `n_spills' is the number of
208 /* This vector of reg sets indicates, for each pseudo, which hard registers
210    formerly spilled from one of them.  If we allowed reallocating a pseudo to
215 /* This vector of reg sets indicates, for each pseudo, which hard
218    pseudo is live.  */
242    Used to avoid counting one pseudo twice.  */
306 				   register corresponding to a pseudo
717 /* Temporary array of pseudo-register number.  */
720 /* If a pseudo has no hard reg, delete the insns that made the equivalence.
787    so any pseudo reg that is spilled must go to the stack.
830      as homes for pseudo registers.
848   /* Find all the pseudo registers that didn't get hard regs
869   /* Alter each pseudo-reg rtx to contain its hard reg number.  Assign
878     /* Ask IRA to order pseudo-registers for better stack slot
947       /* For each pseudo register that has an equivalent location defined,
965 	 a pseudo that didn't get a hard register and has an equivalent memory
966 	 location that also involves a pseudo that didn't get a hard register.
996 		   will be set up for this pseudo on the next pass around
1106      virtue of being in a pseudo, that pseudo will be marked live
1108      pseudo.  */
1122   /* Now eliminate all pseudo regs by modifying them into
1759    only the first hard reg for a multi-reg pseudo.  */
1762 /* Map of hard regno to pseudo regno currently occupying the hard
1766 /* Update the spill cost arrays, considering that pseudo REG is live.  */
1775   /* Ignore spilled pseudo-registers which can be here only if IRA is used.  */
1814   /* Count number of uses of each hard reg by pseudo regs allocated to it
1849    SPILLED_NREGS.  Determine how pseudo REG, which is live during the insn,
1860   /* Ignore spilled pseudo-registers which can be here only if IRA is used.  */
1941 	      /* Ask IRA to find a better pseudo-register for
2187 /* Modify the home of pseudo-reg I.
2190    FROM_REG may be the hard reg that the pseudo-reg is being spilled from;
2209      number or else to contain its pseudo reg number.  */
2213   /* If we have a pseudo that is needed but has no hard reg or equivalent,
2244       /* Each pseudo reg has an inherent size which comes from its own mode,
2246 	 which refer to the pseudo reg in wider modes.
2350    pseudo-reg number REGNO, accessed in MODE.  */
2366    used by pseudo-reg number REGNO.  */
2570    CLOBBER of the pseudo after INSN so find_equiv_regs will know that
2583    they are not, or if REG_EQUIV_ADDRESS is nonzero for a pseudo we
2708 	    /* If one side is a PLUS and the other side is a pseudo that
2879 	 Also, if we have a non-paradoxical (subreg (pseudo)) and the
2880 	 pseudo didn't get a hard reg, we must replace this with the
4170 /* Find all the pseudo registers that didn't get hard regs
4201 /* Look for REG_EQUIV notes; record what each pseudo is equivalent
4203    find largest such for each pseudo.  FIRST is the head of the insn
4338   /* Spill every pseudo reg that was allocated to this reg
4350    spill pseudo registers and try to reallocate them.  It also sets up the
4389 	/* Record the current hard register the pseudo is allocated to
4411 	 regs in pseudo_forbidden_regs for every pseudo live across the
4609 /* Reload pseudo-registers into hard regs around each insn as needed.
4611    and perhaps store insns after insns that modify the reloaded pseudo reg.
4697 	  /* First find the pseudo regs that must be reloaded for this insn.
4700 	     rtx's for those pseudo regs.  */
4775 	  /* Any previously reloaded spilled pseudo reg, stored in this insn,
4809 		      /* Make sure it is the inc/dec pseudo, and not
4810 			 some other (e.g. output operand) pseudo.  */
4877 			   /* Make sure it is the inc/dec pseudo, and not
4878 			      some other (e.g. output operand) pseudo.  */
4927 	  /* If a pseudo that got a hard register is auto-incremented,
4933 		/* See if this pseudo reg was reloaded in this insn.
4976    or it may be a pseudo reg that was reloaded from.
5012 	 This can happen if a block-local pseudo is allocated to that reg
5104    by being allocated to a pseudo during any point of the current insn.  */
5919   /* We use some pseudo 'time' value to check if the lifetimes of the
6464 /* Compute the offset to pass to subreg_regno_offset, for a pseudo of
6466    SUBREG is non-NULL if the pseudo is a subreg whose reg is a pseudo,
6495 /* Assign hard reg targets for the pseudo-registers we must reload
6589 	     Try also when reload_in is a pseudo without a hard reg.  */
6613 	  /* First see if this pseudo is already available as reloaded
6669 	      /* This won't work, since REGNO can be a pseudo reg number.
6767 			      /* Don't use it if we'd clobber a pseudo reg.  */
7314      the original pseudo register.  Since this is replaced with a
7316      find the pseudo in RELOAD_IN_REG.  This is also used to
7413   /* If we are reloading a pseudo-register that was set by the previous
7414      insn, see if we can get rid of that pseudo-register entirely
7440 	  /* Store into the reload register instead of the pseudo.  */
7467 	      /* If these are the only uses of the pseudo reg,
7518       /* If OLDEQUIV is a pseudo with a MEM, get the real MEM
7521       /* If it is a pseudo that cannot be replaced with its
7524 	 Likewise for a pseudo that can't be replaced with its
7894 	   clear any memory of reloaded copies of the pseudo reg.
7922 		     has and where the actual store to the pseudo is
7991 	 If foo is in memory due to spilling a pseudo reg, this is safe,
8059 	 original pseudo.  */
8077   rtx pseudo = rl->out_reg;
8103   if (pseudo
8105       && REG_P (pseudo)
8106       && ! rtx_equal_p (rl->in_reg, pseudo)
8107       && REGNO (pseudo) >= FIRST_PSEUDO_REGISTER
8108       && reg_last_reload_reg[REGNO (pseudo)])
8110       int pseudo_no = REGNO (pseudo);
8115 	 matches the pseudo.  */
8119 	  && rtx_equal_p (pseudo, spill_reg_stored_to[last_regno]))
8283       /* If this is a non-inherited input reload from a pseudo, we must
8284 	 clear any memory of a previous store to the same pseudo.  Only do
8285 	 something if there will not be an output reload for the pseudo
8517 	     If we know that REG_RTX holds the value of a pseudo
8667      asked to reload a simple operand, such as a MEM, a constant, or a pseudo
8748 	 to reload a constant, MEM or pseudo since the move patterns can
8750 	 pseudo and OP1 is not a valid operand for an add instruction, then
8913   /* Get the raw pseudo-register referred to.  */
8964   /* If the pseudo-reg we are reloading is no longer referenced
9002      optimization - maybe even improving the code: See if the pseudo
9004      the store insn and forget we had a stack slot for the pseudo.  */
9021 	  /* Uses which just store in the pseudo don't count,
9038       /* Delete the now-dead stores into this pseudo.  Note that this
9053       /* For the debugging info, say the pseudo lives in this reload reg.  */
9201 		 allocated to a pseudo in this block if no reload in this