predecode_table.cc

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

  fpop1[FDIVs]            = fp_3s;
  ifpop1[FDIVs]           = iFDIVs;

  fpop1[FDIVd]            = fp_3;
  ifpop1[FDIVd]           = iFDIVd;

  fpop1[FDIVq]            = fp_3;
  ifpop1[FDIVq]           = iFDIVq;

  
  fpop1[FsMULd]           = fp_3sd;
  ifpop1[FsMULd]          = iFsMULd;

  fpop1[FdMULq]           = fp_3;
  ifpop1[FdMULq]          = iFdMULq;

  
  fpop1[FsTOx]            = fp_2sd;
  ifpop1[FsTOx]           = iFsTOx;

  fpop1[FdTOx]            = fp_2;
  ifpop1[FdTOx]           = iFdTOx;

  fpop1[FqTOx]            = fp_2;
  ifpop1[FqTOx]           = iFqTOx;

  fpop1[FxTOs]            = fp_2ds;
  ifpop1[FxTOs]           = iFxTOs;
  
  fpop1[FxTOd]            = fp_2;
  ifpop1[FxTOd]           = iFxTOd;

  fpop1[FxToq]            = fp_2;
  ifpop1[FxToq]           = iFxToq;

  
  fpop1[FiTOs]            = fp_2s;
  ifpop1[FiTOs]           = iFiTOs;

  
  fpop1[FdTOs]            = fp_2ds;
  ifpop1[FdTOs]           = iFdTOs;

  fpop1[FqTOs]            = fp_2ds;
  ifpop1[FqTOs]           = iFqTOs;

  fpop1[FiTOd]            = fp_2sd; 
  ifpop1[FiTOd]           = iFiTOd;

  fpop1[FsTOd]            = fp_2sd;
  ifpop1[FsTOd]           = iFsTOd;
  
  fpop1[FqTOd]            = fp_2;
  ifpop1[FqTOd]           = iFqTOd;

  fpop1[FiTOq]            = fp_2sd;
  ifpop1[FiTOq]           = iFiTOq;

  fpop1[FsTOq]            = fp_2sd;
  ifpop1[FsTOq]           = iFsTOq;
    
  fpop1[FdTOq]            = fp_2;
  ifpop1[FdTOq]           = iFdTOq;

  
  fpop1[FsTOi]            = fp_2s;
  ifpop1[FsTOi]           = iFsTOi;

  fpop1[FdTOi]            = fp_2ds;
  ifpop1[FdTOi]           = iFdTOi;

  fpop1[FqTOi]            = fp_2ds;
  ifpop1[FqTOi]           = iFqTOi;

  

  for (i = 0; i < 512; i++)
    {
      fpop2[i]            = arith_res;
      ifpop2[i]           = iRESERVED;
    }

  fpop2[FMOVs0]           = fmovccs;
  ifpop2[FMOVs0]          = iFMOVs0;

  fpop2[FMOVd0]           = fmovcc;
  ifpop2[FMOVd0]          = iFMOVd0;

  fpop2[FMOVq0]           = fmovcc;
  ifpop2[FMOVq0]          = iFMOVq0;

  
  fpop2[FMOVs1]           = fmovccs;
  ifpop2[FMOVs1]          = iFMOVs1;

  fpop2[FMOVd1]           = fmovcc;
  ifpop2[FMOVd1]          = iFMOVd1;

  fpop2[FMOVq1]           = fmovcc;
  ifpop2[FMOVq1]          = iFMOVq1;

  
  fpop2[FMOVs2]           = fmovccs;
  ifpop2[FMOVs2]          = iFMOVs2;

  fpop2[FMOVd2]           = fmovcc;
  ifpop2[FMOVd2]          = iFMOVd2;

  fpop2[FMOVq2]           = fmovcc;
  ifpop2[FMOVq2]          = iFMOVq2;

  
  fpop2[FMOVs3]           = fmovccs;
  ifpop2[FMOVs3]          = iFMOVs3;

  fpop2[FMOVd3]           = fmovcc;
  ifpop2[FMOVd3]          = iFMOVd3;

  fpop2[FMOVq3]           = fmovcc;
  ifpop2[FMOVq3]          = iFMOVq3;

  
  fpop2[FMOVsi]           = fmovccs;
  ifpop2[FMOVsi]          = iFMOVsi;

  fpop2[FMOVdi]           = fmovcc;
  ifpop2[FMOVdi]          = iFMOVdi;

  fpop2[FMOVqi]           = fmovcc;
  ifpop2[FMOVqi]          = iFMOVqi;

  
  fpop2[FMOVsx]           = fmovccs;
  ifpop2[FMOVsx]          = iFMOVsx;

  fpop2[FMOVdx]           = fmovcc;
  ifpop2[FMOVdx]          = iFMOVdx;

  fpop2[FMOVqx]           = fmovcc;
  ifpop2[FMOVqx]          = iFMOVqx;

  
  fpop2[FCMPs]            = fcmps;
  ifpop2[FCMPs]           = iFCMPs;

  fpop2[FCMPd]            = fcmp;
  ifpop2[FCMPd]           = iFCMPd;

  fpop2[FCMPq]            = fcmp;
  ifpop2[FCMPq]           = iFCMPq;

  fpop2[FCMPEs]           = fcmps;
  ifpop2[FCMPEs]          = iFCMPEs;

  fpop2[FCMPEd]           = fcmp;
  ifpop2[FCMPEd]          = iFCMPEd;

  fpop2[FCMPEq]           = fcmp;
  ifpop2[FCMPEq]          = iFCMPEq;

  
  fpop2[FMOVRsZ]          = fmovrccs;
  ifpop2[FMOVRsZ]         = iFMOVRsZ;

  fpop2[FMOVRdZ]          = fmovrcc;
  ifpop2[FMOVRdZ]         = iFMOVRdZ;

  fpop2[FMOVRqZ]          = fmovrcc;
  ifpop2[FMOVRqZ]         = iFMOVRqZ;

  
  fpop2[FMOVRsLEZ]        = fmovrccs;
  ifpop2[FMOVRsLEZ]       = iFMOVRsLEZ;

  fpop2[FMOVRdLEZ]        = fmovrcc;
  ifpop2[FMOVRdLEZ]       = iFMOVRdLEZ;

  fpop2[FMOVRqLEZ]        = fmovrcc;
  ifpop2[FMOVRqLEZ]       = iFMOVRqLEZ;

  
  fpop2[FMOVRsLZ]         = fmovrccs;
  ifpop2[FMOVRsLZ]        = iFMOVRsLZ;

  fpop2[FMOVRdLZ]         = fmovrcc;
  ifpop2[FMOVRdLZ]        = iFMOVRdLZ;

  fpop2[FMOVRqLZ]         = fmovrcc;
  ifpop2[FMOVRqLZ]        = iFMOVRqLZ;

  
  fpop2[FMOVRsNZ]         = fmovrccs;
  ifpop2[FMOVRsNZ]        = iFMOVRsNZ;

  fpop2[FMOVRdNZ]         = fmovrcc;
  ifpop2[FMOVRdNZ]        = iFMOVRdNZ;

  fpop2[FMOVRqNZ]         = fmovrcc;
  ifpop2[FMOVRqNZ]        = iFMOVRqNZ;

  
  fpop2[FMOVRsGZ]         = fmovrccs;
  ifpop2[FMOVRsGZ]        = iFMOVRsGZ;

  fpop2[FMOVRdGZ]         = fmovrcc;
  ifpop2[FMOVRdGZ]        = iFMOVRdGZ;

  fpop2[FMOVRqGZ]         = fmovrcc;
  ifpop2[FMOVRqGZ]        = iFMOVRqGZ;

  
  fpop2[FMOVRsGEZ]        = fmovrccs;
  ifpop2[FMOVRsGEZ]       = iFMOVRsGEZ;

  fpop2[FMOVRdGEZ]        = fmovrcc;
  ifpop2[FMOVRdGEZ]       = iFMOVRdGEZ;

  fpop2[FMOVRqGEZ]        = fmovrcc;
  ifpop2[FMOVRqGEZ]       = iFMOVRqGEZ;


  for (i = 0; i < 64; i++)
    {
      imemop3[i]          = iRESERVED;
    }
  
  memop3[LDUW]            = mem_op2;
  imemop3[LDUW]           = iLDUW;
  memop3[LDUB]            = mem_op2;
  imemop3[LDUB]           = iLDUB;

  memop3[LDUH]            = mem_op2;
  imemop3[LDUH]           = iLDUH;

  memop3[LDD]             = dmem_op2;
  imemop3[LDD]            = iLDD;

  memop3[STW]             = smem_op2;
  imemop3[STW]            = iSTW;

  memop3[STB]             = smem_op2;
  imemop3[STB]            = iSTB;

  memop3[STH]             = smem_op2;
  imemop3[STH]            = iSTH;

  memop3[STD]             = sdmem_op2;
  imemop3[STD]            = iSTD;
  
  memop3[LDSW]            = mem_op2;
  imemop3[LDSW]           = iLDSW;

  memop3[LDSB]            = mem_op2;
  imemop3[LDSB]           = iLDSB;

  memop3[LDSH]            = mem_op2;
  imemop3[LDSH]           = iLDSH;

  memop3[LDX]             = mem_op2;
  imemop3[LDX]            = iLDX;

  memop3[memRES1]         = mem_res;
  memop3[LDSTUB]          = mem_op2;
  imemop3[LDSTUB]         = iLDSTUB;

  memop3[STX]             = smem_op2;
  imemop3[STX]            = iSTX;

  memop3[SWAP]            = swap;
  imemop3[SWAP]           = iSWAP;

  
  memop3[LDUWA]           = amem_op2;
  imemop3[LDUWA]          = iLDUWA;

  memop3[LDUBA]           = amem_op2;
  imemop3[LDUBA]          = iLDUBA; 

  memop3[LDUHA]           = amem_op2;
  imemop3[LDUHA]          = iLDUHA;

  memop3[LDDA]            = damem_op2;
  imemop3[LDDA]           = iLDDA;

  memop3[STWA]            = samem_op2;
  imemop3[STWA]           = iSTWA;

  memop3[STBA]            = samem_op2;
  imemop3[STBA]           = iSTBA;

  memop3[STHA]            = samem_op2;
  imemop3[STHA]           = iSTHA;

  memop3[STDA]            = sdamem_op2;
  imemop3[STDA]           = iSTDA;

  
  memop3[LDSWA]           = amem_op2;
  imemop3[LDSWA]          = iLDSWA;

  memop3[LDSBA]           = amem_op2;
  imemop3[LDSBA]          = iLDSBA;

  memop3[LDSHA]           = amem_op2;
  imemop3[LDSHA]          = iLDSHA;

  memop3[LDXA]            = amem_op2;
  imemop3[LDXA]           = iLDXA;

  memop3[memRES2]         = mem_res;
  memop3[LDSTUBA]         = amem_op2;
  imemop3[LDSTUBA]        = iLDSTUBA;

  memop3[STXA]            = samem_op2;
  imemop3[STXA]           = iSTXA;

  memop3[SWAPA]           = aswap;
  imemop3[SWAPA]          = iSWAPA;

  
  memop3[LDF]             = mem_op2fs;
  imemop3[LDF]            = iLDF;

  memop3[LDFSR]           = mem_op2fsr;
  imemop3[LDFSR]          = iLDFSR;

  memop3[LDQF]            = mem_op2f;
  imemop3[LDQF]           = iLDQF;

  memop3[LDDF]            = mem_op2f;
  imemop3[LDDF]           = iLDDF;

  memop3[STF]             = smem_op2fs;
  imemop3[STF]            = iSTF;

  memop3[STFSR]           = smem_op2fsr;
  imemop3[STFSR]          = iSTFSR;

  memop3[STQF]            = smem_op2f;
  imemop3[STQF]           = iSTQF;

  memop3[STDF]            = smem_op2f;
  imemop3[STDF]           = iSTDF;

  
  memop3[memRES3]         = mem_res;

  memop3[memRES4]         = mem_res;
  memop3[memRES5]         = mem_res;
  memop3[memRES6]         = mem_res;

  memop3[memRES7]         = mem_res;
  
  memop3[PREFETCH]        = pref;
  imemop3[PREFETCH]       = iPREFETCH;

  memop3[memRES8]         = mem_res;
  memop3[memRES9]         = mem_res;
  
  memop3[LDFA]            = amem_op2fs;
  imemop3[LDFA]           = iLDFA;
    
  memop3[memRES10]        = mem_res;
  memop3[LDQFA]           = amem_op2f;
  imemop3[LDQFA]          = iLDQFA;

  memop3[LDDFA]           = amem_op2f;
  imemop3[LDDFA]          = iLDDFA;

  memop3[STFA]            = samem_op2fs;
  imemop3[STFA]           = iSTFA;

  memop3[memRES11]        = mem_res;
  memop3[STQFA]           = samem_op2f;
  imemop3[STQFA]          = iSTQFA;

  memop3[STDFA]           = samem_op2f;
  imemop3[STDFA]          = iSTDFA;

  memop3[memRES12]        = mem_res;

  memop3[memRES13]        = mem_res;
  memop3[memRES14]        = mem_res;
  memop3[memRES15]        = mem_res;
  
  memop3[CASA]            = cas;
  imemop3[CASA]           = iCASA;

  memop3[PREFETCHA]       = apref;
  imemop3[PREFETCHA]      = iPREFETCHA;

  memop3[CASXA]           = cas;
  imemop3[CASXA]          = iCASXA;

  memop3[memRES16]        = mem_res;

  //------------------------------

  struct instr in;
 
  SIZEOF_INSTR = sizeof(in);
  if ((SIZEOF_INSTR % sizeof(double)) != 0)
    YS__errmsg(0, "Size of instr not a multiple of %i (%i)!\n",
	       sizeof(double), SIZEOF_INSTR);

  if (sizeof(in.instruction) * 256 < numINSTRS)
    YS__errmsg(0, "Size of instr.code insufficient to hold opcode\n");

  if (sizeof(instance) % sizeof(double) != 0)
    YS__errmsg(0, "Size of instance not a multiple of %i (%i)\n",
	       sizeof(double), sizeof(instance));

  if ((sizeof(short) * NO_OF_LOG_INT_REGS) % sizeof(double) != 0)
    YS__errmsg(0,
	       "Size of integer register map table not a multiple of %i (%i)\n",
	       sizeof(double),
	       sizeof(short) * NO_OF_LOG_INT_REGS);

  if ((sizeof(short) * NO_OF_LOG_FP_REGS) % sizeof(double) != 0)
    YS__errmsg(0, "Size of FP register map table not a multiple of %i (%i)\n",
	       sizeof(double),
	       sizeof(short) * NO_OF_LOG_FP_REGS);
}