libcxxabi_lit.patch

lit.cfg.py

# -*- 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
from lit.util import Compiler as Compiler

# name: The name of this test suite.
config.name = 'libc++abi'

# test_source_root: The root path where tests are located.
config.test_source_root = os.path.dirname(__file__)

# Gather various compiler parameters.
cxx_path= lit_config.params.get('cxx_under_test', None)
if cxx_path is None:
    cxx_path = getattr(config, 'cxx_under_test', None)

    # If no specific cxx_under_test was given, attempt to infer it as clang++.
    if cxx_path is None:
        cxx_path = lit.util.which('clang++', config.environment['PATH'])
        if cxx_path is not None:
            lit_config.note("inferred cxx_under_test as: %r" % (cxx_path,))
if cxx_path is None:
    lit_config.fatal('must specify user parameter cxx_under_test '
                     '(e.g., --param=cxx_under_test=clang++)')
cxx = Compiler(cxx_path)

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_obj_root = lit_config.params.get('libcxxabi_obj_root', None)
if libcxxabi_obj_root is None:
    libcxxabi_obj_root = getattr(config, 'libcxxabi_obj_root', None)
    if libcxxabi_obj_root is None:
        libcxxabi_obj_root = libcxxabi_src_root

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")

llvm_unwinder = getattr(config, 'llvm_unwinder', None)
if llvm_unwinder is None:
    lit_config.fatal("llvm_unwinder must be defined")

link_flags = []
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', '-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.
include_paths = ['-I' + libcxxabi_src_root + '/include',
                 '-I' + libcxx_includes]
library_paths = ['-L' + libcxxabi_obj_root + '/lib']
compile_flags = ['-std=c++11']


san = lit_config.params.get('llvm_use_sanitizer', None)
if san is None:
    san = getattr(config, 'llvm_use_sanitizer', None)
if san:
    if sys.platform.startswith('linux'):
        link_flags += ['-ldl']
    if san == 'Address':
        compile_flags += ['-fsanitize=address']
        config.available_features.add('asan')
    elif san == 'Memory' or san == 'MemoryWithOrigins':
        compile_flags += ['-fsanitize=memory']
        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')
    else:
        lit_config.fatal('unsupported value for '
                         'llvm_use_sanitizer: {0}'.format(san))


# Configure extra linker parameters.
exec_env = {}
if sys.platform == 'darwin':
    exec_env['DYLD_LIBRARY_PATH'] = os.path.join(libcxxabi_obj_root, 'lib')
elif sys.platform.startswith('linux'):
    link_flags += ['-Wl,-R', libcxxabi_obj_root + '/lib']
else:
    lit_config.fatal("unrecognized system")

# Configure the compiler flags
cxx.compile_flags += ['-nostdinc++'] + compile_flags + include_paths
cxx.link_flags += ['-nodefaultlibs'] + library_paths + ['-lc++'] + link_flags

# Configure the test format
config.test_format = lit.formats.SuffixDispatchTest()

# suffixes: A list of file extensions to treat as test files.
config.suffixes = ['.cpp']
test_runner = lit.formats.CompileAndExecuteTestRunner(cxx, exec_env=exec_env)
config.test_format.add_suffix_test('.cpp', test_runner)

# 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.path, '-dumpmachine']).strip()
    lit_config.note("inferred target_triple as: %r" % (config.target_triple,))

lit.patch

diff --git a/test/lit.cfg b/test/lit.cfg
index 7963ddd..7cfa8cf 100644
--- a/test/lit.cfg
+++ b/test/lit.cfg
@@ -16,164 +16,28 @@ 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_command(self, command, in_dir=None):
-        kwargs = {
-            'stdin' :subprocess.PIPE,
-            'stdout':subprocess.PIPE,
-            'stderr':subprocess.PIPE,
-        }
-        if in_dir:
-            kwargs['cwd'] = in_dir
-        p = subprocess.Popen(command, **kwargs)
-        out,err = p.communicate()
-        exitCode = p.wait()
-
-        # Detect Ctrl-C in subprocess.
-        if exitCode == -signal.SIGINT:
-            raise KeyboardInterrupt
-
-        return out, err, exitCode
-
-    def execute(self, test, lit_config):
-        while True:
-            try:
-                return self._execute(test, lit_config)
-            except OSError, 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 = self.execute_command(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 = self.execute_command(cmd, 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, ""
+from lit.util import Compiler as Compiler
 
 # 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)
+cxx_path= lit_config.params.get('cxx_under_test', None)
+if cxx_path is None:
+    cxx_path = 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:
+    if cxx_path is None:
+        cxx_path = lit.util.which('clang++', config.environment['PATH'])
+        if cxx_path is not None:
+            lit_config.note("inferred cxx_under_test as: %r" % (cxx_path,))
+if cxx_path is None:
     lit_config.fatal('must specify user parameter cxx_under_test '
                      '(e.g., --param=cxx_under_test=clang++)')
+cxx = Compiler(cxx_path)
 
 libcxxabi_src_root = lit_config.params.get('libcxxabi_src_root', None)
 if libcxxabi_src_root is None:
@@ -267,16 +131,22 @@ elif sys.platform.startswith('linux'):
 else:
     lit_config.fatal("unrecognized system")
 
-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)
+# Configure the compiler flags
+cxx.compile_flags += ['-nostdinc++'] + compile_flags + include_paths
+cxx.link_flags += ['-nodefaultlibs'] + library_paths + ['-lc++'] + link_flags
+
+# Configure the test format
+config.test_format = lit.formats.SuffixDispatchTest()
+
+# suffixes: A list of file extensions to treat as test files.
+config.suffixes = ['.cpp']
+test_runner = lit.formats.CompileAndExecuteTestRunner(cxx, exec_env=exec_env)
+config.test_format.add_suffix_test('.cpp', test_runner)
 
 # 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()
+        [cxx.path, '-dumpmachine']).strip()
     lit_config.note("inferred target_triple as: %r" % (config.target_triple,))