func_command.c

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

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

  mem_file_changed[30/8]|=(1<<30%8)|(1<<31%8);
  mem_file_changed[z/8]|=1<<z%8;
  pc++;
  clocks+=2;
}

void st_minus_z_command(void)
{
  
  uint16_t z;
  int n,size=controllers[type_micro].size_gpr+
    controllers[type_micro].size_io_reg+controllers[type_micro].size_sram;
  
  z=gpr_pointer[30];
  if(size>0xFF) z+=gpr_pointer[31]<<8;
  z--;

  if(z>size) {fprintf(stderr,"Error: Z points out of memory\n");return;}
  
  if(z<controllers[type_micro].size_gpr||
     (z>=controllers[type_micro].size_gpr+controllers[type_micro].size_io_reg))
    gpr_pointer[z]=gpr_pointer[list_commands[pc].arg2];
  else
    {
      z-=controllers[type_micro].size_gpr;
      for(n=0;controllers[type_micro].io_registers[n].code!=-1;n++)
	if(z==controllers[type_micro].io_registers[n].address)
	  {
	    io_pointer[z]=gpr_pointer[list_commands[pc].arg2]&
	      controllers[type_micro].io_registers[n].write_mask;
	    break;
	  }
      if(controllers[type_micro].io_registers[n].code==-1)
	fprintf(stderr,"Error: Port doesn't exist\n");
    }
  gpr_pointer[30]=(uint8_t)z;
  gpr_pointer[31]=(uint8_t)(z>>8);

  mem_file_changed[30/8]|=(1<<30%8)|(1<<31%8);
  mem_file_changed[z/8]|=1<<z%8;
  pc++;
  clocks+=2; 
}

void std_z_commad(void)
{
  uint16_t z;
  int n,size=controllers[type_micro].size_gpr+
    controllers[type_micro].size_io_reg+controllers[type_micro].size_sram;
  
  z=gpr_pointer[30];
  if(size>0xFF) z+=gpr_pointer[31]<<8;
  z+=list_commands[pc].arg1;

  if(z>size) {fprintf(stderr,"Error: Z points out of memory\n");return;}
  
  if(z<controllers[type_micro].size_gpr||
     (z>=controllers[type_micro].size_gpr+controllers[type_micro].size_io_reg))
    gpr_pointer[z]=gpr_pointer[list_commands[pc].arg2];
  else
    {
      z-=controllers[type_micro].size_gpr;
      for(n=0;controllers[type_micro].io_registers[n].code!=-1;n++)
	if(z==controllers[type_micro].io_registers[n].address)
	  {
	    io_pointer[z]=gpr_pointer[list_commands[pc].arg2]&
	      controllers[type_micro].io_registers[n].write_mask;
	    break;
	  }
      if(controllers[type_micro].io_registers[n].code==-1)
	fprintf(stderr,"Error: Port doesn't exist\n");
    }

  mem_file_changed[z/8]|=1<<z%8;
  pc++;
  clocks+=2;
}

void sts_command(void)
{
  uint16_t addr,n;

  addr=list_commands[pc].arg1;

  mem_file_changed[addr/8]|=1<<addr%8;

  if(addr<controllers[type_micro].size_gpr+
     controllers[type_micro].size_io_reg+controllers[type_micro].size_sram)
    {fprintf(stderr,"Error: out of memory\n");return;}

  if(addr<controllers[type_micro].size_gpr||
     (addr>=controllers[type_micro].size_gpr+
      controllers[type_micro].size_io_reg))
    gpr_pointer[addr]=gpr_pointer[list_commands[pc].arg2];
  else
    {
      addr-=controllers[type_micro].size_gpr;
      for(n=0;controllers[type_micro].io_registers[n].code!=-1;n++)
	if(addr==controllers[type_micro].io_registers[n].address)
	  {
	    io_pointer[addr]=gpr_pointer[list_commands[pc].arg2]&
	      controllers[type_micro].io_registers[n].write_mask;
	    break;
	  }
    }
  
  pc+=2;
  clocks+=2;  
}

void sub_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;
  
  mem_file_changed[list_commands[pc].arg1/8]|=1<<list_commands[pc].arg1%8;

  check_Z_N_flags(gpr_pointer[list_commands[pc].arg1]);
  
  /* check flag C */
  if((~(arg1&0x80)&(arg2&0x80))|
     ((arg2&0x80)&(gpr_pointer[list_commands[pc].arg1]&0x80))|
     ((gpr_pointer[list_commands[pc].arg1]&0x80)&~(arg1&0x80)))
    set_sreg_flag(FLAG_C);
  else clear_sreg_flag(FLAG_C);    

   /* 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);  

  /* check flag V */
  if(((arg1&0x80)&(~(arg2&0x80))&
      (~(gpr_pointer[list_commands[pc].arg1]&0x80)))|
     ((~(arg1&0x80))&(arg2&0x80)&(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);  

  pc++;
  clocks++;
}

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

  mem_file_changed[list_commands[pc].arg1/8]|=1<<list_commands[pc].arg1%8;
  
  check_Z_N_flags(gpr_pointer[list_commands[pc].arg1]);
  
  /* check flag C */
  if((~(arg1&0x80)&(arg2&0x80))|
     ((arg2&0x80)&(gpr_pointer[list_commands[pc].arg1]&0x80))|
     ((gpr_pointer[list_commands[pc].arg1]&0x80)&~(arg1&0x80)))
    set_sreg_flag(FLAG_C);
  else clear_sreg_flag(FLAG_C);

   /* 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);  

  /* check flag V */
  if(((arg1&0x80)&(~(arg2&0x80))&
      (~(gpr_pointer[list_commands[pc].arg1]&0x80)))|
     ((~(arg1&0x80))&(arg2&0x80)&(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);  
  pc++;
  clocks++;
}

void swap_command(void)
{
  
  gpr_pointer[list_commands[pc].arg1]=(gpr_pointer[list_commands[pc].arg1]<<4)+
    (gpr_pointer[list_commands[pc].arg1]>>4);

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

void wdr_command(void)
{
  watchdog_prescaler=0;
  clocks++;
  pc++;
}


int reg_d5(char * mnemocode,int command,int address)
/* 0000000d dddd0000 destantion  r0-r31*/
{

  command=(command&0x01F0)>>4;
  sprintf(&mnemocode[strlen(mnemocode)],"r%d",command);
  return command;
}

int reg_s5(char * mnemocode,int command,int address)
/* 000000d0 0000dddd source  r0-r31    */
{
  command=((command&0x0200)>>5)|(command&0x000F);
  sprintf(&mnemocode[strlen(mnemocode)],"r%d",command);
  return command;
} 

int const_6(char * mnemocode,int command,int address)
/* 00000000 dd00dddd const 0-63  */
{
  command=((command&0x00C0)>>2)|(command&0x000F);
  sprintf(&mnemocode[strlen(mnemocode)],"%Xh",command);
  return command;
}

int bit_sreg(char * mnemocode,int command,int address)
/* 00000000 0ddd0000  */
{
  char bit;

  command=(command&0x0070)>>4;
  switch(command)
    {
    case 7: bit='I'; break;
    case 6: bit='T'; break;
    case 5: bit='H'; break;
    case 4: bit='S'; break;
    case 3: bit='V'; break;
    case 2: bit='N'; break;
    case 1: bit='Z'; break;
    case 0: bit='C'; break;
    }
  sprintf(&mnemocode[strlen(mnemocode)],"'%c'",bit);
  return command;
}

int bit_sreg2(char * mnemocode,int command,int address)
/* 00000000 00000ddd bld         */
{
  char bit;

  command=command&7;
  switch(command)
    {
    case 7: bit='I'; break;
    case 6: bit='T'; break;
    case 5: bit='H'; break;
    case 4: bit='S'; break;
    case 3: bit='V'; break;
    case 2: bit='N'; break;
    case 1: bit='Z'; break;
    case 0: bit='C'; break;
    }
  sprintf(&mnemocode[strlen(mnemocode)],"'%c'",bit);
  return command;
}

int bit_num2(char * mnemocode,int command,int address)
/* 00000000 00000ddd 0-7         */
{

  command=command&7;
  sprintf(&mnemocode[strlen(mnemocode)],"%d",command);
  return command;
}

int reg_d4(char * mnemocode,int command,int address)
/* 00000000 dddd0000 destantion r16-r31 */
{
  command=((command&0x00F0)>>4)|0x0010;
  sprintf(&mnemocode[strlen(mnemocode)],"r%d",command);
  return command;
}

int reg_s4(char * mnemocode,int command,int address)
/* 00000000 0000dddd source r16-r31     */
{
  command=(command&0x000F)|0x0010;
  sprintf(&mnemocode[strlen(mnemocode)],"r%d",command);
  return command;
}

int reg_s3(char * mnemocode,int command,int address)
/* 00000000 00000ddd r16-r23      */
{
  command=(command&0x0007)+16;
  sprintf(&mnemocode[strlen(mnemocode)],"r%d",command);
  return command;
}

int reg_d3(char * mnemocode,int command,int address)
/* 00000000 0ddd0000 r16-r23      */
{
  command=((command&0x0070)>>4)+16;
  sprintf(&mnemocode[strlen(mnemocode)],"r%d",command);
  return command;
}

int none(char * mnemocode,int command,int address)
{
  return 0;
}

int none_last(char * mnemocode,int command,int address)
{
  mnemocode[strlen(mnemocode)-1]=0;
  return 0;
}

int addr_shift(char * mnemocode,int command,int address)
/* 000000dd ddddd000             */
{
  if(command&0x0200) command=((command&0x03F8)>>3)|(-1<<7);
  else command=(command&0x03F8)>>3;
  command+=address+1;
  sprintf(&mnemocode[strlen(mnemocode)],"%Xh",command);
  return command;
}

int port(char * mnemocode,int command,int address)
/* 00000000 ddddd000 port I/O low*/
{
  int n;
  IO_port *port=NULL;

  command=(command&0x00F8)>>3;
  
  for(n=0;controllers[type_micro].io_registers[n].code!=-1;n++)
    if(command==controllers[type_micro].io_registers[n].address)
      {port=&controllers[type_micro].io_registers[n];break;}
  
  if(port==NULL)
    sprintf(&mnemocode[strlen(mnemocode)],"%Xh",command);
  else strcat(mnemocode,descr_io_ports[port->code].name);
  return command;
}

int port_all(char * mnemocode,int command,int address)
/* 00000dd0 0000dddd port I/O all*/
{
  int n;
  IO_port *port=NULL;

  command=((command&0x0600)>>5)|(command&0x000F);
  
  for(n=0;controllers[type_micro].io_registers[n].code!=-1;n++)
    if(command==controllers[type_micro].io_registers[n].address)
      {port=&controllers[type_micro].io_registers[n];break;}
  
  if(port==NULL)
    sprintf(&mnemocode[strlen(mnemocode)],"%Xh",command);
  else strcat(mnemocode,descr_io_ports[port->code].name);
  return command;
}

unsigned char byte(char * mnemocode,int command,int address)
/* 0000dddd 0000dddd             */
{
  command=((command&0x0F00)>>4)|(command&0x000F);
  sprintf(&mnemocode[strlen(mnemocode)],"%Xh",command);
  return (unsigned char)command;
}

int indir_addr(char * mnemocode,int command,int address)
/* 00000000 000000dd X,X+,-X           */
{
  char c;
  switch(command&0x000C)
    {
    case 0xC: c='X'; break;
    case 0x8: c='Y'; break;
    case 0x0: c='Z'; break;
    case 0x4: c='Z'; break;
    }
  command=command&0x0003;
  switch(command)
    {
      case 0:sprintf(&mnemocode[strlen(mnemocode)],"%c",c);
      break;
      case 1:sprintf(&mnemocode[strlen(mnemocode)],"%c+",c);
      break;
      case 2:sprintf(&mnemocode[strlen(mnemocode)],"-%c",c);
      break;
    }
  return command;
}

int indir_shift(char * mnemocode,int command,int address)
/* 00d0dd00 00000ddd 0-63         */
{
  switch(command&0x0008)
    {
    case 8: sprintf(&mnemocode[strlen(mnemocode)],"Y+");break;
    case 0: sprintf(&mnemocode[strlen(mnemocode)],"Z+");break;
    }
  command=((command&0x2000)>>8)|((command&0x0C00)>>7)|(command&0x0007);
  sprintf(&mnemocode[strlen(mnemocode)],"%Xh",command);
  return command;
}

int addr_shift12(char *mnemocode,int command,int address)
/* 0000dddd dddddddd rcall,rjmp  */
{
  int buf,addr;

  if(command&0x0800) buf=command|(-1^0xFFF); 
  else buf=command&0x0FFF;
  /*printf("\ncom: %X\t%X\t%X\n",command,buf,address);*/ /* test line*/
  addr=buf+address+1;
  sprintf(&mnemocode[strlen(mnemocode)],"%Xh",addr);
  return buf;
}

int reg_d2(char * mnemocode,int command,int address)
/* 00000000 00dd0000 r24,r26,r28,r30 */
{
  command=((command&0x0030)>>3)+24;
  sprintf(&mnemocode[strlen(mnemocode)],"r%d",command);
  return command;
}

int put_z(char *mnemocode,int command,int address)
{
  sprintf(&mnemocode[strlen(mnemocode)],"Z");
  return 0;
}

int put_zplus(char *mnemocode,int command,int address)
{
  sprintf(&mnemocode[strlen(mnemocode)],"Z+");
  return 0;
}

int word_d(char *mnemocode,int command,int address)
/* 00000000 dddd0000 r0,r2,...,r30*/
{
  command=(command&0x00F0)>>3;
  sprintf(&mnemocode[strlen(mnemocode)],"r%d",command);
  return command;
}

int word_s(char *mnemocode,int command,int address)
/* 00000000 0000dddd r0,r2,...,r30*/
{
  command=(command&0x000F)<<1;
  sprintf(&mnemocode[strlen(mnemocode)],"r%d",command);
  return command;
}

int addr22(char *mnemocode,int command,int address)
/* use in long call and long jmp to get address */
{
  char buf[10];

  sprintf(buf,"%X",list_commands[address+1].code);
  fill_zero(buf,5);
  strcat(mnemocode,buf);
  return list_commands[address+1].code;
}

int word(char *mnemocode,int command,int address)
/* dddd dddd dddd dddd */
{
  char buf[10];

  sprintf(buf,"%X",command);
  fill_zero(buf,4);
  strcat(mnemocode,buf);
  return command;
}