ppc32_exec.c

思科路由器仿真器,用来仿7200系列得,可以在电脑上模拟路由器

{
   int rd = bits(insn,21,25);
   int ra = bits(insn,16,20);
   int rb = bits(insn,11,15);
   m_int64_t tmp;
 
   tmp =  (m_int64_t)(m_int32_t)cpu->gpr[ra];
   tmp *= (m_int64_t)(m_int32_t)cpu->gpr[rb];

   cpu->xer &= ~PPC32_XER_OV;

   if (unlikely(tmp != (m_int64_t)(m_int32_t)tmp))
      cpu->xer |= PPC32_XER_OV|PPC32_XER_SO;

   cpu->gpr[rd] = (m_uint32_t)tmp;
   return(0);
}

/* MULLWO. */
static fastcall int ppc32_exec_MULLWO_dot(cpu_ppc_t *cpu,ppc_insn_t insn)
{
   int rd = bits(insn,21,25);
   int ra = bits(insn,16,20);
   int rb = bits(insn,11,15);
   register m_uint32_t res;
   m_int64_t tmp;
 
   tmp =  (m_int64_t)(m_int32_t)cpu->gpr[ra];
   tmp *= (m_int64_t)(m_int32_t)cpu->gpr[rb];

   cpu->xer &= ~PPC32_XER_OV;

   if (unlikely(tmp != (m_int64_t)(m_int32_t)tmp))
      cpu->xer |= PPC32_XER_OV|PPC32_XER_SO;

   res = (m_uint32_t)tmp;
   ppc32_exec_update_cr0(cpu,res);
   cpu->gpr[rd] = res;
   return(0);
}

/* NAND */
static fastcall int ppc32_exec_NAND(cpu_ppc_t *cpu,ppc_insn_t insn)
{
   int rs = bits(insn,21,25);
   int ra = bits(insn,16,20);
   int rb = bits(insn,11,15);

   cpu->gpr[ra] = ~(cpu->gpr[rs] & cpu->gpr[rb]);
   return(0);
}

/* NAND. */
static fastcall int ppc32_exec_NAND_dot(cpu_ppc_t *cpu,ppc_insn_t insn)
{
   int rs = bits(insn,21,25);
   int ra = bits(insn,16,20);
   int rb = bits(insn,11,15);
   register m_uint32_t tmp;

   tmp = ~(cpu->gpr[rs] & cpu->gpr[rb]);
   ppc32_exec_update_cr0(cpu,tmp);
   cpu->gpr[ra] = tmp;
   return(0);
}

/* NEG - Negate */
static fastcall int ppc32_exec_NEG(cpu_ppc_t *cpu,ppc_insn_t insn)
{
   int rd = bits(insn,21,25);
   int ra = bits(insn,16,20);

   cpu->gpr[rd] = ~cpu->gpr[ra] + 1;
   return(0);
}

/* NEG. */
static fastcall int ppc32_exec_NEG_dot(cpu_ppc_t *cpu,ppc_insn_t insn)
{
   int rd = bits(insn,21,25);
   int ra = bits(insn,16,20);
   register m_uint32_t tmp;

   tmp = ~cpu->gpr[ra] + 1;
   ppc32_exec_update_cr0(cpu,tmp);
   cpu->gpr[rd] = tmp;
   return(0);
}

/* NEGO */
static fastcall int ppc32_exec_NEGO(cpu_ppc_t *cpu,ppc_insn_t insn)
{
   int rd = bits(insn,21,25);
   int ra = bits(insn,16,20);
   register m_uint32_t tmp;

   tmp = ~cpu->gpr[ra] + 1;
   cpu->gpr[rd] = tmp;

   cpu->xer &= ~PPC32_XER_OV;

   if (unlikely(tmp == 0x80000000))
      cpu->xer |= PPC32_XER_OV|PPC32_XER_SO;

   ppc32_exec_update_cr0(cpu,tmp);
   return(0);
}

