| ''' |
| Created on Nov 20, 2019 |
| |
| @author: ballance |
| ''' |
| import cocotb |
| from cocotb.triggers import RisingEdge, Event |
| from cocotb.bfms import BfmMgr |
| from fwrisc_tracer_bfm import FwriscTracerBfmIF |
| from elftools.elf.elffile import ELFFile |
| from elftools.elf.sections import SymbolTableSection |
| from fwrisc_tracer_bfm.fwrisc_tracer_signal_bfm import FwriscTracerSignalBfm |
| |
| class InstrTests(FwriscTracerBfmIF): |
| |
| def __init__(self, tracer_bfm, mem_size=1024, halt_addr=0x80000004, max_instr=1000000): |
| self.instr_count = 0 |
| self.test_done_ev = Event() |
| self.halt_addr = halt_addr |
| self.max_instr = max_instr |
| self.complete = False |
| self.tracer_bfm = tracer_bfm |
| self.mem = [0] * mem_size |
| |
| self.trace_instr = "trace_instr" in cocotb.plusargs |
| self.trace_memwrite = "trace_memwrite" in cocotb.plusargs |
| |
| |
| def init_mem(self): |
| pass |
| |
| def configure_tracer(self): |
| self.tracer_bfm.set_trace_reg_writes(0) |
| self.tracer_bfm.set_trace_instr(1, 1, 1) |
| self.tracer_bfm.set_trace_all_memwrite(1) |
| |
| def instr_exec(self, pc, instr): |
| if self.trace_instr: |
| cocotb.log.info("[InstrExec] addr=0x%08x instr=0x%08x" % (pc, instr)) |
| self.instr_count += 1 |
| |
| if self.halt_addr != -1 and pc == self.halt_addr: |
| print("Done!") |
| self.complete = True |
| self.test_done_ev.set() |
| |
| if self.max_instr != 0 and self.instr_count >= self.max_instr: |
| print("TIMEOUT") |
| self.test_done_ev.set() |
| |
| def mem_write(self, maddr, mstrb, mdata): |
| |
| if self.trace_memwrite: |
| cocotb.log.info("[MemWrite] maddr=%08x mstrb=%x mdata=%08x" % (maddr, mstrb, mdata)) |
| |
| if ((maddr & 0xFFFF8000) == 0x80000000): |
| offset = ((maddr & 0x0000FFFF) >> 2) |
| |
| for i in range(4): |
| if (mstrb & (1 << i)) != 0: |
| self.mem[offset] &= ~(0xFF << (8*i)) |
| self.mem[offset] |= (mdata & (0xFF << (8*i))) |
| else: |
| print("Error: out-of-bounds access") |
| |
| @cocotb.coroutine |
| def run(self): |
| self.configure_tracer() |
| self.init_mem() |
| |
| yield self.test_done_ev.wait() |
| |
| yield self.check() |
| |
| @cocotb.coroutine |
| def check(self): |
| reg_data = [] |
| |
| sw_image = cocotb.plusargs["SW_IMAGE"] |
| testname = cocotb.plusargs["TESTNAME"] |
| print("SW_IMAGE=" + sw_image) |
| |
| with open(sw_image, "rb") as f: |
| elffile = ELFFile(f) |
| |
| symtab = elffile.get_section_by_name('.symtab') |
| start_expected = symtab.get_symbol_by_name("start_expected")[0]["st_value"] |
| end_expected = symtab.get_symbol_by_name("end_expected")[0]["st_value"] |
| |
| section = None |
| for i in range(elffile.num_sections()): |
| shdr = elffile._get_section_header(i) |
| if (start_expected >= shdr['sh_addr']) and (end_expected <= (shdr['sh_addr'] + shdr['sh_size'])): |
| start_expected -= shdr['sh_addr'] |
| end_expected -= shdr['sh_addr'] |
| section = elffile.get_section(i) |
| break |
| |
| data = section.data() |
| |
| exp_l = [] |
| |
| for i in range(start_expected,end_expected,8): |
| reg = data[i+0] | (data[i+1] << 8) | (data[i+2] << 16) | (data[i+3] << 24) |
| exp = data[i+4] | (data[i+5] << 8) | (data[i+6] << 16) | (data[i+7] << 24) |
| |
| exp_l.append([reg, exp]) |
| |
| for i in range(64): |
| info = yield self.tracer_bfm.get_reg_info(i) |
| reg_data.append(info) |
| |
| if not self.complete: |
| print("FAIL: " + testname) |
| else: |
| print("PASS: " + testname) |
| |
| |
| @cocotb.test() |
| def runtest(dut): |
| # print("--> runtest") |
| # yield RisingEdge(dut.clock) |
| # print("<-- runtest") |
| # |
| # BfmMgr.init() |
| # |
| # bfms = BfmMgr.get_bfms() |
| # for b in bfms: |
| # print("BFM: " + b.bfm_info.inst_name) |
| # |
| tracer_bfm = BfmMgr.find_bfm(".*u_tracer") |
| test = InstrTests(tracer_bfm) |
| tracer_bfm.add_listener(test) |
| |
| # signal_tracer = FwriscTracerSignalBfm(dut.u_tracer) |
| |
| yield test.run() |
| |
| |
