common_iacxl10_2004_3_16.cpp

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

#include "common_IAcxl10_2004_3_16.h"
#include <string.h>
#include <iostream.h>

void bit_stru::operator =(int t)
{
        b = t;
}

bit_stru::operator unsigned()
{
        return b;
}

bit_stru& bit32_stru::operator[](int index)
{
     return bits[index];
}

void bit32_stru::operator = (long t)
{
      for(int i=0;i<32;i++)
          bits[i] = t >> i;
}

bit32_stru::operator long()
{
        long t = 0;
        
        for( int i=0;i<32;i++)
            {
                 t = t << 1;
                 t = t + bits[31-i];
            }
       
        return t;
}

void bit32_stru::rotate(int mount)
{
        int t;

        for(int i=0; i<mount; i++)
            {
                  t = bits[0];
                  for( int j=0; j<32; j++)
                      bits[j] = bits[j+1];
                  bits[31] = t;
             }
} //将数据bits循环移mount位，在程序设计中凡是需要循环移位的地方均可以采用定义一个32位的变量，然后
//将要移位的数据赋给这个位变量，在循环移位后再将其值赋回给变量； 

int bit32_stru::operator + (bit32_stru a )
{
      bit32_stru c;
      int i;
   
      for(i=0;i<32;i++)
      {
            if( i==0 )
                c.bits[i] =bits[i]&a.bits[i];
            else
                c.bits[i] =bits[i]&a.bits[i] | bits[i]&c.bits[i-1] | a.bits[i]&c.bits[i-1];
           
     }
        return ( c.bits[31] );
} //进行两个32位数据间的加法操作；


void CPSR_stru::operator = (UNL status)
{
         M   = status;
         T   = status >> 5;
         F   = status >> 6;
         I   = status >> 7;
         DNM = status >> 8;
         Q   = status >> 27;
         V   = status >> 28;
         C   = status >> 29;
         Z   = status >> 30;
         N   = status >> 31;
}

CPSR_stru::operator UNL ()
{
      UNL  rst;
      
      rst = N;
      rst = rst << 1;
      rst = rst + Z;
      rst = rst << 1;
      rst = rst + C;
      rst = rst << 1;
      rst = rst + V;
      rst = rst << 1;
      rst = rst + Q;
      rst = rst << 19;
      rst = rst + DNM;
      rst = rst << 1;
      rst = rst + I;
      rst = rst << 1;
      rst = rst + F;
      rst = rst << 1;
      rst = rst + T;
      rst = rst << 5;
      rst = rst + M;

      return rst ;
}

void common_dec_stru::operator = (UNL instruct)
{
     
       mcoder = instruct >> 25;
       flags  = instruct >> 28;
}

void miscell_stru::operator = (UNL instr)
{
       SBZ1     = instr;
       b7       = instr >> 4;
       SBZ2     = instr >> 8;
       Rd1      = instr >> 12;
       SBO1     = instr >> 16;
       b21      = instr >> 21;
       R        = instr >> 22;
       Rm       = instr;
       SBO2     = instr >> 12;
       mask     = instr >> 16;
       SBO3     = instr >> 8;
       Rn1      = instr >> 16;
       op       = instr >> 21;
       imm1     = instr;
       imm2     = instr >> 8;
       Rs       = instr >> 8;
       Rn2      = instr >> 12;
       Rd2      = instr >> 16;
}

void mul_ext_stru::operator = (UNL instr)
{
       Rm         = instr;
       b7         = instr >> 4;
       Rs         = instr >> 8;
       Rn1        = instr >> 12;
       Rd1        = instr >> 16;
       S1         = instr >> 20;
       A          = instr >> 21;
       b23        = instr >> 23;
       b24        = instr >> 24;
       Rdlo       = instr >> 12;
       Rdhi       = instr >> 16;
       U1         = instr >> 22;
       SBZ        = instr >> 8;
       Rd2        = instr >> 12;
       Rn2        = instr >> 16;
       B          = instr >> 22;
       L          = instr >> 20;
       W          = instr >> 21;
       b22        = instr >> 22;
       U2         = instr >> 23;
       P          = instr >> 24;
       Loffset    = instr;
       Hioffset   = instr >> 8;
       S2         = instr >> 5;
       H          = instr >> 5;
}//可以看出通过重载运算符＝可以得到属于该类结构的指令的所有位的信息，以便于译码；
      

