func_command.c

linux上实现的多种型号的AVR模拟器

  /* set bit, it means that field's value will be update */
  mem_file_changed[list_commands[pc].arg1/8]|=1<<list_commands[pc].arg1%8;
  
  pc++;
  clocks++;
}

void lds_command(void)
{
  if(list_commands[pc].arg2<controllers[type_micro].size_gpr+
     controllers[type_micro].size_io_reg+controllers[type_micro].size_sram)
     gpr_pointer[list_commands[pc].arg1]=gpr_pointer[list_commands[pc].arg2];
  else fprintf(stderr,"Error: argument don't point to data memory\n");

  /* set bit, it means that field's value will be update */
  mem_file_changed[list_commands[pc].arg1/8]|=1<<list_commands[pc].arg1%8;

  pc+=2;
  clocks+=2;
}

void lpm_command(void)
{
  int address;
  uint16_t code;
  
  address=gpr_pointer[30];
  address+=gpr_pointer[31]<<8;
  
  code=list_commands[address>>1].code;

  if(address&1) gpr_pointer[0]=code>>8;
  else gpr_pointer[0]=code;

  /* set bit, it means that field's value will be update */
  mem_file_changed[0]|=1;

  pc++;
  clocks+=3;
}

void lpm_z_command(void)
{
  int address;
  uint16_t code;
  
  address=gpr_pointer[30];
  address+=gpr_pointer[31]<<8;
  
  code=list_commands[address>>1].code;

  if(address&1) gpr_pointer[list_commands[pc].arg1]=code>>8;
  else gpr_pointer[list_commands[pc].arg1]=code;

  /* set bit, it means that field's value will be update */
  mem_file_changed[list_commands[pc].arg1/8]|=1<<list_commands[pc].arg1%8;

  pc++;
  clocks+=3;
}

void lpm_z_plus_command(void)
{
  int address;
  uint16_t code;
  
  address=gpr_pointer[30];
  address+=gpr_pointer[31]<<8;
  
  code=list_commands[address>>1].code;

  if(address&1) gpr_pointer[list_commands[pc].arg1]=code>>8;
  else gpr_pointer[list_commands[pc].arg1]=code;

  address ++;
  gpr_pointer[30]=(uint8_t)address;
  gpr_pointer[31]=(uint8_t)(address>>8);

  /* set bit, it means that field's value will be update */
  mem_file_changed[list_commands[pc].arg1/8]|=1<<list_commands[pc].arg1%8;
  mem_file_changed[30/8]|=(1<<30%8)|(1<<31%8);

  pc++;
  clocks+=3;
}

void lsr_command(void)
{
  /* check Flag C */
  if(gpr_pointer[list_commands[pc].arg1]&0x1) set_sreg_flag(FLAG_C);
  else clear_sreg_flag(FLAG_C);

  gpr_pointer[list_commands[pc].arg1]=gpr_pointer[list_commands[pc].arg1]>>1;

  /* set bit, it means that field's value will be update */
  mem_file_changed[list_commands[pc].arg1/8]|=1<<list_commands[pc].arg1%8;

  /* check Flag Z */
  if(gpr_pointer[list_commands[pc].arg1]==0) set_sreg_flag(FLAG_Z);
  else clear_sreg_flag(FLAG_Z);
  
  clear_sreg_flag(FLAG_N);

  /* check flag V */
  if(get_sreg_flag(FLAG_N)^get_sreg_flag(FLAG_C)) set_sreg_flag(FLAG_V);
  else clear_sreg_flag(FLAG_V);
  
  /* check flag S */
  if(get_sreg_flag(FLAG_N)^get_sreg_flag(FLAG_V)) set_sreg_flag(FLAG_S);
  else clear_sreg_flag(FLAG_S);

  pc++;
  clocks++;
}

void mov_command(void)
{
  gpr_pointer[list_commands[pc].arg1]=gpr_pointer[list_commands[pc].arg2];

  /* set bit, it means that field's value will be update */
  mem_file_changed[list_commands[pc].arg1/8]|=1<<list_commands[pc].arg1%8;

  pc++;
  clocks++;  
}

