dsp16xx.c

来自「gcc3.2.1源代码」· C语言 代码 · 共 2,611 行 · 第 1/5 页

	case YH_REG:
	  return (!reload_in_progress ? NO_REGS : class);

	case YH_OR_ACCUM_HIGH_REGS:
	  return ACCUM_HIGH_REGS;

	case X_OR_YH_REGS: 
	case YL_REG:
	  return (!reload_in_progress ? NO_REGS : class);

	case YL_OR_ACCUM_LOW_REGS: 
	  return ACCUM_LOW_REGS;

	case X_OR_YL_REGS:
	case X_OR_Y_REGS: case Y_REG:
	  return (!reload_in_progress ? NO_REGS : class);

	case ACCUM_OR_Y_REGS: 
	  return ACCUM_REGS;

	case PH_REG:
	case X_OR_PH_REGS: case PL_REG: 
	  return (!reload_in_progress ? NO_REGS : class);

	case PL_OR_ACCUM_LOW_REGS:
 	  return ACCUM_LOW_REGS;

	case X_OR_PL_REGS:
	  return (!reload_in_progress ? NO_REGS : class);

	case YL_OR_PL_OR_ACCUM_LOW_REGS: 
 	  return ACCUM_LOW_REGS;

	case P_REG:
	  return (!reload_in_progress ? NO_REGS : class);

	case ACCUM_OR_P_REGS: 
	  return ACCUM_REGS;

	case YL_OR_P_REGS:
	  return (!reload_in_progress ? NO_REGS : class);

	case ACCUM_LOW_OR_YL_OR_P_REGS: 
 	  return ACCUM_LOW_REGS;

	case Y_OR_P_REGS:
	  return (!reload_in_progress ? NO_REGS : class);

	case ACCUM_Y_OR_P_REGS: 
	  return ACCUM_REGS;

	case NO_FRAME_Y_ADDR_REGS:
	case Y_ADDR_REGS:
	  return (!reload_in_progress ? NO_REGS : class);

	case ACCUM_LOW_OR_Y_ADDR_REGS:
 	  return ACCUM_LOW_REGS;

	case ACCUM_OR_Y_ADDR_REGS: 
	  return ACCUM_REGS;

	case X_OR_Y_ADDR_REGS:
	case Y_OR_Y_ADDR_REGS: 
	case P_OR_Y_ADDR_REGS:
	  return (!reload_in_progress ? NO_REGS : class);

	case NON_HIGH_YBASE_ELIGIBLE_REGS: 
 	  return ACCUM_LOW_REGS;

	case YBASE_ELIGIBLE_REGS:
	  return ACCUM_REGS;

	case J_REG:
	case J_OR_DAU_16_BIT_REGS:
	case BMU_REGS: 
	  return (!reload_in_progress ? NO_REGS : class);

	case YBASE_VIRT_REGS:
	  if (IS_YBASE_ELIGIBLE_REG (REGNO (x)))
	    return class;
	  else
	    return (!reload_in_progress ? NO_REGS : class);

	case ACCUM_LOW_OR_YBASE_REGS:
	  if (IS_YBASE_ELIGIBLE_REG (REGNO (x)))
	    return class;
	  else
	    return ACCUM_LOW_REGS;

	case ACCUM_OR_YBASE_REGS:
	  if (IS_YBASE_ELIGIBLE_REG (REGNO (x)))
	    return class;
	  else
	    return ACCUM_REGS;

	case X_OR_YBASE_REGS:
	case Y_OR_YBASE_REGS:
	  if (IS_YBASE_ELIGIBLE_REG (REGNO (x)))
	    return YBASE_VIRT_REGS;
	  else
	    return (!reload_in_progress ? NO_REGS : class);

	case ACCUM_LOW_YL_PL_OR_YBASE_REGS:
	  if (IS_YBASE_ELIGIBLE_REG (REGNO (x)))
	    return ACCUM_LOW_OR_YBASE_REGS;
	  else
	    return ACCUM_LOW_REGS;

	case P_OR_YBASE_REGS:
	  if (IS_YBASE_ELIGIBLE_REG (REGNO (x)))
	    return YBASE_VIRT_REGS;
	  else
	    return (!reload_in_progress ? NO_REGS : class);

	case ACCUM_Y_P_OR_YBASE_REGS:
	  if (IS_YBASE_ELIGIBLE_REG (REGNO (x)))
	    return ACCUM_OR_YBASE_REGS;
	  else
	    return ACCUM_REGS;

	case Y_ADDR_OR_YBASE_REGS:
	  if (IS_YBASE_ELIGIBLE_REG (REGNO (x)))
	    return YBASE_VIRT_REGS;
	  else
	    return (!reload_in_progress ? NO_REGS : class);

	case YBASE_OR_NOHIGH_YBASE_ELIGIBLE_REGS:
	  if (IS_YBASE_ELIGIBLE_REG (REGNO (x)))
	    return ACCUM_LOW_OR_YBASE_REGS;
	  else
	    return ACCUM_LOW_REGS;

	case YBASE_OR_YBASE_ELIGIBLE_REGS:
	  if (IS_YBASE_ELIGIBLE_REG (REGNO (x)))
	    return ACCUM_OR_YBASE_REGS;
	  else
	    return ACCUM_REGS;

	case NO_HIGH_ALL_REGS:
	  if (IS_YBASE_ELIGIBLE_REG (REGNO (x)))
	    return ACCUM_LOW_OR_YBASE_REGS;
	  else
	    return ACCUM_LOW_REGS;

	case ALL_REGS: 
	  if (IS_YBASE_ELIGIBLE_REG (REGNO (x)))
	    return ACCUM_OR_YBASE_REGS;
	  else
	    return ACCUM_REGS;

	case NOHIGH_NON_ADDR_REGS:
	    return ACCUM_LOW_REGS;

	case NON_ADDR_REGS:
	case SLOW_MEM_LOAD_REGS:
	    return ACCUM_REGS;

	case NOHIGH_NON_YBASE_REGS:
	    return ACCUM_LOW_REGS;

	case NO_ACCUM_NON_YBASE_REGS:
	  return (!reload_in_progress ? NO_REGS : class);

	case NON_YBASE_REGS:
	    return ACCUM_REGS;

	default:
	  return class;
	}
    }

  /* If x (the input) is a ybase register, restrict the class of registers
     we can copy the register into.  */

  if (REG_P (x) && !TARGET_RESERVE_YBASE
      && IS_YBASE_REGISTER_WINDOW (REGNO(x)))
    {
      switch ((int) class)
	{
	case NO_REGS:
	case A0H_REG: case A0L_REG: case A0_REG: case A1H_REG:
	case ACCUM_HIGH_REGS: case A1L_REG: case ACCUM_LOW_REGS: 
	case A1_REG: case ACCUM_REGS: case X_REG: 
	case X_OR_ACCUM_LOW_REGS: case X_OR_ACCUM_REGS:
	case YH_REG: case YH_OR_ACCUM_HIGH_REGS:
	case X_OR_YH_REGS: case YL_REG:
	case YL_OR_ACCUM_LOW_REGS: case X_OR_YL_REGS:
	case X_OR_Y_REGS: case Y_REG:
	case ACCUM_OR_Y_REGS: case PH_REG:
	case X_OR_PH_REGS: case PL_REG: 
	case PL_OR_ACCUM_LOW_REGS: case X_OR_PL_REGS:
	case YL_OR_PL_OR_ACCUM_LOW_REGS: case P_REG:
	case ACCUM_OR_P_REGS: case YL_OR_P_REGS:
	case ACCUM_LOW_OR_YL_OR_P_REGS: case Y_OR_P_REGS:
	case ACCUM_Y_OR_P_REGS: case NO_FRAME_Y_ADDR_REGS:
	case Y_ADDR_REGS: case ACCUM_LOW_OR_Y_ADDR_REGS:
	case ACCUM_OR_Y_ADDR_REGS: case X_OR_Y_ADDR_REGS:
	case Y_OR_Y_ADDR_REGS: case P_OR_Y_ADDR_REGS:
	case NON_HIGH_YBASE_ELIGIBLE_REGS: case YBASE_ELIGIBLE_REGS:
	default:
	  return class;

	case J_REG:
	  return (!reload_in_progress ? NO_REGS : class);

	case J_OR_DAU_16_BIT_REGS:
	  return ACCUM_HIGH_REGS;

	case BMU_REGS: 
	case YBASE_VIRT_REGS:
	  return (!reload_in_progress ? NO_REGS : class);

	case ACCUM_LOW_OR_YBASE_REGS:
	  return ACCUM_LOW_REGS;

	case ACCUM_OR_YBASE_REGS:
	  return ACCUM_REGS;

	case X_OR_YBASE_REGS:
	  return X_REG;

	case Y_OR_YBASE_REGS:
	  return Y_REG;

	case ACCUM_LOW_YL_PL_OR_YBASE_REGS:
	  return YL_OR_PL_OR_ACCUM_LOW_REGS; 

	case P_OR_YBASE_REGS:
	  return P_REG;

	case ACCUM_Y_P_OR_YBASE_REGS:
	  return ACCUM_Y_OR_P_REGS;

	case Y_ADDR_OR_YBASE_REGS:
	  return Y_ADDR_REGS;

	case YBASE_OR_NOHIGH_YBASE_ELIGIBLE_REGS:
	  return NON_HIGH_YBASE_ELIGIBLE_REGS;

	case YBASE_OR_YBASE_ELIGIBLE_REGS:
	  return YBASE_ELIGIBLE_REGS;

	case NO_HIGH_ALL_REGS:
	  return NON_HIGH_YBASE_ELIGIBLE_REGS;

	case ALL_REGS: 
	  return YBASE_ELIGIBLE_REGS;

	case NOHIGH_NON_ADDR_REGS:
	  return ACCUM_LOW_OR_YL_OR_P_REGS;

	case NON_ADDR_REGS:
	  return ACCUM_Y_OR_P_REGS;

	case SLOW_MEM_LOAD_REGS:
	  return ACCUM_OR_Y_ADDR_REGS;

	case NOHIGH_NON_YBASE_REGS:
    	  return NON_HIGH_YBASE_ELIGIBLE_REGS;

    	case NO_ACCUM_NON_YBASE_REGS:
	  return Y_ADDR_REGS;

    	case NON_YBASE_REGS:
	  return YBASE_ELIGIBLE_REGS;
	}
    }

  if (GET_CODE (x) == PLUS)
    {
      if (GET_MODE (x) == QImode
	  && REG_P (XEXP (x,0))
	  && (XEXP (x,0) == frame_pointer_rtx
	      || XEXP (x,0) == stack_pointer_rtx)
	  && (GET_CODE (XEXP (x,1)) == CONST_INT))
	{
	  if (class == ACCUM_HIGH_REGS)
	    return class;

	  /* If the accumulators are not part of the class
	     being reloaded into, return NO_REGS.  */
#if 0
	  if (!reg_class_subset_p (ACCUM_REGS, class))
	    return (!reload_in_progress ? NO_REGS : class);
#endif
	  if (reg_class_subset_p (ACCUM_HIGH_REGS, class))
	    return ACCUM_HIGH_REGS;

	  /* We will use accumulator 'a1l' for reloading a
	     PLUS.  We can only use one accumulator because
	     'reload_inqi' only allows one alternative to be
	     used.  */

	  else if (class == ACCUM_LOW_REGS)
	    return A1L_REG;
	  else if (class == A0L_REG)
	    return NO_REGS;
	  else
	    return class;
	}

      if (class == NON_YBASE_REGS || class == YBASE_ELIGIBLE_REGS)
	return Y_ADDR_REGS;
      else
	return class;
    }
  else if (GET_CODE (x) == MEM)
    {
      /* We can't copy from a memory location into a
	 ybase register.  */
      if (reg_class_subset_p(YBASE_VIRT_REGS, class))
	{
	  switch ((int) class)
	    {
	    case YBASE_VIRT_REGS:
	      return (!reload_in_progress ? NO_REGS : class);

	    case ACCUM_LOW_OR_YBASE_REGS:
	      return ACCUM_LOW_REGS;

	    case ACCUM_OR_YBASE_REGS:
	      return ACCUM_REGS;

	    case X_OR_YBASE_REGS:
	      return X_REG;

	    case Y_OR_YBASE_REGS:
	      return Y_REG;

	    case ACCUM_LOW_YL_PL_OR_YBASE_REGS:
	      return YL_OR_PL_OR_ACCUM_LOW_REGS;

	    case P_OR_YBASE_REGS:
	      return P_REG;

	    case ACCUM_Y_P_OR_YBASE_REGS:
	      return ACCUM_Y_OR_P_REGS;

	    case Y_ADDR_OR_YBASE_REGS:
	      return Y_ADDR_REGS;

	    case YBASE_OR_NOHIGH_YBASE_ELIGIBLE_REGS:
	      return NON_HIGH_YBASE_ELIGIBLE_REGS;
	  
	    case YBASE_OR_YBASE_ELIGIBLE_REGS:
	      return YBASE_ELIGIBLE_REGS;

	    case NO_HIGH_ALL_REGS:
	      return NOHIGH_NON_YBASE_REGS;

	    case ALL_REGS:
	      return NON_YBASE_REGS;

	    default:
	      return class;
	    }
	}
      else
	return class;
    }
  else
    return class;
}
	