void ARM_type0_stru::operator = (UNL instr)
{
       Rm          = instr;
       b4          = instr >> 4;
       shift       = instr >> 5;
       shiftm      = instr >> 7;
       Rd          = instr >> 12;
       Rn          = instr >> 16;
       S           = instr >> 20;
       opcode      = instr >> 21;
       b7          = instr >> 7;
       Rs          = instr >> 8;
       mis         = instr;
       mul_ext     = instr;
}

void ARM_type1_stru::operator = (UNL instr)
{
       imm    = instr;
       rotate = instr >> 8;
       Rd     = instr >> 12;
       Rn     = instr >> 16;
       S      = instr >> 20;
       opcode = instr >> 21;
       SBO    = instr >> 12;
       mask   = instr >> 16;
       b21    = instr >> 20;
       R      = instr >> 22;
       b24    = instr >> 23;
} 

void ARM_type2_stru::operator =(UNL instr)
{
      imm = instr;
      Rd  = instr >> 12;
      Rn  = instr >> 16;
      L   = instr >> 20;
      W   = instr >> 21;
      B   = instr >> 22;
      U   = instr >> 23;
      P   = instr >> 24;
}
      

void ARM_type3_stru::operator =(UNL instr)
{
       Rm     = instr;
       b4     = instr >> 4;
       shift  = instr >> 5;
       shiftm = instr >> 7;
       Rd     = instr >> 12;
       Rn     = instr >> 16;
       L      = instr >> 20;
       W      = instr >> 21;
       B      = instr >> 22;
       U      = instr >> 23;
       P      = instr >> 24;
}

ARM_type3_stru::operator UNL()
{
   UNL   value;

   value = P;
   value = (value << 1) + U ;
   value = (value << 1) + B;
   value = (value << 1) + W;
   value = (value << 1) + L;
   value = (value << 4) + Rn;
   value = (value << 4) + Rd;
   value = (value << 5) + shiftm;
   value = (value << 2) + shift;
   value = (value << 1) + b4;
   value = (value << 4) + Rm;

   return value; 
}
      
      
void ARM_type4_stru::operator = (UNL instr)
{
       reg_list = instr;
       Rn       = instr >> 16;
       L        = instr >> 20;
       W        = instr >> 21;
       S        = instr >> 22;
       U        = instr >> 23;
       P        = instr >> 24;
}
 

void ARM_type5_stru::operator = (UNL instr)
{
      offset = instr;
      L      = instr >> 24;
      H      = instr >> 24;
} 

void ARM_type6_stru::operator = (UNL instr)
{
     offset  = instr;
     cp_num  = instr >> 8;
     cRd     = instr >> 12;
     Rn      = instr >> 16;
     L       = instr >> 20;
     W       = instr >> 21;
     N       = instr >> 22;
     U       = instr >> 23;
     P       = instr >> 24;
}


void ARM_type7_stru::operator = (UNL instr)
{
      CRm        = instr;
      b4         = instr >> 4;
      opcode2    = instr >> 5;
      cp_num     = instr >> 8;
      cRd        = instr >> 12;
      cRn        = instr >> 16;
      opcode11   = instr >> 20;
      Rd         = instr >> 12;
      L          = instr >> 20;
      opcode12   = instr >> 21;
      swinum     = instr;
      b24        = instr >> 24;
      
}


void result_stru::reset()
{
      index     = -1;
      address   = -1;
}




str_stru::str_stru(char* t)
{
         int i;  
       
         data = new char[100];
         for(i=0;i<strlen(t);i++)
              data[i] = t[i];
         data[i] = '\0';
}

