funcs.cc

ml-rsim 多处理器模拟器 支持类bsd操作系统

  if (!FP_ENABLED)
    inst->exception_code = FPDISABLED;

  long long *ip = (long long *)&(inst->rdvalf);
  *ip = (long long) inst->rs2valf;
}


// conversions from integer to single-precision float -------------------------

void fnFiTOs(instance *inst, ProcState *proc)
{
  if (!FP_ENABLED)
    inst->exception_code = FPDISABLED;

  int *ip = (int *)&(inst->rs2valfh);
  int res = *ip;
  inst->rdvalfh = float(res);
}


void fnFxTOs(instance *inst, ProcState *proc)
{
  if (!FP_ENABLED)
    inst->exception_code = FPDISABLED;

  long long *ip = (long long *)&(inst->rs2valf);
  long long res = *ip;
  inst->rdvalfh = float(res);
}


// conversions from integer to double-precision float -------------------------

void fnFiTOd(instance *inst,ProcState *proc)
{
  if (!FP_ENABLED)
    inst->exception_code = FPDISABLED;

  int *ip = (int *)&(inst->rs2valfh);
  int res = *ip;
  inst->rdvalf = double(res);
}


void fnFxTOd(instance *inst, ProcState *proc)
{
  if (!FP_ENABLED)
    inst->exception_code = FPDISABLED;

  long long *ip = (long long *)&(inst->rs2valf);
  long long res = *ip;
  inst->rdvalf = double(res);
}


// conversion from integer to quad-precision float ----------------------------

void fnFiTOq(instance *inst, ProcState *proc)
{
  if (!FP_ENABLED)
    inst->exception_code = FPDISABLED;

  int *ip = (int *)&(inst->rs2valfh);
  int res = *ip;
  inst->rdvalf = double(res);
}


void fnFxToq(instance *inst, ProcState *proc)
{
  if (!FP_ENABLED)
    inst->exception_code = FPDISABLED;

  long long *ip = (long long *)&(inst->rs2valf);
  long long res = *ip;
  inst->rdvalf = double(res);
}


// conversion from floating point to single-precision float -------------------

void fnFdTOs(instance *inst, ProcState *proc)
{
  if (!FP_ENABLED)
    inst->exception_code = FPDISABLED;

  inst->rdvalfh = float(inst->rs2valf);
}


void fnFqTOs(instance *inst, ProcState *proc)
{
  if (!FP_ENABLED)
    inst->exception_code = FPDISABLED;

  inst->rdvalfh = float(inst->rs2valf);
}


// conversion from floating-point to double-precision float -------------------

void fnFsTOd(instance *inst, ProcState *proc)
{
  if (!FP_ENABLED)
    inst->exception_code = FPDISABLED;

  inst->rdvalf=double(inst->rs2valfh);
}


void fnFqTOd(instance *inst, ProcState *proc)
{
  if (!FP_ENABLED)
    inst->exception_code = FPDISABLED;

  inst->rdvalf=inst->rs2valf;
}


// conversion from floating point to quad-precision float ---------------------

void fnFsTOq(instance *inst, ProcState *proc)
{
  if (!FP_ENABLED)
    inst->exception_code = FPDISABLED;

  inst->rdvalf=double(inst->rs2valfh);
}


void fnFdTOq(instance *inst, ProcState *proc)
{
  if (!FP_ENABLED)
    inst->exception_code = FPDISABLED;

  inst->rdvalf=inst->rs2valf;
}



#define fnFMOVq0 fnFMOVd0

