def test_execute_gid16(): state = new_state(rfSTATUS=0) instr = opcode_factory.gid16() name, executefn = decode(instr) executefn(state, Instruction(instr, None)) expected_state = StateChecker(rfSTATUS=0b10) expected_state.check(state)
def test_execute_add16sub16(factory, expected): state = new_state(rf0=2, rf1=5) instr = factory(rd=2, rn=1, rm=0) name, executefn = decode(instr) executefn(state, Instruction(instr, None)) expected_state = StateChecker(pc=(2 + RESET_ADDR), **expected) expected_state.check(state)
def test_execute_nop16(): state = new_state() instr = opcode_factory.nop16() name, executefn = decode(instr) executefn(state, Instruction(instr, None)) expected_state = StateChecker(pc=(2 + RESET_ADDR)) expected_state.check(state)
def test_execute_rti16(): state = new_state(rfIRET=224, rfSTATUS=0b10, pc=0) instr = opcode_factory.rti16() name, executefn = decode(instr) executefn(state, Instruction(instr, None)) expected_state = StateChecker(pc=224, rfIRET=224, rfSTATUS=0b00) expected_state.check(state)
def test_execute_arith32_immediate(opcode, imm, expected): state = new_state(rf0=5) instr = opcode(rd=1, rn=0, imm=imm) name, executefn = decode(instr) executefn(state, Instruction(instr, None)) expected_state = StateChecker(pc=(4 + RESET_ADDR), **expected) expected_state.check(state)
def test_flags_differ(): expected = StateChecker(AZ=0, rfLR=0) got = new_state(AZ=1, rfLR=0) with pytest.raises(ValueError): expected.check(got) with pytest.raises(ValueError): expected.fp_check(got)
def test_check_memory(): expected = StateChecker() got = new_state() got.mem.write(4, 4, 0xFFFF) got.mem.write(0, 4, 0x0) expected.check(got, memory=[(0x4, 4, 0xFFFF)]) with pytest.raises(ValueError): expected.check(got, memory=[(0x0, 4, 0xFFFF)])
def test_execute_bkpt16(): state = new_state(rfDEBUGSTATUS=0) instr = opcode_factory.bkpt16() name, executefn = decode(instr) executefn(state, Instruction(instr, None)) expected_state = StateChecker(rfDEBUGSTATUS=1) expected_state.check(state) assert not state.running
def test_execute_bcond(is16bit, cond, imm, offset): state = new_state(AZ=1, pc=90) factory = opcode_factory.bcond16 if is16bit else opcode_factory.bcond32 instr = factory(condition=cond, imm=imm) name, executefn = decode(instr) executefn(state, Instruction(instr, None)) expected_state = StateChecker(pc=(90 + offset), AZ=1) expected_state.check(state)
def test_execute_bitwise16(factory, expected): state = new_state(rf0=5, rf1=7) instr = factory(rd=2, rn=1, rm=0) name, executefn = decode(instr) executefn(state, Instruction(instr, None)) expected_state = StateChecker(AZ=0, AV=0, AC=0, pc=(2 + RESET_ADDR), rf2=expected) expected_state.check(state)
def test_execute_str_disp_pm(sub, new_rn): # Store. state = new_state(rf0=0xFFFFFFFF, rf5=8) # bb: 00=byte, 01=half-word, 10=word, 11=double-word instr = opcode_factory.ldstrpmd32(rd=0, rn=5, sub=sub, imm=1, bb=0b10, s=1) name, executefn = decode(instr) executefn(state, Instruction(instr, None)) expected_state = StateChecker(rf0=0xFFFFFFFF, rf5=new_rn) expected_state.check(state, memory=[(8, 4, 0xFFFFFFFF)])
def test_testset32_nonzero(): state = new_state(rf0=0, rf1=0x80002, rf2=0x80002) size = 0b10 # Word state.mem.write(0x00100004, 4, 0xFFFF) instr = opcode_factory.testset32(rd=0, rn=1, rm=2, sub=0, bb=size) name, executefn = decode(instr) executefn(state, Instruction(instr, None)) expected_state = StateChecker(rf0=0xFFFF, rf1=0x80002, rf2=0x80002,) expected_state.check(state, memory=[(0x00100004, 4, 0xFFFF)])
def test_execute_shift_left(factory, is16bit): state = new_state(rf0=5, rf1=7) instr = factory(rd=2, rn=1, rm=0) name, executefn = decode(instr) executefn(state, Instruction(instr, None)) expected_state = StateChecker(AZ=0, AN=0, AC=0, AV=0, pc=((2 if is16bit else 4) + RESET_ADDR), rf2=7 << 5) expected_state.check(state)
def test_execute_movcond(is16bit, val): state = new_state(AZ=1, rf1=val) instr = (opcode_factory.movcond16(condition=0b0000, rd=0, rn=1) if is16bit else opcode_factory.movcond32(condition=0b0000, rd=0, rn=1)) name, executefn = decode(instr) executefn(state, Instruction(instr, None)) pc_expected = (2 if is16bit else 4) + RESET_ADDR expected_state = StateChecker(pc=pc_expected, rf0=val) expected_state.check(state)
def test_execute_bitr(bits, expected, is16bit): state = new_state(rf0=0, rf1=bits) instr = (opcode_factory.bitr16_immediate(rd=2, rn=1, imm=0) if is16bit else opcode_factory.bitr32_immediate(rd=2, rn=1, imm=0)) name, executefn = decode(instr) executefn(state, Instruction(instr, None)) expected_state = StateChecker(AZ=0, AC=0, AV=0, pc=((2 if is16bit else 4) + RESET_ADDR), rf2=expected) expected_state.check(state)
def test_execute_ldr_disp_pm(sub, new_rn): # Load. state = new_state(rf5=8) state.mem.write(8, 4, 42) # Start address, number of bytes, value # bb: 00=byte, 01=half-word, 10=word, 11=double-word instr = opcode_factory.ldstrpmd32(rd=0, rn=5, sub=sub, imm=1, bb=0b10, s=0) name, executefn = decode(instr) executefn(state, Instruction(instr, None)) expected_state = StateChecker(rf0=42, rf5=new_rn) expected_state.check(state)
def test_sim_bkpt16(): instructions = [(opcode_factory.bkpt16(), 16), # BKPT16 ] epiphany = MockEpiphany() epiphany.init_state(instructions) assert epiphany.state.running epiphany.run() expected_state = StateChecker(pc=(2 + RESET_ADDR)) expected_state.check(epiphany.state) assert not epiphany.state.running
def test_single_inst_add32(): instructions = [(opcode_factory.add32_immediate(rd=1, rn=0, imm=0b01010101010), 32), (opcode_factory.bkpt16(), 16)] epiphany = MockEpiphany() epiphany.init_state(instructions, rf0=0b01010101010) assert epiphany.state.running epiphany.run() expected_state = StateChecker(AZ=0, pc=(6 + RESET_ADDR), rf1=(0b01010101010 * 2)) expected_state.check(epiphany.state) assert not epiphany.state.running
def test_branch_link(is16bit): state = new_state() cond = 0b1111 # Condition code for branch-and-link factory = opcode_factory.bcond16 if is16bit else opcode_factory.bcond32 instr = factory(condition=cond, imm=0b00011000) name, executefn = decode(instr) executefn(state, Instruction(instr, None)) expected_LR = (2 if is16bit else 4) + RESET_ADDR expected = StateChecker(rfLR=expected_LR, pc=(RESET_ADDR + (0b00011000 << 1))) expected.check(state)
def test_testset32(): elf_filename = os.path.join(elf_dir, 'testset.elf') epiphany = Epiphany() with open(elf_filename, 'rb') as elf: if elf == 'movts.elf': print 'MOVTS' epiphany.init_state(elf, elf_filename, '', [], False, is_test=True) epiphany.state.mem.write(0x100004, 4, 0x0) epiphany.max_insts = 100000 epiphany.run() expected = StateChecker(AZ=1, rf0=0, rf1=0x100000, rf2=0x4) expected.check(epiphany.state, memory=[(0x100004, 4, 0xFFFF)])
def test_str_index(is16bit): # Store. state = new_state(rf0=0xFFFFFFFF, rf5=8, rf6=8) if is16bit: instr = opcode_factory.ldstrind16(rd=0, rn=5, rm=6, bb=0b10, s=1) else: instr = opcode_factory.ldstrind32(rd=0, rn=5, rm=6, sub=0, bb=0b10, s=1) name, executefn = decode(instr) executefn(state, Instruction(instr, None)) expected_state = StateChecker(rf0=0xFFFFFFFF, rf5=8, rf6=8) expected_state.check(state, memory=[(16, 4, 0xFFFFFFFF)])
def test_sub16_neg_imm(): state = new_state(rf2=0, rf1=0) bits = opcode_factory.sub16_immediate(rd=2, rn=1, imm=0b111) name, executefn = decode(bits) instr = Instruction(bits, '') assert instr.rd == 2 assert instr.rn == 1 assert instr.imm3 == 0b111 executefn(state, instr) expected_state = StateChecker(rf2=1, rf1=0) expected_state.check(state)
def test_single_inst_sub32(): from pydgin.utils import trim_32 instructions = [(opcode_factory.sub32_immediate(rd=1, rn=0, imm=0b01010101010), 32), (opcode_factory.bkpt16(), 16)] epiphany = MockEpiphany() epiphany.init_state(instructions, rf0=5) assert epiphany.state.running epiphany.run() expected_state = StateChecker(AZ=0, AN=1, AC=0, pc=(6 + RESET_ADDR), rf1=trim_32(5 - 0b01010101010)) expected_state.check(epiphany.state) assert not epiphany.state.running
def test_execute_arith_shift_right_imm(rn, imm, is16bit): rd = 2 state = new_state(rf0=trim_32(rn)) instr = (opcode_factory.asr16_immediate(rd=rd, rn=0, imm=imm) if is16bit else opcode_factory.asr32_immediate(rd=rd, rn=0, imm=imm)) name, executefn = decode(instr) executefn(state, Instruction(instr, None)) expected_state = StateChecker(AZ=(False if rn < 0 else True), # 1 >> 5 == 0 AV=0, AC=0, pc=((2 if is16bit else 4) + RESET_ADDR), rf2=(trim_32(-1) if rn < 0 else 0)) expected_state.check(state)
def test_execute_trap_warning(capsys): state = new_state() instr = opcode_factory.trap16(trap=0b11111) name, executefn = decode(instr) executefn(state, Instruction(instr, None)) out, err = capsys.readouterr() expected_state = StateChecker(pc=(2 + RESET_ADDR)) expected_text = ('WARNING: syscall not implemented: 31') expected_state.check(state) assert expected_text in out assert err == '' assert state.running
def test_ldr_pm(is16bit): # Load. state = new_state(rf0=0, rf5=8, rf6=8) state.mem.write(16, 4, 0xFFFFFFFF) if is16bit: instr = opcode_factory.ldstrpm16(rd=0, rn=5, rm=6, bb=0b10, s=0) else: instr = opcode_factory.ldstrpm32(rd=0, rn=5, rm=6, sub=0, bb=0b10, s=0) name, executefn = decode(instr) executefn(state, Instruction(instr, None)) expected_state = StateChecker(rf0=0xFFFFFFFF, rf5=16, rf6=8) expected_state.check(state)
def test_execute_logical_shift_right(rn, rm, is16bit): rd = 2 state = new_state(rf0=trim_32(rn), rf1=trim_32(rm)) instr = (opcode_factory.lsr16(rd=rd, rn=0, rm=1) if is16bit else opcode_factory.lsr32(rd=rd, rn=0, rm=1)) name, executefn = decode(instr) executefn(state, Instruction(instr, None)) expected_state = StateChecker(AZ=(False if rn < 0 else True), # 1 >> 5 == 0 AV=0, AC=0, pc=((2 if is16bit else 4) + RESET_ADDR), rf2=(0b1111 if rn < 0 else 0)) expected_state.check(state)
def test_sim_all_16bit(): instructions = [ (opcode_factory.gie16(), 16), (opcode_factory.gid16(), 16), (opcode_factory.idle16(), 16), (opcode_factory.bkpt16(), 16), ] epiphany = MockEpiphany() epiphany.init_state(instructions) assert epiphany.state.running epiphany.run() expected_state = StateChecker(pc=(8 + RESET_ADDR)) expected_state.check(epiphany.state) assert not epiphany.state.running
def test_execute_idle16(capsys): state = new_state(rfSTATUS=1) instr = opcode_factory.idle16() name, executefn = decode(instr) executefn(state, Instruction(instr, None)) out, err = capsys.readouterr() expected_state = StateChecker(pc=(2 + RESET_ADDR), rfSTATUS=0) expected_text = ('IDLE16 does not wait in this simulator. ' + 'Moving to next instruction.') expected_state.check(state) assert expected_text in out assert err == '' assert state.running
def test_execute_str_disp(is16bit, sub, expected): # Store. state = new_state(rf0=0xFFFFFFFF, rf5=8) # bb: 00=byte, 01=half-word, 10=word, 11=double-word if is16bit: instr = opcode_factory.ldstrdisp16(rd=0, rn=5, imm=1, bb=0b10, s=1) else: instr = opcode_factory.ldstrdisp32(rd=0, rn=5, sub=sub, imm=1, bb=0b10, s=1) name, executefn = decode(instr) executefn(state, Instruction(instr, None)) address = 8 - (1 << 2) if sub else 8 + (1 << 2) expected_state = StateChecker(rf0=0xFFFFFFFF, rf5=8) expected_state.check(state, memory=[(address, 4, 0xFFFFFFFF)])