/* NEGO. */
static fastcall int ppc32_exec_NEGO_dot(cpu_ppc_t *cpu,ppc_insn_t insn)
{
   int rd = bits(insn,21,25);
   int ra = bits(insn,16,20);
   register m_uint32_t tmp;

   tmp = ~cpu->gpr[ra] + 1;
   cpu->gpr[rd] = tmp;

   cpu->xer &= ~PPC32_XER_OV;

   if (unlikely(tmp == 0x80000000))
      cpu->xer |= PPC32_XER_OV|PPC32_XER_SO;

   ppc32_exec_update_cr0(cpu,tmp);
   return(0);
}

/* NOR */
static fastcall int ppc32_exec_NOR(cpu_ppc_t *cpu,ppc_insn_t insn)
{
   int rs = bits(insn,21,25);
   int ra = bits(insn,16,20);
   int rb = bits(insn,11,15);

   cpu->gpr[ra] = ~(cpu->gpr[rs] | cpu->gpr[rb]);
   return(0);
}

/* NOR. */
static fastcall int ppc32_exec_NOR_dot(cpu_ppc_t *cpu,ppc_insn_t insn)
{
   int rs = bits(insn,21,25);
   int ra = bits(insn,16,20);
   int rb = bits(insn,11,15);
   register m_uint32_t tmp;

   tmp = ~(cpu->gpr[rs] | cpu->gpr[rb]);
   ppc32_exec_update_cr0(cpu,tmp);
   cpu->gpr[ra] = tmp;
   return(0);
}

/* OR */
static fastcall int ppc32_exec_OR(cpu_ppc_t *cpu,ppc_insn_t insn)
{
   int rs = bits(insn,21,25);
   int ra = bits(insn,16,20);
   int rb = bits(insn,11,15);

   cpu->gpr[ra] = cpu->gpr[rs] | cpu->gpr[rb];
   return(0);
}

/* OR. */
static fastcall int ppc32_exec_OR_dot(cpu_ppc_t *cpu,ppc_insn_t insn)
{
   int rs = bits(insn,21,25);
   int ra = bits(insn,16,20);
   int rb = bits(insn,11,15);
   register m_uint32_t tmp;

   tmp = cpu->gpr[rs] | cpu->gpr[rb];
   ppc32_exec_update_cr0(cpu,tmp);
   cpu->gpr[ra] = tmp;
   return(0);
}

/* ORC - OR with Complement */
static fastcall int ppc32_exec_ORC(cpu_ppc_t *cpu,ppc_insn_t insn)
{
   int rs = bits(insn,21,25);
   int ra = bits(insn,16,20);
   int rb = bits(insn,11,15);

   cpu->gpr[ra] = cpu->gpr[rs] | ~cpu->gpr[rb];
   return(0);
}

/* ORC. */
static fastcall int ppc32_exec_ORC_dot(cpu_ppc_t *cpu,ppc_insn_t insn)
{
   int rs = bits(insn,21,25);
   int ra = bits(insn,16,20);
   int rb = bits(insn,11,15);
   register m_uint32_t tmp;

   tmp = cpu->gpr[rs] | ~cpu->gpr[rb];
   ppc32_exec_update_cr0(cpu,tmp);
   cpu->gpr[ra] = tmp;
   return(0);
}

/* ORI - OR Immediate */
static fastcall int ppc32_exec_ORI(cpu_ppc_t *cpu,ppc_insn_t insn)
{
   int rs = bits(insn,21,25);
   int ra = bits(insn,16,20);
   m_uint16_t imm = bits(insn,0,15);

   cpu->gpr[ra] = cpu->gpr[rs] | imm;
   return(0);
}

/* ORIS - OR Immediate Shifted */
static fastcall int ppc32_exec_ORIS(cpu_ppc_t *cpu,ppc_insn_t insn)
{
   int rs = bits(insn,21,25);
   int ra = bits(insn,16,20);
   m_uint32_t imm = bits(insn,0,15);

   cpu->gpr[ra] = cpu->gpr[rs] | (imm << 16);
   return(0);
}

/* RFI - Return From Interrupt */
static fastcall int ppc32_exec_RFI(cpu_ppc_t *cpu,ppc_insn_t insn)
{
   //printf("RFI: srr0=0x%8.8x, srr1=0x%8.8x\n",cpu->srr0,cpu->srr1);

   cpu->msr &= ~PPC32_RFI_MSR_MASK;
   cpu->msr |= cpu->srr1 & PPC32_RFI_MSR_MASK;

   cpu->msr &= ~(1 << 13);
   cpu->ia = cpu->srr0 & ~0x03;

   cpu->irq_check = (cpu->msr & PPC32_MSR_EE) && cpu->irq_pending;

   //printf("NEW IA=0x%8.8x, NEW MSR=0x%8.8x\n",cpu->ia,cpu->msr);
   return(1);
}