void fnFMOVd0(instance *inst, ProcState *proc)
{
// Cleanup -- see orig out should be ref, not ptr
  int v1;
  long long *v2;
  long long *out;
  out = (long long *) &(inst->rs1valf);

  if (!FP_ENABLED)
    inst->exception_code = FPDISABLED;

  v2 = (long long *) &(inst->rs2valf);

  v1 = inst->rsccvali;
  if (inst->code.rscc >= COND_ICC) /* the integer condition code register */
    {
      if (inst->code.rscc == COND_XCC) /* the xcc */
	v1 = xccTOicc(v1);
      switch (inst->code.aux2) /* these will be cases of bp_conds */
	{
	case Ab:
	  out=v2;
	  break;
	case Nb:
	  break;
	case NEb:
	  if (!iccZERO)
	    out=v2;
	  break;
	case Eb:
	  if (iccZERO)
	    out=v2;
	  break;
	case Gb:
	  if (!(iccZERO || Xor(iccNEG,iccOVERFLOW)))
	    out = v2;
	  break;
	case LEb:
	  if (iccZERO || Xor(iccNEG,iccOVERFLOW))
	    out = v2;
	  break;
	case GEb:
	  if (!Xor(iccNEG,iccOVERFLOW))
	    out = v2;
	  break;
	case Lb:
	  if (Xor(iccNEG,iccOVERFLOW))
	    out = v2;
	  break;
	case GUb:
	  if (!(iccCARRY || iccZERO))
	    out = v2;
	  break;
	case LEUb:
	  if (iccCARRY || iccZERO)
	    out = v2;
	  break;
	case CCb:
	  if (!iccCARRY)
	    out=v2;
	  break;
	case CSb:
	  if (iccCARRY)
	    out=v2;
	  break;
	case POSb:
	  if (!iccNEG)
	    out=v2;
	  break;
	case NEGb:
	  if (iccNEG)
	    out=v2;
	  break;
	case VCb:
	  if (!iccOVERFLOW)
	    out=v2;
	  break;
	case VSb:
	default:
	  if (iccOVERFLOW)
	    out=v2;
	  break;
	}
    }
  else /* use floating point condition codes */
    {
      #define E (v1 == fccEQ)
      #define L (v1 == fccLT)
      #define G (v1 == fccGT)
      #define U (v1 == fccUO)
      
      switch(inst->code.aux2)
	{
	case Af:
	  out=v2;
	  break;
	case Nf:
	  break;
	case Uf:
	  if (U)
	    out=v2;	
	  break;
	case Gf:
	  if (G)
	    out=v2;
	  break;
	case UGf:
	  if (U || G)
	    out=v2;
	  break;
	case Lf:
	  if (L)
	    out=v2;
	  break;
	case ULf:
	  if (U || L)
	    out=v2;
	  break;
	case LGf:
	  if (L || G)
	    out=v2;
	  break;
	case NEf:
	  if (L || G || U)
	    out=v2;
	  break;
	case Ef:
	  if (E)
	    out=v2;
	  break;
	case UEf:
	  if (E || U)
	    out=v2;
	  break;
	case GEf:
	  if (G || E)
	    out=v2;
	  break;
	case UGEf:
	  if (U || G || E)
	    out=v2;
	  break;
	case LEf:
	  if (L||E)
	    out=v2;
	  break;
	case ULEf:
	  if (U||L||E)
	    out=v2;
	  break;
	case Of:
	  if (E||L||G)
	    out=v2;
	  break;
	}
    }
  *((long long *) &(inst->rdvalf)) = *out;
}


