URL https://opencores.org/ocsvn/t6507lp/t6507lp/trunk

Subversion Repositories t6507lp

[/] [t6507lp/] [trunk/] [fv/] [fsm_chk.e] - Blame information for rev 212

Go to most recent revision | Details | Compare with Previous | View Log


<'
import fsm_components;
type state_t : [RESET, CYCLE_1, CYCLE_2, CYCLE_3, CYCLE_4, CYCLE_5, CYCLE_6, CYCLE_7];
unit fsm_chk_u {
        !A  : byte;
          keep soft A == 0;
        !X  : byte;
          keep soft X == 0;
        !Y  : byte;
          keep soft Y == 0;
        !PC : uint(bits : 13);
          keep soft PC == 0;
//      !SP : uint(bits : 9);
//        keep soft SP == 9'b100000000;
        !SP : byte;
          keep soft SP == 0;
 
        !more_cycles : bool;
          keep soft more_cycles == FALSE;
        --!R  : byte;
        -- keep soft R == 0;
        --!PS : byte;
        --  keep soft PS[0:0] == 0;
        --  keep soft PS[1:1] == 0;
        --  keep soft PS[2:2] == 0;
        --  keep soft PS[3:3] == 0;
        --  keep soft PS[4:4] == 0;
        --  keep soft PS[5:5] == 1;
        --  keep soft PS[6:6] == 0;
        --  keep soft PS[7:7] == 0;
        -- N : bit;
        -- V : bit;
        -- B : bit;
        -- D : bit;
        -- I : bit;
        -- Z : bit;
        -- C : bit;
        -- keep soft N == 0;
        -- keep soft V == 0;
        -- keep soft B == 0;
        -- keep soft D == 0;
        -- keep soft I == 0;
        -- keep soft Z == 0;
        -- keep soft C == 0;
 
        !new_inst   : bool;
        keep new_inst == FALSE;
        !new_input : fsm_input_s;
        !old_input : fsm_input_s;
        --!new_inst  : bool;
        --keep soft new_inst == FALSE;
 
        --!i : ps_index;
 
        !new_state : state_t;
        !old_state : state_t;
 
        --count_cycles : int;
        --first_cycle  : bool;
        --last_a       : byte;
        --last_status  : byte;
        --last_result  : byte;
        !PCL:byte;
        !PCH:byte;
        !SP_aux:byte;
        !rst : bit;
        !rst_counter  : byte;
 
        --keep first_cycle  == TRUE;
        --keep count_cycles == 0;
        keep rst_counter  == 0;
 
        !instruction      : valid_opcodes;
        !last_instruction : valid_opcodes;
        !instructions     : valid_opcodes;
 
        print_state () is {
                outf("-------------------------------------------------------\n");
                print instructions;
                -- print instruction;
                print 't6507lp_fsm.ir';
                print 't6507lp_fsm.sp';
                print SP + 256;
                print 't6507lp_fsm.pc';
                print PC;
                --print addr;
                case ('t6507lp_fsm.state') {
 
                        2  : { outf("  t6507lp_fsm.state = FETCH_LOW\n");};
                        3  : { outf("  t6507lp_fsm.state = FETCH_HIGH\n"); };
                        4  : { outf("  t6507lp_fsm.state = READ_MEM\n"); };
                        5  : { outf("  t6507lp_fsm.state = DUMMY_WRT_CALC\n"); };
                        6  : { outf("  t6507lp_fsm.state = WRITE_MEM\n"); };
                        7  : { outf("  t6507lp_fsm.state = FETCH_OP_CALC_PARAM\n"); };
                        8  : { outf("  t6507lp_fsm.state = READ_MEM_CALC_INDEX\n"); };
                        9  : { outf("  t6507lp_fsm.state = FETCH_HIGH_CALC_INDEX\n"); };
                        10 : { outf("  t6507lp_fsm.state = READ_MEM_FIX_ADDR\n"); };
                        11 : { outf("  t6507lp_fsm.state = FETCH_OP_EVAL_BRANCH\n"); };
                        12 : { outf("  t6507lp_fsm.state = FETCH_OP_FIX_PC\n"); };
                        13 : { outf("  t6507lp_fsm.state = READ_FROM_POINTER\n"); };
                        14 : { outf("  t6507lp_fsm.state = READ_FROM_POINTER_X\n"); };
                        15 : { outf("  t6507lp_fsm.state = READ_FROM_POINTER_X1\n"); };
                        16 : { outf("  t6507lp_fsm.state = PUSH_PCH\n"); };
                        17 : { outf("  t6507lp_fsm.state = PUSH_PCL\n"); };
                        18 : { outf("  t6507lp_fsm.state = PUSH_STATUS\n"); };
                        19 : { outf("  t6507lp_fsm.state = FETCH_PCL\n"); };
                        20 : { outf("  t6507lp_fsm.state = FETCH_PCH\n"); };
                        21 : { outf("  t6507lp_fsm.state = INCREMENT_SP\n"); };
                        22 : { outf("  t6507lp_fsm.state = PULL_STATUS\n"); };
                        23 : { outf("  t6507lp_fsm.state = PULL_PCL\n"); };
                        24 : { outf("  t6507lp_fsm.state = PULL_PCH\n"); };
                        25 : { outf("  t6507lp_fsm.state = INCREMENT_PC\n"); };
                        26 : { outf("  t6507lp_fsm.state = PUSH_REGISTER\n"); };
                        27 : { outf("  t6507lp_fsm.state = PULL_REGISTER\n"); };
                        28 : { outf("  t6507lp_fsm.state = DUMMY\n"); };
                        31 : { outf("  t6507lp_fsm.state = RESET\n"); };
                };
        };
 
        store(input : fsm_input_s) is {
        --reset_n    : bit;
        --alu_result : byte;
        --alu_status : byte;
        --data_in    : byte;
        --alu_x      : byte;
        --alu_y      : byte;
        //print me;
        //print input;
                if (input.reset_n == 0) {
                  rst_counter = 0;
                  new_state = RESET;
                  old_state = RESET;
                  A = 0;
                  X = 0;
                  Y = 0;
                  PC = 0;
                  SP = 255;
                }
                else {
                        case (old_state) {
                                RESET    : {
                                        if (rst_counter == 7) {
                                                new_state = CYCLE_1;
                                        };
                                };
                                CYCLE_1 : {
                                        instruction = input.data_in.as_a(valid_opcodes);
                                        new_state = CYCLE_2;
                                };
                                CYCLE_2 : {
                                        X = input.alu_x;
                                        Y = input.alu_y;
                                        print X, Y;
                                        outf("CYCLE_1\n");
                                        case {
                                                (
                                                  instruction == BRK_IMP ||
                                                  instruction == PHA_IMP ||
                                                  instruction == PHP_IMP ||
                                                  instruction == PLA_IMP ||
                                                  instruction == PLP_IMP ||
                                                  instruction == RTI_IMP ||
                                                  instruction == RTS_IMP
                                                ) : {
                                                        new_state = CYCLE_3;
                                                };
                                                //JSR_ABS : {
                                                //      new_state = CYCLE_3;
                                                //      PCL = input.data_in;
                                                //};
                                                (
                                                  instruction == ADC_ABS ||
                                                  instruction == ASL_ABS ||
                                                  instruction == BIT_ABS ||
                                                  instruction == AND_ABS ||
                                                  instruction == CMP_ABS ||
                                                  instruction == DEC_ABS ||
                                                  instruction == EOR_ABS ||
                                                  instruction == INC_ABS ||
                                                  instruction == JMP_ABS ||
                                                  instruction == LDA_ABS ||
                                                  instruction == LDX_ABS ||
                                                  instruction == LDY_ABS ||
                                                  instruction == LSR_ABS ||
                                                  instruction == ORA_ABS ||
                                                  instruction == ROL_ABS ||
                                                  instruction == ROR_ABS ||
                                                  instruction == SBC_ABS ||
                                                  instruction == STA_ABS ||
                                                  instruction == STX_ABS ||
                                                  instruction == STY_ABS ||
                                                  instruction == LDA_ZPG ||
                                                  instruction == LDX_ZPG ||
                                                  instruction == LDY_ZPG ||
                                                  instruction == EOR_ZPG ||
                                                  instruction == AND_ZPG ||
                                                  instruction == ORA_ZPG ||
                                                  instruction == ADC_ZPG ||
                                                  instruction == SBC_ZPG ||
                                                  instruction == CMP_ZPG ||
                                                  instruction == BIT_ZPG ||
                                                  instruction == STA_ZPG ||
                                                  instruction == STX_ZPG ||
                                                  instruction == STY_ZPG ||
                                                  instruction == ASL_ZPG ||
                                                  instruction == LSR_ZPG ||
                                                  instruction == ROL_ZPG ||
                                                  instruction == ROR_ZPG ||
                                                  instruction == INC_ZPG ||
                                                  instruction == DEC_ZPG ||
                                                  instruction == LDA_ZPX ||
                                                  instruction == LDX_ZPY ||
                                                  instruction == LDY_ZPX ||
                                                  instruction == EOR_ZPX ||
                                                  instruction == AND_ZPX ||
                                                  instruction == ORA_ZPX ||
                                                  instruction == ADC_ZPX ||
                                                  instruction == SBC_ZPX ||
                                                  instruction == CMP_ZPX ||
                                                  instruction == ASL_ZPX ||
                                                  instruction == LSR_ZPX ||
                                                  instruction == ROL_ZPX ||
                                                  instruction == ROR_ZPX ||
                                                  instruction == INC_ZPX ||
                                                  instruction == DEC_ZPX ||
                                                  instruction == STA_ZPX ||
                                                  instruction == STX_ZPY ||
                                                  instruction == STY_ZPX
                                                ) : {
                                                        new_state = CYCLE_3;
                                                        PCL = input.data_in;
                                                        --print X, Y;
                                                        --print input.alu_x, input.alu_y;
                                                        --print 't6507lp_fsm.index';
                                                };
                                                (
                                                  instruction == LDA_ABX ||
                                                  instruction == LDA_ABY ||
                                                  instruction == LDX_ABY ||
                                                  instruction == LDY_ABX ||
                                                  instruction == EOR_ABX ||
                                                  instruction == EOR_ABY ||
                                                  instruction == AND_ABX ||
                                                  instruction == AND_ABY ||
                                                  instruction == ORA_ABX ||
                                                  instruction == ORA_ABY ||
                                                  instruction == ADC_ABX ||
                                                  instruction == ADC_ABY ||
                                                  instruction == SBC_ABX ||
                                                  instruction == SBC_ABY ||
                                                  instruction == CMP_ABX ||
                                                  instruction == CMP_ABY
                                                ) : {
                                                        new_state = CYCLE_3;
                                                        PCL = input.data_in;
                                                        --X = input.alu_x;
                                                        --Y = input.alu_y;
                                                        --print X, Y;
                                                        --print input.alu_x, input.alu_y;
                                                        --print 't6507lp_fsm.index';
                                                        --outf("CYCLE_2\n");
                                                };
                                                (
                                                  instruction == TXS_IMP
                                                ) : {
                                                        new_state = CYCLE_1;
                                                        SP_aux    = input.alu_x;
                                                };
                                                default : {
                                                        new_state = CYCLE_1;
                                                };
                                        };
                                };
                                CYCLE_3 : {
                                        case {
                                                (
                                                  instruction == BRK_IMP ||
                                                  instruction == PLA_IMP ||
                                                  instruction == PLP_IMP ||
                                                  instruction == RTI_IMP ||
                                                  instruction == RTS_IMP ||
                                                  instruction == ASL_ZPG ||
                                                  instruction == LSR_ZPG ||
                                                  instruction == ROL_ZPG ||
                                                  instruction == ROR_ZPG ||
                                                  instruction == INC_ZPG ||
                                                  instruction == DEC_ZPG
                                                ) : {
                                                        new_state = CYCLE_4;
                                                };
                                                //JSR_ABS : {
                                                //      new_state = CYCLE_4;
                                                //      PCH = input.data_in;
                                                //};
                                                (
                                                  instruction == LDA_ZPX ||
                                                  instruction == LDX_ZPY ||
                                                  instruction == LDY_ZPX ||
                                                  instruction == EOR_ZPX ||
                                                  instruction == AND_ZPX ||
                                                  instruction == ORA_ZPX ||
                                                  instruction == ADC_ZPX ||
                                                  instruction == SBC_ZPX ||
                                                  instruction == CMP_ZPX ||
                                                  instruction == ASL_ZPX ||
                                                  instruction == LSR_ZPX ||
                                                  instruction == ROL_ZPX ||
                                                  instruction == ROR_ZPX ||
                                                  instruction == INC_ZPX ||
                                                  instruction == DEC_ZPX ||
                                                  instruction == STA_ZPX ||
                                                  instruction == STX_ZPY ||
                                                  instruction == STY_ZPX
                                                ) : {
                                                        new_state = CYCLE_4;
                                                        --X = input.alu_x;
                                                        --Y = input.alu_y;
                                                        --print X, Y;
                                                        --print input.alu_x, input.alu_y;
                                                        --print 't6507lp_fsm.index';
                                                };
                                                (
                                                  instruction == ADC_ABS ||
                                                  instruction == ASL_ABS ||
                                                  instruction == BIT_ABS ||
                                                  instruction == AND_ABS ||
                                                  instruction == CMP_ABS ||
                                                  instruction == DEC_ABS ||
                                                  instruction == EOR_ABS ||
                                                  instruction == INC_ABS ||
                                                  instruction == LDA_ABS ||
                                                  instruction == LDX_ABS ||
                                                  instruction == LDY_ABS ||
                                                  instruction == LSR_ABS ||
                                                  instruction == ORA_ABS ||
                                                  instruction == ROL_ABS ||
                                                  instruction == ROR_ABS ||
                                                  instruction == SBC_ABS ||
                                                  instruction == STA_ABS ||
                                                  instruction == STX_ABS ||
                                                  instruction == STY_ABS ||
                                                  instruction == LDA_ABX ||
                                                  instruction == LDA_ABY ||
                                                  instruction == LDX_ABY ||
                                                  instruction == LDY_ABX ||
                                                  instruction == EOR_ABX ||
                                                  instruction == EOR_ABY ||
                                                  instruction == AND_ABX ||
                                                  instruction == AND_ABY ||
                                                  instruction == ORA_ABX ||
                                                  instruction == ORA_ABY ||
                                                  instruction == ADC_ABX ||
                                                  instruction == ADC_ABY ||
                                                  instruction == SBC_ABX ||
                                                  instruction == SBC_ABY ||
                                                  instruction == CMP_ABX ||
                                                  instruction == CMP_ABY
                                                ) : {
                                                        new_state = CYCLE_4;
                                                        PCH = input.data_in;
                                                        --X = input.alu_x;
                                                        --Y = input.alu_y;
                                                        --print X, Y;
                                                        --print input.alu_x, input.alu_y;
                                                        --print 't6507lp_fsm.index';
                                                        --outf("CYCLE_3\n");
                                                };
                                                (
                                                  instruction == JMP_ABS
                                                ) : {
                                                        new_state = CYCLE_1;
                                                        PCH = input.data_in;
                                                };
                                                default : {
                                                        new_state = CYCLE_1;
                                                };
                                        };
                                };
                                CYCLE_4 : {
                                        case {
                                                //JSR_ABS : {
                                                //      new_state = CYCLE_5;
                                                //};
                                                (
                                                  instruction == RTS_IMP
                                                ) : {
                                                        new_state = CYCLE_5;
                                                        PCL = input.data_in;
                                                };
                                                (
                                                  instruction == ASL_ABS ||
                                                  instruction == BRK_IMP ||
                                                  instruction == DEC_ABS ||
                                                  instruction == INC_ABS ||
                                                  instruction == LSR_ABS ||
                                                  instruction == ROL_ABS ||
                                                  instruction == ROR_ABS ||
                                                  instruction == RTI_IMP ||
                                                  instruction == ASL_ZPG ||
                                                  instruction == LSR_ZPG ||
                                                  instruction == ROL_ZPG ||
                                                  instruction == ROR_ZPG ||
                                                  instruction == INC_ZPG ||
                                                  instruction == DEC_ZPG ||
                                                  instruction == ASL_ZPX ||
                                                  instruction == LSR_ZPX ||
                                                  instruction == ROL_ZPX ||
                                                  instruction == ROR_ZPX ||
                                                  instruction == INC_ZPX ||
                                                  instruction == DEC_ZPX ||
                                                  (
                                                        more_cycles == TRUE &&
                                                        (
                                                          instruction == LDA_ABX ||
                                                          instruction == LDA_ABY ||
                                                          instruction == LDX_ABY ||
                                                          instruction == LDY_ABX ||
                                                          instruction == EOR_ABX ||
                                                          instruction == EOR_ABY ||
                                                          instruction == AND_ABX ||
                                                          instruction == AND_ABY ||
                                                          instruction == ORA_ABX ||
                                                          instruction == ORA_ABY ||
                                                          instruction == ADC_ABX ||
                                                          instruction == ADC_ABY ||
                                                          instruction == SBC_ABX ||
                                                          instruction == SBC_ABY ||
                                                          instruction == CMP_ABX ||
                                                          instruction == CMP_ABY
                                                        )
                                                  )
                                                ) : {
                                                        --X = input.alu_x;
                                                        --Y = input.alu_y;
                                                        --print X, Y;
                                                        --print input.alu_x, input.alu_y;
                                                        --print 't6507lp_fsm.index';
                                                        --outf("CYCLE_4\n");
                                                        new_state = CYCLE_5;
                                                };
                                                default : {
                                                        new_state = CYCLE_1;
                                                };
                                        };
                                };
                                CYCLE_5 : {
                                        case {
                                                //JSR_ABS : {
                                                //      new_state = CYCLE_6;
                                                //};
                                                (
                                                  instruction == RTI_IMP
                                                ) : {
                                                        new_state = CYCLE_6;
                                                        PCL = input.data_in;
                                                };
                                                (
                                                  instruction == RTS_IMP
                                                ) : {
                                                        new_state = CYCLE_6;
                                                        PCH = input.data_in;
                                                };
                                                (
                                                  instruction == ASL_ABS ||
                                                  instruction == BRK_IMP ||
                                                  instruction == DEC_ABS ||
                                                  instruction == INC_ABS ||
                                                  instruction == LSR_ABS ||
                                                  instruction == ROL_ABS ||
                                                  instruction == ROR_ABS ||
                                                  instruction == ASL_ZPX ||
                                                  instruction == LSR_ZPX ||
                                                  instruction == ROL_ZPX ||
                                                  instruction == ROR_ZPX ||
                                                  instruction == INC_ZPX ||
                                                  instruction == DEC_ZPX
                                                ) : {
                                                        new_state = CYCLE_6;
                                                };
                                                (
                                                  instruction == LDA_ABX ||
                                                  instruction == LDA_ABY ||
                                                  instruction == LDX_ABY ||
                                                  instruction == LDY_ABX ||
                                                  instruction == EOR_ABX ||
                                                  instruction == EOR_ABY ||
                                                  instruction == AND_ABX ||
                                                  instruction == AND_ABY ||
                                                  instruction == ORA_ABX ||
                                                  instruction == ORA_ABY ||
                                                  instruction == ADC_ABX ||
                                                  instruction == ADC_ABY ||
                                                  instruction == SBC_ABX ||
                                                  instruction == SBC_ABY ||
                                                  instruction == CMP_ABX ||
                                                  instruction == CMP_ABY
                                                ) : {
                                                        new_state = CYCLE_1;
                                                        --X = input.alu_x;
                                                        --Y = input.alu_y;
                                                        --print X, Y;
                                                        --print input.alu_x, input.alu_y;
                                                        --print 't6507lp_fsm.index';
                                                        --outf("CYCLE_5\n");
                                                };
                                                --(
                                                --  instruction == LDA_ZPX ||
                                                --  instruction == LDX_ZPY ||
                                                --  instruction == LDY_ZPX ||
                                                --  instruction == EOR_ZPX ||
                                                --  instruction == AND_ZPX ||
                                                --  instruction == ORA_ZPX ||
                                                --  instruction == ADC_ZPX ||
                                                --  instruction == SBC_ZPX ||
                                                --  instruction == CMP_ZPX ||
                                                --  instruction == ASL_ZPX ||
                                                --  instruction == LSR_ZPX ||
                                                --  instruction == ROL_ZPX ||
                                                --  instruction == ROR_ZPX ||
                                                --  instruction == INC_ZPX ||
                                                --  instruction == DEC_ZPX ||
                                                --  instruction == STA_ZPX ||
                                                --  instruction == STX_ZPY ||
                                                --  instruction == STY_ZPX
                                                --) : {
                                                --      new_state = CYCLE_1;
                                                        --X = input.alu_x;
                                                        --Y = input.alu_y;
                                                        --print input.alu_x, input.alu_y;
 
                                                --};
                                                default : {
                                                        new_state = CYCLE_1;
                                                };
                                        };
                                };
                                CYCLE_6 : {
                                        case {
                                                (
                                                  instruction == BRK_IMP
                                                ) : {
                                                        new_state = CYCLE_7;
                                                        PCL = input.data_in;
                                                };
                                                (
                                                  instructions == RTI_IMP
                                                ) : {
                                                        new_state = CYCLE_1;
                                                        PCH = input.data_in;
                                                };
                                                default : {
                                                        new_state = CYCLE_1;
                                                };
                                        };
                                };
                                CYCLE_7 : {
                                        //case (instruction) {
                                        //      BRK_IMP : {
                                        //              new_state = CYCLE_6;
                                        //      };
                                        //      default :
                                                new_state = CYCLE_1;
                                                PCH = input.data_in
                                        };
                        };
                        old_input = new_input;
                        new_input = input;
                };
        };
 
        compare(addr: uint(bits:13), mem_rw:bit, data_out:byte, alu_opcode:valid_opcodes, alu_a:byte, alu_enable:bit) is {
                case (old_state) {
                        RESET    : {
                                print_state();
                                rst = 1;
                                rst_counter = rst_counter + 1;
                        };
                        CYCLE_1 : {
                                more_cycles = FALSE;
                                print_state();
                                print addr;
                                last_instruction = instructions;
                                instructions = instruction;
                                //print instructions;
                                //print last_instruction;
                                if (mem_rw != 0) {
                                        dut_error("Mem_rw is Wrong!");
                                };
                                if (rst == 0) {
                                        case {
                                                (
                                                  last_instruction == ADC_ABS ||
                                                  last_instruction == ADC_IMM ||
                                                  last_instruction == AND_ABS ||
                                                  last_instruction == AND_IMM ||
                                                  last_instruction == BIT_ABS ||
                                                  last_instruction == CMP_ABS ||
                                                  last_instruction == CMP_IMM ||
                                                  last_instruction == CPX_IMM ||
                                                  last_instruction == CPY_IMM ||
                                                  last_instruction == EOR_ABS ||
                                                  last_instruction == EOR_IMM ||
                                                  last_instruction == LDA_ABS ||
                                                  last_instruction == LDA_IMM ||
                                                  last_instruction == LDX_ABS ||
                                                  last_instruction == LDX_IMM ||
                                                  last_instruction == LDY_ABS ||
                                                  last_instruction == LDY_IMM ||
                                                  last_instruction == ORA_ABS ||
                                                  last_instruction == ORA_IMM ||
                                                  last_instruction == PLA_IMP ||
                                                  last_instruction == PLP_IMP ||
                                                  last_instruction == SBC_ABS ||
                                                  last_instruction == SBC_IMM ||
                                                  last_instruction == LDA_ZPG ||
                                                  last_instruction == LDX_ZPG ||
                                                  last_instruction == LDY_ZPG ||
                                                  last_instruction == EOR_ZPG ||
                                                  last_instruction == AND_ZPG ||
                                                  last_instruction == ORA_ZPG ||
                                                  last_instruction == ADC_ZPG ||
                                                  last_instruction == SBC_ZPG ||
                                                  last_instruction == CMP_ZPG ||
                                                  last_instruction == BIT_ZPG ||
                                                  last_instruction == LDA_ZPX ||
                                                  last_instruction == LDX_ZPY ||
                                                  last_instruction == LDY_ZPX ||
                                                  last_instruction == EOR_ZPX ||
                                                  last_instruction == AND_ZPX ||
                                                  last_instruction == ORA_ZPX ||
                                                  last_instruction == ADC_ZPX ||
                                                  last_instruction == SBC_ZPX ||
                                                  last_instruction == CMP_ZPX ||
                                                  last_instruction == LDA_ABX ||
                                                  last_instruction == LDA_ABY ||
                                                  last_instruction == LDX_ABY ||
                                                  last_instruction == LDY_ABX ||
                                                  last_instruction == EOR_ABX ||
                                                  last_instruction == EOR_ABY ||
                                                  last_instruction == AND_ABX ||
                                                  last_instruction == AND_ABY ||
                                                  last_instruction == ORA_ABX ||
                                                  last_instruction == ORA_ABY ||
                                                  last_instruction == ADC_ABX ||
                                                  last_instruction == ADC_ABY ||
                                                  last_instruction == SBC_ABX ||
                                                  last_instruction == SBC_ABY ||
                                                  last_instruction == CMP_ABX ||
                                                  last_instruction == CMP_ABY
                                                ) : {
                                                        if (alu_opcode != last_instruction) {
                                                                --print addr[7:0],X + PCL;
                                                                dut_error("alu_opcode is Wrong!");
                                                        };
                                                        if (alu_enable != 1) {
                                                                dut_error("alu_enable is Wrong!");
                                                        };
                                                        if (addr != PC) {
                                                                dut_error("Address is Wrong!");
                                                        };
                                                };
                                                default : {
                                                        if (alu_opcode.as_a(byte) != 0) {
                                                                --print alu_enable;
                                                                --print alu_opcode;
                                                                --print last_instruction;
                                                                dut_error("alu_opcode is Wrong!");
                                                        };
                                                        if (alu_enable != 0) {
                                                                dut_error("alu_enable is Wrong!");
                                                        };
                                                        if (alu_a != 0) {
                                                                dut_error("alu_a is Wrong!");
                                                        };
                                                        if (addr != PC) {
                                                                dut_error("Address is Wrong!");
                                                        };
                                                };
                                        };
                                }
                                else {
                                        rst = 0;
                                        if (alu_enable != 0) {
                                                dut_error("alu_enable is Wrong!");
                                        };
                                        if (alu_opcode.as_a(byte) != 0) {
                                                dut_error("alu_opcode is Wrong!");
                                        };
                                        if (alu_a != 0) {
                                                dut_error("alu_a is Wrong!");
                                        };
                                        if (addr != PC) {
                                                dut_error("Address is Wrong!");
                                        };
                                };
                                PC = PC + 1;
                        };
                        CYCLE_2 : {
                                print_state();
                                print addr;
                                if (addr != PC) {
                                        dut_error("ADDR should be equal PC!");
                                };
                                if (mem_rw != 0) {
                                        dut_error("MEM_RW should be 0 (READ)");
                                };
                                case {
                                        (
                                          instructions == ADC_ABS ||
                                          instructions == ADC_IMM ||
                                          instructions == AND_ABS ||
                                          instructions == AND_IMM ||
                                          instructions == ASL_ABS ||
                                          instructions == BIT_ABS ||
                                          instructions == BRK_IMP ||
                                          instructions == CMP_ABS ||
                                          instructions == CMP_IMM ||
                                          instructions == CPX_IMM ||
                                          instructions == CPY_IMM ||
                                          instructions == DEC_ABS ||
                                          instructions == EOR_ABS ||
                                          instructions == EOR_IMM ||
                                          instructions == INC_ABS ||
                                          instructions == JMP_ABS ||
                                          instructions == LDA_ABS ||
                                          instructions == LDA_IMM ||
                                          instructions == LDX_ABS ||
                                          instructions == LDX_IMM ||
                                          instructions == LDY_ABS ||
                                          instructions == LDY_IMM ||
                                          instructions == LSR_ABS ||
                                          instructions == ORA_ABS ||
                                          instructions == ORA_IMM ||
                                          instructions == ROL_ABS ||
                                          instructions == ROR_ABS ||
                                          instructions == SBC_ABS ||
                                          instructions == SBC_IMM ||
                                          instructions == LDA_ZPG ||
                                          instructions == LDX_ZPG ||
                                          instructions == LDY_ZPG ||
                                          instructions == EOR_ZPG ||
                                          instructions == AND_ZPG ||
                                          instructions == ORA_ZPG ||
                                          instructions == ADC_ZPG ||
                                          instructions == SBC_ZPG ||
                                          instructions == CMP_ZPG ||
                                          instructions == BIT_ZPG ||
                                          instructions == ASL_ZPG ||
                                          instructions == LSR_ZPG ||
                                          instructions == ROL_ZPG ||
                                          instructions == ROR_ZPG ||
                                          instructions == INC_ZPG ||
                                          instructions == DEC_ZPG ||
                                          instructions == LDA_ZPX ||
                                          instructions == LDX_ZPY ||
                                          instructions == LDY_ZPX ||
                                          instructions == EOR_ZPX ||
                                          instructions == AND_ZPX ||
                                          instructions == ORA_ZPX ||
                                          instructions == ADC_ZPX ||
                                          instructions == SBC_ZPX ||
                                          instructions == CMP_ZPX ||
                                          instructions == ASL_ZPX ||
                                          instructions == LSR_ZPX ||
                                          instructions == ROL_ZPX ||
                                          instructions == ROR_ZPX ||
                                          instructions == INC_ZPX ||
                                          instructions == DEC_ZPX ||
                                          instructions == STX_ZPY ||
                                          instructions == STY_ZPX ||
                                          instructions == STA_ZPX ||
                                          instructions == LDA_ABX ||
                                          instructions == LDA_ABY ||
                                          instructions == LDX_ABY ||
                                          instructions == LDY_ABX ||
                                          instructions == EOR_ABX ||
                                          instructions == EOR_ABY ||
                                          instructions == AND_ABX ||
                                          instructions == AND_ABY ||
                                          instructions == ORA_ABX ||
                                          instructions == ORA_ABY ||
                                          instructions == ADC_ABX ||
                                          instructions == ADC_ABY ||
                                          instructions == SBC_ABX ||
                                          instructions == SBC_ABY ||
                                          instructions == CMP_ABX ||
                                          instructions == CMP_ABY
                                        ) : {
                                                if (alu_opcode.as_a(byte) != 0) {
                                                        dut_error("Opcode is Wrong!");
                                                };
                                                if (alu_enable != 0) {
                                                        dut_error("BRK_IMP is Wrong!");
                                                };
                                                PC = PC + 1;
                                        };
                                        -- TODO: STX and STY should not
                                        -- TODO: they dont need access to alu at any cycle
                                        -- TODO: because X and Y are available at alu_x and alu_y
                                        (
                                          instructions == STA_ABS ||
                                          instructions == STA_ZPG ||
                                          instructions == STX_ABS ||
                                          instructions == STY_ABS ||
                                          instructions == STX_ZPG ||
                                          instructions == STY_ZPG
                                        ) : {
                                                if (alu_opcode != instructions) {
                                                        dut_error("Opcode is Wrong!");
                                                };
                                                if (alu_enable != 1) {
                                                        dut_error("ASL_ACC is Wrong!");
                                                };
                                                PC = PC + 1;
                                        };
                                        (
                                          instructions == NOP_IMP ||
                                          instructions == PHP_IMP ||
                                          instructions == PLA_IMP ||
                                          instructions == PLP_IMP ||
                                          instructions == RTI_IMP ||
                                          instructions == RTS_IMP
 
                                        ) : {
                                                if (alu_opcode.as_a(byte) != 0) {
                                                        dut_error("Opcode is Wrong!");
                                                };
                                                if (alu_enable != 0) {
                                                        dut_error("ASL_ACC is Wrong!");
                                                };
                                        };
                                        (
                                          instructions == ASL_ACC ||
                                          instructions == CLC_IMP ||
                                          instructions == CLD_IMP ||
                                          instructions == CLI_IMP ||
                                          instructions == CLV_IMP ||
                                          instructions == DEX_IMP ||
                                          instructions == DEY_IMP ||
                                          instructions == INX_IMP ||
                                          instructions == INY_IMP ||
                                          instructions == LSR_ACC ||
                                          instructions == PHA_IMP ||
                                          instructions == ROL_ACC ||
                                          instructions == SEC_IMP ||
                                          instructions == SED_IMP ||
                                          instructions == SEI_IMP ||
                                          instructions == TAX_IMP ||
                                          instructions == TAY_IMP ||
                                          instructions == TXA_IMP ||
                                          instructions == TYA_IMP
                                        ) : {
                                                if (alu_opcode != instructions) {
                                                        dut_error("Opcode is Wrong!");
                                                };
                                                if (alu_enable != 1) {
                                                        dut_error("ASL_ACC is Wrong!");
                                                };
                                        };
                                        //JSR_ABS : {
                                        //      if (alu_opcode.as_a(byte) != 0) {
                                        //              dut_error("Opcode is Wrong!");
                                        //      };
                                        //      if (mem_rw != 0) {
                                        //              dut_error("MEM_RW should be 1 (WRITE)");
                                        //      };
                                        //      if (alu_enable != 0) {
                                        //              dut_error("JSR_IMP is Wrong!");
                                        //      };
                                        //      if (addr != PC) {
                                        //              dut_error("ADDR should be equal SP!");
                                        //      };
                                        //      PC = PC + 1;
                                        //};
                                        (
                                          instructions == TSX_IMP
                                        ) : {
                                                if (alu_opcode != instructions) {
                                                        dut_error("Opcode is Wrong!");
                                                };
                                                if (alu_enable != 1) {
                                                        dut_error("TSX_IMP is Wrong!");
                                                };
                                                if (alu_a != SP) {
                                                        dut_error("TSX_IMP is Wrong!");
                                                };
                                        };
                                        (
                                          instructions == TXS_IMP
                                        ) : {
                                                if (alu_opcode != instructions) {
                                                        dut_error("Opcode is Wrong!");
                                                };
                                                if (alu_enable != 1) {
                                                        dut_error("TXS_IMP is Wrong!");
                                                };
                                                SP = SP_aux;
                                        };
                                };
                        };
                        CYCLE_3 : {
                                print_state();
                                print addr;
                                case {
                                        (
                                          instructions == BRK_IMP
                                        ) : {
                                                if (alu_opcode.as_a(byte) != 0) {
                                                        dut_error("Opcode is Wrong!");
                                                };
                                                if (mem_rw != 1) {
                                                        dut_error("MEM_RW should be 1 (WRITE)");
                                                };
                                                if (alu_enable != 0) {
                                                        dut_error("BRK_IMP is Wrong!");
                                                };
                                                if (data_out[4:0] != PC[12:8] && data_out[7:5] != 0) {
                                                        dut_error("BRK_IMP is Wrong!");
                                                };
                                                if (addr != SP + 256) {
                                                        dut_error("ADDR should be equal SP!");
                                                };
                                                SP = SP - 1;
                                        };
                                        //JSR_ABS : {
                                        //      if (alu_opcode.as_a(byte) != 0) {
                                        //              dut_error("Opcode is Wrong!");
                                        //      };
                                        //      if (mem_rw != 0) {
                                        //              dut_error("MEM_RW should be 1 (WRITE)");
                                        //      };
                                        //      if (alu_enable != 0) {
                                        //              dut_error("JSR_IMP is Wrong!");
                                        //      };
                                        //      if (addr != PC) {
                                        //              dut_error("ADDR should be equal PC!");
                                        //      };
                                        //};
                                        -- TODO: This is probably an error STA should not use ALU on the third cycle
                                        (
                                          instructions == STA_ZPX ||
                                          instructions == STX_ZPY ||
                                          instructions == STY_ZPX
                                        ) : {
                                                if (alu_opcode != instructions) {
                                                        dut_error("Opcode is Wrong!");
                                                };
                                                if (alu_enable != 1) {
                                                        dut_error("ASL_ACC is Wrong!");
                                                };
                                                if (mem_rw != 0) {
                                                        dut_error("MEM_RW should be 1 (WRITE)");
                                                };
                                                if (addr != PCL) {
                                                        dut_error("ADDR should be equal SP!");
                                                };
                                        };
                                        (
                                          instructions == STA_ZPG ||
                                          instructions == STX_ZPG ||
                                          instructions == STY_ZPG
                                        ) : {
                                                if (alu_opcode.as_a(byte) != 0) {
                                                        dut_error("Opcode is Wrong!");
                                                };
                                                if (alu_enable != 0) {
                                                        dut_error("ASL_ACC is Wrong!");
                                                };
                                                if (mem_rw != 1) {
                                                        dut_error("MEM_RW should be 1 (WRITE)");
                                                };
                                                if (addr != PCL) {
                                                        dut_error("ADDR should be equal SP!");
                                                };
                                        };
                                        (
                                          instructions == JMP_ABS
                                        ) : {
                                                if (alu_opcode.as_a(byte) != 0) {
                                                        dut_error("Opcode is Wrong!");
                                                };
                                                if (alu_enable != 0) {
                                                        dut_error("ASL_ACC is Wrong!");
                                                };
                                                if (mem_rw != 0) {
                                                        dut_error("MEM_RW should be 1 (WRITE)");
                                                };
                                                PC[7:0] = PCL;
                                                PC[12:8] = PCH[4:0];
                                        };
                                        (
                                          instructions == LDA_ZPX ||
                                          instructions == LDX_ZPY ||
                                          instructions == LDY_ZPX ||
                                          instructions == EOR_ZPX ||
                                          instructions == AND_ZPX ||
                                          instructions == ORA_ZPX ||
                                          instructions == ADC_ZPX ||
                                          instructions == SBC_ZPX ||
                                          instructions == CMP_ZPX ||
                                          instructions == ASL_ZPX ||
                                          instructions == LSR_ZPX ||
                                          instructions == ROL_ZPX ||
                                          instructions == ROR_ZPX ||
                                          instructions == INC_ZPX ||
                                          instructions == DEC_ZPX
                                        ) : {
                                                if (alu_opcode.as_a(byte) != 0) {
                                                        dut_error("Opcode is Wrong!");
                                                };
                                                if (alu_enable != 0) {
                                                        dut_error("ASL_ACC is Wrong!");
                                                };
                                                if (mem_rw != 0) {
                                                        dut_error("MEM_RW should be 0 (WRITE)");
                                                };
                                                if (addr != PCL) {
                                                        dut_error("ADDR should be equal SP!");
                                                };
                                        };
                                        (
                                          instructions == ADC_ABS ||
                                          instructions == AND_ABS ||
                                          instructions == ASL_ABS ||
                                          instructions == BIT_ABS ||
                                          instructions == CMP_ABS ||
                                          instructions == DEC_ABS ||
                                          instructions == EOR_ABS ||
                                          instructions == INC_ABS ||
                                          instructions == LDA_ABS ||
                                          instructions == LDX_ABS ||
                                          instructions == LDY_ABS ||
                                          instructions == LSR_ABS ||
                                          instructions == ORA_ABS ||
                                          instructions == ROL_ABS ||
                                          instructions == ROR_ABS ||
                                          instructions == SBC_ABS ||
                                          instructions == STA_ABS ||
                                          instructions == STX_ABS ||
                                          instructions == STY_ABS ||
                                          instructions == LDA_ABX ||
                                          instructions == LDY_ABX ||
                                          instructions == EOR_ABX ||
                                          instructions == AND_ABX ||
                                          instructions == ORA_ABX ||
                                          instructions == ADC_ABX ||
                                          instructions == SBC_ABX ||
                                          instructions == CMP_ABX
                                        ) : {
                                                if (alu_opcode.as_a(byte) != 0) {
                                                        dut_error("Opcode is Wrong!");
                                                };
                                                if (alu_enable != 0) {
                                                        dut_error("ASL_ACC is Wrong!");
                                                };
                                                if (addr != PC) {
                                                        dut_error("ADDR should be equal SP!");
                                                };
                                                if (mem_rw != 0) {
                                                        dut_error("MEM_RW should be 1 (WRITE)");
                                                };
                                                PC = PC + 1;
                                                if (PCL + X > 255) {
                                                        more_cycles = TRUE;
                                                };
                                        };
                                        (
                                          instructions == LDA_ABY ||
                                          instructions == LDX_ABY ||
                                          instructions == AND_ABY ||
                                          instructions == EOR_ABY ||
                                          instructions == ORA_ABY ||
                                          instructions == ADC_ABY ||
                                          instructions == SBC_ABY ||
                                          instructions == CMP_ABY
                                        ) : {
                                                if (alu_opcode.as_a(byte) != 0) {
                                                        dut_error("Opcode is Wrong!");
                                                };
                                                if (alu_enable != 0) {
                                                        dut_error("ASL_ACC is Wrong!");
                                                };
                                                if (addr != PC) {
                                                        dut_error("ADDR should be equal SP!");
                                                };
                                                if (mem_rw != 0) {
                                                        dut_error("MEM_RW should be 1 (WRITE)");
                                                };
                                                PC = PC + 1;
                                                if (PCL + Y > 255) {
                                                        more_cycles = TRUE;
                                                };
                                        };
                                        (
                                          instructions == LDA_ZPG ||
                                          instructions == LDX_ZPG ||
                                          instructions == LDY_ZPG ||
                                          instructions == EOR_ZPG ||
                                          instructions == AND_ZPG ||
                                          instructions == ORA_ZPG ||
                                          instructions == ADC_ZPG ||
                                          instructions == SBC_ZPG ||
                                          instructions == CMP_ZPG ||
                                          instructions == BIT_ZPG ||
                                          instructions == ASL_ZPG ||
                                          instructions == LSR_ZPG ||
                                          instructions == ROL_ZPG ||
                                          instructions == ROR_ZPG ||
                                          instructions == INC_ZPG ||
                                          instructions == DEC_ZPG
                                        ) : {
                                                if (alu_opcode.as_a(byte) != 0) {
                                                        dut_error("Opcode is Wrong!");
                                                };
                                                if (alu_enable != 0) {
                                                        dut_error("ASL_ACC is Wrong!");
                                                };
                                                if (mem_rw != 0) {
                                                        dut_error("MEM_RW should be 1 (WRITE)");
                                                };
                                                if (addr != PCL) {
                                                        dut_error("ADDR should be equal SP!");
                                                };
                                        };
                                        (
                                          instructions == PHA_IMP ||
                                          instructions == PHP_IMP
                                        ) : {
                                                if (alu_opcode.as_a(byte) != 0) {
                                                        dut_error("Opcode is Wrong!");
                                                };
                                                if (mem_rw != 1) {
                                                        dut_error("MEM_RW should be 1 (WRITE)");
                                                };
                                                if (alu_a != 0) {
                                                        dut_error("PHP_IMP is Wrong!");
                                                };
                                                if (addr != SP + 256) {
                                                        dut_error("ADDR should be equal SP!");
                                                };
                                                SP = SP - 1;
                                                if (alu_enable != 0) {
                                                        dut_error("PHP_IMP is Wrong!");
                                                };
                                        };
                                        (
                                          instructions == PLA_IMP ||
                                          instructions == PLP_IMP ||
                                          instructions == RTI_IMP ||
                                          instructions == RTS_IMP
                                        ) : {
                                                if (alu_opcode.as_a(byte) != 0) {
                                                        dut_error("Opcode is Wrong!");
                                                };
                                                if (alu_enable != 0) {
                                                        dut_error("PLA_IMP is Wrong!");
                                                };
                                                if (mem_rw != 0) {
                                                        dut_error("MEM_RW should be 0 (READ)");
                                                };
                                                if (addr != SP + 256) {
                                                        dut_error("ADDR should be equal SP!");
                                                };
                                                SP = SP + 1;
                                        };
                                };
                        };
                        CYCLE_4 : {
                                print_state();
                                print addr;
                                case {
                                        (
                                          instructions == BRK_IMP
                                        ) : {
                                                if (alu_opcode.as_a(byte) != 0) {
                                                        dut_error("Opcode is Wrong!");
                                                };
                                                if (mem_rw != 1) {
                                                        dut_error("MEM_RW should be 1 (WRITE)");
                                                };
                                                if (alu_enable != 0) {
                                                        dut_error("BRK_IMP is Wrong!");
                                                };
                                                if (data_out != PC[7:0]) {
                                                        dut_error("BRK_IMP is Wrong!");
                                                };
                                                if (addr != SP + 256) {
                                                        dut_error("ADDR should be equal SP!");
                                                };
                                                SP = SP - 1;
                                        };
                                        //JSR_ABS : {
                                        //      if (alu_opcode.as_a(byte) != 0) {
                                        //              dut_error("Opcode is Wrong!");
                                        //      };
                                        //      if (mem_rw != 1) {
                                        //              dut_error("MEM_RW should be 1 (WRITE)");
                                        //      };
                                        //      if (alu_enable != 0) {
                                        //              dut_error("JSR_ABS is Wrong!");
                                        //      };
                                        //      if (data_out != PC[7:0]) {
                                        //              dut_error("JSR_ABS is Wrong!");
                                        //      };
                                        //      if (addr != SP + 256) {
                                        //              dut_error("ADDR should be equal SP!");
                                        //      };
                                        //      SP = SP - 1;
                                        //};
                                        (
                                          instructions == LDA_ZPX ||
                                          instructions == LDY_ZPX ||
                                          instructions == EOR_ZPX ||
                                          instructions == AND_ZPX ||
                                          instructions == ORA_ZPX ||
                                          instructions == ADC_ZPX ||
                                          instructions == SBC_ZPX ||
                                          instructions == CMP_ZPX ||
                                          instructions == ASL_ZPX ||
                                          instructions == LSR_ZPX ||
                                          instructions == ROL_ZPX ||
                                          instructions == ROR_ZPX ||
                                          instructions == INC_ZPX ||
                                          instructions == DEC_ZPX
                                        ) : {
                                                if (alu_opcode.as_a(byte) != 0) {
                                                        dut_error("Opcode is Wrong!");
                                                };
                                                if (alu_enable != 0) {
                                                        dut_error("ASL_ACC is Wrong!");
                                                };
                                                if (mem_rw != 0) {
                                                        dut_error("MEM_RW should be 0 (WRITE)");
                                                };
                                                --TODO: Isn`t it suppose to have ADDRH == 0????
                                                if (addr != PCL + X) {
                                                        print addr[7:0], PCL+X, PCL, X, 't6507lp_fsm.index';
                                                        dut_error("ADDR should be equal SP!");
                                                };
                                        };
                                        (
                                          instructions == LDA_ABX ||
                                          instructions == LDY_ABX ||
                                          instructions == EOR_ABX ||
                                          instructions == AND_ABX ||
                                          instructions == ORA_ABX ||
                                          instructions == ADC_ABX ||
                                          instructions == SBC_ABX ||
                                          instructions == CMP_ABX
                                        ) : {
                                                if (alu_opcode.as_a(byte) != 0) {
                                                        dut_error("Opcode is Wrong!");
                                                };
                                                if (alu_enable != 0) {
                                                        dut_error("ASL_ACC is Wrong!");
                                                };
                                                if (mem_rw != 0) {
                                                        dut_error("MEM_RW should be 0 (WRITE)");
                                                };
                                                if (PCL + X > 255) {
                                                        more_cycles = TRUE;
                                                        if (addr[7:0] != PCL + X - 256) {
                                                                --print addr[7:0], PCL + X - 256;
                                                                dut_error("ADDR should be equal SP!");
                                                        };
                                                }
                                                else {
                                                        if (addr[7:0] != PCL + X) {
                                                                dut_error("ADDR should be equal SP!");
                                                        };
                                                };
                                        };
                                        (
                                          instructions == LDX_ZPY ||
                                          instructions == LDA_ABY ||
                                          instructions == LDX_ABY ||
                                          instructions == EOR_ABY ||
                                          instructions == AND_ABY ||
                                          instructions == ORA_ABY ||
                                          instructions == ADC_ABY ||
                                          instructions == SBC_ABY ||
                                          instructions == CMP_ABY
                                        ) : {
                                                if (alu_opcode.as_a(byte) != 0) {
                                                        dut_error("Opcode is Wrong!");
                                                };
                                                if (alu_enable != 0) {
                                                        dut_error("ASL_ACC is Wrong!");
                                                };
                                                if (mem_rw != 0) {
                                                        dut_error("MEM_RW should be 0 (WRITE)");
                                                };
                                                if (PCL + Y > 255) {
                                                        more_cycles = TRUE;
                                                        if (addr[7:0] != PCL + Y - 256) {
                                                                print addr[7:0], PCL + Y - 256;
                                                                print PCL, Y;
                                                                print 't6507lp_fsm.index';
                                                                dut_error("ADDR should be equal SP!");
                                                        };
                                                }
                                                else {
                                                        if (addr[7:0] != PCL + Y) {
                                                                dut_error("ADDR should be equal SP!");
                                                        };
                                                };
                                        };
                                        (
                                          instructions == ADC_ABS ||
                                          instructions == AND_ABS ||
                                          instructions == ASL_ABS ||
                                          instructions == BIT_ABS ||
                                          instructions == CMP_ABS ||
                                          instructions == DEC_ABS ||
                                          instructions == EOR_ABS ||
                                          instructions == INC_ABS ||
                                          instructions == LDA_ABS ||
                                          instructions == LDX_ABS ||
                                          instructions == LDY_ABS ||
                                          instructions == LSR_ABS ||
                                          instructions == ORA_ABS ||
                                          instructions == ROL_ABS ||
                                          instructions == ROR_ABS ||
                                          instructions == SBC_ABS
                                          ) : {
                                                if (alu_opcode.as_a(byte) != 0) {
                                                        dut_error("Opcode is Wrong!");
                                                };
                                                if (alu_enable != 0) {
                                                        dut_error("ASL_ACC is Wrong!");
                                                };
                                                if (addr[7:0] != PCL) {
                                                        dut_error("ADDR should be equal SP!");
                                                };
                                                if (addr[12:8] != PCH[4:0]) {
                                                        dut_error("ADDR should be equal SP!");
                                                };
                                                if (mem_rw != 0) {
                                                        dut_error("MEM_RW should be 1 (WRITE)");
                                                };
                                        };
                                        (
                                          instructions == STA_ABS ||
                                          instructions == STX_ABS ||
                                          instructions == STY_ABS
                                        ) : {
                                                if (alu_opcode.as_a(byte) != 0) {
                                                        dut_error("Opcode is Wrong!");
                                                };
                                                if (alu_enable != 0) {
                                                        dut_error("ASL_ACC is Wrong!");
                                                };
                                                if (addr[7:0] != PCL) {
                                                        dut_error("ADDR should be equal SP!");
                                                };
                                                if (addr[12:8] != PCH[4:0]) {
                                                        dut_error("ADDR should be equal SP!");
                                                };
                                                if (mem_rw != 1) {
                                                        dut_error("MEM_RW should be 1 (WRITE)");
                                                };
                                        };
                                        (
                                          instructions == ASL_ZPG ||
                                          instructions == LSR_ZPG ||
                                          instructions == ROL_ZPG ||
                                          instructions == ROR_ZPG ||
                                          instructions == INC_ZPG ||
                                          instructions == DEC_ZPG
                                        ) : {
                                                if (alu_opcode != instructions) {
                                                        dut_error("Opcode is Wrong!");
                                                };
                                                if (mem_rw != 1) {
                                                        dut_error("MEM_RW should be 1 (WRITE)");
                                                };
                                                if (alu_enable != 1) {
                                                        dut_error("BRK_IMP is Wrong!");
                                                };
                                                if (addr[7:0] != PCL) {
                                                        dut_error("ADDR should be equal SP!");
                                                };
                                        };
                                        (
                                          instructions == STA_ZPX ||
                                          instructions == STY_ZPX
                                        ) : {
                                                if (alu_opcode.as_a(byte) != 0) {
                                                        dut_error("Opcode is Wrong!");
                                                };
                                                if (alu_enable != 0) {
                                                        dut_error("ASL_ACC is Wrong!");
                                                };
                                                if (mem_rw != 1) {
                                                        dut_error("MEM_RW should be 1 (WRITE)");
                                                };
                                                if (addr != PCL + X) {
                                                        dut_error("ADDR should be equal SP!");
                                                };
                                        };
                                        (
                                          instructions == STX_ZPY
                                        ) : {
                                                if (alu_opcode.as_a(byte) != 0) {
                                                        dut_error("Opcode is Wrong!");
                                                };
                                                if (alu_enable != 0) {
                                                        dut_error("ASL_ACC is Wrong!");
                                                };
                                                if (mem_rw != 1) {
                                                        dut_error("MEM_RW should be 1 (WRITE)");
                                                };
                                                if (addr != PCL + Y) {
                                                        dut_error("ADDR should be equal SP!");
                                                };
                                        };
                                        (
                                          instructions == PLA_IMP ||
                                          instructions == PLP_IMP
                                        ) : {
                                                if (alu_opcode.as_a(byte) != 0) {
                                                        dut_error("Opcode is Wrong!");
                                                };
                                                if (mem_rw != 0) {
                                                        dut_error("MEM_RW should be 0 (READ)");
                                                };
                                                if (alu_enable != 0) {
                                                        dut_error("PLP_IMP is Wrong!");
                                                };
                                                if (addr != SP + 256) {
                                                        dut_error("ADDR should be equal SP!");
                                                };
                                        };
                                        (
                                          instructions == RTI_IMP
                                        ) : {
                                                if (alu_opcode.as_a(byte) != 0) {
                                                        dut_error("Opcode is Wrong!");
                                                };
                                                if (mem_rw != 0) {
                                                        dut_error("MEM_RW should be 1 (WRITE)");
                                                };
                                                if (alu_enable != 0) {
                                                        dut_error("RTI_IMP is Wrong!");
                                                };
                                                if (addr != SP + 256) {
                                                        --print addr, SP;
                                                        dut_error("ADDR should be equal SP!");
                                                };
                                                SP = SP + 1;
                                        };
                                        (
                                          instructions == RTS_IMP
                                        ) : {
                                                if (alu_opcode.as_a(byte) != 0) {
                                                        dut_error("Opcode is Wrong!");
                                                };
                                                if (alu_enable != 0) {
                                                        dut_error("RTS_IMP is Wrong!");
                                                };
                                                if (addr != SP + 256) {
                                                        dut_error("ADDR should be equal SP!");
                                                };
                                                SP = SP + 1;
                                                PC[7:0] = PCL;
                                        };
                                };
                        };
                        CYCLE_5 : {
                                print_state();
                                print addr;
                                case {
                                        (
                                          instructions == BRK_IMP
                                        ) : {
                                                if (alu_opcode.as_a(byte) != 0) {
                                                        dut_error("Opcode is Wrong!");
                                                };
                                                if (mem_rw != 1) {
                                                        dut_error("MEM_RW should be 1 (WRITE)");
                                                };
                                                if (alu_enable != 0) {
                                                        dut_error("BRK_IMP is Wrong!");
                                                };
                                                if (addr != SP + 256) {
                                                        dut_error("ADDR should be equal SP!");
                                                };
                                                SP = SP - 1;
                                        };
                                        //JSR_ABS : {
                                        //      if (alu_opcode.as_a(byte) != 0) {
                                        //              dut_error("Opcode is Wrong!");
                                        //      };
                                        //      if (mem_rw != 1) {
                                        //              dut_error("MEM_RW should be 1 (WRITE)");
                                        //      };
                                        //      if (alu_enable != 0) {
                                        //              dut_error("JSR_ABS is Wrong!");
                                        //      };
                                        //      if (data_out != PC[12:8]) {
                                        //              dut_error("JSR_ABS is Wrong!");
                                        //      };
                                        //      if (addr != SP + 256) {
                                        //              dut_error("ADDR should be equal SP!");
                                        //      };
                                        //      SP = SP - 1;
                                        //};
                                        (
                                          instructions == RTI_IMP
                                        ) : {
                                                if (alu_opcode != instructions) {
                                                        dut_error("Opcode is Wrong!");
                                                };
                                                if (mem_rw != 0) {
                                                        dut_error("MEM_RW should be 1 (WRITE)");
                                                };
                                                if (alu_enable != 1) {
                                                        dut_error("RTI_IMP is Wrong!");
                                                };
                                                if (addr != SP + 256) {
                                                        dut_error("ADDR should be equal SP!");
                                                };
                                                SP = SP + 1;
                                                PC[7:0] = PCL;
                                        };
                                        (
                                          instructions == RTS_IMP
                                        ) : {
                                                if (alu_opcode.as_a(byte) != 0) {
                                                        dut_error("Opcode is Wrong!");
                                                };
                                                if (alu_enable != 0) {
                                                        dut_error("SEI_IMP is Wrong!");
                                                };
                                                if (addr != SP + 256) {
                                                        dut_error("ADDR should be equal SP!");
                                                };
                                                PC[12:8] = PCH[4:0];
                                        };
                                        (
                                          instructions == ASL_ZPG ||
                                          instructions == LSR_ZPG ||
                                          instructions == ROL_ZPG ||
                                          instructions == ROR_ZPG ||
                                          instructions == INC_ZPG ||
                                          instructions == DEC_ZPG
                                        ) : {
                                                if (alu_opcode.as_a(byte) != 0) {
                                                        dut_error("Opcode is Wrong!");
                                                };
                                                if (mem_rw != 1) {
                                                        dut_error("MEM_RW should be 1 (WRITE)");
                                                };
                                                if (alu_enable != 0) {
                                                        dut_error("BRK_IMP is Wrong!");
                                                };
                                                if (addr[7:0] != PCL) {
                                                        dut_error("ADDR should be equal SP!");
                                                };
                                        };
                                        (
                                          instructions == LDA_ABX ||
                                          instructions == LDY_ABX ||
                                          instructions == EOR_ABX ||
                                          instructions == AND_ABX ||
                                          instructions == ORA_ABX ||
                                          instructions == ADC_ABX ||
                                          instructions == SBC_ABX ||
                                          instructions == CMP_ABX
                                        ) : {
                                                if (alu_opcode.as_a(byte) != 0) {
                                                        dut_error("Opcode is Wrong!");
                                                };
                                                if (alu_enable != 0) {
                                                        dut_error("ASL_ACC is Wrong!");
                                                };
                                                if (mem_rw != 0) {
                                                        dut_error("MEM_RW should be 0 (WRITE)");
                                                };
                                                if (addr[7:0] != PCL + X - 256) {
                                                        dut_error("ADDR is wrong!");
                                                };
                                                if (addr[12:8] != PCH[4:0] + 1) {
                                                        dut_error("ADDR is wrong!");
                                                };
                                        };
                                        (
                                          instructions == LDX_ZPY ||
                                          instructions == LDA_ABY ||
                                          instructions == LDX_ABY ||
                                          instructions == EOR_ABY ||
                                          instructions == AND_ABY ||
                                          instructions == ORA_ABY ||
                                          instructions == ADC_ABY ||
                                          instructions == SBC_ABY ||
                                          instructions == CMP_ABY
                                        ) : {
                                                if (alu_opcode.as_a(byte) != 0) {
                                                        dut_error("Opcode is Wrong!");
                                                };
                                                if (alu_enable != 0) {
                                                        dut_error("ASL_ACC is Wrong!");
                                                };
                                                if (mem_rw != 0) {
                                                        dut_error("MEM_RW should be 0 (WRITE)");
                                                };
                                                if (addr[7:0] != PCL + Y - 256) {
                                                        dut_error("ADDR is wrong!");
                                                };
                                                if (addr[12:8] != PCH[4:0] + 1) {
                                                        dut_error("ADDR is wrong!");
                                                };
                                        };
                                        (
                                          instructions == ASL_ZPX ||
                                          instructions == LSR_ZPX ||
                                          instructions == ROL_ZPX ||
                                          instructions == ROR_ZPX ||
                                          instructions == INC_ZPX ||
                                          instructions == DEC_ZPX
                                        ) : {
                                                if (alu_opcode != instructions) {
                                                        dut_error("Opcode is Wrong!");
                                                };
                                                if (alu_enable != 1) {
                                                        dut_error("ASL_ACC is Wrong!");
                                                };
                                                if (mem_rw != 1) {
                                                        dut_error("MEM_RW should be 0 (WRITE)");
                                                };
                                                if (addr != PCL + X) {
                                                        dut_error("ADDR should be equal SP!");
                                                };
                                        };
                                        (
                                          instructions == ASL_ABS ||
                                          instructions == DEC_ABS ||
                                          instructions == INC_ABS ||
                                          instructions == LSR_ABS ||
                                          instructions == ROL_ABS ||
                                          instructions == ROR_ABS
                                        ) : {
                                                if (alu_opcode != instructions) {
                                                        dut_error("Opcode is Wrong!");
                                                };
                                                if (mem_rw != 1) {
                                                        dut_error("MEM_RW should be 1 (WRITE)");
                                                };
                                                if (alu_enable != 1) {
                                                        dut_error("BRK_IMP is Wrong!");
                                                };
                                                if (addr[7:0] != PCL) {
                                                        dut_error("ADDR should be equal SP!");
                                                };
                                                if (addr[12:8] != PCH[4:0]) {
                                                        dut_error("ADDR should be equal SP!");
                                                };
                                        };
                                };
                        };
                        CYCLE_6 : {
                                print_state();
                                print addr;
                                case {
                                        (
                                          instructions == BRK_IMP
                                        ) : {
                                                if (alu_opcode.as_a(byte) != 0) {
                                                        dut_error("Opcode is Wrong!");
                                                };
                                                if (mem_rw != 0) {
                                                        dut_error("MEM_RW should be 1 (WRITE)");
                                                };
                                                if (alu_enable != 0) {
                                                        dut_error("BRK_IMP is Wrong!");
                                                };
                                                if (addr != 13'b1111111111110) {
                                                        dut_error("BRK_IMP is Wrong!");
                                                };
                                                PC[7:0] = PCL;
                                        };
                                        //JSR_ABS : {
                                        //      if (alu_opcode.as_a(byte) != 0) {
                                        //              dut_error("Opcode is Wrong!");
                                        //      };
                                        //      if (mem_rw != 0) {
                                        //              dut_error("MEM_RW should be 1 (WRITE)");
                                        //      };
                                        //      if (alu_enable != 0) {
                                        //              dut_error("JSR_ABS is Wrong!");
                                        //      };
                                        //      if (addr != PC) {
                                        //              dut_error("ADDR should be equal SP!");
                                        //      };
                                        //      PC [7:0] = PCL;
                                        //      PC[12:8] = PCH[4:0];
                                        //};
                                        (
                                          instructions == RTI_IMP
                                        ) : {
                                                if (alu_opcode.as_a(byte) != 0) {
                                                        dut_error("Opcode is Wrong!");
                                                };
                                                if (mem_rw != 0) {
                                                        dut_error("MEM_RW should be 1 (WRITE)");
                                                };
                                                if (alu_enable != 0) {
                                                        dut_error("RTI_IMP is Wrong!");
                                                };
                                                if (addr != SP + 256) {
                                                        dut_error("ADDR should be equal SP!");
                                                };
                                                PC[12:8] = PCH[4:0];
                                        };
                                        (
                                          instructions == RTS_IMP
                                        ) : {
                                                if (alu_opcode.as_a(byte) != 0) {
                                                        dut_error("Opcode is Wrong!");
                                                };
                                                if (mem_rw != 0) {
                                                        dut_error("MEM_RW should be 1 (WRITE)");
                                                };
                                                if (alu_enable != 0) {
                                                        dut_error("RTI_IMP is Wrong!");
                                                };
                                                if (addr != PC) {
                                                        dut_error("ADDR should be equal SP!");
                                                };
                                                PC = PC + 1;
                                        };
                                        (
                                          instructions == ASL_ZPX ||
                                          instructions == LSR_ZPX ||
                                          instructions == ROL_ZPX ||
                                          instructions == ROR_ZPX ||
                                          instructions == INC_ZPX ||
                                          instructions == DEC_ZPX
                                        ) : {
                                                if (alu_opcode.as_a(byte) != 0) {
                                                        dut_error("Opcode is Wrong!");
                                                };
                                                if (alu_enable != 0) {
                                                        dut_error("ASL_ACC is Wrong!");
                                                };
                                                if (mem_rw != 1) {
                                                        dut_error("MEM_RW should be 0 (WRITE)");
                                                };
                                                if (addr != PCL + X) {
                                                        dut_error("ADDR should be equal SP!");
                                                };
                                        };
                                        (
                                          instructions == ASL_ABS ||
                                          instructions == DEC_ABS ||
                                          instructions == INC_ABS ||
                                          instructions == LSR_ABS ||
                                          instructions == ROL_ABS ||
                                          instructions == ROR_ABS
                                        ) : {
                                                if (alu_opcode.as_a(byte) != 0) {
                                                        dut_error("Opcode is Wrong!");
                                                };
                                                if (mem_rw != 1) {
                                                        dut_error("MEM_RW should be 1 (WRITE)");
                                                };
                                                if (alu_enable != 0) {
                                                        dut_error("BRK_IMP is Wrong!");
                                                };
                                                if (addr[7:0] != PCL) {
                                                        dut_error("ADDR should be equal SP!");
                                                };
                                                if (addr[12:8] != PCH[4:0]) {
                                                        dut_error("ADDR should be equal SP!");
                                                };
                                        };
                                };
                        };
                        CYCLE_7 : {
                                print_state();
                                print addr;
                                case {
                                        (
                                          instructions == BRK_IMP
                                        ) : {
                                                if (alu_opcode.as_a(byte) != 0) {
                                                        dut_error("Opcode is Wrong!");
                                                };
                                                if (mem_rw != 0) {
                                                        dut_error("MEM_RW should be 1 (WRITE)");
                                                };
                                                if (alu_enable != 0) {
                                                        dut_error("BRK_IMP is Wrong!");
                                                };
                                                if (addr != 13'b1111111111111) {
                                                        dut_error("BRK_IMP is Wrong!");
                                                };
                                                PC[12:8] = PCH[4:0];
                                        };
                                };
                        };
                };
        old_state = new_state;
        };
};
'>

Line No.	Rev	Author	Line
1	206	creep	`<'`
2			`import fsm_components;`
3			`type state_t : [RESET, CYCLE_1, CYCLE_2, CYCLE_3, CYCLE_4, CYCLE_5, CYCLE_6, CYCLE_7];`
4			`unit fsm_chk_u {`
5			`!A : byte;`
6			`keep soft A == 0;`
7			`!X : byte;`
8			`keep soft X == 0;`
9			`!Y : byte;`
10			`keep soft Y == 0;`
11			`!PC : uint(bits : 13);`
12			`keep soft PC == 0;`
13			`// !SP : uint(bits : 9);`
14			`// keep soft SP == 9'b100000000;`
15			`!SP : byte;`
16			`keep soft SP == 0;`
17
18	212	creep	`!more_cycles : bool;`
19			`keep soft more_cycles == FALSE;`
20	206	creep	`--!R : byte;`
21			`-- keep soft R == 0;`
22			`--!PS : byte;`
23			`-- keep soft PS[0:0] == 0;`
24			`-- keep soft PS[1:1] == 0;`
25			`-- keep soft PS[2:2] == 0;`
26			`-- keep soft PS[3:3] == 0;`
27			`-- keep soft PS[4:4] == 0;`
28			`-- keep soft PS[5:5] == 1;`
29			`-- keep soft PS[6:6] == 0;`
30			`-- keep soft PS[7:7] == 0;`
31			`-- N : bit;`
32			`-- V : bit;`
33			`-- B : bit;`
34			`-- D : bit;`
35			`-- I : bit;`
36			`-- Z : bit;`
37			`-- C : bit;`
38			`-- keep soft N == 0;`
39			`-- keep soft V == 0;`
40			`-- keep soft B == 0;`
41			`-- keep soft D == 0;`
42			`-- keep soft I == 0;`
43			`-- keep soft Z == 0;`
44			`-- keep soft C == 0;`
45
46			`!new_inst : bool;`
47			`keep new_inst == FALSE;`
48			`!new_input : fsm_input_s;`
49			`!old_input : fsm_input_s;`
50			`--!new_inst : bool;`
51			`--keep soft new_inst == FALSE;`
52
53			`--!i : ps_index;`
54
55			`!new_state : state_t;`
56			`!old_state : state_t;`
57
58			`--count_cycles : int;`
59			`--first_cycle : bool;`
60			`--last_a : byte;`
61			`--last_status : byte;`
62			`--last_result : byte;`
63			`!PCL:byte;`
64			`!PCH:byte;`
65			`!SP_aux:byte;`
66			`!rst : bit;`
67			`!rst_counter : byte;`
68
69			`--keep first_cycle == TRUE;`
70			`--keep count_cycles == 0;`
71			`keep rst_counter == 0;`
72
73			`!instruction : valid_opcodes;`
74			`!last_instruction : valid_opcodes;`
75			`!instructions : valid_opcodes;`
76
77			`print_state () is {`
78			`outf("-------------------------------------------------------\n");`
79			`print instructions;`
80			`-- print instruction;`
81			`print 't6507lp_fsm.ir';`
82			`print 't6507lp_fsm.sp';`
83			`print SP + 256;`
84			`print 't6507lp_fsm.pc';`
85			`print PC;`
86			`--print addr;`
87			`case ('t6507lp_fsm.state') {`
88
89			`2 : { outf(" t6507lp_fsm.state = FETCH_LOW\n");};`
90			`3 : { outf(" t6507lp_fsm.state = FETCH_HIGH\n"); };`
91			`4 : { outf(" t6507lp_fsm.state = READ_MEM\n"); };`
92			`5 : { outf(" t6507lp_fsm.state = DUMMY_WRT_CALC\n"); };`
93			`6 : { outf(" t6507lp_fsm.state = WRITE_MEM\n"); };`
94			`7 : { outf(" t6507lp_fsm.state = FETCH_OP_CALC_PARAM\n"); };`
95			`8 : { outf(" t6507lp_fsm.state = READ_MEM_CALC_INDEX\n"); };`
96			`9 : { outf(" t6507lp_fsm.state = FETCH_HIGH_CALC_INDEX\n"); };`
97			`10 : { outf(" t6507lp_fsm.state = READ_MEM_FIX_ADDR\n"); };`
98			`11 : { outf(" t6507lp_fsm.state = FETCH_OP_EVAL_BRANCH\n"); };`
99			`12 : { outf(" t6507lp_fsm.state = FETCH_OP_FIX_PC\n"); };`
100			`13 : { outf(" t6507lp_fsm.state = READ_FROM_POINTER\n"); };`
101			`14 : { outf(" t6507lp_fsm.state = READ_FROM_POINTER_X\n"); };`
102			`15 : { outf(" t6507lp_fsm.state = READ_FROM_POINTER_X1\n"); };`
103			`16 : { outf(" t6507lp_fsm.state = PUSH_PCH\n"); };`
104			`17 : { outf(" t6507lp_fsm.state = PUSH_PCL\n"); };`
105			`18 : { outf(" t6507lp_fsm.state = PUSH_STATUS\n"); };`
106			`19 : { outf(" t6507lp_fsm.state = FETCH_PCL\n"); };`
107			`20 : { outf(" t6507lp_fsm.state = FETCH_PCH\n"); };`
108			`21 : { outf(" t6507lp_fsm.state = INCREMENT_SP\n"); };`
109			`22 : { outf(" t6507lp_fsm.state = PULL_STATUS\n"); };`
110			`23 : { outf(" t6507lp_fsm.state = PULL_PCL\n"); };`
111			`24 : { outf(" t6507lp_fsm.state = PULL_PCH\n"); };`
112			`25 : { outf(" t6507lp_fsm.state = INCREMENT_PC\n"); };`
113			`26 : { outf(" t6507lp_fsm.state = PUSH_REGISTER\n"); };`
114			`27 : { outf(" t6507lp_fsm.state = PULL_REGISTER\n"); };`
115			`28 : { outf(" t6507lp_fsm.state = DUMMY\n"); };`
116			`31 : { outf(" t6507lp_fsm.state = RESET\n"); };`
117			`};`
118			`};`
119
120			`store(input : fsm_input_s) is {`
121			`--reset_n : bit;`
122			`--alu_result : byte;`
123			`--alu_status : byte;`
124			`--data_in : byte;`
125			`--alu_x : byte;`
126			`--alu_y : byte;`
127			`//print me;`
128			`//print input;`
129			`if (input.reset_n == 0) {`
130			`rst_counter = 0;`
131			`new_state = RESET;`
132			`old_state = RESET;`
133			`A = 0;`
134			`X = 0;`
135			`Y = 0;`
136			`PC = 0;`
137			`SP = 255;`
138			`}`
139			`else {`
140			`case (old_state) {`
141			`RESET : {`
142			`if (rst_counter == 7) {`
143			`new_state = CYCLE_1;`
144			`};`
145			`};`
146			`CYCLE_1 : {`
147			`instruction = input.data_in.as_a(valid_opcodes);`
148			`new_state = CYCLE_2;`
149			`};`
150			`CYCLE_2 : {`
151	212	creep	`X = input.alu_x;`
152			`Y = input.alu_y;`
153			`print X, Y;`
154			`outf("CYCLE_1\n");`
155	206	creep	`case {`
156			`(`
157			`instruction == BRK_IMP \|\|`
158			`instruction == PHA_IMP \|\|`
159			`instruction == PHP_IMP \|\|`
160			`instruction == PLA_IMP \|\|`
161			`instruction == PLP_IMP \|\|`
162			`instruction == RTI_IMP \|\|`
163			`instruction == RTS_IMP`
164			`) : {`
165			`new_state = CYCLE_3;`
166			`};`
167			`//JSR_ABS : {`
168			`// new_state = CYCLE_3;`
169			`// PCL = input.data_in;`
170			`//};`
171			`(`
172			`instruction == ADC_ABS \|\|`
173			`instruction == ASL_ABS \|\|`
174			`instruction == BIT_ABS \|\|`
175			`instruction == AND_ABS \|\|`
176			`instruction == CMP_ABS \|\|`
177			`instruction == DEC_ABS \|\|`
178			`instruction == EOR_ABS \|\|`
179			`instruction == INC_ABS \|\|`
180			`instruction == JMP_ABS \|\|`
181			`instruction == LDA_ABS \|\|`
182			`instruction == LDX_ABS \|\|`
183			`instruction == LDY_ABS \|\|`
184			`instruction == LSR_ABS \|\|`
185			`instruction == ORA_ABS \|\|`
186			`instruction == ROL_ABS \|\|`
187			`instruction == ROR_ABS \|\|`
188			`instruction == SBC_ABS \|\|`
189			`instruction == STA_ABS \|\|`
190			`instruction == STX_ABS \|\|`
191			`instruction == STY_ABS \|\|`
192			`instruction == LDA_ZPG \|\|`
193			`instruction == LDX_ZPG \|\|`
194			`instruction == LDY_ZPG \|\|`
195			`instruction == EOR_ZPG \|\|`
196			`instruction == AND_ZPG \|\|`
197			`instruction == ORA_ZPG \|\|`
198			`instruction == ADC_ZPG \|\|`
199			`instruction == SBC_ZPG \|\|`
200			`instruction == CMP_ZPG \|\|`
201			`instruction == BIT_ZPG \|\|`
202			`instruction == STA_ZPG \|\|`
203			`instruction == STX_ZPG \|\|`
204			`instruction == STY_ZPG \|\|`
205			`instruction == ASL_ZPG \|\|`
206			`instruction == LSR_ZPG \|\|`
207			`instruction == ROL_ZPG \|\|`
208			`instruction == ROR_ZPG \|\|`
209			`instruction == INC_ZPG \|\|`
210	212	creep	`instruction == DEC_ZPG \|\|`
211	206	creep	`instruction == LDA_ZPX \|\|`
212			`instruction == LDX_ZPY \|\|`
213			`instruction == LDY_ZPX \|\|`
214			`instruction == EOR_ZPX \|\|`
215			`instruction == AND_ZPX \|\|`
216			`instruction == ORA_ZPX \|\|`
217			`instruction == ADC_ZPX \|\|`
218			`instruction == SBC_ZPX \|\|`
219	212	creep	`instruction == CMP_ZPX \|\|`
220			`instruction == ASL_ZPX \|\|`
221			`instruction == LSR_ZPX \|\|`
222			`instruction == ROL_ZPX \|\|`
223			`instruction == ROR_ZPX \|\|`
224			`instruction == INC_ZPX \|\|`
225			`instruction == DEC_ZPX \|\|`
226			`instruction == STA_ZPX \|\|`
227			`instruction == STX_ZPY \|\|`
228			`instruction == STY_ZPX`
229	206	creep	`) : {`
230			`new_state = CYCLE_3;`
231			`PCL = input.data_in;`
232	212	creep	`--print X, Y;`
233			`--print input.alu_x, input.alu_y;`
234			`--print 't6507lp_fsm.index';`
235	206	creep	`};`
236			`(`
237	212	creep	`instruction == LDA_ABX \|\|`
238			`instruction == LDA_ABY \|\|`
239			`instruction == LDX_ABY \|\|`
240			`instruction == LDY_ABX \|\|`
241			`instruction == EOR_ABX \|\|`
242			`instruction == EOR_ABY \|\|`
243			`instruction == AND_ABX \|\|`
244			`instruction == AND_ABY \|\|`
245			`instruction == ORA_ABX \|\|`
246			`instruction == ORA_ABY \|\|`
247			`instruction == ADC_ABX \|\|`
248			`instruction == ADC_ABY \|\|`
249			`instruction == SBC_ABX \|\|`
250			`instruction == SBC_ABY \|\|`
251			`instruction == CMP_ABX \|\|`
252			`instruction == CMP_ABY`
253			`) : {`
254			`new_state = CYCLE_3;`
255			`PCL = input.data_in;`
256			`--X = input.alu_x;`
257			`--Y = input.alu_y;`
258			`--print X, Y;`
259			`--print input.alu_x, input.alu_y;`
260			`--print 't6507lp_fsm.index';`
261			`--outf("CYCLE_2\n");`
262			`};`
263			`(`
264	206	creep	`instruction == TXS_IMP`
265			`) : {`
266			`new_state = CYCLE_1;`
267			`SP_aux = input.alu_x;`
268			`};`
269			`default : {`
270			`new_state = CYCLE_1;`
271			`};`
272			`};`
273			`};`
274			`CYCLE_3 : {`
275			`case {`
276			`(`
277			`instruction == BRK_IMP \|\|`
278			`instruction == PLA_IMP \|\|`
279			`instruction == PLP_IMP \|\|`
280			`instruction == RTI_IMP \|\|`
281			`instruction == RTS_IMP \|\|`
282			`instruction == ASL_ZPG \|\|`
283			`instruction == LSR_ZPG \|\|`
284			`instruction == ROL_ZPG \|\|`
285			`instruction == ROR_ZPG \|\|`
286			`instruction == INC_ZPG \|\|`
287	212	creep	`instruction == DEC_ZPG`
288			`) : {`
289			`new_state = CYCLE_4;`
290			`};`
291			`//JSR_ABS : {`
292			`// new_state = CYCLE_4;`
293			`// PCH = input.data_in;`
294			`//};`
295			`(`
296	206	creep	`instruction == LDA_ZPX \|\|`
297			`instruction == LDX_ZPY \|\|`
298			`instruction == LDY_ZPX \|\|`
299			`instruction == EOR_ZPX \|\|`
300			`instruction == AND_ZPX \|\|`
301			`instruction == ORA_ZPX \|\|`
302			`instruction == ADC_ZPX \|\|`
303			`instruction == SBC_ZPX \|\|`
304	212	creep	`instruction == CMP_ZPX \|\|`
305			`instruction == ASL_ZPX \|\|`
306			`instruction == LSR_ZPX \|\|`
307			`instruction == ROL_ZPX \|\|`
308			`instruction == ROR_ZPX \|\|`
309			`instruction == INC_ZPX \|\|`
310			`instruction == DEC_ZPX \|\|`
311			`instruction == STA_ZPX \|\|`
312			`instruction == STX_ZPY \|\|`
313			`instruction == STY_ZPX`
314	206	creep	`) : {`
315			`new_state = CYCLE_4;`
316	212	creep	`--X = input.alu_x;`
317			`--Y = input.alu_y;`
318			`--print X, Y;`
319			`--print input.alu_x, input.alu_y;`
320			`--print 't6507lp_fsm.index';`
321	206	creep	`};`
322			`(`
323			`instruction == ADC_ABS \|\|`
324			`instruction == ASL_ABS \|\|`
325			`instruction == BIT_ABS \|\|`
326			`instruction == AND_ABS \|\|`
327			`instruction == CMP_ABS \|\|`
328			`instruction == DEC_ABS \|\|`
329			`instruction == EOR_ABS \|\|`
330			`instruction == INC_ABS \|\|`
331			`instruction == LDA_ABS \|\|`
332			`instruction == LDX_ABS \|\|`
333			`instruction == LDY_ABS \|\|`
334			`instruction == LSR_ABS \|\|`
335			`instruction == ORA_ABS \|\|`
336			`instruction == ROL_ABS \|\|`
337			`instruction == ROR_ABS \|\|`
338			`instruction == SBC_ABS \|\|`
339			`instruction == STA_ABS \|\|`
340			`instruction == STX_ABS \|\|`
341	212	creep	`instruction == STY_ABS \|\|`
342			`instruction == LDA_ABX \|\|`
343			`instruction == LDA_ABY \|\|`
344			`instruction == LDX_ABY \|\|`
345			`instruction == LDY_ABX \|\|`
346			`instruction == EOR_ABX \|\|`
347			`instruction == EOR_ABY \|\|`
348			`instruction == AND_ABX \|\|`
349			`instruction == AND_ABY \|\|`
350			`instruction == ORA_ABX \|\|`
351			`instruction == ORA_ABY \|\|`
352			`instruction == ADC_ABX \|\|`
353			`instruction == ADC_ABY \|\|`
354			`instruction == SBC_ABX \|\|`
355			`instruction == SBC_ABY \|\|`
356			`instruction == CMP_ABX \|\|`
357			`instruction == CMP_ABY`
358	206	creep	`) : {`
359			`new_state = CYCLE_4;`
360			`PCH = input.data_in;`
361	212	creep	`--X = input.alu_x;`
362			`--Y = input.alu_y;`
363			`--print X, Y;`
364			`--print input.alu_x, input.alu_y;`
365			`--print 't6507lp_fsm.index';`
366			`--outf("CYCLE_3\n");`
367	206	creep	`};`
368			`(`
369			`instruction == JMP_ABS`
370			`) : {`
371			`new_state = CYCLE_1;`
372			`PCH = input.data_in;`
373			`};`
374			`default : {`
375			`new_state = CYCLE_1;`
376			`};`
377			`};`
378			`};`
379			`CYCLE_4 : {`
380			`case {`
381			`//JSR_ABS : {`
382			`// new_state = CYCLE_5;`
383			`//};`
384			`(`
385			`instruction == RTS_IMP`
386			`) : {`
387			`new_state = CYCLE_5;`
388			`PCL = input.data_in;`
389			`};`
390			`(`
391			`instruction == ASL_ABS \|\|`
392			`instruction == BRK_IMP \|\|`
393			`instruction == DEC_ABS \|\|`
394			`instruction == INC_ABS \|\|`
395			`instruction == LSR_ABS \|\|`
396			`instruction == ROL_ABS \|\|`
397			`instruction == ROR_ABS \|\|`
398			`instruction == RTI_IMP \|\|`
399			`instruction == ASL_ZPG \|\|`
400			`instruction == LSR_ZPG \|\|`
401			`instruction == ROL_ZPG \|\|`
402			`instruction == ROR_ZPG \|\|`
403			`instruction == INC_ZPG \|\|`
404	212	creep	`instruction == DEC_ZPG \|\|`
405			`instruction == ASL_ZPX \|\|`
406			`instruction == LSR_ZPX \|\|`
407			`instruction == ROL_ZPX \|\|`
408			`instruction == ROR_ZPX \|\|`
409			`instruction == INC_ZPX \|\|`
410			`instruction == DEC_ZPX \|\|`
411			`(`
412			`more_cycles == TRUE &&`
413			`(`
414			`instruction == LDA_ABX \|\|`
415			`instruction == LDA_ABY \|\|`
416			`instruction == LDX_ABY \|\|`
417			`instruction == LDY_ABX \|\|`
418			`instruction == EOR_ABX \|\|`
419			`instruction == EOR_ABY \|\|`
420			`instruction == AND_ABX \|\|`
421			`instruction == AND_ABY \|\|`
422			`instruction == ORA_ABX \|\|`
423			`instruction == ORA_ABY \|\|`
424			`instruction == ADC_ABX \|\|`
425			`instruction == ADC_ABY \|\|`
426			`instruction == SBC_ABX \|\|`
427			`instruction == SBC_ABY \|\|`
428			`instruction == CMP_ABX \|\|`
429			`instruction == CMP_ABY`
430			`)`
431			`)`
432	206	creep	`) : {`
433	212	creep	`--X = input.alu_x;`
434			`--Y = input.alu_y;`
435			`--print X, Y;`
436			`--print input.alu_x, input.alu_y;`
437			`--print 't6507lp_fsm.index';`
438			`--outf("CYCLE_4\n");`
439	206	creep	`new_state = CYCLE_5;`
440			`};`
441			`default : {`
442			`new_state = CYCLE_1;`
443			`};`
444			`};`
445			`};`
446			`CYCLE_5 : {`
447			`case {`
448			`//JSR_ABS : {`
449			`// new_state = CYCLE_6;`
450			`//};`
451			`(`
452			`instruction == RTI_IMP`
453			`) : {`
454			`new_state = CYCLE_6;`
455			`PCL = input.data_in;`
456			`};`
457			`(`
458			`instruction == RTS_IMP`
459			`) : {`
460			`new_state = CYCLE_6;`
461			`PCH = input.data_in;`
462			`};`
463			`(`
464			`instruction == ASL_ABS \|\|`
465			`instruction == BRK_IMP \|\|`
466			`instruction == DEC_ABS \|\|`
467			`instruction == INC_ABS \|\|`
468			`instruction == LSR_ABS \|\|`
469			`instruction == ROL_ABS \|\|`
470	212	creep	`instruction == ROR_ABS \|\|`
471			`instruction == ASL_ZPX \|\|`
472			`instruction == LSR_ZPX \|\|`
473			`instruction == ROL_ZPX \|\|`
474			`instruction == ROR_ZPX \|\|`
475			`instruction == INC_ZPX \|\|`
476			`instruction == DEC_ZPX`
477	206	creep	`) : {`
478			`new_state = CYCLE_6;`
479			`};`
480	212	creep	`(`
481			`instruction == LDA_ABX \|\|`
482			`instruction == LDA_ABY \|\|`
483			`instruction == LDX_ABY \|\|`
484			`instruction == LDY_ABX \|\|`
485			`instruction == EOR_ABX \|\|`
486			`instruction == EOR_ABY \|\|`
487			`instruction == AND_ABX \|\|`
488			`instruction == AND_ABY \|\|`
489			`instruction == ORA_ABX \|\|`
490			`instruction == ORA_ABY \|\|`
491			`instruction == ADC_ABX \|\|`
492			`instruction == ADC_ABY \|\|`
493			`instruction == SBC_ABX \|\|`
494			`instruction == SBC_ABY \|\|`
495			`instruction == CMP_ABX \|\|`
496			`instruction == CMP_ABY`
497			`) : {`
498			`new_state = CYCLE_1;`
499			`--X = input.alu_x;`
500			`--Y = input.alu_y;`

Browse

Tools

Subversion Repositories t6507lp

[/] [t6507lp/] [trunk/] [fv/] [fsm_chk.e] - Blame information for rev 212