void movw_command(void)
{
  gpr_pointer[list_commands[pc].arg1]=gpr_pointer[list_commands[pc].arg2];
  gpr_pointer[list_commands[pc].arg1+1]=gpr_pointer[list_commands[pc].arg2+1];

  /* set bit, it means that field's value will be update */
  mem_file_changed[list_commands[pc].arg1/8]|=1<<list_commands[pc].arg1%8;
  mem_file_changed[(list_commands[pc].arg1+1)/8]|=
    1<<(list_commands[pc].arg1+1)%8;
  pc++;
  clocks++;
}

void mul_command(void)
{
  uint16_t result;

  result=gpr_pointer[list_commands[pc].arg1]*
    gpr_pointer[list_commands[pc].arg2];
  gpr_pointer[0]=(uint8_t)result;
  gpr_pointer[1]=(uint8_t)(result>>8);

  /* set bit, it means that field's value will be update */
  mem_file_changed[0]|=0x03;
  
  /* check Flag Z */
  if(!result) set_sreg_flag(FLAG_Z);
  else clear_sreg_flag(FLAG_Z);
   
  /* check Flag C*/
  if(result&0x8000) set_sreg_flag(FLAG_C);
  else clear_sreg_flag(FLAG_C); 
  
  pc++;
  clocks+=2;
}

void muls_command(void)
{
  int16_t result;
  
  result=((int8_t)gpr_pointer[list_commands[pc].arg1])*
    ((int8_t)gpr_pointer[list_commands[pc].arg2]);
  gpr_pointer[0]=(uint8_t)result;
  gpr_pointer[1]=(uint8_t)(result>>8);

  /* set bit, it means that field's value will be update */
  mem_file_changed[0]|=0x03;
  
  /* check Flag Z */
  if(!result) set_sreg_flag(FLAG_Z);
  else clear_sreg_flag(FLAG_Z);
    
  /* check Flag C*/
  if(result&0x8000) set_sreg_flag(FLAG_C);
  else clear_sreg_flag(FLAG_C);
  
  pc++;
  clocks+=2;
}

void mulsu_command(void)
{
  int16_t result;
  
  result=((int8_t)gpr_pointer[list_commands[pc].arg1])*
    (gpr_pointer[list_commands[pc].arg2]);
  gpr_pointer[0]=(uint8_t)result;
  gpr_pointer[1]=(uint8_t)(result>>8);

  /* set bit, it means that field's value will be update */
  mem_file_changed[0]|=0x03;
  
  /* check Flag Z */
  if(!result) set_sreg_flag(FLAG_Z);
  else clear_sreg_flag(FLAG_Z);

  /* check Flag C*/
  if(result&0x8000) set_sreg_flag(FLAG_C);
  else clear_sreg_flag(FLAG_C);
  
  pc++;
  clocks+=2;
}

void neg_command(void)
{
  uint8_t old;
  
  old=gpr_pointer[list_commands[pc].arg1];
  gpr_pointer[list_commands[pc].arg1]=0-old;

  /* set bit, it means that field's value will be update */
  mem_file_changed[list_commands[pc].arg1/8]|=1<<list_commands[pc].arg1%8;
  
  /* check Flag C */
  if(gpr_pointer[list_commands[pc].arg1]) set_sreg_flag(FLAG_C);
  else clear_sreg_flag(FLAG_C);
  
  check_Z_N_flags(gpr_pointer[list_commands[pc].arg1]);

  /* check Flag V */
  if(gpr_pointer[list_commands[pc].arg1]==0x80) set_sreg_flag(FLAG_V);
  else clear_sreg_flag(FLAG_V);

  /* check flag S */
  if(get_sreg_flag(FLAG_N)^get_sreg_flag(FLAG_V)) set_sreg_flag(FLAG_S);
  else clear_sreg_flag(FLAG_S);

  /* check Flag H */
  if((old&0x08)!=(gpr_pointer[list_commands[pc].arg1]&0x08))
    set_sreg_flag(FLAG_H);
  else clear_sreg_flag(FLAG_H);

  pc++;
  clocks++; 
}

void nop_command(void)
{
  pc++;
  clocks++;
}