void fnFMOVs0(instance *inst, ProcState *proc)
{
// Cleanup -- see orig out should be ref, not ptr
  int v1;
  int *v2;
  int *out;
  out = (int *) &(inst->rs1valfh);

  if (!FP_ENABLED)
    inst->exception_code = FPDISABLED;

  v2 = (int *) &(inst->rs2valfh);

  v1 = inst->rsccvali;
  if (inst->code.rscc >= COND_ICC) /* the integer condition code register */
    {
      if (inst->code.rscc == COND_XCC) /* the xcc */
	v1 = xccTOicc(v1);
      switch (inst->code.aux2) /* these will be cases of bp_conds */
	{
	case Ab:
	  out=v2;
	  break;
	case Nb:
	  break;
	case NEb:
	  if (!iccZERO)
	    out=v2;
	  break;
	case Eb:
	  if (iccZERO)
	    out=v2;
	  break;
	case Gb:
	  if (!(iccZERO || Xor(iccNEG,iccOVERFLOW)))
	    out = v2;
	  break;
	case LEb:
	  if (iccZERO || Xor(iccNEG,iccOVERFLOW))
	    out = v2;
	  break;
	case GEb:
	  if (!Xor(iccNEG,iccOVERFLOW))
	    out = v2;
	  break;
	case Lb:
	  if (Xor(iccNEG,iccOVERFLOW))
	    out = v2;
	  break;
	case GUb:
	  if (!(iccCARRY || iccZERO))
	    out = v2;
	  break;
	case LEUb:
	  if (iccCARRY || iccZERO)
	    out = v2;
	  break;
	case CCb:
	  if (!iccCARRY)
	    out=v2;
	  break;
	case CSb:
	  if (iccCARRY)
	    out=v2;
	  break;
	case POSb:
	  if (!iccNEG)
	    out=v2;
	  break;
	case NEGb:
	  if (iccNEG)
	    out=v2;
	  break;
	case VCb:
	  if (!iccOVERFLOW)
	    out=v2;
	  break;
	case VSb:
	default:
	  if (iccOVERFLOW)
	    out=v2;
	  break;
	}
    }
  else /* use floating point condition codes */
    {
      #define E (v1 == fccEQ)
      #define L (v1 == fccLT)
      #define G (v1 == fccGT)
      #define U (v1 == fccUO)
      
      switch(inst->code.aux2)
	{
	case Af:
	  out=v2;
	  break;
	case Nf:
	  break;
	case Uf:
	  if (U)
	    out=v2;	
	  break;
	case Gf:
	  if (G)
	    out=v2;
	  break;
	case UGf:
	  if (U || G)
	    out=v2;
	  break;
	case Lf:
	  if (L)
	    out=v2;
	  break;
	case ULf:
	  if (U || L)
	    out=v2;
	  break;
	case LGf:
	  if (L || G)
	    out=v2;
	  break;
	case NEf:
	  if (L || G || U)
	    out=v2;
	  break;
	case Ef:
	  if (E)
	    out=v2;
	  break;
	case UEf:
	  if (E || U)
	    out=v2;
	  break;
	case GEf:
	  if (G || E)
	    out=v2;
	  break;
	case UGEf:
	  if (U || G || E)
	    out=v2;
	  break;
	case LEf:
	  if (L||E)
	    out=v2;
	  break;
	case ULEf:
	  if (U||L||E)
	    out=v2;
	  break;
	case Of:
	  if (E||L||G)
	    out=v2;
	  break;
	}
    }
  *((int *) &(inst->rdvalfh)) = *out;
}

#define fnFCMPq fnFCMPd
#define fnFCMPEq fnFCMPEd

void fnFCMPd(instance *inst, ProcState *proc)
{
  double v1 = inst->rs1valf, v2=inst->rs2valf;
  int& out = inst->rdvali;

  if (!FP_ENABLED)
    inst->exception_code = FPDISABLED;

  if (v1==v2)
    out=fccEQ;
  else if (v1 < v2)
    out=fccLT;
  else if (v1 > v2)
    out=fccGT;
  else
    out=fccUO;
}


void fnFCMPs(instance *inst, ProcState *proc)
{
  float v1 = inst->rs1valfh, v2=inst->rs2valfh;
  int& out = inst->rdvali;

  if (!FP_ENABLED)
    inst->exception_code = FPDISABLED;

  if (v1==v2)
    out=fccEQ;
  else if (v1 < v2)
    out=fccLT;
  else if (v1 > v2)
    out=fccGT;
  else
    out=fccUO;
}