/* RLWIMI - Rotate Left Word Immediate then Mask Insert */
static fastcall int ppc32_exec_RLWIMI(cpu_ppc_t *cpu,ppc_insn_t insn)
{
   int rs = bits(insn,21,25);
   int ra = bits(insn,16,20);
   int sh = bits(insn,11,15);
   int mb = bits(insn,6,10);
   int me = bits(insn,1,5);
   register m_uint32_t r,mask;
   
   r = (cpu->gpr[rs] << sh) | (cpu->gpr[rs] >> (32 - sh));
   mask = ppc32_rotate_mask(mb,me);
   cpu->gpr[ra] = (r & mask) | (cpu->gpr[ra] & ~mask);
   return(0);
}

/* RLWIMI. - Rotate Left Word Immediate then Mask Insert */
static fastcall int ppc32_exec_RLWIMI_dot(cpu_ppc_t *cpu,ppc_insn_t insn)
{
   int rs = bits(insn,21,25);
   int ra = bits(insn,16,20);
   int sh = bits(insn,11,15);
   int mb = bits(insn,6,10);
   int me = bits(insn,1,5);
   register m_uint32_t r,mask,tmp;
   
   r = (cpu->gpr[rs] << sh) | (cpu->gpr[rs] >> (32 - sh));
   mask = ppc32_rotate_mask(mb,me);
   tmp = (r & mask) | (cpu->gpr[ra] & ~mask);
   ppc32_exec_update_cr0(cpu,tmp);
   cpu->gpr[ra] = tmp;
   return(0);
}

/* RLWINM - Rotate Left Word Immediate AND with Mask */
static fastcall int ppc32_exec_RLWINM(cpu_ppc_t *cpu,ppc_insn_t insn)
{
   int rs = bits(insn,21,25);
   int ra = bits(insn,16,20);
   int sh = bits(insn,11,15);
   int mb = bits(insn,6,10);
   int me = bits(insn,1,5);
   register m_uint32_t r,mask;
   
   r = (cpu->gpr[rs] << sh) | (cpu->gpr[rs] >> (32 - sh));
   mask = ppc32_rotate_mask(mb,me);
   cpu->gpr[ra] = r & mask;
   return(0);
}

/* RLWINM. - Rotate Left Word Immediate AND with Mask */
static fastcall int ppc32_exec_RLWINM_dot(cpu_ppc_t *cpu,ppc_insn_t insn)
{
   int rs = bits(insn,21,25);
   int ra = bits(insn,16,20);
   int sh = bits(insn,11,15);
   int mb = bits(insn,6,10);
   int me = bits(insn,1,5);
   register m_uint32_t r,mask,tmp;
   
   r = (cpu->gpr[rs] << sh) | (cpu->gpr[rs] >> (32 - sh));
   mask = ppc32_rotate_mask(mb,me);
   tmp = r & mask;
   ppc32_exec_update_cr0(cpu,tmp);
   cpu->gpr[ra] = tmp;
   return(0);
}

/* RLWNM - Rotate Left Word then Mask Insert */
static fastcall int ppc32_exec_RLWNM(cpu_ppc_t *cpu,ppc_insn_t insn)
{
   int rs = bits(insn,21,25);
   int ra = bits(insn,16,20);
   int rb = bits(insn,11,15);
   int mb = bits(insn,6,10);
   int me = bits(insn,1,5);
   register m_uint32_t r,sh,mask;

   sh = cpu->gpr[rb] & 0x1f;
   r = (cpu->gpr[rs] << sh) | (cpu->gpr[rs] >> (32 - sh));
   mask = ppc32_rotate_mask(mb,me);
   cpu->gpr[ra] = r & mask;
   return(0);
}

/* RLWNM. - Rotate Left Word then Mask Insert */
static fastcall int ppc32_exec_RLWNM_dot(cpu_ppc_t *cpu,ppc_insn_t insn)
{
   int rs = bits(insn,21,25);
   int ra = bits(insn,16,20);
   int rb = bits(insn,11,15);
   int mb = bits(insn,6,10);
   int me = bits(insn,1,5);
   register m_uint32_t r,sh,mask,tmp;

   sh = cpu->gpr[rb] & 0x1f;
   r = (cpu->gpr[rs] << sh) | (cpu->gpr[rs] >> (32 - sh));
   mask = ppc32_rotate_mask(mb,me);
   tmp = r & mask;
   ppc32_exec_update_cr0(cpu,tmp);
   cpu->gpr[ra] = tmp;
   return(0);
}

/* SC - System Call */
static fastcall int ppc32_exec_SC(cpu_ppc_t *cpu,ppc_insn_t insn)
{
   ppc32_trigger_exception(cpu,PPC32_EXC_SYSCALL);
   return(1);
}

/* SLW - Shift Left Word */
static fastcall int ppc32_exec_SLW(cpu_ppc_t *cpu,ppc_insn_t insn)
{
   int rs = bits(insn,21,25);
   int ra = bits(insn,16,20);
   int rb = bits(insn,11,15);
   register m_uint32_t s;

   s = cpu->gpr[rb] & 0x3f;

   if (likely(!(s & 0x20)))
      cpu->gpr[ra] = cpu->gpr[rs] << s;
   else
      cpu->gpr[ra] = 0;
   
   return(0);
}

/* SLW. */
static fastcall int ppc32_exec_SLW_dot(cpu_ppc_t *cpu,ppc_insn_t insn)
{
   int rs = bits(insn,21,25);
   int ra = bits(insn,16,20);
   int rb = bits(insn,11,15);
   register m_uint32_t s,tmp;

   s = cpu->gpr[rb] & 0x3f;

   if (likely(!(s & 0x20)))
      tmp = cpu->gpr[rs] << s;
   else
      tmp = 0;
   
   ppc32_exec_update_cr0(cpu,tmp);
   cpu->gpr[ra] = tmp;
   return(0);
}

/* SRAW - Shift Right Algebraic Word */
static fastcall int ppc32_exec_SRAW(cpu_ppc_t *cpu,ppc_insn_t insn)
{
   int rs = bits(insn,21,25);
   int ra = bits(insn,16,20);
   int rb = bits(insn,11,15);
   register m_uint32_t s,mask;
   int sh;

   cpu->xer_ca = 0;

   s  = cpu->gpr[rs];
   sh = cpu->gpr[rb];

   if (unlikely(sh & 0x20)) {
      cpu->gpr[ra] = (m_int32_t)s >> 31;
      cpu->xer_ca = cpu->gpr[ra] & 0x1;
      return(0);
   }

   cpu->gpr[ra] = (m_int32_t)s >> sh;
   mask = ~(0xFFFFFFFFU << sh);
   
   if ((s & 0x80000000) && ((s & mask) != 0))
      cpu->xer_ca = 1;

   return(0);
}

/* SRAWI - Shift Right Algebraic Word Immediate */
static fastcall int ppc32_exec_SRAWI(cpu_ppc_t *cpu,ppc_insn_t insn)
{
   int rs = bits(insn,21,25);
   int ra = bits(insn,16,20);
   int sh = bits(insn,11,15);
   register m_uint32_t s,mask;

   cpu->xer_ca = 0;

   s = cpu->gpr[rs];
   cpu->gpr[ra] = (m_int32_t)s >> sh;
   mask = ~(0xFFFFFFFFU << sh);
   
   if ((s & 0x80000000) && ((s & mask) != 0))
      cpu->xer_ca = 1;

   return(0);
}

/* SRAWI. */
static fastcall int ppc32_exec_SRAWI_dot(cpu_ppc_t *cpu,ppc_insn_t insn)
{
   int rs = bits(insn,21,25);
   int ra = bits(insn,16,20);
   int sh = bits(insn,11,15);
   register m_uint32_t s,r,mask;

   cpu->xer_ca = 0;

   s = cpu->gpr[rs];
   r = (m_int32_t)s >> sh;
   mask = ~(0xFFFFFFFFU << sh);
   
   if ((s & 0x80000000) && ((s & mask) != 0))
      cpu->xer_ca = 1;

   ppc32_exec_update_cr0(cpu,r);
   cpu->gpr[ra] = r;
   return(0);
}