void or_command(void)
{
  gpr_pointer[list_commands[pc].arg1]|=gpr_pointer[list_commands[pc].arg2];
  
  /* set bit, it means that field's value will be update */
  mem_file_changed[list_commands[pc].arg1/8]|=1<<list_commands[pc].arg1%8;

  check_Z_N_flags(gpr_pointer[list_commands[pc].arg1]);

  clear_sreg_flag(FLAG_V);

  /* check flag S */
  if(get_sreg_flag(FLAG_N)^get_sreg_flag(FLAG_V)) set_sreg_flag(FLAG_S);
  else clear_sreg_flag(FLAG_S);
  
  pc++;
  clocks++;
}

void ori_command(void)
{
  gpr_pointer[list_commands[pc].arg1]=gpr_pointer[list_commands[pc].arg1]|
    list_commands[pc].arg2;

  /* set bit, it means that field's value will be update */
  mem_file_changed[list_commands[pc].arg1/8]|=1<<list_commands[pc].arg1%8;
  
  check_Z_N_flags(gpr_pointer[list_commands[pc].arg1]);

  clear_sreg_flag(FLAG_V);

  /* check flag S */
  if(get_sreg_flag(FLAG_N)^get_sreg_flag(FLAG_V)) set_sreg_flag(FLAG_S);
  else clear_sreg_flag(FLAG_S);
  
  pc++;
  clocks++;
}

void out_command(void)
{
  int n,address;
  IO_port *port=NULL;
  
  
  for(n=0;controllers[type_micro].io_registers[n].code!=-1;n++)
    if(list_commands[pc].arg1==controllers[type_micro].io_registers[n].address)
      {port=&controllers[type_micro].io_registers[n];break;}

  if(port==NULL)
    {
      fprintf(stderr,"Port not defined, address: 0x%X\n",
	      list_commands[pc].arg1);
      pc++;
      clocks++;
      return;
    }

  for(n=0;port16_wr[n].code!=-1;n++)
    if(port16_wr[n].code==port->code) break;
  
  if(port16_wr[n].code==-1)
    {
      io_pointer[list_commands[pc].arg1]=gpr_pointer[list_commands[pc].arg2]&
	port->write_mask;
      address=list_commands[pc].arg1+controllers[type_micro].size_gpr;
      mem_file_changed[address/8]=1<<address%8;
    }
  else
    {
      switch(port16_wr[n].type){
      case LOW:
	set_port16(port16_wr[n].code,port16_wr[n-1].code,
		   gpr_pointer[list_commands[pc].arg2]|*port16_wr[n].temp<<8);
	break;
      case HIGH: *port16_wr[n].temp=gpr_pointer[list_commands[pc].arg2];
      }
    }
  pc++;
  clocks++;
}

void pop_command(void)
{
  uint16_t sp;
  
  if(!type_micro)
    {
      puts("This command doesn't support by this device.");
      return;
    } 
  if(ISPORT(SPH)) sp=get_port16(SPL,SPH);
  else sp=get_port(SPL);
  /*  if(sp<0) {fprintf(stderr,"Error: Stack Pointer not set\n");} */
  sp++;
  gpr_pointer[list_commands[pc].arg1]=gpr_pointer[sp];
  if(ISPORT(SPH)) set_port16(SPL,SPH,sp);
  else set_port(SPL,sp);  

  mem_file_changed[list_commands[pc].arg1/8]|=1<<list_commands[pc].arg1%8;

  pc++;
  clocks+=2;
}

void push_command(void)
{
  uint16_t sp;
  
  if(!type_micro)
    {
      puts("This command doesn't support by this device.");
      return;
    } 
  if(ISPORT(SPH)) sp=get_port16(SPL,SPH);
  else sp=get_port(SPL);
  if(sp<1) {fprintf(stderr,"Error: Stack Pointer not set\n");}
  gpr_pointer[sp]=gpr_pointer[list_commands[pc].arg1];
  sp--;
  if(ISPORT(SPH)) set_port16(SPL,SPH,sp);
  else set_port(SPL,sp);  
  mem_file_changed[sp/8]|=1<<sp%8;

  pc++;
  clocks+=2;
}

