contrib/gcc/reload1.c

1721   struct reload *rl = rld + rnum;
1732   IOR_COMPL_HARD_REG_SET (not_usable, reg_class_contents[rl->class]);
1750 	  && HARD_REGNO_MODE_OK (regno, rl->mode))
1754 	  unsigned int this_nregs = hard_regno_nregs[regno][rl->mode];
1765 	  if (rl->in && REG_P (rl->in) && REGNO (rl->in) == regno)
1767 	  if (rl->out && REG_P (rl->out) && REGNO (rl->out) == regno)
1793   rl->nregs = hard_regno_nregs[best_reg][rl->mode];
1794   rl->regno = best_reg;
1799       count_spilled_pseudo (best_reg, rl->nregs, j);
1805       count_spilled_pseudo (best_reg, rl->nregs, j);
1808   for (i = 0; i < rl->nregs; i++)
6389 emit_input_reload_insns (struct insn_chain *chain, struct reload *rl,
6393   rtx reloadreg = rl->reg_rtx;
6402      There is the mode the insn operand wants (rl->inmode).
6434     mode = rl->inmode;
6441       && REG_P (rl->in_reg))
6444       old = rl->in_reg;
6463 			  rl->out_reg)))
6481   switch (rl->when_needed)
6487       where = &input_reload_insns[rl->opnum];
6490       where = &input_address_reload_insns[rl->opnum];
6493       where = &inpaddr_address_reload_insns[rl->opnum];
6496       where = &output_address_reload_insns[rl->opnum];
6499       where = &outaddr_address_reload_insns[rl->opnum];
6517   if (rl->out && ! rl->out_reg)
6522       gcc_assert (rl->secondary_in_reload < 0);
6527       old = XEXP (rl->in_reg, 0);
6543 	= inc_for_reload (reloadreg, oldequiv, rl->out,
6544 			  rl->inc);
6557 	   && free_for_value_p (REGNO (reloadreg), rl->mode, rl->opnum,
6558 				rl->when_needed, old, rl->out, j, 0))
6597 		  reg_renumber[REGNO (old)] = REGNO (rl->reg_rtx);
6622   if (! special && rl->secondary_in_reload >= 0)
6626       int secondary_reload = rl->secondary_in_reload;
6657 	    real_oldequiv = rl->in;
6673 	    real_old = rl->in;
6688       icode = rl->secondary_in_icode;
6691 	  || (rl->in != 0 && rl->out != 0))
6698 	  new_class = targetm.secondary_reload (1, real_oldequiv, rl->class,
6796 			      rl->opnum,
6797 			      rl->when_needed);
6799 			      rl->opnum,
6800 			      rl->when_needed);
6804 			    rl->opnum,
6805 			    rl->when_needed);
6832 	real_oldequiv = rl->in;
6833       gen_reload (reloadreg, real_oldequiv, rl->opnum,
6834 		  rl->when_needed);
6853 emit_output_reload_insns (struct insn_chain *chain, struct reload *rl,
6856   rtx reloadreg = rl->reg_rtx;
6859   rtx old = rl->out;
6863   if (rl->when_needed == RELOAD_OTHER)
6866     push_to_sequence (output_reload_insns[rl->opnum]);
6890   if (rl->secondary_out_reload >= 0)
6893       int secondary_reload = rl->secondary_out_reload;
6900       if (secondary_reload_class (0, rl->class, mode, real_old) != NO_REGS)
6907 	  if (rl->secondary_out_icode != CODE_FOR_nothing)
6912 	      emit_insn ((GEN_FCN (rl->secondary_out_icode)
6952 			      rl->opnum, rl->when_needed);
6964 			      rl->opnum, rl->when_needed);
6970 				  rl->opnum, rl->when_needed);
6991 	       && regno_clobbered_p (REGNO (old), insn, rl->mode, 0)))
6992 	gen_reload (old, reloadreg, rl->opnum,
6993 		    rl->when_needed);
7008 	if (reg_mentioned_p (rl->reg_rtx, pat))
7013 		&& SET_SRC (set) == rl->reg_rtx)
7022 	    if (REGNO (rl->reg_rtx) < FIRST_PSEUDO_REGISTER)
7024 		int s = rl->secondary_out_reload;
7035 			 && SET_SRC (set) == rl->reg_rtx
7044 		    rld[s].out = rl->out;
7045 		    rld[s].out_reg = rl->out_reg;
7056 		  new_spill_reg_store[REGNO (rl->reg_rtx)] = p;
7061   if (rl->when_needed == RELOAD_OTHER)
7063       emit_insn (other_output_reload_insns[rl->opnum]);
7064       other_output_reload_insns[rl->opnum] = get_insns ();
7067     output_reload_insns[rl->opnum] = get_insns ();
7078 do_input_reload (struct insn_chain *chain, struct reload *rl, int j)
7081   rtx old = (rl->in && MEM_P (rl->in)
7082 	     ? rl->in_reg : rl->in);
7087       && (! reload_inherited[j] || (rl->out && ! rl->out_reg))
7088       && ! rtx_equal_p (rl->reg_rtx, old)
7089       && rl->reg_rtx != 0)
7092   /* When inheriting a wider reload, we have a MEM in rl->in,
7095   if (optimize && reload_inherited[j] && rl->in
7096       && MEM_P (rl->in)
7097       && MEM_P (rl->in_reg)
7100     rl->in = regno_reg_rtx[reg_reloaded_contents[reload_spill_index[j]]];
7110       && rl->when_needed == RELOAD_FOR_INPUT
7112       && rl->reg_rtx
7113       && REG_P (rl->reg_rtx)
7114       && spill_reg_store[REGNO (rl->reg_rtx)] != 0
7119       && (REGNO (spill_reg_stored_to[REGNO (rl->reg_rtx)])
7126 			 spill_reg_stored_to[REGNO (rl->reg_rtx)])
7127 	  || rtx_equal_p (spill_reg_stored_to[REGNO (rl->reg_rtx)],
7128 			  rl->out_reg)))
7129     delete_output_reload (insn, j, REGNO (rl->reg_rtx));
7137 do_output_reload (struct insn_chain *chain, struct reload *rl, int j)
7144   rtx pseudo = rl->out_reg;
7149       && ! rtx_equal_p (rl->in_reg, pseudo)
7166   old = rl->out_reg;
7168       || rl->reg_rtx == old
7169       || rl->reg_rtx == 0)
7178       XEXP (note, 0) = rl->reg_rtx;
7188 					   rl->reg_rtx);