forked from Github_Repos/cvw
228 lines
7.8 KiB
Python
Executable File
228 lines
7.8 KiB
Python
Executable File
#!/usr/bin/python3
|
|
##################################
|
|
# testgen-LOAD.py
|
|
#
|
|
# Jarred Allen <jaallen@g.hmc.edu> 02 February 2021
|
|
#
|
|
# Generate directed and random test vectors for RISC-V Design Validation.
|
|
##################################
|
|
|
|
##################################
|
|
# libraries
|
|
##################################
|
|
from datetime import datetime
|
|
from random import randint, seed, getrandbits
|
|
|
|
##################################
|
|
# functions
|
|
##################################
|
|
|
|
def rand_reg():
|
|
"""Produce a random register (skipping 6 and 31, since they're used for other things)"""
|
|
r = randint(1,29)
|
|
if r >= 6:
|
|
r += 1
|
|
return r
|
|
|
|
def rand_value(width):
|
|
"""Generate a random value which fits in the given width"""
|
|
return randint(0, (1 << width) - 1)
|
|
|
|
def rand_offset():
|
|
"""Generate a random offset"""
|
|
ret = rand_value(12)
|
|
# print("Random offset: %d" % ret)
|
|
return ret
|
|
|
|
def rand_source():
|
|
"""Generate a random value for the source register, such that the load address is in the test data"""
|
|
ret = randint(1 << 12, (1 << 12) + (1 << 10))
|
|
# print("Random source: %d" % ret)
|
|
return ret
|
|
|
|
def add_offset_to_source(source, offset):
|
|
"""Find the address from the given source value and offset"""
|
|
if offset & 0x800:
|
|
offset -= 0x1000
|
|
return source + offset
|
|
|
|
def insert_into_data(test_data, source, offset, value, width, xlen):
|
|
"""Insert the given value into the given location of the test data"""
|
|
address = add_offset_to_source(source, offset)
|
|
# print("Test #%d" % testcase_num)
|
|
# print(f"Source: {source}, Offset: {offset}, Value: {value}, Width: {width}, xlen: {xlen}, Addr: {address}")
|
|
if address < 0:
|
|
return False
|
|
word_offset = address % (xlen // 8)
|
|
word_address = address - word_offset
|
|
if word_address in test_data:
|
|
return False
|
|
test_data[word_address] = value * (1 << (word_offset*8)) + ((~(((1 << width)-1) << (word_offset*8))) & rand_value(xlen))
|
|
# print(f"Word: {hex(test_data[word_address])}")
|
|
return True
|
|
|
|
def align(address, width):
|
|
"""Align the address to the given width, in bits"""
|
|
return address - (address % (width // 8))
|
|
|
|
testcase_num = 0
|
|
def generate_case(xlen, instruction, load_register, source_register, source_register_value, offset, expected):
|
|
"""Produce the specified test case and return it as a pair of strings, where the first is the test case and the second is the output"""
|
|
global testcase_num
|
|
if xlen == 64:
|
|
store = "sd"
|
|
elif xlen == 32:
|
|
if instruction in ["lwu", "ld"]:
|
|
raise Exception("Instruction %s not supported in RV32I" % instruction)
|
|
store = "sw"
|
|
else:
|
|
raise Exception("Unknown xlen value: %s" % xlen)
|
|
if offset >= 0x800:
|
|
offset -= 0x1000
|
|
if widths[instruction] != xlen:
|
|
expected = expected % (1 << widths[instruction])
|
|
if 'u' not in instruction:
|
|
if expected & (1 << (widths[instruction] - 1)):
|
|
expected = (expected + ~((1 << widths[instruction]) - 1)) & ((1 << xlen) - 1)
|
|
data = f"""# Testcase {testcase_num}: source {offset}(x{source_register} == {source_register_value}), result: x{load_register} == {expected}
|
|
la x31, test_data
|
|
lui x{source_register}, {source_register_value // (1 << 12)}
|
|
addi x{source_register}, x{source_register}, {source_register_value % (1 << 12)}
|
|
add x{source_register}, x{source_register}, x31
|
|
{instruction} x{load_register}, {offset}(x{source_register})
|
|
{store} x{load_register}, {(testcase_num*xlen//8) % 0x800}(x6)
|
|
RVTEST_IO_ASSERT_GPR_EQ(x8, x{load_register}, {expected})
|
|
|
|
"""
|
|
testcase_num += 1
|
|
if testcase_num*xlen//8 % 0x800 == 0:
|
|
data += "# Adjust x6 because we're storing too many things\naddi x6, x6, 1024\naddi x6, x6, 1024\n\n"
|
|
if xlen == 32:
|
|
reference_output = "{:08x}\n".format(expected)
|
|
elif xlen == 64:
|
|
reference_output = "{:08x}\n{:08x}\n".format(expected % (1 << 32), expected >> 32)
|
|
return (data, reference_output)
|
|
|
|
def write_header(outfile):
|
|
outfile.write(f"""///////////////////////////////////////////
|
|
//
|
|
// WALLY-LOAD
|
|
//
|
|
// Author: {author}
|
|
//
|
|
// Created {str(datetime.now())}
|
|
//
|
|
""")
|
|
outfile.write(open("testgen_header.S", "r").read())
|
|
|
|
def write_test_data(outfile, test_data, xlen):
|
|
# print("Begin writing test data:")
|
|
# print("{} entries, from address {} to {}".format(len(test_data), min(test_data.keys()), max(test_data.keys())))
|
|
# print(test_data)
|
|
outfile.write("""
|
|
.align 16
|
|
test_data:
|
|
|
|
""")
|
|
if xlen == 32:
|
|
data_word = ".word"
|
|
elif xlen == 64:
|
|
data_word = ".dword"
|
|
else:
|
|
raise Exception("Unknown xlen: %d" % xlen)
|
|
byte_width = xlen // 8
|
|
for addr in [0] + sorted(test_data.keys()):
|
|
if addr in test_data:
|
|
word = f" {data_word} {hex(test_data[addr] % (1 << xlen))} # test_data+{hex(addr)}\n"
|
|
else:
|
|
word = ""
|
|
try:
|
|
fill_len = (min(k for k in test_data.keys() if k > addr) - addr) // byte_width - 1
|
|
if word == "":
|
|
fill_len += 1
|
|
fill = f" .fill {fill_len}, {byte_width}, 0x0\n"
|
|
except:
|
|
fill = ""
|
|
case = word+fill
|
|
outfile.write(case)
|
|
|
|
##################################
|
|
# main body
|
|
##################################
|
|
|
|
widths = {
|
|
"lb": 8,
|
|
"lbu": 8,
|
|
"lh": 16,
|
|
"lhu": 16,
|
|
"lw": 32,
|
|
"lwu": 32,
|
|
"ld": 64,
|
|
}
|
|
instructions = [i for i in widths]
|
|
author = "Jarred Allen"
|
|
xlens = [32, 64]
|
|
numrand = 100;
|
|
|
|
# setup
|
|
seed(0) # make tests reproducible
|
|
|
|
for xlen in xlens:
|
|
testcase_num = 0
|
|
fname = "../../imperas-riscv-tests/riscv-test-suite/rv{}i/src/WALLY-LOAD.S".format(xlen)
|
|
refname = "../../imperas-riscv-tests/riscv-test-suite/rv{}i/references/WALLY-LOAD.reference_output".format(xlen)
|
|
f = open(fname, "w")
|
|
r = open(refname, "w")
|
|
write_header(f)
|
|
test_data = dict()
|
|
corner_values = [0x00, 0xFFFFFFFF, 0x7F, 0x7FFF, 0x7FFFFFFF]
|
|
if xlen == 64:
|
|
corner_values += [0xFFFFFFFFFFFFFFFF, 0x7FFFFFFFFFFFFFF]
|
|
corner_offsets = [0x800, 0x000, 0x7FF]
|
|
for instruction in instructions:
|
|
print("Running xlen: %d, instruction: %s" % (xlen, instruction))
|
|
if xlen == 32:
|
|
if instruction in ["lwu", "ld"]:
|
|
continue
|
|
for value in corner_values + [rand_value(widths[instruction]) for _ in range(3)]:
|
|
value = value % (1 << widths[instruction])
|
|
source_reg = rand_source()
|
|
for offset in corner_offsets + [rand_offset() for _ in range(3)]:
|
|
offset = align(offset, widths[instruction])
|
|
source_reg = align(source_reg, widths[instruction])
|
|
if insert_into_data(test_data, source_reg, offset, value, widths[instruction], xlen):
|
|
data, output = generate_case(xlen, instruction, rand_reg(), rand_reg(), source_reg, offset, value)
|
|
f.write(data)
|
|
r.write(output)
|
|
while testcase_num % 4:
|
|
source = rand_source()
|
|
offset = rand_offset()
|
|
value = rand_value(widths[instruction])
|
|
if insert_into_data(test_data, source, offset, value, widths['lb'], xlen):
|
|
data, output = generate_case(xlen, 'lb', rand_reg(), rand_reg(), source, offset, value)
|
|
f.write(data)
|
|
r.write(output)
|
|
f.write("""# ---------------------------------------------------------------------------------------------
|
|
|
|
RVTEST_IO_WRITE_STR(x31, "Test End\\n")
|
|
|
|
# ---------------------------------------------------------------------------------------------
|
|
|
|
RV_COMPLIANCE_HALT
|
|
|
|
RV_COMPLIANCE_CODE_END
|
|
|
|
.data
|
|
# Input data section
|
|
""")
|
|
write_test_data(f, test_data, xlen)
|
|
f.write("""# Output data section.
|
|
RV_COMPLIANCE_DATA_BEGIN
|
|
|
|
test_1_res:
|
|
""")
|
|
f.write(f".fill {testcase_num}, {xlen//8}, -1\n")
|
|
f.write("\nRV_COMPLIANCE_DATA_END\n")
|
|
f.close()
|
|
r.close()
|