forked from OSchip/llvm-project
301 lines
12 KiB
Python
301 lines
12 KiB
Python
# -*- Python -*- vim: set syntax=python tabstop=4 expandtab cc=80:
|
|
|
|
# Configuration file for the 'lit' test runner.
|
|
|
|
import errno
|
|
import os
|
|
import platform
|
|
import re
|
|
import shlex
|
|
import signal
|
|
import subprocess
|
|
import sys
|
|
import tempfile
|
|
import time
|
|
|
|
import lit.Test
|
|
import lit.formats
|
|
import lit.util
|
|
|
|
class LibcxxabiTestFormat(lit.formats.FileBasedTest):
|
|
"""
|
|
Custom test format handler for use with the test format use by libc++abi.
|
|
"""
|
|
|
|
def __init__(self, cxx_under_test, cpp_flags, ld_flags, exec_env):
|
|
self.cxx_under_test = cxx_under_test
|
|
self.cpp_flags = list(cpp_flags)
|
|
self.ld_flags = list(ld_flags)
|
|
self.exec_env = dict(exec_env)
|
|
|
|
def execute(self, test, lit_config):
|
|
while True:
|
|
try:
|
|
return self._execute(test, lit_config)
|
|
except OSError as oe:
|
|
if oe.errno != errno.ETXTBSY:
|
|
raise
|
|
time.sleep(0.1)
|
|
|
|
def _execute(self, test, lit_config):
|
|
# Extract test metadata from the test file.
|
|
requires = []
|
|
unsupported = []
|
|
with open(test.getSourcePath()) as f:
|
|
for ln in f:
|
|
if 'XFAIL:' in ln:
|
|
items = ln[ln.index('XFAIL:') + 6:].split(',')
|
|
test.xfails.extend([s.strip() for s in items])
|
|
elif 'REQUIRES:' in ln:
|
|
items = ln[ln.index('REQUIRES:') + 9:].split(',')
|
|
requires.extend([s.strip() for s in items])
|
|
elif 'UNSUPPORTED:' in ln:
|
|
items = ln[ln.index('UNSUPPORTED:') + 12:].split(',')
|
|
unsupported.extend([s.strip() for s in items])
|
|
elif not ln.strip().startswith("//") and ln.strip():
|
|
# Stop at the first non-empty line that is not a C++
|
|
# comment.
|
|
break
|
|
|
|
# Check that we have the required features.
|
|
#
|
|
# FIXME: For now, this is cribbed from lit.TestRunner, to avoid
|
|
# introducing a dependency there. What we more ideally would like to do
|
|
# is lift the "requires" handling to be a core lit framework feature.
|
|
missing_required_features = [f for f in requires
|
|
if f not in test.config.available_features]
|
|
if missing_required_features:
|
|
return (lit.Test.UNSUPPORTED,
|
|
"Test requires the following features: %s" % (
|
|
', '.join(missing_required_features),))
|
|
|
|
unsupported_features = [f for f in unsupported
|
|
if f in test.config.available_features]
|
|
if unsupported_features:
|
|
return (lit.Test.UNSUPPORTED,
|
|
"Test is unsupported with the following features: %s" % (
|
|
', '.join(unsupported_features),))
|
|
|
|
# Evaluate the test.
|
|
return self._evaluate_test(test, lit_config)
|
|
|
|
def _evaluate_test(self, test, lit_config):
|
|
name = test.path_in_suite[-1]
|
|
source_path = test.getSourcePath()
|
|
source_dir = os.path.dirname(source_path)
|
|
|
|
# If this is a compile (failure) test, build it and check for failure.
|
|
exec_file = tempfile.NamedTemporaryFile(suffix="exe", delete=False)
|
|
exec_path = exec_file.name
|
|
exec_file.close()
|
|
|
|
try:
|
|
compile_cmd = [self.cxx_under_test, '-o', exec_path,
|
|
source_path] + self.cpp_flags + self.ld_flags
|
|
cmd = compile_cmd
|
|
out, err, exitCode = lit.util.executeCommand(cmd)
|
|
if exitCode != 0:
|
|
report = """Command: %s\n""" % ' '.join(["'%s'" % a
|
|
for a in cmd])
|
|
report += """Exit Code: %d\n""" % exitCode
|
|
if out:
|
|
report += """Standard Output:\n--\n%s--""" % out
|
|
if err:
|
|
report += """Standard Error:\n--\n%s--""" % err
|
|
report += "\n\nCompilation failed unexpectedly!"
|
|
return lit.Test.FAIL, report
|
|
|
|
cmd = []
|
|
if self.exec_env:
|
|
cmd.append('env')
|
|
cmd.extend('%s=%s' % (name, value)
|
|
for name,value in self.exec_env.items())
|
|
cmd.append(exec_path)
|
|
if lit_config.useValgrind:
|
|
cmd = lit_config.valgrindArgs + cmd
|
|
out, err, exitCode = lit.util.executeCommand(cmd, cwd=source_dir)
|
|
if exitCode != 0:
|
|
report = """Compiled With: %s\n""" % \
|
|
' '.join(["'%s'" % a for a in compile_cmd])
|
|
report += """Command: %s\n""" % \
|
|
' '.join(["'%s'" % a for a in cmd])
|
|
report += """Exit Code: %d\n""" % exitCode
|
|
if out:
|
|
report += """Standard Output:\n--\n%s--""" % out
|
|
if err:
|
|
report += """Standard Error:\n--\n%s--""" % err
|
|
report += "\n\nCompiled test failed unexpectedly!"
|
|
return lit.Test.FAIL, report
|
|
finally:
|
|
try:
|
|
os.remove(exec_path)
|
|
except:
|
|
pass
|
|
return lit.Test.PASS, ""
|
|
|
|
# name: The name of this test suite.
|
|
config.name = 'libc++abi'
|
|
|
|
# suffixes: A list of file extensions to treat as test files.
|
|
config.suffixes = ['.cpp']
|
|
|
|
# test_source_root: The root path where tests are located.
|
|
config.test_source_root = os.path.dirname(__file__)
|
|
|
|
# Gather various compiler parameters.
|
|
cxx_under_test = lit_config.params.get('cxx_under_test', None)
|
|
if cxx_under_test is None:
|
|
cxx_under_test = getattr(config, 'cxx_under_test', None)
|
|
|
|
# If no specific cxx_under_test was given, attempt to infer it as clang++.
|
|
if cxx_under_test is None:
|
|
clangxx = lit.util.which('clang++', config.environment['PATH'])
|
|
if clangxx is not None:
|
|
cxx_under_test = clangxx
|
|
lit_config.note("inferred cxx_under_test as: %r" % (cxx_under_test,))
|
|
if cxx_under_test is None:
|
|
lit_config.fatal('must specify user parameter cxx_under_test '
|
|
'(e.g., --param=cxx_under_test=clang++)')
|
|
|
|
libcxxabi_src_root = lit_config.params.get('libcxxabi_src_root', None)
|
|
if libcxxabi_src_root is None:
|
|
libcxxabi_src_root = getattr(config, 'libcxxabi_src_root', None)
|
|
if libcxxabi_src_root is None:
|
|
libcxxabi_src_root = os.path.dirname(config.test_source_root)
|
|
|
|
libcxxabi_library_root = lit_config.params.get('libcxxabi_library_root', None)
|
|
if libcxxabi_library_root is None:
|
|
libcxxabi_library_root = getattr(config, 'libcxxabi_library_root', None)
|
|
if libcxxabi_library_root is None:
|
|
lit_config.fatal("libcxxabi_library_root must be defined")
|
|
|
|
libcxx_includes = lit_config.params.get('libcxx_includes', None)
|
|
if libcxx_includes is None:
|
|
libcxx_includes = getattr(config, 'libcxx_includes', None)
|
|
if libcxx_includes is None:
|
|
lit_config.fatal("libcxx_includes must be defined")
|
|
|
|
enable_shared = lit_config.params.get('enable_shared', None)
|
|
if enable_shared is None:
|
|
enable_shared = getattr(config, 'enable_shared', None)
|
|
if enable_shared is None:
|
|
lit_config.fatal("enable_shared must be defined")
|
|
|
|
enable_threads = lit_config.params.get('enable_threads', None)
|
|
if enable_threads is None:
|
|
enable_threads = getattr(config, 'enable_threads', None)
|
|
if enable_threads is None:
|
|
lit_config.fatal('enable_threads must be defined')
|
|
|
|
llvm_unwinder = getattr(config, 'llvm_unwinder', None)
|
|
if llvm_unwinder is None:
|
|
lit_config.fatal("llvm_unwinder must be defined")
|
|
|
|
|
|
# Compiler parameters
|
|
include_paths = ['-I' + libcxxabi_src_root + '/include',
|
|
'-I' + libcxx_includes]
|
|
library_paths = ['-L' + libcxxabi_library_root]
|
|
compile_flags = ['-std=c++11']
|
|
link_flags = []
|
|
exec_env = {}
|
|
|
|
link_flags_str = lit_config.params.get('link_flags', None)
|
|
if link_flags_str is None:
|
|
link_flags_str = getattr(config, 'link_flags', None)
|
|
if link_flags_str is None:
|
|
if enable_shared:
|
|
link_flags += ['-lc++abi']
|
|
if sys.platform == 'darwin':
|
|
link_flags += ['-lSystem']
|
|
elif sys.platform.startswith('linux'):
|
|
if not llvm_unwinder:
|
|
link_flags += ['-lgcc_eh']
|
|
link_flags += ['-lc', '-lm']
|
|
if enable_threads:
|
|
link_flags += ['-lpthread']
|
|
if llvm_unwinder:
|
|
link_flags += ['-lunwind', '-ldl']
|
|
else:
|
|
link_flags += ['-lgcc_s']
|
|
else:
|
|
lit_config.fatal("unrecognized system")
|
|
|
|
lit_config.note("inferred link_flags as: %r" % (link_flags,))
|
|
if link_flags_str is not None:
|
|
link_flags += shlex.split(link_flags_str)
|
|
|
|
# Configure extra compiler flags.
|
|
if not enable_threads:
|
|
compile_flags += ['-DLIBCXXABI_HAS_NO_THREADS=1']
|
|
|
|
# Always disable timed test when using LIT since the output gets lost and since
|
|
# using the timer requires <chrono> as a dependancy.
|
|
compile_flags += ['-DLIBCXXABI_NO_TIMER']
|
|
|
|
san = lit_config.params.get('llvm_use_sanitizer', None)
|
|
if san is None:
|
|
san = getattr(config, 'llvm_use_sanitizer', None)
|
|
if san:
|
|
# Search for llvm-symbolizer along the compiler path first
|
|
# and then along the PATH env variable.
|
|
symbolizer_search_paths = os.environ.get('PATH', '')
|
|
cxx_path = lit.util.which(cxx_under_test)
|
|
if cxx_path is not None:
|
|
symbolizer_search_paths = os.path.dirname(cxx_path) + \
|
|
os.pathsep + symbolizer_search_paths
|
|
llvm_symbolizer = lit.util.which('llvm-symbolizer',
|
|
symbolizer_search_paths)
|
|
compile_flags += ['-g', '-fno-omit-frame-pointer']
|
|
if sys.platform.startswith('linux'):
|
|
link_flags += ['-ldl']
|
|
if san == 'Address':
|
|
compile_flags += ['-fsanitize=address']
|
|
if llvm_symbolizer is not None:
|
|
exec_env['ASAN_SYMBOLIZER_PATH'] = llvm_symbolizer
|
|
config.available_features.add('asan')
|
|
elif san == 'Memory' or san == 'MemoryWithOrigins':
|
|
compile_flags += ['-fsanitize=memory']
|
|
if llvm_symbolizer is not None:
|
|
exec_env['MSAN_SYMBOLIZER_PATH'] = llvm_symbolizer
|
|
config.available_features.add('msan')
|
|
if san == 'MemoryWithOrigins':
|
|
compile_flags += ['-fsanitize-memory-track-origins']
|
|
elif san == 'Undefined':
|
|
compile_flags += ['-fsanitize=undefined',
|
|
'-fno-sanitize=vptr,function',
|
|
'-fno-sanitize-recover']
|
|
config.available_features.add('ubsan')
|
|
elif san == 'Thread':
|
|
compile_flags += ['-fsanitize=thread']
|
|
config.available_features.add('tsan')
|
|
else:
|
|
lit_config.fatal('unsupported value for '
|
|
'llvm_use_sanitizer: {0}'.format(san))
|
|
|
|
|
|
# Configure extra linker parameters.
|
|
|
|
if sys.platform == 'darwin':
|
|
exec_env['DYLD_LIBRARY_PATH'] = os.path.join(libcxxabi_library_root)
|
|
elif sys.platform.startswith('linux'):
|
|
link_flags += ['-Wl,-R', libcxxabi_library_root]
|
|
else:
|
|
lit_config.fatal("unrecognized system")
|
|
|
|
config.available_features.add(sys.platform)
|
|
|
|
config.test_format = LibcxxabiTestFormat(
|
|
cxx_under_test,
|
|
cpp_flags = ['-nostdinc++'] + compile_flags + include_paths,
|
|
ld_flags = ['-nodefaultlibs'] + library_paths + ['-lc++'] + link_flags,
|
|
exec_env = exec_env)
|
|
|
|
# Get or infer the target triple.
|
|
config.target_triple = lit_config.params.get('target_triple', None)
|
|
# If no target triple was given, try to infer it from the compiler under test.
|
|
if config.target_triple is None:
|
|
config.target_triple = lit.util.capture(
|
|
[cxx_under_test, '-dumpmachine']).strip()
|
|
lit_config.note("inferred target_triple as: %r" % (config.target_triple,))
|