/* Return the register class of a scratch register needed to copy IN into
   or out of a register in CLASS in MODE.  If it can be done directly,
   NO_REGS is returned.  */

enum reg_class
secondary_reload_class (class, mode, in)
     enum reg_class class;
     enum machine_mode mode;
     rtx in;
{
  int regno = -1;

  if (GET_CODE (in) == REG || GET_CODE (in) == SUBREG)
    regno = true_regnum (in);

  /* If we are reloading a plus into a high accumulator register,
     we need a scratch low accumulator, because the low half gets
     clobbered.  */

  if (class == ACCUM_HIGH_REGS 
      || class == A1H_REG
      || class == A0H_REG)
    {
      if (GET_CODE (in) == PLUS && mode == QImode)
	return ACCUM_LOW_REGS;
    }

  if (class == ACCUM_HIGH_REGS 
      || class == ACCUM_LOW_REGS
      || class == A1L_REG
      || class == A0L_REG
      || class == A1H_REG
      || class == A0H_REG)
    {
      if (GET_CODE (in) == PLUS && mode == QImode)
	{
	  rtx addr0 = XEXP (in, 0);
	  rtx addr1 = XEXP (in, 1);
	  
	  /* If we are reloading a plus (reg:QI) (reg:QI)
	     we need an additional register.  */ 
	  if (REG_P (addr0) && REG_P (addr1))
	    return NO_REGS;
	}
    }

  /* We can place anything into ACCUM_REGS and can put ACCUM_REGS
     into anything.  */

  if ((class == ACCUM_REGS || class == ACCUM_HIGH_REGS ||
       class == ACCUM_LOW_REGS || class == A0H_REG || class == A0L_REG ||
       class == A1H_REG || class == A1_REG) || 
      (regno >= REG_A0 && regno < REG_A1L + 1))
    return NO_REGS;

  if (class == ACCUM_OR_YBASE_REGS && REG_P(in)
      && IS_YBASE_ELIGIBLE_REG(regno))
    {
      return NO_REGS;
    }

  /* We can copy the ybase registers into:
     r0-r3, a0-a1, y, p, & x or the union of
     any of these.  */

  if (!TARGET_RESERVE_YBASE && IS_YBASE_REGISTER_WINDOW(regno))
    {
      switch ((int) class)
	{
	case (int) X_REG:
	case (int) X_OR_ACCUM_LOW_REGS:
	case (int) X_OR_ACCUM_REGS:
	case (int) YH_REG:
	case (int) YH_OR_ACCUM_HIGH_REGS:
	case (int) X_OR_YH_REGS:
	case (int) YL_REG:
	case (int) YL_OR_ACCUM_LOW_REGS:
	case (int) X_OR_Y_REGS:
	case (int) X_OR_YL_REGS:
	case (int) Y_REG:
	case (int) ACCUM_OR_Y_REGS:
	case (int) PH_REG:
	case (int) X_OR_PH_REGS:
	case (int) PL_REG:
	case (int) PL_OR_ACCUM_LOW_REGS:
	case (int) X_OR_PL_REGS:
	case (int) YL_OR_PL_OR_ACCUM_LOW_REGS:
	case (int) P_REG:
	case (int) ACCUM_OR_P_REGS:
	case (int) YL_OR_P_REGS:
	case (int) ACCUM_LOW_OR_YL_OR_P_REGS:
	case (int) Y_OR_P_REGS:
	case (int) ACCUM_Y_OR_P_REGS:
	case (int) Y_ADDR_REGS:
	case (int) ACCUM_LOW_OR_Y_ADDR_REGS:
	case (int) ACCUM_OR_Y_ADDR_REGS:
	case (int) X_OR_Y_ADDR_REGS:
	case (int) Y_OR_Y_ADDR_REGS:
	case (int) P_OR_Y_ADDR_REGS:
	case (int) YBASE_ELIGIBLE_REGS:
	  return NO_REGS;

	default:
	  return ACCUM_HIGH_REGS;
	}
    }

  /* We can copy r0-r3, a0-a1, y, & p
     directly to the ybase registers. In addition
     we can use any of the ybase virtual registers
     as the secondary reload registers when copying
     between any of these registers.  */

  if (!TARGET_RESERVE_YBASE && regno != -1)
    {
      switch (regno)
	{
	case REG_A0:
	case REG_A0L:
	case REG_A1:
	case REG_A1L:
	case REG_X:
	case REG_Y:
	case REG_YL:
	case REG_PROD:
	case REG_PRODL:
	case REG_R0:
	case REG_R1:
	case REG_R2:
	case REG_R3:
	  if (class == YBASE_VIRT_REGS)
	    return NO_REGS;
	  else
	    {
	      switch ((int) class)
		{
		case (int) X_REG:
		case (int) X_OR_ACCUM_LOW_REGS:
		case (int) X_OR_ACCUM_REGS:
		case (int) YH_REG:
		case (int) YH_OR_ACCUM_HIGH_REGS:
		case (int) X_OR_YH_REGS:
		case (int) YL_REG:
		case (int) YL_OR_ACCUM_LOW_REGS:
		case (int) X_OR_Y_REGS:
		case (int) X_OR_YL_REGS:
		case (int) Y_REG:
		case (int) ACCUM_OR_Y_REGS:
		case (int) PH_REG:
		case (int) X_OR_PH_REGS:
		case (int) PL_REG:
		case (int) PL_OR_ACCUM_LOW_REGS:
		case (int) X_OR_PL_REGS:
		case (int) YL_OR_PL_OR_ACCUM_LOW_REGS:
		case (int) P_REG:
		case (int) ACCUM_OR_P_REGS:
		case (int) YL_OR_P_REGS:
		case (int) ACCUM_LOW_OR_YL_OR_P_REGS: