armia_iacxl10_2004_3_16.cpp

自己编写的ARM处理器的指令集仿真

                 {
                      t = SPSR[getid()];
                      if( (tmp.mis.mask & 0x1) == 1 )
                    {
                            
                             t = t & 0xffffff00;
                             t = t | (oper & 0xff);
                    }
                if( (tmp.mis.mask & 0x2) > 0 )
                    {
                             t = t & 0xffff00ff;
                             t = t | (oper & 0xff00);
                    }
                if( (tmp.mis.mask & 0x4) > 0 )
                    {
                             t = t & 0xff00ffff;
                             t = t | (oper & 0xff0000);
                    }
                if( (tmp.mis.mask & 0x8) > 0 )
                    {
                             t = t & 0xff000000;
                             t = t | (oper & 0xff000000);
                    }
                SPSR[getid()] = t;
            }
         }
      
          
}

long ARMISS_stru::CLZ()
{
      ARM_type0_stru       tmp   = ARM_type0;
      UNL&                 r     = getreg( tmp.Rm );
      bit32_stru           bit32 ;
      int                  i     = 0;
       
      bit32 = r;  

      if( r == 0 )
           return 32;
      else
         {
             for( i=31; i>=0; i-- )
               if( bit32[i] == 1 )
                break;
             return 31 - i;
         }
}

void ARMISS_stru::BX()
{
       ARM_type0_stru&      tmp = ARM_type0;
       UNL&                 r   = getreg( tmp.mis.Rm );
      
     if( executable() )
     {  
       if( getid() == -1 )
             CPSR.T = r;
       else
             SPSR[getid()].T = r;
       r_gen[PC] = r & 0xfffffffe;
       pc_changed = true;
     }
}
       
void ARMISS_stru::LDR(int i)
{
     ARM_type2_stru&   tmp = ARM_type2;
     UNL&              rd  = getreg( tmp.Rd );
     UNL               value;
     UNL               address;
 
    if( executable() )
  {
     address = Addressing_mod2(i);
     nrw     = false;
     (*pmemfun)(address,&data,nrw,2,&abort);
     if( abort ) data_abt = true;
     value   = data;
     if( !data_abt )
       if( tmp.Rd == PC )
         {
             r_gen[PC]  = value & 0xfffffffc;
             pc_changed = true;
         }
       else 
             rd = value;
   }
  
}

void ARMISS_stru::LDRT(int i)
{
     ARM_type2_stru&   tmp = ARM_type2;
     UNL&              rd  = r_gen[tmp.Rd];
     UNL               value;
     UNL               address;
 
    if( executable() )
  {
     address = Addressing_mod2(i);
     nrw     = false;
     (*pmemfun)(address,&data,nrw,2,&abort);
     if( abort ) data_abt = true;
     value   = data;
   if( !data_abt )
    { if( tmp.Rd == PC )
         {
             r_gen[PC]  = value & 0xfffffffc;
             pc_changed = true;
         }
     else 
          rd = value;
   }
  }
}

void ARMISS_stru::LDRB(int i)
{
   ARM_type2_stru&     tmp = ARM_type2;
   UNL&                rd  = getreg( tmp.Rd );
   UNL                 value;
   UNL                 address;
   
   if( executable() )
   {
      address = Addressing_mod2(i);
      nrw     = false;
      (*pmemfun)(address,&data,nrw,0,&abort);
      if( abort ) data_abt = true;
      value   = data ;
      if( !data_abt )
       { if( tmp.Rd == PC )
          {
            r_gen[PC]  = value & 0xfffffffc;
            pc_changed = true;
          }
        else 
          rd = value;
       }
   }
   
}
  
void ARMISS_stru::LDRBT(int i)
{
   ARM_type2_stru&     tmp = ARM_type2;
   UNL&                rd  = r_gen[tmp.Rd];
   UNL                 value;
   UNL                 address;
   
   if( executable() )
   {
      address = Addressing_mod2(i);
      nrw     = false;
      (*pmemfun)(address,&data,nrw,0,&abort);
      if( abort ) data_abt = true;
      value   = data ;
      if( !data_abt )
        if( tmp.Rd == PC )
          {
            r_gen[PC]  = value & 0xfffffffc;
            pc_changed = true;
          }
        else 
            rd = value;
    
   }
    
}
    
       
void ARMISS_stru::STR(int i)
{
     ARM_type2_stru&   tmp = ARM_type2;
     UNL&              rd  = getreg( tmp.Rd );
     UNL               value;
     UNL               address;
   
     
     if( executable() )
    {
       address = Addressing_mod2(i);
       nrw     = true;  
      if( tmp.Rd == 15 ) data = rd + 8;
      else               data = rd;
     
     (*pmemfun)(address,&data,nrw,2,&abort);
      if( abort ) data_abt = true;
    }
}

void ARMISS_stru::STRT(int i)
{
     ARM_type2_stru&   tmp = ARM_type2;
     UNL&              rd  = r_gen[tmp.Rd];
     UNL               value;
     UNL               address;
   
     if( executable() )
    {
       address = Addressing_mod2(i);
       nrw     = true;  
      if( tmp.Rd == 15 ) data = rd + 8;
      else               data = rd;
     (*pmemfun)(address,&data,nrw,2,&abort);
      if( abort ) data_abt = true;
    }
}

void ARMISS_stru::STRB(int i)
{
    ARM_type2_stru&   tmp = ARM_type2;
    UNL&              rd  = getreg( tmp.Rd );
    UNL               value;
    UNL               address;
  
   if( executable() )
    {
       address = Addressing_mod2(i);
       nrw     = true;
       data    = rd & 0xff;
      
       (*pmemfun)(address,&data,nrw,0,&abort);
       if( abort ) data_abt = true;
    }
}  

void ARMISS_stru::STRBT(int i)
{
    ARM_type2_stru&   tmp = ARM_type2;
    UNL&              rd  = r_gen[tmp.Rd];
    UNL               value;
    UNL               address;
  
   if( executable() )
    {
       address = Addressing_mod2(i);
       nrw     = true;
       data    = rd & 0xff;
      
       (*pmemfun)(address,&data,nrw,0,&abort);
       if( abort ) data_abt = true;
    }
}
          
void ARMISS_stru::LDM1()
{
     ARM_type4_stru&  tmp  = ARM_type4;
     long             t    = tmp.reg_list;
     bit32_stru       regs;
     addr_stru        addr;
     UNL              reg[16];
     
     if( executable() )
      {
        regs = t;
        addr = Addressing_mod4();
        for( int i=0; i<15; i++)
         if( regs[i] == 1 )
         {
          
           (*pmemfun)(addr.start,&data,false,2,&abort);
           if( abort ) data_abt = true;
            reg[i]   = data;
            addr.start = addr.start + 4;
         }
       if( regs[PC] == 1 )
         {
             (*pmemfun)(addr.start,&data,false,2,&abort);
              if( abort ) data_abt = true;
              reg[PC]  = data & 0xfffffffc;
         }
       if( !data_abt )
          {
             for( int j=0;j<16;j++)
               if( regs[j] == 1 )
               { 
                  UNL&  r = getreg( j );
                  r = reg[j];
               }
             if( regs[PC] == 1 )
             {      
                addr.start = addr.start + 4;
                pc_changed = true;
             }
          } 
      
       
        assert( addr.end == (addr.start - 4) );
     }
}

void ARMISS_stru::LDM2()
{
   ARM_type4_stru&  tmp  = ARM_type4;
     long           t    = tmp.reg_list;
     bit32_stru     regs;
     addr_stru      addr;
     UNL            reg[16];

    if( executable() )
    {
     regs = t;
     addr = Addressing_mod4();
     for( int i=0; i<15; i++)
        if( regs[i] == 1 )
       {
           (*pmemfun)(addr.start,&data,false,2,&abort);
            if( abort ) data_abt = true;
            reg[i] = data;
            addr.start += 4;
       }
     if( !data_abt )
        for(int j=0;j<15;j++)
          if( regs[j] == 1 )
            {
                UNL&  r = getreg( j );
                r   = reg[j];
            }

    assert( addr.end == (addr.start - 4) );
   }
}
     

void ARMISS_stru::LDM3()
{
     ARM_type4_stru&  tmp  = ARM_type4;
     long             t    = tmp.reg_list;
     bit32_stru       regs;
     addr_stru        addr;
     UNL              reg[16];

   if( executable() )
   {
     regs = t;
     addr = Addressing_mod4();
     for( int i=0; i<15; i++)
        if( regs[i] == 1 )
       {
           (*pmemfun)(addr.start,&data,false,2,&abort);
            if( abort ) data_abt = true;
            reg[i] = data;
            addr.start += 4;
       }
     CPSR = SPSR[ getid() ];

     
     (*pmemfun)(addr.start,&data,false,2,&abort);
     if( abort ) data_abt = true;
     reg[PC] = data & 0xfffffffc;
     if( !data_abt )
        for(int j=0;j<16;j++)
          if( regs[j] == 1 )
            {
                UNL&  r = getreg( j );
                r   = reg[j];
            }
 
     
     assert( addr.end == (addr.start - 4) );
   }
}

void ARMISS_stru::STM1()
{
     ARM_type4_stru&  tmp = ARM_type4 ;
     long             t   = tmp.reg_list;
     bit32_stru       regs;
     addr_stru        addr;

    if( executable() )
    {
     regs = t;
     addr = Addressing_mod4();
     for( int i=0; i<=15; i++)
        if( regs[i] == 1 )
       {
             if( i == 15 ) { data = getregd(i) + 8;}
             else          data = getregd(i);
             (*pmemfun)(addr.start,&data,true,2,&abort);
              if( abort ) data_abt = true;
              addr.start = addr.start + 4;
         }    
     assert( addr.end == (addr.start - 4) );
   }
}

void ARMISS_stru::STM2()
{
        ARM_type4_stru&  tmp = ARM_type4 ;
     long             t   = tmp.reg_list;
     bit32_stru       regs;
     addr_stru        addr;

    if( executable() )
    {
     regs = t;
     addr = Addressing_mod4();
     for( int i=0; i<=15; i++)
        if( regs[i] == 1 )
       {
             if( i == 15 ) { data = r_gen[i] + 8;}
             else          data = r_gen[i];
             (*pmemfun)(addr.start,&data,true,2,&abort);
             if( abort ) data_abt = true;
              addr.start = addr.start + 4;
         }    
     assert( addr.end == (addr.start - 4) );
   }
}   
  
void ARMISS_stru::MLA()
{
     ARM_type0_stru&       tmp = ARM_type0;
     UNL&                  rd  = getreg(tmp.mul_ext.Rd1);
     UNL                   rn  = getregd(tmp.mul_ext.Rn1);
     UNL                   rs  = getregd(tmp.mul_ext.Rs);
     UNL                   rm  = getregd(tmp.mul_ext.Rm);
     bit32_stru            bit;

     if( tmp.mul_ext.Rn1 == 15 ) rn = rn + 8;
     if( tmp.mul_ext.Rm == 15 ) rm = rm + 8;
     if( tmp.mul_ext.Rs == 15 ) rs = rs + 8;
     rd  = (rm * rs + rn);
     bit = rd;
     if( tmp.mul_ext.S1 == 1 )
      {
           CPSR.N = bit[31];
           CPSR.Z = (rd == 0)? 1:0;
      }
     if( tmp.mul_ext.Rd1 == 15 ) pc_changed = true;
    
} 



void ARMISS_stru::MUL()
{
     ARM_type0_stru&   tmp = ARM_type0;
     UNL&              rd  = getreg(tmp.mul_ext.Rd1);
     UNL               rs  = getregd(tmp.mul_ext.Rs);
     UNL               rm  = getregd(tmp.mul_ext.Rm);
     bit32_stru        bit;

   
     if( tmp.mul_ext.Rs == 15 ) rs = rs + 8;
     if( tmp.mul_ext.Rm == 15 ) rm = rm + 8;
     rd  = rm * rs;
     bit = rd;
     if( tmp.mul_ext.S1 == 1 )
      {
           CPSR.N = bit[31];
           CPSR.Z = (rd == 0)? 1:0;
      }
    if( tmp.mul_ext.Rd1 == 15 ) pc_changed = true;    
}

void ARMISS_stru::SMLAL()
{
     ARM_type0_stru       tmp  = ARM_type0;
     UNL&                 rdlo = getreg( tmp.mul_ext.Rdlo );
     UNL&                 rdhi = getreg( tmp.mul_ext.Rdhi );
     UNL                  rs   = getregd( tmp.mul_ext.Rs );
     UNL                  rm   = getregd( tmp.mul_ext.Rm );
     bit32_stru           bit;
     long long            rst1 = 1,rst2=0;

     if( tmp.mul_ext.Rs == 15 ) rs   = rs   + 8;
     if( tmp.mul_ext.Rm == 15 ) rm   = rm   + 8;
     if( tmp.mul_ext.Rdlo == 15 ) rdlo = rdlo + 8;
     if( tmp.mul_ext.Rdhi == 15 ) rdhi = rdhi + 8;
     rst1 = rst1 * rs * rm ;
     rst2 = rst2 + rst1 + rdlo;
     rdlo = rdlo + rst1;
     if( rst2 > (unsigned)0xffffffff )
         rdhi = rdhi + (rst1 >> 32) + 1;
     else
         rdhi = rdhi + (rst1 >> 32);
     

     if( tmp.mul_ext.S1 == 1 )
       {
             bit = rdhi;
             CPSR.N = bit[31];
             if( (rdlo == 0) && (rdhi == 0) )
                     CPSR.Z = 0;
             else
                     CPSR.Z = 1;
       }
     if( (tmp.mul_ext.Rdlo == 15) || (tmp.mul_ext.Rdhi == 15) )
          pc_changed = true;
}

void ARMISS_stru::SMULL()
{
     ARM_type0_stru&  tmp  = ARM_type0;
     UNL                  rs   = getregd( tmp.mul_ext.Rs );
     UNL                  rm   = getregd( tmp.mul_ext.Rm );
     UNL&                 rdhi = getreg( tmp.mul_ext.Rdhi );
     UNL&                 rdlo = getreg( tmp.mul_ext.Rdlo );
     bit32_stru           bit;
     long long            rst  = 1;

     if( tmp.mul_ext.Rs == 15 ) rs   = rs   + 8;
     if( tmp.mul_ext.Rm == 15 ) rm   = rm   + 8;
     
     rst  = rst * rm * rs;