/* SRW - Shift Right Word */
static fastcall int ppc32_exec_SRW(cpu_ppc_t *cpu,ppc_insn_t insn)
{
   int rs = bits(insn,21,25);
   int ra = bits(insn,16,20);
   int rb = bits(insn,11,15);
   register m_uint32_t s;

   s = cpu->gpr[rb] & 0x3f;

   if (likely(!(s & 0x20)))
      cpu->gpr[ra] = cpu->gpr[rs] >> s;
   else
      cpu->gpr[ra] = 0;
   
   return(0);
}

/* SRW. */
static fastcall int ppc32_exec_SRW_dot(cpu_ppc_t *cpu,ppc_insn_t insn)
{
   int rs = bits(insn,21,25);
   int ra = bits(insn,16,20);
   int rb = bits(insn,11,15);
   register m_uint32_t s,tmp;

   s = cpu->gpr[rb] & 0x3f;

   if (likely(!(s & 0x20)))
      tmp = cpu->gpr[rs] >> s;
   else
      tmp = 0;
   
   ppc32_exec_update_cr0(cpu,tmp);
   cpu->gpr[ra] = tmp;
   return(0);
}

/* STB - Store Byte */
static fastcall int ppc32_exec_STB(cpu_ppc_t *cpu,ppc_insn_t insn)
{  
   int rs = bits(insn,21,25);
   int ra = bits(insn,16,20);
   m_uint16_t imm = bits(insn,0,15);
   m_uint32_t vaddr;

   vaddr = sign_extend_32(imm,16);
   
   if (ra != 0)
      vaddr += cpu->gpr[ra];

   ppc32_exec_memop(cpu,PPC_MEMOP_STB,vaddr,rs);
   return(0);
}

/* STBU - Store Byte with Update */
static fastcall int ppc32_exec_STBU(cpu_ppc_t *cpu,ppc_insn_t insn)
{  
   int rs = bits(insn,21,25);
   int ra = bits(insn,16,20);
   m_uint16_t imm = bits(insn,0,15);
   m_uint32_t vaddr;

   vaddr = cpu->gpr[ra] + sign_extend_32(imm,16);
   ppc32_exec_memop(cpu,PPC_MEMOP_STB,vaddr,rs);
   cpu->gpr[ra] = vaddr;
   return(0);
}

/* STBUX - Store Byte with Update Indexed */
static fastcall int ppc32_exec_STBUX(cpu_ppc_t *cpu,ppc_insn_t insn)
{  
   int rs = bits(insn,21,25);
   int ra = bits(insn,16,20);
   int rb = bits(insn,11,15);
   m_uint32_t vaddr;

   vaddr = cpu->gpr[ra] + cpu->gpr[rb];
   ppc32_exec_memop(cpu,PPC_MEMOP_STB,vaddr,rs);
   cpu->gpr[ra] = vaddr;
   return(0);
}

/* STBX - Store Byte Indexed */
static fastcall int ppc32_exec_STBX(cpu_ppc_t *cpu,ppc_insn_t insn)
{  
   int rs = bits(insn,21,25);
   int ra = bits(insn,16,20);
   int rb = bits(insn,11,15);
   m_uint32_t vaddr;

   vaddr = cpu->gpr[rb];

   if (ra != 0)
      vaddr += cpu->gpr[ra];

   ppc32_exec_memop(cpu,PPC_MEMOP_STB,vaddr,rs);
   return(0);
}

/* STH - Store Half-Word */
static fastcall int ppc32_exec_STH(cpu_ppc_t *cpu,ppc_insn_t insn)
{  
   int rs = bits(insn,21,25);
   int ra = bits(insn,16,20);
   m_uint16_t imm = bits(insn,0,15);
   m_uint32_t vaddr;

   vaddr = sign_extend_32(imm,16);
   
   if (ra != 0)
      vaddr += cpu->gpr[ra];

   ppc32_exec_memop(cpu,PPC_MEMOP_STH,vaddr,rs);
   return(0);
}

/* STHU - Store Half-Word with Update */
static fastcall int ppc32_exec_STHU(cpu_ppc_t *cpu,ppc_insn_t insn)
{