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

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

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

Tools

Subversion Repositories t6507lp

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