318 lines
12 KiB
Python
318 lines
12 KiB
Python
|
import collections
|
||
|
|
from pathlib import PurePath
|
||
|
|
import re
|
||
|
|
import os
|
||
|
|
import subprocess
|
||
|
|
import sys
|
||
|
|
import pytest
|
||
|
|
|
||
|
|
testinfo = collections.namedtuple(
|
||
|
|
'testinfo',
|
||
|
|
['exitcode', 'execcode', 'output', 'linkargs', 'skip_test_expected'])
|
||
|
|
default_testinfo = testinfo(
|
||
|
|
exitcode=0, execcode=0, output='', linkargs=[], skip_test_expected=False)
|
||
|
|
|
||
|
|
ASM = 'riscv64-unknown-elf-gcc'
|
||
|
|
SIMU = 'spike'
|
||
|
|
|
||
|
|
LIBPRINT = 'libprint.s'
|
||
|
|
if 'LIBPRINT' in os.environ:
|
||
|
|
LIBPRINT = os.environ['LIBPRINT']
|
||
|
|
|
||
|
|
|
||
|
|
def cat(filename):
|
||
|
|
with open(filename, "rb") as f:
|
||
|
|
for line in f:
|
||
|
|
sys.stdout.buffer.write(line)
|
||
|
|
|
||
|
|
|
||
|
|
def env_bool_variable(name, globals):
|
||
|
|
if name not in globals:
|
||
|
|
globals[name] = False
|
||
|
|
if name in os.environ:
|
||
|
|
globals[name] = True
|
||
|
|
|
||
|
|
|
||
|
|
def env_str_variable(name, globals):
|
||
|
|
if name in os.environ:
|
||
|
|
globals[name] = os.environ[name]
|
||
|
|
|
||
|
|
|
||
|
|
def filter_pathnames(pathlist, pattern):
|
||
|
|
return tuple(path for path in pathlist if PurePath(path).match(pattern))
|
||
|
|
|
||
|
|
|
||
|
|
class TestExpectPragmas(object):
|
||
|
|
"""Base class for tests that read the expected result as annotations
|
||
|
|
in test files.
|
||
|
|
|
||
|
|
get_expect(file) will parse the file, looking EXPECT and EXITCODE
|
||
|
|
pragmas.
|
||
|
|
|
||
|
|
run_command(command) is a wrapper around subprocess.check_output()
|
||
|
|
that extracts the output and exit code.
|
||
|
|
|
||
|
|
"""
|
||
|
|
|
||
|
|
def get_expect(self, filename):
|
||
|
|
"""Parse "filename" looking for EXPECT and EXITCODE annotations.
|
||
|
|
|
||
|
|
Look for a line "EXPECTED" (possibly with whitespaces and
|
||
|
|
comments). Text after this "EXPECTED" line is the expected
|
||
|
|
output.
|
||
|
|
|
||
|
|
The file may also contain a line like "EXITCODE <n>" where <n>
|
||
|
|
is an integer, and is the expected exitcode of the command.
|
||
|
|
|
||
|
|
The result is cached to avoid re-parsing the file multiple
|
||
|
|
times.
|
||
|
|
"""
|
||
|
|
if filename not in self.__expect:
|
||
|
|
self.__expect[filename] = self._extract_expect(filename)
|
||
|
|
return self.__expect[filename]
|
||
|
|
|
||
|
|
def skip_if_partial_match(self, actual, expect, ignore_error_message):
|
||
|
|
if not ignore_error_message:
|
||
|
|
return False
|
||
|
|
|
||
|
|
if expect.exitcode != actual.exitcode:
|
||
|
|
# Not the same exit code => something's wrong anyway
|
||
|
|
return False
|
||
|
|
|
||
|
|
if actual.exitcode == 3:
|
||
|
|
# There's a syntax error in both expected and actual,
|
||
|
|
# but the actual error may slightly differ if we don't
|
||
|
|
# have the exact same .g4.
|
||
|
|
return True
|
||
|
|
|
||
|
|
# Let the test pass with 'return True' if appropriate.
|
||
|
|
# Otherwise, continue to the full assertion for a
|
||
|
|
# complete diagnostic.
|
||
|
|
if actual.exitcode != 0 and expect.exitcode == actual.exitcode:
|
||
|
|
if expect.output == '':
|
||
|
|
# No output expected, but we know there must be an
|
||
|
|
# error. If there was a particular error message
|
||
|
|
# expected, we'd have written it in the output,
|
||
|
|
# hence just ignore the actual message.
|
||
|
|
return True
|
||
|
|
# Ignore difference in error message except in the
|
||
|
|
# line number (ignore the column too, it may
|
||
|
|
# slightly vary, eg. in "foo" / 4, the error may
|
||
|
|
# be considered on "foo" or on /):
|
||
|
|
if re.match(r'^In function [^ :]*: Line [0-9]* col [0-9]*:', actual.output):
|
||
|
|
out_loc = re.sub(r' col [0-9]*:.*$', '', actual.output)
|
||
|
|
exp_loc = re.sub(r' col [0-9]*:.*$', '', expect.output)
|
||
|
|
if out_loc == exp_loc:
|
||
|
|
return True
|
||
|
|
if any(x.output and (x.output.endswith('has no value yet!' + os.linesep)
|
||
|
|
or x.output.endswith(' by 0' + os.linesep))
|
||
|
|
for x in (actual, expect)):
|
||
|
|
# Ignore the error message when our compiler
|
||
|
|
# raises this error (either in actual or expect,
|
||
|
|
# depending on what we're testing).
|
||
|
|
return True
|
||
|
|
|
||
|
|
return False
|
||
|
|
|
||
|
|
__expect = {}
|
||
|
|
|
||
|
|
def _extract_expect(self, file):
|
||
|
|
exitcode = 0
|
||
|
|
execcode = 0
|
||
|
|
linkargs = []
|
||
|
|
inside_expected = False
|
||
|
|
skip_test_expected = False
|
||
|
|
expected_lines = []
|
||
|
|
expected_present = False
|
||
|
|
with open(file, encoding="utf-8") as f:
|
||
|
|
for line in f.readlines():
|
||
|
|
# Ignore non-comments
|
||
|
|
if not re.match(r'\s*//', line):
|
||
|
|
continue
|
||
|
|
# Cleanup comment start and whitespaces
|
||
|
|
line = re.sub(r'\s*//\s*', '', line)
|
||
|
|
line = re.sub(r'\s*$', '', line)
|
||
|
|
|
||
|
|
if line == 'END EXPECTED':
|
||
|
|
inside_expected = False
|
||
|
|
elif line.startswith('EXITCODE'):
|
||
|
|
words = line.split(' ')
|
||
|
|
assert len(words) == 2
|
||
|
|
exitcode = int(words[1])
|
||
|
|
elif line.startswith('EXECCODE'):
|
||
|
|
words = line.split(' ')
|
||
|
|
assert len(words) == 2
|
||
|
|
execcode = int(words[1])
|
||
|
|
elif line.startswith('LINKARGS'):
|
||
|
|
words = line.split(' ')
|
||
|
|
assert len(words) >= 2
|
||
|
|
linkargs += [w.replace("$dir", os.path.dirname(file))
|
||
|
|
for w in words[1:]]
|
||
|
|
elif line == 'EXPECTED':
|
||
|
|
inside_expected = True
|
||
|
|
expected_present = True
|
||
|
|
elif line == 'SKIP TEST EXPECTED':
|
||
|
|
skip_test_expected = True
|
||
|
|
elif inside_expected:
|
||
|
|
expected_lines.append(line)
|
||
|
|
|
||
|
|
if not expected_present:
|
||
|
|
pytest.fail("Missing EXPECTED directive in test file")
|
||
|
|
|
||
|
|
if expected_lines == []:
|
||
|
|
output = ''
|
||
|
|
else:
|
||
|
|
output = os.linesep.join(expected_lines) + os.linesep
|
||
|
|
|
||
|
|
return testinfo(exitcode=exitcode, execcode=execcode,
|
||
|
|
output=output, linkargs=linkargs,
|
||
|
|
skip_test_expected=skip_test_expected)
|
||
|
|
|
||
|
|
|
||
|
|
class TestCompiler(object):
|
||
|
|
DISABLE_CODEGEN: bool
|
||
|
|
SKIP_NOT_IMPLEMENTED: bool
|
||
|
|
MINIC_COMPILE: str
|
||
|
|
MINICC_OPTS: list[str]
|
||
|
|
|
||
|
|
def remove(self, file):
|
||
|
|
"""Like os.remove(), but ignore errors, e.g. don't complain if the
|
||
|
|
file doesn't exist.
|
||
|
|
"""
|
||
|
|
try:
|
||
|
|
os.remove(file)
|
||
|
|
except OSError:
|
||
|
|
pass
|
||
|
|
|
||
|
|
def run_command(self, cmd, scope="compile"):
|
||
|
|
"""Run the command cmd (given as [command, arg1, arg2, ...]), and
|
||
|
|
return testinfo(exitcode=..., output=...) containing the
|
||
|
|
exit code of the command it its standard output + standard error.
|
||
|
|
|
||
|
|
If scope="compile" (resp. "runtime"), then the exitcode (resp.
|
||
|
|
execcode) is set with the exit status of the command, and the
|
||
|
|
execcode (resp. exitcode) is set to 0.
|
||
|
|
"""
|
||
|
|
try:
|
||
|
|
output = subprocess.check_output(cmd, timeout=60,
|
||
|
|
stderr=subprocess.STDOUT)
|
||
|
|
status = 0
|
||
|
|
except subprocess.CalledProcessError as e:
|
||
|
|
output = e.output
|
||
|
|
status = e.returncode
|
||
|
|
if scope == "runtime":
|
||
|
|
return default_testinfo._replace(execcode=status,
|
||
|
|
output=output.decode())
|
||
|
|
else:
|
||
|
|
return default_testinfo._replace(exitcode=status,
|
||
|
|
output=output.decode())
|
||
|
|
|
||
|
|
def run_with_gcc(self, file, info):
|
||
|
|
return self.compile_and_simulate(file, info, reg_alloc='gcc', use_gcc=True)
|
||
|
|
|
||
|
|
def compile_with_gcc(self, file, output_name):
|
||
|
|
print("Compiling with GCC...")
|
||
|
|
result = self.run_command(
|
||
|
|
[ASM, '-S', '-I./',
|
||
|
|
'--output=' + output_name,
|
||
|
|
'-Werror',
|
||
|
|
'-Wno-div-by-zero', # We need to accept 1/0 at compile-time
|
||
|
|
file])
|
||
|
|
print(result.output)
|
||
|
|
print("Compiling with GCC... DONE")
|
||
|
|
return result
|
||
|
|
|
||
|
|
def compile_and_simulate(self, file, info, reg_alloc,
|
||
|
|
use_gcc=False):
|
||
|
|
basename, _ = os.path.splitext(file)
|
||
|
|
output_name = basename + '-' + reg_alloc + '.s'
|
||
|
|
if use_gcc:
|
||
|
|
result = self.compile_with_gcc(file, output_name)
|
||
|
|
if result.exitcode != 0:
|
||
|
|
# We don't consider the exact exitcode, and ignore the
|
||
|
|
# output (our error messages may be different from
|
||
|
|
# GCC's)
|
||
|
|
return result._replace(exitcode=1,
|
||
|
|
output=None)
|
||
|
|
else:
|
||
|
|
result = self.compile_with_ours(file, output_name, reg_alloc)
|
||
|
|
if (self.DISABLE_CODEGEN or
|
||
|
|
reg_alloc == 'none' or
|
||
|
|
info.exitcode != 0 or result.exitcode != 0):
|
||
|
|
# Either the result is meaningless, or we already failed
|
||
|
|
# and don't need to go any further:
|
||
|
|
return result
|
||
|
|
# Only executable code past this point.
|
||
|
|
exec_name = basename + '-' + reg_alloc + '.riscv'
|
||
|
|
return self.link_and_run(output_name, exec_name, info)
|
||
|
|
|
||
|
|
def link_and_run(self, output_name, exec_name, info):
|
||
|
|
self.remove(exec_name)
|
||
|
|
cmd = [
|
||
|
|
ASM, output_name, LIBPRINT,
|
||
|
|
'-o', exec_name
|
||
|
|
] + info.linkargs
|
||
|
|
print(info)
|
||
|
|
print("Assembling and linking " + output_name + ": " + ' '.join(cmd))
|
||
|
|
try:
|
||
|
|
subprocess.check_output(cmd, timeout=60, stderr=subprocess.STDOUT)
|
||
|
|
except subprocess.CalledProcessError as e:
|
||
|
|
print("Assembling failed:\n")
|
||
|
|
print(e.output.decode())
|
||
|
|
print("Assembler code below:\n")
|
||
|
|
cat(output_name)
|
||
|
|
pytest.fail()
|
||
|
|
assert (os.path.isfile(exec_name))
|
||
|
|
sys.stdout.write("Assembling and linking ... OK\n")
|
||
|
|
try:
|
||
|
|
result = self.run_command(
|
||
|
|
[SIMU,
|
||
|
|
'-m100', # Limit memory usage to 100MB, more than enough and
|
||
|
|
# avoids crashing on a VM with <= 2GB RAM for example.
|
||
|
|
'pk',
|
||
|
|
exec_name],
|
||
|
|
scope="runtime")
|
||
|
|
output = re.sub(r'bbl loader\r?\n', '', result.output)
|
||
|
|
print("Output of the program:")
|
||
|
|
print(output)
|
||
|
|
return testinfo(execcode=result.execcode,
|
||
|
|
exitcode=result.exitcode,
|
||
|
|
output=output,
|
||
|
|
linkargs=[],
|
||
|
|
skip_test_expected=False)
|
||
|
|
except subprocess.TimeoutExpired:
|
||
|
|
pytest.fail("Timeout executing program. Infinite loop in generated code?")
|
||
|
|
|
||
|
|
def compile_with_ours(self, file, output_name, reg_alloc):
|
||
|
|
print("Compiling ...")
|
||
|
|
self.remove(output_name)
|
||
|
|
alloc_opt = '--reg-alloc=' + reg_alloc
|
||
|
|
out_opt = '--output=' + output_name
|
||
|
|
cmd = [sys.executable, self.MINIC_COMPILE]
|
||
|
|
if not self.DISABLE_CODEGEN:
|
||
|
|
cmd += [out_opt, alloc_opt]
|
||
|
|
cmd += self.MINICC_OPTS
|
||
|
|
cmd += [file]
|
||
|
|
result = self.run_command(cmd)
|
||
|
|
print(' '.join(cmd))
|
||
|
|
print("Exited with status:", result.exitcode)
|
||
|
|
print(result.output)
|
||
|
|
if result.exitcode == 4:
|
||
|
|
if "AllocationError" in result.output:
|
||
|
|
if reg_alloc == 'naive':
|
||
|
|
pytest.skip("Too big for the naive allocator")
|
||
|
|
else:
|
||
|
|
pytest.skip("Offsets too big to be manipulated")
|
||
|
|
elif ("NotImplementedError" in result.output and
|
||
|
|
self.SKIP_NOT_IMPLEMENTED):
|
||
|
|
pytest.skip("Feature not implemented in this compiler")
|
||
|
|
if result.exitcode != 0:
|
||
|
|
# May either be a failing test or a test with expected
|
||
|
|
# compilation failure (bad type, ...). Let the caller
|
||
|
|
# do the assertion and decide:
|
||
|
|
return result
|
||
|
|
if not self.DISABLE_CODEGEN:
|
||
|
|
assert os.path.isfile(output_name)
|
||
|
|
print("Compiling ... OK")
|
||
|
|
return result
|