126 lines
3.4 KiB
Python
Executable file
126 lines
3.4 KiB
Python
Executable file
#! /usr/bin/python3
|
|
|
|
import json
|
|
from machine import PDP1170
|
|
import random
|
|
import sys
|
|
|
|
|
|
class PDP1170_wrapper(PDP1170):
|
|
def __init__(self, *args, **kwargs):
|
|
super().__init__(*args, **kwargs)
|
|
|
|
self.reset_mem_transactions_dict()
|
|
|
|
def reset_mem_transactions_dict(self):
|
|
self.mem_transactions = dict()
|
|
|
|
def get_mem_transactions_dict(self):
|
|
return self.mem_transactions
|
|
|
|
def physRW(self, physaddr, value=None):
|
|
if value == None: # read
|
|
self.mem_transactions[physaddr] = random.randint(0, 65536)
|
|
return super().physRW(physaddr, self.mem_transactions[physaddr])
|
|
|
|
self.mem_transactions[physaddr] = value
|
|
super().physRW(physaddr, value)
|
|
|
|
def physRW_N(self, physaddr, nwords, words=None):
|
|
temp_addr = physaddr
|
|
if words == None:
|
|
for i in range(nwords):
|
|
physRW(temp_addr, random.randint(0, 65536))
|
|
temp_addr += 2
|
|
return super().physRW_N(physaddr, nwords)
|
|
|
|
for w in words:
|
|
self.mem_transactions[temp_addr] = w
|
|
temp_addr += 2
|
|
|
|
super().physRW_N(physaddr, nwords, words=words)
|
|
|
|
class test_generator:
|
|
def _invoke_bp(self, a, i):
|
|
return True
|
|
|
|
def _run_test(self, addr, mem_setup, reg_setup, psw):
|
|
p = PDP1170_wrapper(loglevel='DEBUG')
|
|
|
|
for a, v in mem_setup:
|
|
p.mmu.wordRW(a, v)
|
|
|
|
for r, v in reg_setup:
|
|
p.r[r] = v
|
|
|
|
p.reset_mem_transactions_dict()
|
|
|
|
p._syncregs()
|
|
p.run_steps(pc=addr, steps=1)
|
|
p._syncregs()
|
|
|
|
return p
|
|
|
|
def create_test(self):
|
|
out = { }
|
|
|
|
addr = random.randint(0, 65536) & ~3
|
|
|
|
# TODO what is the maximum size of an instruction?
|
|
mem_kv = []
|
|
mem_kv.append((addr + 0, random.randint(0, 65536)))
|
|
mem_kv.append((addr + 2, random.randint(0, 65536)))
|
|
mem_kv.append((addr + 4, random.randint(0, 65536)))
|
|
mem_kv.append((addr + 6, random.randint(0, 65536)))
|
|
|
|
out['memory-before'] = dict()
|
|
for a, v in mem_kv:
|
|
out['memory-before'][a] = v
|
|
|
|
reg_kv = []
|
|
for i in range(7):
|
|
reg_kv.append((i, random.randint(0, 65536)))
|
|
reg_kv.append((7, addr))
|
|
|
|
out['registers-before'] = dict()
|
|
for r, v in reg_kv:
|
|
out['registers-before'][r] = v
|
|
|
|
out['registers-before']['psw'] = 0 # TODO random.randint(0, 65536)
|
|
|
|
try:
|
|
p = self._run_test(addr, mem_kv, reg_kv, out['registers-before']['psw'])
|
|
|
|
out['registers-after'] = dict()
|
|
for r, v in reg_kv:
|
|
out['registers-after'][r] = v
|
|
out['registers-after']['psw'] = p.psw
|
|
|
|
out['memory-after'] = dict()
|
|
for a, v in mem_kv:
|
|
out['memory-after'][a] = v
|
|
mem_transactions = p.get_mem_transactions_dict()
|
|
for a in mem_transactions:
|
|
out['memory-after'][a] = mem_transactions[a]
|
|
|
|
# TODO check if mem_transactions affects I/O, then return None
|
|
|
|
return out
|
|
|
|
except Exception as e:
|
|
# handle PDP11 traps; store them
|
|
print('test failed', e)
|
|
return None
|
|
|
|
fh = open(sys.argv[1], 'w')
|
|
|
|
t = test_generator()
|
|
|
|
tests = []
|
|
for i in range(0, 4096):
|
|
test = t.create_test()
|
|
if test != None:
|
|
tests.append(test)
|
|
|
|
fh.write(json.dumps(tests))
|
|
fh.close()
|