void fnFCMPEd(instance *inst, ProcState *proc)
{
  double v1 = inst->rs1valf, v2=inst->rs2valf;
  int& out = inst->rdvali;

  if (!FP_ENABLED)
    inst->exception_code = FPDISABLED;

  if (v1==v2)
    out=fccEQ;
  else if (v1 < v2)
    out=fccLT;
  else if (v1 > v2)
    out=fccGT;
  else
    set_fp754_exception(proc, inst, FP754_TRAP_INVALID);
}


void fnFCMPEs(instance *inst, ProcState *proc)
{
  float v1 = inst->rs1valfh, v2=inst->rs2valfh;
  int& out = inst->rdvali;

  if (!FP_ENABLED)
    inst->exception_code = FPDISABLED;

  if (v1==v2)
    out=fccEQ;
  else if (v1 < v2)
    out=fccLT;
  else if (v1 > v2)
    out=fccGT;
  else
    set_fp754_exception(proc, inst, FP754_TRAP_INVALID);
}


#define fnFMOVRq fnFMOVRd

void fnFMOVRd(instance *inst, ProcState *proc)
{
// Cleanup -- see orig out should be ref, not ptr
  long long *out;  

  if (!FP_ENABLED)
    inst->exception_code = FPDISABLED;

  out=(long long *) &(inst->rs1valf);
  int v1 = inst->rsccvali;
  long long *v2 = (long long *) &(inst->rs2valf);

  switch (inst->code.aux2)
    {
    case 1:
      if (v1 == 0)
	out = v2;
      break;
    case 2:
      if (v1 <= 0)
	out = v2;
      break;
    case 3:
      if (v1 < 0)
	out = v2;
      break;
    case 5:
      if (v1 != 0)
	out = v2;
      break;
    case 6:
      if (v1 > 0)
	out = v2;
      break;
    case 7:
      if (v1 >= 0)
	out = v2;
      break;
    case 0:
    case 4:
    default:
      break;
    }
  *((long long *) &(inst->rdvalf)) = *out;
}


void fnFMOVRs(instance *inst, ProcState *proc)
{
// Cleanup -- see orig out should be ref, not ptr
  int *out;
  out= (int *) &(inst->rs1valfh);
  int v1 = inst->rsccvali;
  int *v2 = (int *) &(inst->rs2valfh);

  if (!FP_ENABLED)
    inst->exception_code = FPDISABLED;

  switch (inst->code.aux2)
    {
    case 1:
      if (v1 == 0)
	out = v2;
      break;
    case 2:
      if (v1 <= 0)
	out = v2;
      break;
    case 3:
      if (v1 < 0)
	out = v2;
      break;
    case 5:
      if (v1 != 0)
	out = v2;
      break;
    case 6:
      if (v1 > 0)
	out = v2;
      break;
    case 7:
      if (v1 >= 0)
	out = v2;
      break;
    case 0:
    case 4:
    default:
      break;
    }
  *((int *) &(inst->rdvalfh)) = *out;
}

/************* Memory instructions *************/


/****** Template for a variety of integer loads  *********/
template <class T> void ldi(instance *inst, ProcState *proc, T t)
{
  char *pa = GetMap(inst, proc);
  T *ptr = (T *)pa; 
  if (ptr)
    {
      T result = *ptr;

      result = endian_swap(result);
      if (t)
	result = SE(result, sizeof(T)*8);
      inst->rdvali = result;
    }
  else
    inst->exception_code = BUSERR;
}


void fnLDUW(instance *inst,ProcState *proc)
{
  ldi(inst, proc, (unsigned)0);
}


void fnLDUB(instance *inst,ProcState *proc)
{
  ldi(inst, proc, (unsigned char)0);
}


void fnLDUH(instance *inst,ProcState *proc)
{
  ldi(inst, proc, (unsigned short)0);
}


void fnLDSW(instance *inst,ProcState *proc)
{