// Main CPU file #pragma regalloc- #include #include #include "cpu.h" #include "actions.h" #include "delay.h" void print(char* str); #pragma regalloc- unsigned char instr[3]; unsigned char ind_addr; unsigned int ind_addr2; unsigned int addr_tmp; // for use in mem(addr) unsigned char counter = 0; //unsigned char mem[837+512]; #define SIZE_MODE 0 #define DATA_MODE 1 char rxcstate = SIZE_MODE; unsigned int rxc_size = 0; unsigned int num_rec = 0; unsigned char outputvar = 0; unsigned char getmem(unsigned int addr){ unsigned char data = 0x00; //delay_us(1); DDRA = 0x00; // set data lines to read //delay_us(1); PORTB = (unsigned char)((addr & 0xff00) >> 8); //PORTB.1 = 1; //delay_us(1); PORTC = (unsigned char)(addr & 0x00ff); //delay_us(1); PORTD.3 = 1; // set to read //delay_us(1); #asm("nop"); #asm("nop"); data = PINA; //delay_us(1); return data; } void setmem(unsigned int addr, unsigned char value){ DDRA = 0xff; // set data lines to write //delay_us(1); PORTB = (unsigned char)((addr & 0xff00) >> 8); //PORTB.1 = 1; //delay_us(1); PORTC = (unsigned char)(addr & 0x00ff); //delay_us(1); PORTA = value; //delay_us(1); PORTD.3 = 0; // set to write //delay_ms(1); PORTD.3 = 1; // set back to read (for video) //delay_us(1); DDRA = 0x00; // set data lines to read again //delay_us(1); } #define mem(addr) \ (\ addr_tmp = (addr), \ ((addr_tmp == 0xFFFF) ? report_error() : 0), \ getmem(addr_tmp)) // store value in memory at addr #define store_mem(value,addr) \ setmem(addr,value); int report_error(){ unsigned char sreg; unsigned int pc; sreg = mem(rSP + 1); pc = mem(rSP+2) | (((unsigned int)mem(rSP+3)) << 8); sprintf(temp_buffer, "E:\r" "PC: %x\t" "SP: %x\t" "A: %x\t" "X: %x\t" "Y: %x\t" "SR: %x\r", pc, rSP, rA, rX, rY, sreg); print(temp_buffer); while(1); return 0; } /*unsigned char getmem(unsigned int addr){ if(addr >= 0x1000) return mem[addr-0x1000+0x200]; else if(addr < 0x200) return mem[addr]; else{ sprintf(temp_buffer,"mem out of range\r"); print(temp_buffer); while(1); } }*/ /* unsigned char getmem(unsigned int addr){ unsigned char data = 0x00; DDRA = 0x00; // set data lines to read PORTB = (unsigned char)((addr & 0xff00) >> 8); PORTC = (unsigned char)(addr & 0x00ff); PORTD.3 = 1; // set to read PORTD.2 = 0; // mux control line #asm("nop"); #asm("nop"); data = PINA; PORTD.2 = 1; // restore control to video return data; } */ /* void setmem(unsigned int addr, unsigned char value){ DDRA = 0xff; // set data lines to write PORTB = (unsigned char)((addr & 0xff00) >> 8); PORTC = (unsigned char)(addr & 0x00ff); PORTA = value; //delay_ms(50); PORTD.2 = 0; // mux control line PORTD.3 = 0; // set to write //delay_us(1400); //delay_ms(10); PORTD.3 = 1; // set back to read (for video) DDRA = 0x00; // set data lines to read again PORTD.2 = 1; // restore control to video //delay_ms(1); } */ /*void setmem(unsigned int addr, unsigned char value){ if(addr >= 0x1000) mem[addr-0x1000+0x200] = value; else if(addr < 0x200) mem[addr] = value; else{ sprintf(temp_buffer,"mem out of range\r"); print(temp_buffer); while(1); } } */ // get value stored in memory at addr // operand = mem((unsigned int)mem((unsigned int)instr[1]) + rY) // This function prints string to serial; txc_interrupt takes over after first byte is written to UDR. // Two buffers are used, txc_read_buffer and txc_write_buffer, so that when data is being transmitted // out of txc_write_buffer, any new data that comes in can go into txc_read_buffer. void print(char* data){ sprintf(txc_read_buffer, "%s", data); //put data in read buffer if(trans_done){ //checks if there is data being transmitted before trying to transmit buffer_switch= txc_read_buffer; //swaps the read and write pointers, preparing the newly written to buffer to be transmitted txc_read_buffer = txc_write_buffer; txc_write_buffer = buffer_switch; UDR = txc_write_buffer[0]; //writes first byte in buffer to begin transmission UCSRB.5 = 1; //turns on transmit interrupt } else write_ready=1; //if the transmitter is currently running, it waits to begin new transmission } // When we want to receive from serial, the interrupt is turned on. When it triggers, it means // that there are data waiting to be read (from hyperterm), and this data is read in char by char into a buffer until // an enter key. The resulting string is then 0-terminated (to show it is complete) and // after setting a flag indicating receive done, the interrupt turns itself off so // anything coming in from the hyperterm before the system is ready again is ignored. interrupt [USART_RXC] void uart_rec(void) { unsigned long i; r_char = UDR; //PORTB = r_char; //echo //UDR = r_char+48; num_rec++; if(rxcstate == SIZE_MODE){ rxc_size += (unsigned int)r_char << ((num_rec-1)*4); if(num_rec == 4){ num_rec = 0; rxcstate = DATA_MODE; sprintf(temp_buffer,"Size set to: 0x%X\r",rxc_size); print(temp_buffer); } } else{ setmem(0x1000 + (unsigned int)(num_rec-1),r_char); /* DDRA = 0xff; PORTA = 0xff; UDR = mem(0x1000 + (num_rec-1));*/ /* UDR = (0x1000 + (unsigned int)(num_rec-1) & 0xff00) >> 8; delay_ms(5); UDR = 0x1000 + (unsigned int)(num_rec-1) & 0x00ff; delay_ms(5);*/ //UDR = mem(0x1000); // delay_ms(5); if(num_rec == rxc_size){ // UDR = mem(0x1000); /*for(i = 0x1000; i < 0x1400; i++){ sprintf(temp_buffer,"%X ",getmem(i)); print(temp_buffer); delay_ms(10); } */ rxc_done = 1; UCSRB.7 = 0; // disable interrupt //UDR = 'd'; } } /* if (r_char != '\n') //read until we get an enter rxc_buffer[r_index++] = r_char; else { rxc_buffer[r_index] = 0x00; rxc_done = 1; UCSRB.7 = 0; // disable this interrupt }*/ } // txc interrupt, handles all the usart transmit work after first byte is sent by print interrupt [USART_DRE] void txc_interrupt(void){ if(txc_write_buffer[buf_index]){ //checks if there is data left in the buffer to transmit trans_done = 0; //sets transdone flag low, indicating tansmission in progress UDR = txc_write_buffer[buf_index]; //writes one byte buf_index++; //advances buffer index } else { //this means there is no more data in the buffer to send trans_done = 1; //indicates transmission is over buf_index=1; //resets the buffer index if(write_ready){ //checks if another set of data is ready to be sent (in the read buffer) buffer_switch= txc_read_buffer; //swaps pointers, preparing new data for transmission txc_read_buffer = txc_write_buffer; txc_write_buffer = buffer_switch; write_ready = 0; //indicates the read buffer is no longer holding data waiting to be sent UDR = txc_write_buffer[0]; //writes first byte of new data to continue transmission } else{ UCSRB.5 = 0; //turns interrupt off if we don't need to transmit anything anymore } } } // This function resets and sets up the ISR-driven receive by enabling the usart rxc // interrupt, setting the r_index to 0 to overwrite the rxc_buffer, and clearing // the rxc_done flag. The usart_rxc interrupt will then handle all the receiving // that comes through. // This function should only be called during initialization or after each // received msg has been processed. void reset_rxc(void){ rxc_done=0; r_index=0; UCSRB.7=1; } // for 6502 instruction set with opcode aaabbbcc void init(){ unsigned long i; // initialize usart receive variables rxc_done = 0; r_index = 0; i = 0; // initialize usart transmit variables buf_index = 1; trans_done = 1; txc_write_buffer = txc_buffer2; txc_read_buffer = txc_buffer1; write_ready = 0; UBRRL = 103 ; //sets UART baud rate, using a 16 MHz crystal this is 9600 baud // initialize interrupts UCSRB = 0b00111000 ; // enables usart transmit and receive, and TXempty interrupt //TIMSK = 0b00000001; // enables timer0 overflow interrupts //TCCR0 = 0b00000001; // runs timer0 with no prescaling (so that timer0 overflows 62500 times / sec) reset_rxc(); // sets up usart_rxc ISR /*for(i = 0; i < 1024; i++){ mem[i] = 0; } */ DDRB = 0xff; // address output (high) DDRC = 0xff; // address output (low) DDRA = 0x00; // data DDRD = 0xff; // control lines #asm("sei"); sprintf(temp_buffer,"Hello!\r"); print(temp_buffer); delay_ms(10); /*DDRA = 0xff; DDRB = 0xff; DDRC = 0xff; PORTA = 0xff; PORTB = 0xff; PORTC = 0xff;*/ while(!rxc_done); /*for(i = 0x1000; i < 0x1400; i++){ sprintf(temp_buffer,"%X ",getmem(i)); print(temp_buffer); delay_ms(10); } */ // initialize registers #asm("ldi REG_TMP, 0"); #asm("ldi REG_TMP2, 0"); #asm("mov REG_SR, REG_TMP"); rA = 0; rX = 0; rY = 0; rIR = 0; rSP = 0xff; rPC = 0x100C; operand = 0; op_addr = 0; sprintf(temp_buffer,"Done loading program memory. rPC = 0x%X\r",rPC); print(temp_buffer); delay_ms(100); } //#pragma regalloc+ int main(){ init(); #asm("newinstr:"); //addr_tmp = instr[0]; //sprintf(temp_buffer,"Last Instr Executed = 0x%X\r\n",addr_tmp); //print(temp_buffer); //delay_ms(50); /*sprintf(temp_buffer,"%X\r",rPC+1); print(temp_buffer);*/ instr[0] = operand = mem(rPC); // we could reduce some overhead if we only read the next two bytes as necessary // to do this, we'd have to read the memory in the instruction code itself // this would work, and we should implement this if we have the time and need // at least for now, though, this is fine and works // I thought about caching them, but this would add several mega32 cycles, too. instr[1] = mem(rPC+1); instr[2] = mem(rPC+2); #asm("mov REG_OP, REG_SR"); sprintf(temp_buffer, "PC: %x\t" "SP: %x\t" "A: %x\t" "X: %x\t" "Y: %x\t" "SR: %x\t" "np: %x\t" "ot: %x\t" "op: %x\r", rPC, rSP, rA, rX, rY, operand, counter, outputvar, instr[0]); print(temp_buffer); delay_ms(100); operand = instr[0]; // jump table #asm ldi r31, 0 ;reset r31 mov r30, REG_OP ;r31:r30 = operand << 1 lsl r30 rol r31 ldi REG_TMP, low(jmptable) ;r30 = r30 + lowbyteOfjmptbl add r30, REG_TMP ldi REG_TMP, high(jmptable) ;r31 = r31 + hibyteOfjmptbl adc r31, REG_TMP ijmp ;jump to r31:r30 #endasm #asm("BRK:"); // PC incremented by 2 inside macro EX_BRK; #asm("jmp newinstr"); #asm("ORAXINDIRECT:"); XIND_SET; #asm("EX_OR ORAXINDIRECT1, ORAXINDIRECT2, ORAXINDIRECT3, ORAXINDIRECT4"); rPC = rPC + 2; #asm("jmp newinstr"); #asm("instr2:"); #asm("nop"); #asm("jmp newinstr"); #asm("instr3:"); #asm("nop"); #asm("jmp newinstr"); #asm("instr4:"); #asm("nop"); #asm("jmp newinstr"); #asm("ORAZP:"); ZP_SET; #asm("EX_OR ORAZP1, ORAZP2, ORAZP3, ORAZP4"); rPC = rPC + 2; #asm("jmp newinstr"); #asm("ASLZP:"); ZP_ADDR; operand = mem(op_addr); #asm("EX_ASL ASLZP1, ASLZP2, ASLZP3, ASLZP4, ASLZP5, ASLZP6"); store_mem(operand,op_addr); rPC = rPC + 2; #asm("jmp newinstr"); #asm("instr7:"); #asm("nop"); #asm("jmp newinstr"); #asm("PHP:"); EX_PHP; rPC += 1; #asm("jmp newinstr"); #asm("ORAIMM:"); IMM_SET; #asm("EX_OR ORAIMM1, ORAIMM2, ORAIMM3, ORAIMM4"); rPC = rPC + 2; #asm("jmp newinstr"); #asm("ASLACC:"); ACC_SET; #asm("EX_ASL ASLACC1, ASLACC2, ASLACC3, ASLACC4, ASLACC5, ASLACC6"); rA = operand; rPC = rPC + 1; #asm("jmp newinstr"); #asm("instrb:"); #asm("nop"); #asm("jmp newinstr"); #asm("instrc:"); #asm("nop"); #asm("jmp newinstr"); #asm("ORAABS:"); ABS_SET; #asm("EX_OR ORAABS1, ORAABS2, ORAABS3, ORAABS4"); rPC = rPC + 3; #asm("jmp newinstr"); #asm("ASLABS:"); ABS_ADDR; operand = mem(op_addr); #asm("EX_ASL ASLABS1, ASLABS2, ASLABS3, ASLABS4, ASLABS5, ASLABS6"); store_mem(operand,op_addr); rPC = rPC + 3; #asm("jmp newinstr"); #asm("instrf:"); #asm("nop"); #asm("jmp newinstr"); #asm("BPL:"); REL_ADDR; #asm("EX_BPL BPL1"); rPC += 2; #asm("jmp newinstr"); #asm("ORAINDIRECTY:"); INDY_SET; #asm("EX_OR ORAINDIRECTY1, ORAINDIRECTY2, ORAINDIRECTY3, ORAINDIRECTY4"); rPC = rPC + 2; #asm("jmp newinstr"); #asm("instr12:"); #asm("nop"); #asm("jmp newinstr"); #asm("instr13:"); #asm("nop"); #asm("jmp newinstr"); #asm("instr14:"); #asm("nop"); #asm("jmp newinstr"); #asm("ORAZPX:"); ZPX_SET; #asm("EX_OR ORAZPX1, ORAZPX2, ORAZPX3, ORAZPX4"); rPC = rPC + 2; #asm("jmp newinstr"); #asm("ASLZPX:"); ZPX_ADDR; operand = mem(op_addr); #asm("EX_ASL ASLZPX1, ASLZPX2, ASLZPX3, ASLZPX4, ASLZPX5, ASLZPX6"); store_mem(operand,op_addr); rPC = rPC + 2; #asm("jmp newinstr"); #asm("instr17:"); #asm("nop"); #asm("jmp newinstr"); #asm("_CLC:"); #asm("SET_SREG_BIT 0, ASR_CB"); rPC += 1; #asm("jmp newinstr"); #asm("ORAABSY:"); ABSY_SET; #asm("EX_OR ORAABSY1, ORAABSY2, ORAABSY3, ORAABSY4"); rPC = rPC + 3; #asm("jmp newinstr"); #asm("instr1a:"); #asm("nop"); #asm("jmp newinstr"); #asm("instr1b:"); #asm("nop"); #asm("jmp newinstr"); #asm("instr1c:"); #asm("nop"); #asm("jmp newinstr"); #asm("ORAABSX:"); ABSX_SET; #asm("EX_OR ORAABSX1, ORAABSX2, ORAABSX3, ORAABSX4"); rPC = rPC + 3; #asm("jmp newinstr"); #asm("ASLABSX:"); ABSX_ADDR; operand = mem(op_addr); #asm("EX_ASL ASLABSX1, ASLABSX2, ASLABSX3, ASLABSX4, ASLABSX5, ASLABSX6"); store_mem(operand,op_addr); rPC = rPC + 3; #asm("jmp newinstr"); #asm("instr1f:"); #asm("nop"); #asm("jmp newinstr"); #asm("JSRABS:"); ABS_ADDR; // PC incremented by 2 inside JSR, then by 1 at RTS EX_JSR; #asm("jmp newinstr"); #asm("ANDXINDIRECT:"); XIND_SET; #asm("EX_AND ANDXINDIRECT1, ANDXINDIRECT2, ANDXINDIRECT3, ANDXINDIRECT4"); rPC = rPC + 2; #asm("jmp newinstr"); #asm("instr22:"); #asm("nop"); #asm("jmp newinstr"); #asm("instr23:"); #asm("nop"); #asm("jmp newinstr"); #asm("BITZP:"); ZP_SET; #asm("EX_BIT BITZP1, BITZP2"); rPC += 2; #asm("jmp newinstr"); #asm("ANDZP:"); ZP_SET; #asm("EX_AND ANDZP1, ANDZP2, ANDZP3, ANDZP4"); rPC = rPC + 2; #asm("jmp newinstr"); #asm("ROLZP:"); ZP_ADDR; operand = mem(op_addr); #asm("EX_ROL ROLZP1, ROLZP2, ROLZP3, ROLZP4, ROLZP5, ROLZP6"); store_mem(operand,op_addr); rPC = rPC + 2; #asm("jmp newinstr"); #asm("instr27:"); #asm("nop"); #asm("jmp newinstr"); #asm("PLP:"); EX_PLP; rPC += 1; #asm("jmp newinstr"); #asm("ANDIMM:"); IMM_SET; #asm("EX_AND ANDIMM1, ANDIMM2, ANDIMM3, ANDIMM4"); rPC = rPC + 2; #asm("jmp newinstr"); #asm("ROLACC:"); ACC_SET; #asm("EX_ROL ROLACC1, ROLACC2, ROLACC3, ROLACC4, ROLACC5, ROLACC6") rA = operand; rPC = rPC + 1; #asm("jmp newinstr"); #asm("instr2b:"); #asm("nop"); #asm("jmp newinstr"); #asm("BITABS:"); ABS_SET; #asm("EX_BIT BITABS1, BITABS2"); rPC += 3; #asm("jmp newinstr"); #asm("ANDABS:"); ABS_SET; #asm("EX_AND ANDABS1, ANDABS2, ANDABS3, ANDABS4"); rPC = rPC + 3; #asm("jmp newinstr"); #asm("ROLABS:"); ABS_ADDR; operand = mem(op_addr); #asm("EX_ROL ROLABS1, ROLABS2, ROLABS3, ROLABS4, ROLABS5, ROLABS6"); store_mem(operand,op_addr); rPC = rPC + 3; #asm("jmp newinstr"); #asm("instr2f:"); #asm("nop"); #asm("jmp newinstr"); #asm("BMI:"); REL_ADDR; #asm("EX_BMI BMI1"); rPC += 2; #asm("jmp newinstr"); #asm("ANDINDIRECTY:"); INDY_SET; #asm("EX_AND ANDINDIRECTY1, ANDINDIRECTY2, ANDINDIRECTY3, ANDINDIRECTY4"); rPC = rPC + 2; #asm("jmp newinstr"); #asm("instr32:"); #asm("nop"); #asm("jmp newinstr"); #asm("instr33:"); #asm("nop"); #asm("jmp newinstr"); #asm("instr34:"); #asm("nop"); #asm("jmp newinstr"); #asm("ANDZPX:"); ZPX_SET; #asm("EX_AND ANDZPX1, ANDZPX2, ANDZPX3, ANDZPX4"); rPC = rPC + 2; #asm("jmp newinstr"); #asm("ROLZPX:"); ZPX_ADDR; operand = mem(op_addr); #asm("EX_ROL ROLZPX1, ROLZPX2, ROLZPX3, ROLZPX4, ROLZPX5, ROLZPX6"); store_mem(operand,op_addr); rPC = rPC + 2; #asm("jmp newinstr"); #asm("instr37:"); #asm("nop"); #asm("jmp newinstr"); #asm("_SEC:"); #asm("SET_SREG_BIT 1, ASR_CB"); rPC += 1; #asm("jmp newinstr"); #asm("ANDABSY:"); ABSY_SET; #asm("EX_AND ANDABSY1, ANDABSY2, ANDABSY3, ANDABSY4"); rPC = rPC + 3; #asm("jmp newinstr"); #asm("instr3a:"); #asm("nop"); #asm("jmp newinstr"); #asm("instr3b:"); #asm("nop"); #asm("jmp newinstr"); #asm("instr3c:"); #asm("nop"); #asm("jmp newinstr"); #asm("ANDABSX:"); ABSX_SET; #asm("EX_AND ANDABSX1, ANDABSX2, ANDABSX3, ANDABSX4"); rPC = rPC + 3; #asm("jmp newinstr"); #asm("ROLABSX:"); ABSX_ADDR; operand = mem(op_addr); #asm("EX_ROL ROLABSX1, ROLABSX2, ROLABSX3, ROLABSX4, ROLABSX5, ROLABSX6"); store_mem(operand,op_addr); rPC = rPC + 3; #asm("jmp newinstr"); #asm("instr3f:"); #asm("nop"); #asm("jmp newinstr"); #asm("RTI:"); // No PC increment needed since BRK stores PC + 2 EX_RTI; #asm("jmp newinstr"); #asm("EORXINDIRECT:"); XIND_SET; #asm("EX_EOR EORXINDIRECT1, EORXINDIRECT2, EORXINDIRECT3, EORXINDIRECT4"); rPC = rPC + 2; #asm("jmp newinstr"); #asm("instr42:"); #asm("nop"); #asm("jmp newinstr"); #asm("instr43:"); #asm("nop"); #asm("jmp newinstr"); #asm("instr44:"); #asm("nop"); #asm("jmp newinstr"); #asm("EORZP:"); ZP_SET; #asm("EX_EOR EORZP1, EORZP2, EORZP3, EORZP4"); rPC = rPC + 2; #asm("jmp newinstr"); #asm("LSRZP:"); ZP_ADDR; operand = mem(op_addr); #asm("EX_LSR LSRZP1, LSRZP2, LSRZP3, LSRZP4"); store_mem(operand,op_addr); rPC = rPC + 2; #asm("jmp newinstr"); #asm("instr47:"); #asm("nop"); #asm("jmp newinstr"); #asm("PHA:"); EX_PHA; rPC += 1; #asm("jmp newinstr"); #asm("EORIMM:"); IMM_SET; #asm("EX_EOR EORIMM1, EORIMM2, EORIMM3, EORIMM4"); rPC = rPC + 2; #asm("jmp newinstr"); #asm("LSRACC:"); ACC_SET; #asm("EX_LSR LSRACC1, LSRACC2, LSRACC3, LSRACC4"); rA = operand; rPC = rPC + 1; #asm("jmp newinstr"); #asm("instr4b:"); #asm("nop"); #asm("jmp newinstr"); #asm("JMPABS:"); ABS_ADDR; EX_JMP; #asm("jmp newinstr"); #asm("EORABS:"); ABS_SET; #asm("EX_EOR EORABS1, EORABS2, EORABS3, EORABS4"); rPC = rPC + 3; #asm("jmp newinstr"); #asm("LSRABS:"); ABS_ADDR; operand = mem(op_addr); #asm("EX_LSR LSRABS1, LSRABS2, LSRABS3, LSRABS4"); store_mem(operand,op_addr); rPC = rPC + 3; #asm("jmp newinstr"); #asm("instr4f:"); #asm("nop"); #asm("jmp newinstr"); #asm("BVC:"); REL_ADDR; #asm("EX_BVC BVC1"); rPC += 2; #asm("jmp newinstr"); #asm("EORINDIRECTY:"); INDY_SET; #asm("EX_EOR EORINDIRECTY1, EORINDIRECTY2, EORINDIRECTY3, EORINDIRECTY4"); rPC = rPC + 2; #asm("jmp newinstr"); #asm("instr52:"); #asm("nop"); #asm("jmp newinstr"); #asm("instr53:"); #asm("nop"); #asm("jmp newinstr"); #asm("instr54:"); #asm("nop"); #asm("jmp newinstr"); #asm("EORZPX:"); ZPX_SET; #asm("EX_EOR EORZPX1, EORZPX2, EORZPX3, EORZPX4"); rPC = rPC + 2; #asm("jmp newinstr"); #asm("LSRZPX:"); ZPX_ADDR; operand = mem(op_addr); #asm("EX_LSR LSRZPX1, LSRZPX2, LSRZPX3, LSRZPX4"); store_mem(operand,op_addr); rPC = rPC + 2; #asm("jmp newinstr"); #asm("instr57:"); #asm("nop"); #asm("jmp newinstr"); #asm("_CLI:"); #asm("SET_SREG_BIT 0, ASR_IB"); rPC += 1; #asm("jmp newinstr"); #asm("EORABSY:"); ABSY_SET; #asm("EX_EOR EORABSY1, EORABSY2, EORABSY3, EORABSY4"); rPC = rPC + 3; #asm("jmp newinstr"); #asm("instr5a:"); #asm("nop"); #asm("jmp newinstr"); #asm("instr5b:"); #asm("nop"); #asm("jmp newinstr"); #asm("instr5c:"); #asm("nop"); #asm("jmp newinstr"); #asm("EORABSX:"); ABSX_SET; #asm("EX_EOR EORABSX1, EORABSX2, EORABSX3, EORABSX4"); rPC = rPC + 3; #asm("jmp newinstr"); #asm("LSRABSX:"); ABSX_ADDR; operand = mem(op_addr); #asm("EX_LSR LSRABSX1, LSRABSX2, LSRABSX3, LSRABSX4"); store_mem(operand,op_addr); rPC = rPC + 3; #asm("jmp newinstr"); #asm("instr5f:"); #asm("nop"); #asm("jmp newinstr"); #asm("RTS:"); // PC incremented by 2 inside JSR macro, then by 1 in RTS EX_RTS; #asm("jmp newinstr"); #asm("ADCXINDIRECT:"); XIND_SET; #asm EX_ADC1 rjmp ADCXINDIRECTD SET_NVZC ADCXINDIRECT1, ADCXINDIRECT2, ADCXINDIRECT3, ADCXINDIRECT4, ADCXINDIRECT5, ADCXINDIRECT6, ADCXINDIRECT7, ADCXINDIRECT8 rjmp ADCXINDIRECTEND ADCXINDIRECTD: EX_ADC2 ADCXINDIRECTD1, ADCXINDIRECTD2, ADCXINDIRECTD3, ADCXINDIRECTD4, ADCXINDIRECTD5, ADCXINDIRECTD6, ADCXINDIRECTD7 ADCXINDIRECTEND: #endasm rPC = rPC + 2; #asm("jmp newinstr"); #asm("instr62:"); #asm("nop"); #asm("jmp newinstr"); #asm("instr63:"); #asm("nop"); #asm("jmp newinstr"); #asm("instr64:"); #asm("nop"); #asm("jmp newinstr"); #asm("ADCZP:"); ZP_SET; #asm EX_ADC1 rjmp ADCZPD SET_NVZC ADCZP1, ADCZP2, ADCZP3, ADCZP4, ADCZP5, ADCZP6, ADCZP7, ADCZP8 rjmp ADCZPEND ADCZPD: EX_ADC2 ADCZPD1, ADCZPD2, ADCZPD3, ADCZPD4, ADCZPD5, ADCZPD6, ADCZPD7 ADCZPEND: #endasm rPC = rPC + 2; #asm("jmp newinstr"); #asm("RORZP:"); ZP_ADDR; operand = mem(op_addr); #asm("EX_ROR RORZP1, RORZP2, RORZP3, RORZP4, RORZP5, RORZP6"); store_mem(operand,op_addr); rPC = rPC + 2; #asm("jmp newinstr"); #asm("instr67:"); #asm("nop"); #asm("jmp newinstr"); #asm("PLA:"); EX_PLA; rPC += 1; #asm("jmp newinstr"); #asm("ADCIMM:"); IMM_SET; #asm EX_ADC1 rjmp ADCIMMD SET_NVZC ADCIMM1, ADCIMM2, ADCIMM3, ADCIMM4, ADCIMM5, ADCIMM6, ADCIMM7, ADCIMM8 rjmp ADCIMMEND ADCIMMD: EX_ADC2 ADCIMMD1, ADCIMMD2, ADCIMMD3, ADCIMMD4, ADCIMMD5, ADCIMMD6, ADCIMMD7 ADCIMMEND: #endasm rPC = rPC + 2; #asm("jmp newinstr"); #asm("RORACC:"); ACC_SET; #asm("EX_ROR RORACC1, RORACC2, RORACC3, RORACC4, RORACC5, RORACC6"); rA = operand; rPC = rPC + 1; #asm("jmp newinstr"); #asm("instr6b:"); #asm("nop"); #asm("jmp newinstr"); #asm("JMPIND:"); IND_ADDR; EX_JMP; #asm("jmp newinstr"); #asm("ADCABS:"); ABS_SET; #asm EX_ADC1 rjmp ADCABSD SET_NVZC ADCABS1, ADCABS2, ADCABS3, ADCABS4, ADCABS5, ADCABS6, ADCABS7, ADCABS8 rjmp ADCABSEND ADCABSD: EX_ADC2 ADCABSD1, ADCABSD2, ADCABSD3, ADCABSD4, ADCABSD5, ADCABSD6, ADCABSD7 ADCABSEND: #endasm rPC = rPC + 3; #asm("jmp newinstr"); #asm("RORABS:"); ABS_ADDR; operand = mem(op_addr); #asm("EX_ROR RORABS1, RORABS2, RORABS3, RORABS4, RORABS5, RORABS6"); store_mem(operand,op_addr); rPC = rPC + 3; #asm("jmp newinstr"); #asm("instr6f:"); #asm("nop"); #asm("jmp newinstr"); #asm("BVS:"); REL_ADDR; #asm("EX_BVS BVS1"); rPC += 2; #asm("jmp newinstr"); #asm("ADCINDIRECTY:"); INDY_SET; #asm EX_ADC1 rjmp ADCINDIRECTYD SET_NVZC ADCINDIRECTY1, ADCINDIRECTY2, ADCINDIRECTY3, ADCINDIRECTY4, ADCINDIRECTY5, ADCINDIRECTY6, ADCINDIRECTY7, ADCINDIRECTY8 rjmp ADCINDIRECTYEND ADCINDIRECTYD: EX_ADC2 ADCINDIRECTYD1, ADCINDIRECTYD2, ADCINDIRECTYD3, ADCINDIRECTYD4, ADCINDIRECTYD5, ADCINDIRECTYD6, ADCINDIRECTYD7 ADCINDIRECTYEND: #endasm rPC = rPC + 2; #asm("jmp newinstr"); #asm("instr72:"); #asm("nop"); #asm("jmp newinstr"); #asm("instr73:"); #asm("nop"); #asm("jmp newinstr"); #asm("instr74:"); #asm("nop"); #asm("jmp newinstr"); #asm("ADCZPX:"); ZPX_SET; #asm EX_ADC1 rjmp ADCZPXD SET_NVZC ADCZPX1, ADCZPX2, ADCZPX3, ADCZPX4, ADCZPX5, ADCZPX6, ADCZPX7, ADCZPX8 rjmp ADCZPXEND ADCZPXD: EX_ADC2 ADCZPXD1, ADCZPXD2, ADCZPXD3, ADCZPXD4, ADCZPXD5, ADCZPXD6, ADCZPXD7 ADCZPXEND: #endasm rPC = rPC + 2; #asm("jmp newinstr"); #asm("RORZPX:"); ZPX_ADDR; operand = mem(op_addr); #asm("EX_ROR RORZPX1, RORZPX2, RORZPX3, RORZPX4, RORZPX5, RORZPX6"); store_mem(operand,op_addr); rPC = rPC + 2; #asm("jmp newinstr"); #asm("instr77:"); #asm("nop"); #asm("jmp newinstr"); #asm("_SEI:"); #asm("SET_SREG_BIT 1, ASR_IB"); rPC += 1; #asm("jmp newinstr"); #asm("ADCABSY:"); ABSY_SET; #asm EX_ADC1 rjmp ADCABSYD SET_NVZC ADCABSY1, ADCABSY2, ADCABSY3, ADCABSY4, ADCABSY5, ADCABSY6, ADCABSY7, ADCABSY8 rjmp ADCABSYEND ADCABSYD: EX_ADC2 ADCABSYD1, ADCABSYD2, ADCABSYD3, ADCABSYD4, ADCABSYD5, ADCABSYD6, ADCABSYD7 ADCABSYEND: #endasm rPC = rPC + 3; #asm("jmp newinstr"); #asm("instr7a:"); #asm("nop"); #asm("jmp newinstr"); #asm("instr7b:"); #asm("nop"); #asm("jmp newinstr"); #asm("instr7c:"); #asm("nop"); #asm("jmp newinstr"); #asm("ADCABSX:"); ABSX_SET; #asm EX_ADC1 rjmp ADCABSXD SET_NVZC ADCABSX1, ADCABSX2, ADCABSX3, ADCABSX4, ADCABSX5, ADCABSX6, ADCABSX7, ADCABSX8 rjmp ADCABSXEND ADCABSXD: EX_ADC2 ADCABSXD1, ADCABSXD2, ADCABSXD3, ADCABSXD4, ADCABSXD5, ADCABSXD6, ADCABSXD7 ADCABSXEND: #endasm rPC = rPC + 3; #asm("jmp newinstr"); #asm("RORABSX:"); ABSX_ADDR; operand = mem(op_addr); #asm("EX_ROR RORABSX1, RORABSX2, RORABSX3, RORABSX4, RORABSX5, RORABSX6"); store_mem(operand,op_addr); rPC = rPC + 3; #asm("jmp newinstr"); #asm("instr7f:"); #asm("nop"); #asm("jmp newinstr"); #asm("instr80:"); #asm("nop"); #asm("jmp newinstr"); #asm("STAXINDIRECT:"); XIND_ADDR; EX_STA; rPC = rPC + 2; #asm("jmp newinstr"); #asm("instr82:"); #asm("nop"); #asm("jmp newinstr"); #asm("instr83:"); #asm("nop"); #asm("jmp newinstr"); #asm("STYZP:"); ZP_ADDR; EX_STY; rPC += 2; #asm("jmp newinstr"); #asm("STAZP:"); ZP_ADDR; EX_STA; rPC = rPC + 2; #asm("jmp newinstr"); #asm("STXZP:"); ZP_ADDR; store_mem(rX,op_addr); rPC = rPC + 2; #asm("jmp newinstr"); #asm("instr87:"); #asm("nop"); #asm("jmp newinstr"); #asm("DEY:"); #asm("EX_DEY DEY1, DEY2, DEY3, DEY4"); rPC += 1; #asm("jmp newinstr"); #asm("instr89:"); #asm("nop"); #asm("jmp newinstr"); #asm("TXA:"); #asm("EX_TXA TXA1, TXA2, TXA3, TXA4"); rPC += 1; #asm("jmp newinstr"); #asm("instr8b:"); #asm("nop"); #asm("jmp newinstr"); #asm("STYABS:"); ABS_ADDR; EX_STY; rPC += 3; #asm("jmp newinstr"); #asm("STAABS:"); ABS_ADDR; EX_STA; rPC = rPC + 3; #asm("jmp newinstr"); #asm("STXABS:"); ABS_ADDR; store_mem(rX,op_addr); rPC = rPC + 3; #asm("jmp newinstr"); #asm("instr8f:"); #asm("nop"); #asm("jmp newinstr"); #asm("BCC:"); REL_ADDR; #asm("EX_BCC BCC1"); rPC += 2; #asm("jmp newinstr"); #asm("STAINDIRECTY:"); INDY_ADDR; EX_STA; rPC = rPC + 2; #asm("jmp newinstr"); #asm("instr92:"); #asm("nop"); #asm("jmp newinstr"); #asm("instr93:"); #asm("nop"); #asm("jmp newinstr"); #asm("STYZPX:"); ZPX_ADDR; EX_STY; rPC += 2; #asm("jmp newinstr"); #asm("STAZPX:"); ZPX_ADDR; EX_STA; rPC = rPC + 2; #asm("jmp newinstr"); #asm("STXZPY:"); ZPY_ADDR; store_mem(rX,op_addr); rPC = rPC + 2; #asm("jmp newinstr"); #asm("instr97:"); #asm("nop"); #asm("jmp newinstr"); #asm("TYA:"); #asm("EX_TYA TYA1, TYA2, TYA3, TYA4"); rPC += 1; #asm("jmp newinstr"); #asm("STAABSY:"); ABSY_ADDR; EX_STA; rPC = rPC + 3; #asm("jmp newinstr"); #asm("TXS:"); #asm("EX_TXS"); rPC += 1; #asm("jmp newinstr"); #asm("instr9b:"); #asm("nop"); #asm("jmp newinstr"); #asm("instr9c:"); #asm("nop"); #asm("jmp newinstr"); #asm("STAABSX:"); ABSX_ADDR; EX_STA; rPC = rPC + 3; #asm("jmp newinstr"); #asm("instr9e:"); #asm("nop"); #asm("jmp newinstr"); #asm("instr9f:"); #asm("nop"); #asm("jmp newinstr"); #asm("LDYIMM:"); IMM_SET; #asm("EX_LDY LDYIMM1, LDYIMM2, LDYIMM3, LDYIMM4"); rPC += 2; #asm("jmp newinstr"); #asm("LDAXINDIRECT:"); XIND_SET; #asm("EX_LDA LDAXINDIRECT1, LDAXINDIRECT2, LDAXINDRIECT3, LDAXINDIRECT4"); rPC = rPC + 2; #asm("jmp newinstr"); #asm("LDXIMM:"); IMM_SET; #asm("EX_LDX LDXIMM1, LDXIMM2, LDXIMM3, LDXIMM4"); rPC += 2; #asm("jmp newinstr"); #asm("instra3:"); #asm("nop"); #asm("jmp newinstr"); #asm("LDYZP:"); ZP_SET; #asm("EX_LDY LDYZP1, LDYZP2, LDYZP3, LDYZP4"); rPC += 2; #asm("jmp newinstr"); #asm("LDAZP:"); ZP_SET; #asm("EX_LDA LDAZP1, LDAZP2, LDAZP3, LDAZP4"); rPC = rPC + 2; #asm("jmp newinstr"); #asm("LDXZP:"); ZP_SET; #asm("EX_LDX LDXZP1, LDXZP2, LDXZP3, LDXZP4"); rPC += 2; #asm("jmp newinstr"); #asm("instra7:"); #asm("nop"); #asm("jmp newinstr"); #asm("TAY:"); #asm("EX_TAY TAY1, TAY2, TAY3, TAY4"); rPC += 1; #asm("jmp newinstr"); #asm("LDAIMM:"); IMM_SET; #asm("EX_LDA LDAIMM1, LDAIMM2, LDAIMM3, LDAIMM4"); rPC = rPC + 2; #asm("jmp newinstr"); #asm("TAX:"); #asm("EX_TAX TAX1, TAX2, TAX3, TAX4"); rPC += 1; #asm("jmp newinstr"); #asm("instrab:"); #asm("nop"); #asm("jmp newinstr"); #asm("LDYABS:"); ABS_SET; #asm("EX_LDY LDYABS1, LDYABS2, LDYABS3, LDYABS4"); rPC += 3; #asm("jmp newinstr"); #asm("LDAABS:"); ABS_SET; #asm("EX_LDA LDAABS1, LDAABS2, LDAABS3, LDAABS4"); rPC = rPC + 3; #asm("jmp newinstr"); #asm("LDXABS:"); ABS_SET; #asm("EX_LDX LDXABS1, LDXABS2, LDXABS3, LDXABS4"); rPC += 3; #asm("jmp newinstr"); #asm("instraf:"); #asm("nop"); #asm("jmp newinstr"); #asm("BCS:"); REL_ADDR; #asm("EX_BCS BCS1"); rPC += 2; #asm("jmp newinstr"); #asm("LDAINDIRECTY:"); INDY_SET; #asm("EX_LDA LDAINDIRECTY1, LDAINDIRECTY2, LDAINDIRECTY3, LDAINDIRECTY4"); rPC = rPC + 2; #asm("jmp newinstr"); #asm("instrb2:"); #asm("nop"); #asm("jmp newinstr"); #asm("instrb3:"); #asm("nop"); #asm("jmp newinstr"); #asm("LDYZPX:"); ZPX_SET; #asm("EX_LDY LDYZPX1, LDYZPX2, LDYZPX3, LDYZPX4"); rPC += 2; #asm("jmp newinstr"); #asm("LDAZPX:"); ZPX_SET; #asm("EX_LDA LDAZPX1, LDAZPX2, LDAZPX3, LDAZPX4"); rPC = rPC + 2; #asm("jmp newinstr"); #asm("LDXZPY:"); ZPY_SET; #asm("EX_LDX LDXZPY1, LDXZPY2, LDXZPY3, LDXZPY4"); rPC += 2; #asm("jmp newinstr"); #asm("instrb7:"); #asm("nop"); #asm("jmp newinstr"); #asm("_CLV:"); #asm("SET_SREG_BIT 0, ASR_VB"); rPC += 1; #asm("jmp newinstr"); #asm("LDAABSY:"); ABSY_SET; #asm("EX_LDA LDAABSX1, LDAABSX2, LDAABSX3, LDAABSX4"); rPC = rPC + 3; #asm("jmp newinstr"); #asm("TSX:"); #asm("EX_TSX TSX1, TSX2, TSX3, TSX4"); rPC += 1; #asm("jmp newinstr"); #asm("instrbb:"); #asm("nop"); #asm("jmp newinstr"); #asm("LDYABSX:"); ABSX_SET; #asm("EX_LDY LDYABSX1, LDYABSX2, LDYABSX3, LDYABSX4"); rPC += 3; #asm("jmp newinstr"); #asm("LDAABSX:"); ABSX_SET; #asm("EX_LDA LDAABSX1, LDAABSX2, LDAABSX3, LDAABSX4"); rPC = rPC + 3; #asm("jmp newinstr"); #asm("LDXABSY:"); ABSY_SET; #asm("EX_LDX LDXABSY1, LDXABSY2, LDXABSY3, LDXABSY4"); rPC += 3; #asm("jmp newinstr"); #asm("instrbf:"); #asm("nop"); #asm("jmp newinstr"); #asm("CPYIMM:"); IMM_SET; #asm("EX_CMP CPYIMM1, CPYIMM2, CPYIMM3, CPYIMM4, CLR_CPY_CARRY_IMM, SET_CPY_CARRY_IMM, REG_Y"); rPC += 2; #asm("jmp newinstr"); #asm("CMPXINDIRECT:"); XIND_SET; #asm("EX_CMP CMPXINDIRECT1, CMPXINDIRECT2, CMPXINDIRECT3, CMPXINDIRECT4, CLR_CMP_CARRY_XINDIRECT, SET_CMP_CARRY_XINDIRECT, REG_A"); rPC = rPC + 2; #asm("jmp newinstr"); #asm("instrc2:"); #asm("nop"); #asm("jmp newinstr"); #asm("instrc3:"); #asm("nop"); #asm("jmp newinstr"); #asm("CPYZP:"); ZP_SET; #asm("EX_CMP CPYZP1, CPYZP2, CPYZP3, CPYZP4, CLR_CPY_CARRY_ZP, SET_CPY_CARRY_ZP, REG_Y"); rPC += 2; #asm("jmp newinstr"); #asm("CMPZP:"); ZP_SET; #asm("EX_CMP CMPZP1, CMPZP2, CMPZP3, CMPZP4, CLR_CMP_CARRY_ZP, SET_CMP_CARRY_ZP, REG_A"); rPC = rPC + 2; #asm("jmp newinstr"); #asm("DECZP:"); ZP_ADDR; operand = mem(op_addr); #asm("EX_DEC DECZP1, DECZP2, DECZP3, DECZP4"); store_mem(operand,op_addr); rPC += 2; #asm("jmp newinstr"); #asm("instrc7:"); #asm("nop"); #asm("jmp newinstr"); #asm("INY:"); #asm("EX_INY INY1, INY2, INY3, INY4"); rPC += 1; #asm("jmp newinstr"); #asm("CMPIMM:"); IMM_SET; #asm("EX_CMP CMPIMM1, CMPIMM2, CMPIMM3, CMPIMM4, CLR_CMP_CARRY_IMM, SET_CMP_CARRY_IMM, REG_A"); rPC = rPC + 2; #asm("jmp newinstr"); #asm("DEX:"); #asm("EX_DEX DEX1, DEX2, DEX3, DEX4"); rPC += 1; #asm("jmp newinstr"); #asm("instrcb:"); #asm("nop"); #asm("jmp newinstr"); #asm("CPYABS:"); ABS_SET; #asm("EX_CMP CPYABS1, CPYABS2, CPYABS3, CPYABS4, CLR_CPY_CARRY_ABS, SET_CPY_CARRY_ABS, REG_Y"); rPC += 3; #asm("jmp newinstr"); #asm("CMPABS:"); ABS_SET; #asm("EX_CMP CMPABS1, CMPABS2, CMPABS3, CMPABS4, CLR_CMP_CARRY_ABS, SET_CMP_CARRY_ABS, REG_A"); rPC = rPC + 3; #asm("jmp newinstr"); #asm("DECABS:"); ABS_ADDR; operand = mem(op_addr); #asm("EX_DEC DECABS1, DECABS2, DECABS3, DECABS4"); store_mem(operand,op_addr); rPC += 3; #asm("jmp newinstr"); #asm("instrcf:"); #asm("nop"); #asm("jmp newinstr"); #asm("BNE:"); REL_ADDR; #asm("EX_BNE BNE1"); rPC += 2; #asm("jmp newinstr"); #asm("CMPINDIRECTY:"); INDY_SET; #asm("EX_CMP CMPINDIRECTY1, CMPINDIRECTY2, CMPINDIRECTY3, CMPINDIRECTY4, CLR_CMP_CARRY_INDIRECTY, SET_CMP_CARRY_INDIRECTY, REG_A"); rPC = rPC + 2; #asm("jmp newinstr"); #asm("instrd2:"); #asm("nop"); #asm("jmp newinstr"); #asm("instrd3:"); #asm("nop"); #asm("jmp newinstr"); #asm("instrd4:"); #asm("nop"); #asm("jmp newinstr"); #asm("CMPZPX:"); ZPX_SET; #asm("EX_CMP CMPZPX1, CMPZPX2, CMPZPX3, CMPZPX4, CLR_CMP_CARRY_ZPX, SET_CMP_CARRY_ZPX, REG_A"); rPC = rPC + 2; #asm("jmp newinstr"); #asm("DECZPX:"); ZPX_ADDR; operand = mem(op_addr); #asm("EX_DEC DECZPX1, DECZPX2, DECZPX3, DECZPX4"); store_mem(operand,op_addr); rPC += 2; #asm("jmp newinstr"); #asm("instrd7:"); #asm("nop"); #asm("jmp newinstr"); #asm("CLD:"); #asm("SET_SREG_BIT 0, ASR_DB"); rPC += 1; #asm("jmp newinstr"); #asm("CMPABSY:"); ABSY_SET; #asm("EX_CMP CMPABSY1, CMPABSY2, CMPABSY3, CMPABSY4, CLR_CMP_CARRY_ABSY, SET_CMP_CARRY_ABSY, REG_A"); rPC = rPC + 3; #asm("jmp newinstr"); #asm("instrda:"); #asm("nop"); #asm("jmp newinstr"); #asm("instrdb:"); #asm("nop"); #asm("jmp newinstr"); #asm("instrdc:"); #asm("nop"); #asm("jmp newinstr"); #asm("CMPABSX:"); ABSX_SET; #asm("EX_CMP CMPABSX1, CMPABSX2, CMPABSX3, CMPABSX4, CLR_CMP_CARRY_ABSX, SET_CMP_CARRY_ABSX, REG_A"); rPC = rPC + 3; #asm("jmp newinstr"); #asm("DECABSX:"); ABSX_ADDR; operand = mem(op_addr); #asm("EX_DEC DECABSX1, DECABSX2, DECABSX3, DECABSX4"); store_mem(operand,op_addr); rPC += 3; #asm("jmp newinstr"); #asm("instrdf:"); #asm("nop"); #asm("jmp newinstr"); #asm("CPXIMM:"); IMM_SET; #asm("EX_CMP CPXIMM1, CPXIMM2, CPXIMM3, CPXIMM4, CLR_CPX_CARRY_IMM, SET_CPX_CARRY_IMM, REG_X"); rPC += 2; #asm("jmp newinstr"); #asm("SBCXINDIRECT:"); XIND_SET; #asm EX_SBC1 SBCXINDB1, SBCXINDB2, SBCXINDB3 rjmp SBCXINDEND SBCXINDD: EX_SBC2 SBCXINDD1, SBCXINDD2, SBCXINDD3, SBCXINDD4, SBCXINDD5, SBCXINDD6, SBCXINDD7 SBCXINDEND: #endasm rPC = rPC + 2; #asm("jmp newinstr"); #asm("instre2:"); #asm("nop"); #asm("jmp newinstr"); #asm("instre3:"); #asm("nop"); #asm("jmp newinstr"); #asm("CPXZP:"); ZP_SET; #asm("EX_CMP CPXZP1, CPXZP2, CPXZP3, CPXZP4, CLR_CPX_CARRY_ZP, SET_CPX_CARRY_ZP, REG_X"); rPC += 2; #asm("jmp newinstr"); #asm("SBCZP:"); ZP_SET; #asm EX_SBC1 SBCZPB1, SBCZPB2, SBCZPB3 rjmp SBCZPEND SBCZPD: EX_SBC2 SBCZPD1, SBCZPD2, SBCZPD3, SBCZPD4, SBCZPD5, SBCZPD6, SBCZPD7 SBCZPEND: #endasm rPC = rPC + 2; #asm("jmp newinstr"); #asm("INCZP:"); ZP_ADDR; operand = mem(op_addr); #asm("EX_INC INCZP1, INCZP2, INCZP3, INCZP4"); store_mem(operand,op_addr); rPC += 2; #asm("jmp newinstr"); #asm("instre7:"); #asm("nop"); #asm("jmp newinstr"); #asm("INX:"); #asm("EX_INX INX1, INX2, INX3, INX4"); rPC += 1; #asm("jmp newinstr"); #asm("SBCIMM:"); IMM_SET; #asm EX_SBC1 SBCIMMB1, SBCIMMB2, SBCIMMB3 rjmp SBCIMMEND SBCIMMD: EX_SBC2 SBCIMMD1, SBCIMMD2, SBCIMMD3, SBCIMMD4, SBCZPD5, SBCZPD6, SBCZPD7 SBCIMMEND: #endasm rPC = rPC + 2; #asm("jmp newinstr"); #asm("_NOP:"); rPC += 1; counter++; #asm("jmp newinstr"); #asm("instreb:"); #asm("nop"); #asm("jmp newinstr"); #asm("CPXABS:"); ABS_SET; #asm("EX_CMP CPXABS1, CPXABS2, CPXABS3, CPXABS4, CLR_CPX_CARRY_ABS, SET_CPX_CARRY_ABS, REG_X"); rPC += 3; #asm("jmp newinstr"); #asm("SBCABS:"); ABS_SET; #asm EX_SBC1 SBCABSB1, SBCABSB2, SBCABSB3 rjmp SBCABSEND SBCABSD: EX_SBC2 SBCABSD1, SBCABSD2, SBCABSD3, SBCABSD4, SBCXABSD5, SBCXABSD6, SBCABSD7 SBCABSEND: #endasm rPC = rPC + 3; #asm("jmp newinstr"); #asm("INCABS:"); ABS_ADDR; operand = mem(op_addr); #asm("EX_INC INCABS1, INCABS2, INCABS3, INCABS4"); store_mem(operand,op_addr); rPC += 3; #asm("jmp newinstr"); #asm("instref:"); #asm("nop"); #asm("jmp newinstr"); #asm("BEQ:"); REL_ADDR; #asm("EX_BEQ BEQ1"); rPC += 2; #asm("jmp newinstr"); #asm("SBCINDIRECTY:"); INDY_SET; #asm EX_SBC1 SBCINDYB1, SBCINDYB2, SBCINDYB3 rjmp SBCINDYEND SBCINDYD: EX_SBC2 SBCINDYD1, SBCINDYD2, SBCINDYD3, SBCINDYD4, SBCINDYD5, SBCINDYD6, SBCINDYD7 SBCINDYEND: #endasm rPC = rPC + 2; #asm("jmp newinstr"); #asm("instrf2:"); #asm("nop"); #asm("jmp newinstr"); #asm("instrf3:"); #asm("nop"); #asm("jmp newinstr"); #asm("instrf4:"); #asm("nop"); #asm("jmp newinstr"); #asm("SBCZPX:"); ZPX_SET; #asm EX_SBC1 SBCZPXB1, SBCZPXB2, SBCZPXB3 rjmp SBCZPXEND SBCZPXD: EX_SBC2 SBCZPXD1, SBCZPXD2, SBCZPXD3, SBCZPXD4, SBCXZPXD5, SBCZPXD6, SBCZPXD7 SBCZPXEND: #endasm rPC = rPC + 2; #asm("jmp newinstr"); #asm("INCZPX:"); ZPX_ADDR; operand = mem(op_addr); #asm("EX_INC INCZPX1, INCZPX2, INCZPX3, INCZPX4"); store_mem(operand,op_addr); rPC += 2; #asm("jmp newinstr"); #asm("instrf7:"); #asm("nop"); #asm("jmp newinstr"); #asm("SED:"); #asm("SET_SREG_BIT 1, ASR_DB"); rPC += 1; #asm("jmp newinstr"); #asm("SBCABSY:"); ABSY_SET; #asm EX_SBC1 SBCABSYB1, SBCABSYB2, SBCABSYB3 rjmp SBCABSYEND SBCABSYD: EX_SBC2 SBCABSYD1, SBCABSYD2, SBCABSYD3, SBCABSYD4, SBCABSYD5, SBCABSYD6, SBCABSYD7 SBCABSYEND: #endasm rPC = rPC + 3; #asm("jmp newinstr"); #asm("instrfa:"); #asm("nop"); #asm("jmp newinstr"); #asm("instrfb:"); #asm("nop"); #asm("jmp newinstr"); #asm("instrfc:"); #asm("nop"); #asm("jmp newinstr"); #asm("SBCABSX:"); ABSX_SET; #asm EX_SBC1 SBCABSXB1, SBCABSXB2, SBCABSXB3 rjmp SBCABSXEND SBCABSXD: EX_SBC2 SBCABSXD1, SBCABSXD2, SBCABSXD3, SBCABSXD4, SBCABSXD5, SBCABSXD6, SBCABSXD7 SBCABSXEND: #endasm rPC = rPC + 3; #asm("jmp newinstr"); #asm("INCABSX:"); ABSX_ADDR; operand = mem(op_addr); #asm("EX_INC INCABSX1, INCABSX2, INCABSX3, INCABSX4"); store_mem(operand,op_addr); rPC += 3; #asm("jmp newinstr"); #asm("instrff:"); #asm("nop"); #asm("jmp newinstr"); return 0; #asm jmptable: jmp BRK jmp ORAXINDIRECT jmp instr2 jmp instr3 jmp instr4 jmp ORAZP jmp ASLZP jmp instr7 jmp PHP jmp ORAIMM jmp ASLACC jmp instrb jmp instrc jmp ORAABS jmp ASLABS jmp instrf jmp BPL jmp ORAINDIRECTY jmp instr12 jmp instr13 jmp instr14 jmp ORAZPX jmp ASLZPX jmp instr17 jmp _CLC jmp ORAABSY jmp instr1a jmp instr1b jmp instr1c jmp ORAABSX jmp ASLABSX jmp instr1f jmp JSRABS jmp ANDXINDIRECT jmp instr22 jmp instr23 jmp BITZP jmp ANDZP jmp ROLZP jmp instr27 jmp PLP jmp ANDIMM jmp ROLACC jmp instr2b jmp BITABS jmp ANDABS jmp ROLABS jmp instr2f jmp BMI jmp ANDINDIRECTY jmp instr32 jmp instr33 jmp instr34 jmp ANDZPX jmp ROLZPX jmp instr37 jmp _SEC jmp ANDABSY jmp instr3a jmp instr3b jmp instr3c jmp ANDABSX jmp ROLABSX jmp instr3f jmp RTI jmp EORXINDIRECT jmp instr42 jmp instr43 jmp instr44 jmp EORZP jmp LSRZP jmp instr47 jmp PHA jmp EORIMM jmp LSRACC jmp instr4b jmp JMPABS jmp EORABS jmp LSRABS jmp instr4f jmp BVC jmp EORINDIRECTY jmp instr52 jmp instr53 jmp instr54 jmp EORZPX jmp LSRZPX jmp instr57 jmp _CLI jmp EORABSY jmp instr5a jmp instr5b jmp instr5c jmp EORABSX jmp LSRABSX jmp instr5f jmp RTS jmp ADCXINDIRECT jmp instr62 jmp instr63 jmp instr64 jmp ADCZP jmp RORZP jmp instr67 jmp PLA jmp ADCIMM jmp RORACC jmp instr6b jmp JMPIND jmp ADCABS jmp RORABS jmp instr6f jmp BVS jmp ADCINDIRECTY jmp instr72 jmp instr73 jmp instr74 jmp ADCZPX jmp RORZPX jmp instr77 jmp _SEI jmp ADCABSY jmp instr7a jmp instr7b jmp instr7c jmp ADCABSX jmp RORABSX jmp instr7f jmp instr80 jmp STAXINDIRECT jmp instr82 jmp instr83 jmp STYZP jmp STAZP jmp STXZP jmp instr87 jmp DEY jmp instr89 jmp TXA jmp instr8b jmp STYABS jmp STAABS jmp STXABS jmp instr8f jmp BCC jmp STAINDIRECTY jmp instr92 jmp instr93 jmp STYZPX jmp STAZPX jmp STXZPY jmp instr97 jmp TYA jmp STAABSY jmp TXS jmp instr9b jmp instr9c jmp STAABSX jmp instr9e jmp instr9f jmp LDYIMM jmp LDAXINDIRECT jmp LDXIMM jmp instra3 jmp LDYZP jmp LDAZP jmp LDXZP jmp instra7 jmp TAY jmp LDAIMM jmp TAX jmp instrab jmp LDYABS jmp LDAABS jmp LDXABS jmp instraf jmp BCS jmp LDAINDIRECTY jmp instrb2 jmp instrb3 jmp LDYZPX jmp LDAZPX jmp LDXZPY jmp instrb7 jmp _CLV jmp LDAABSY jmp TSX jmp instrbb jmp LDYABSX jmp LDAABSX jmp LDXABSY jmp instrbf jmp CPYIMM jmp CMPXINDIRECT jmp instrc2 jmp instrc3 jmp CPYZP jmp CMPZP jmp DECZP jmp instrc7 jmp INY jmp CMPIMM jmp DEX jmp instrcb jmp CPYABS jmp CMPABS jmp DECABS jmp instrcf jmp BNE jmp CMPINDIRECTY jmp instrd2 jmp instrd3 jmp instrd4 jmp CMPZPX jmp DECZPX jmp instrd7 jmp CLD jmp CMPABSY jmp instrda jmp instrdb jmp instrdc jmp CMPABSX jmp DECABSX jmp instrdf jmp CPXIMM jmp SBCXINDIRECT jmp instre2 jmp instre3 jmp CPXZP jmp SBCZP jmp INCZP jmp instre7 jmp INX jmp SBCIMM jmp _NOP jmp instreb jmp CPXABS jmp SBCABS jmp INCABS jmp instref jmp BEQ jmp SBCINDIRECTY jmp instrf2 jmp instrf3 jmp instrf4 jmp SBCZPX jmp INCZPX jmp instrf7 jmp SED jmp SBCABSY jmp instrfa jmp instrfb jmp instrfc jmp SBCABSX jmp INCABSX jmp instrff #endasm }