void rcall_command(void)
{
  uint16_t sp;
  
  if(type_micro==0)
    {
      stack_90s1200[2]=stack_90s1200[1];
      stack_90s1200[1]=stack_90s1200[0];
      stack_90s1200[0]=pc+1;
    }
  else
    {
      if(ISPORT(SPH)) sp=get_port16(SPL,SPH);
      else sp=get_port(SPL);
      if(sp<2) {fprintf(stderr,"Error: Stack Pointer not set\n");}
      pc++;
      gpr_pointer[sp]=(uint8_t)(pc>>8);
      mem_file_changed[sp/8]|=1<<sp%8;
      sp--;
      gpr_pointer[sp]=(uint8_t)pc;
      mem_file_changed[sp/8]|=1<<sp%8;
      sp--;
      if(ISPORT(SPH)) set_port16(SPL,SPH,sp);
      else set_port(SPL,sp);       
    }
  pc+=list_commands[pc].arg1+1;
  clocks+=3;
}

/* need to change for work on 22 bit PC */
void ret_command(void)
{
  uint16_t sp;

  if(type_micro==0)
    {
      pc=stack_90s1200[0];
      stack_90s1200[0]=stack_90s1200[1];
      stack_90s1200[1]=stack_90s1200[2];
    }
  else
    {
      if(ISPORT(SPH)) sp=get_port16(SPL,SPH);
      else sp=get_port(SPL);
 /*       if(sp<2) {fprintf(stderr,"Error: Stack Pointer not set\n");} */
      sp++;
      pc=gpr_pointer[sp];
      sp++;
      pc+=gpr_pointer[sp]<<8;
      if(ISPORT(SPH)) set_port16(SPL,SPH,sp);
      else set_port(SPL,sp);       
    }
  clocks+=4;
}

void reti_command(void)
{
  ret_command();
  set_sreg_flag(FLAG_I);
}

void rjmp_command(void)
{
  pc=list_commands[pc].arg1+pc+1;
  clocks+=2;
}

void ror_command(void)
{
  int flag;

  flag=get_sreg_flag(FLAG_C);
  if(gpr_pointer[list_commands[pc].arg1]&0x01) set_sreg_flag(FLAG_C);
  else clear_sreg_flag(FLAG_C);
    
  gpr_pointer[list_commands[pc].arg1]=gpr_pointer[list_commands[pc].arg1]>>1;

  /* set bit, it means that field's value will be update */
  mem_file_changed[list_commands[pc].arg1/8]|=1<<list_commands[pc].arg1%8;
  
  if(flag) gpr_pointer[list_commands[pc].arg1]|=0x80;
  else gpr_pointer[list_commands[pc].arg1]&=0x7F;
  pc++;
  clocks++;
}

void sbc_command(void)
{
  unsigned char arg1,arg2; 
  
  arg1=gpr_pointer[list_commands[pc].arg1];
  arg2=gpr_pointer[list_commands[pc].arg2];
  gpr_pointer[list_commands[pc].arg1]-=arg2;

  /* set bit, it means that field's value will be update */
  mem_file_changed[list_commands[pc].arg1/8]|=1<<list_commands[pc].arg1%8;

  if(get_sreg_flag(FLAG_C)) gpr_pointer[list_commands[pc].arg1]--;
 
  if(gpr_pointer[list_commands[pc].arg1]) clear_sreg_flag(FLAG_Z); 
  
  /* check flag C */
  if((~(arg1&0x80)&(arg2&0x80))|
     (~(arg1&0x80)&(gpr_pointer[list_commands[pc].arg1]&0x80))|
     ((gpr_pointer[list_commands[pc].arg1]&0x80)&(arg2&0x80)))
    set_sreg_flag(FLAG_C);
  else clear_sreg_flag(FLAG_C);  
  
  /* check flag N */
  if(gpr_pointer[list_commands[pc].arg1]&0x80)
    set_sreg_flag(FLAG_N);
  else clear_sreg_flag(FLAG_N);  
  
  /* check flag H */
  if((~(arg1&0x08)&(arg2&0x08))|
     ((arg2&0x08)&(gpr_pointer[list_commands[pc].arg1]&0x8))|
     ((gpr_pointer[list_commands[pc].arg1]&0x08)&(arg1&0x08)))
    set_sreg_flag(FLAG_H);
  else clear_sreg_flag(FLAG_H);