str_stru::operator char* ()
{
         return data;
}

void str_stru::operator =(char* t)
{
         int i;

         for(i=0;i<strlen(t);i++)
              data[i] = t[i];
         data[i] = '\0';
}

void str_stru::operator +(char* t)
{
         int len,i;

         len = strlen(data);
         for(i=len;i<len+strlen(t);i++)
               data[i] = t[i-len];
         data[i] = '\0';
        
}



int count1(long t)
{
    bit32_stru  bit;
    int         i=0;
    
    bit = t;
    for(int j=0;j<32;j++)
        if( bit[j] == 1 )
             i++;

    return i;
}

void instruct_reg_stru::operator = (UNL instr)
{
     instruct = instr;
     valid    = true;
}

instruct_reg_stru::operator UNL ()
{
     return instruct;
}

void instruct_reg_stru::operator = (bool valid_)
{
     valid = valid_;
}



oper_info_stru::operator long ()
{
     return data;
}

void oper_info_stru::operator = (long data_)
{
      data = data_;
}

shifter_oper_info_stru::operator long ()
{
      return data;
}

void shifter_oper_info_stru::operator = (long data_)
{
      data = data_;
}

void Thu_common_stru::operator = (UNL instr)
{
      mcoder = instr >> 13;
}

Thu_common_stru::operator UNL()
{
      return mcoder;
}

void Thu_type1_stru::operator = (UNL instr)
{
      Rd     = instr;
      Rn     = Rm1 = instr >> 3;
      imm1   = instr >> 6;
      Rm2    = imm2 = instr >> 6;
      opc    = instr >> 9;
      b10    = instr >> 10;
      opcode = instr >> 11;
}
      
void Thu_type2_stru::operator = (UNL instr)
{
      imm    = instr;
      Rd_Rn  = instr >> 8;
      opcode = instr >> 11;
}

void Thu_type3_stru::operator = (UNL instr)
{
      Rd_Rn    = instr;
      Rm_Rs    = instr >> 3;
      opcode1  = instr >> 6;
      b3       = instr >> 10;
      Rm1      = instr >> 3;
      H2       = instr >> 6;
      H1       = instr >> 7;
      opcode2  = instr >> 8;
      SBZ      = instr;
      L        = instr >> 7;
      PC_R_OFF = instr;
      Rd1      = instr >> 8;
      Rd2      = instr;
      Rn       = instr >> 3;
      Rm2      = instr >> 6;
      opcode3  = instr >> 9;
}

void Thu_type4_stru::operator =(UNL instr)
{
      Rd     = instr;
      Rn     = instr >> 3;
      offset = instr >> 6;
      L      = instr >> 11;
      B      = instr >> 12;
}

void Thu_type5_stru::operator = (UNL instr)
{
      Rd1      = instr;
      Rn       = instr >> 3;
      offset   = instr >> 6;
      L        = instr >> 11;
      b12      = instr >> 12;
      SP_R_OFF = instr;
      Rd2      = instr >> 8;
}

void Thu_oth_stru::operator = (UNL instr)
{
      imm1     = instr;
      opc      = instr >> 7;
      b4       = instr >> 8;
      reg_list = instr;
      R        = instr >> 8;
      L        = instr >> 11;
      imm2     = instr;
}

void Thu_type6_stru::operator = (UNL instr)
{
      imm  = instr;
      Rd   = instr >> 8;
      SP   = instr >> 11;
      b12  = instr >> 12;
      oth  = instr;
}

void Thu_type7_stru::operator = (UNL instr)
{
      reg_list = instr;
      Rn       = instr >> 8;
      L        = instr >> 11;
      b12      = instr >> 12;
      offset   = instr;
      cond     = instr >> 8;
      undef    = instr;
      oth      = instr >> 8;
      imm      = instr;
}

void Thu_type8_stru::operator =(UNL instr)
{
      offset1 = instr;
      bh      = instr >> 11;
      b0      = instr;
      offset2 = instr >> 1;
}