2009-07-31 13:54:17 +08:00
|
|
|
# -*- Python -*-
|
|
|
|
|
2009-09-22 13:16:02 +08:00
|
|
|
import os
|
2009-09-22 18:08:03 +08:00
|
|
|
import platform
|
2011-11-06 04:55:50 +08:00
|
|
|
import re
|
|
|
|
import subprocess
|
2012-11-01 04:59:50 +08:00
|
|
|
import tempfile
|
2011-11-06 04:55:50 +08:00
|
|
|
|
2013-08-09 22:43:04 +08:00
|
|
|
import lit.formats
|
|
|
|
import lit.util
|
2009-09-11 07:00:15 +08:00
|
|
|
|
2009-09-22 13:16:02 +08:00
|
|
|
# Configuration file for the 'lit' test runner.
|
2009-09-09 00:39:23 +08:00
|
|
|
|
2009-09-22 13:16:02 +08:00
|
|
|
# name: The name of this test suite.
|
|
|
|
config.name = 'Clang'
|
2009-09-09 00:39:23 +08:00
|
|
|
|
2011-02-09 12:19:57 +08:00
|
|
|
# Tweak PATH for Win32
|
|
|
|
if platform.system() == 'Windows':
|
|
|
|
# Seek sane tools in directories and set to $PATH.
|
|
|
|
path = getattr(config, 'lit_tools_dir', None)
|
2013-08-09 22:43:04 +08:00
|
|
|
path = lit_config.getToolsPath(path,
|
|
|
|
config.environment['PATH'],
|
|
|
|
['cmp.exe', 'grep.exe', 'sed.exe'])
|
2011-02-09 12:19:57 +08:00
|
|
|
if path is not None:
|
|
|
|
path = os.path.pathsep.join((path,
|
|
|
|
config.environment['PATH']))
|
|
|
|
config.environment['PATH'] = path
|
|
|
|
|
2013-04-11 21:34:18 +08:00
|
|
|
# Choose between lit's internal shell pipeline runner and a real shell. If
|
|
|
|
# LIT_USE_INTERNAL_SHELL is in the environment, we use that as an override.
|
|
|
|
use_lit_shell = os.environ.get("LIT_USE_INTERNAL_SHELL")
|
|
|
|
if use_lit_shell:
|
|
|
|
# 0 is external, "" is default, and everything else is internal.
|
|
|
|
execute_external = (use_lit_shell == "0")
|
|
|
|
else:
|
|
|
|
# Otherwise we default to internal on Windows and external elsewhere, as
|
|
|
|
# bash on Windows is usually very slow.
|
|
|
|
execute_external = (not sys.platform in ['win32'])
|
|
|
|
|
2009-09-22 13:16:02 +08:00
|
|
|
# testFormat: The test format to use to interpret tests.
|
|
|
|
#
|
|
|
|
# For now we require '&&' between commands, until they get globally killed and
|
|
|
|
# the test runner updated.
|
2009-11-08 09:47:35 +08:00
|
|
|
config.test_format = lit.formats.ShTest(execute_external)
|
2009-09-09 00:39:23 +08:00
|
|
|
|
2009-09-22 13:16:02 +08:00
|
|
|
# suffixes: A list of file extensions to treat as test files.
|
2012-02-11 04:37:10 +08:00
|
|
|
config.suffixes = ['.c', '.cpp', '.m', '.mm', '.cu', '.ll', '.cl', '.s']
|
2009-09-22 13:16:02 +08:00
|
|
|
|
2013-11-15 21:37:49 +08:00
|
|
|
# excludes: A list of directories to exclude from the testsuite. The 'Inputs'
|
|
|
|
# subdirectories contain auxiliary inputs for various tests in their parent
|
|
|
|
# directories.
|
|
|
|
config.excludes = ['Inputs', 'CMakeLists.txt', 'README.txt', 'LICENSE.txt']
|
|
|
|
|
2009-09-22 13:16:02 +08:00
|
|
|
# test_source_root: The root path where tests are located.
|
|
|
|
config.test_source_root = os.path.dirname(__file__)
|
|
|
|
|
|
|
|
# test_exec_root: The root path where tests should be run.
|
|
|
|
clang_obj_root = getattr(config, 'clang_obj_root', None)
|
|
|
|
if clang_obj_root is not None:
|
|
|
|
config.test_exec_root = os.path.join(clang_obj_root, 'test')
|
|
|
|
|
|
|
|
# Set llvm_{src,obj}_root for use by others.
|
|
|
|
config.llvm_src_root = getattr(config, 'llvm_src_root', None)
|
|
|
|
config.llvm_obj_root = getattr(config, 'llvm_obj_root', None)
|
|
|
|
|
2012-04-07 02:14:01 +08:00
|
|
|
# Clear some environment variables that might affect Clang.
|
|
|
|
#
|
|
|
|
# This first set of vars are read by Clang, but shouldn't affect tests
|
|
|
|
# that aren't specifically looking for these features, or are required
|
|
|
|
# simply to run the tests at all.
|
|
|
|
#
|
|
|
|
# FIXME: Should we have a tool that enforces this?
|
|
|
|
|
|
|
|
# safe_env_vars = ('TMPDIR', 'TEMP', 'TMP', 'USERPROFILE', 'PWD',
|
|
|
|
# 'MACOSX_DEPLOYMENT_TARGET', 'IPHONEOS_DEPLOYMENT_TARGET',
|
|
|
|
# 'IOS_SIMULATOR_DEPLOYMENT_TARGET',
|
|
|
|
# 'VCINSTALLDIR', 'VC100COMNTOOLS', 'VC90COMNTOOLS',
|
|
|
|
# 'VC80COMNTOOLS')
|
2012-04-07 09:02:53 +08:00
|
|
|
possibly_dangerous_env_vars = ['COMPILER_PATH', 'RC_DEBUG_OPTIONS',
|
2012-04-07 02:14:01 +08:00
|
|
|
'CINDEXTEST_PREAMBLE_FILE', 'LIBRARY_PATH',
|
|
|
|
'CPATH', 'C_INCLUDE_PATH', 'CPLUS_INCLUDE_PATH',
|
|
|
|
'OBJC_INCLUDE_PATH', 'OBJCPLUS_INCLUDE_PATH',
|
|
|
|
'LIBCLANG_TIMING', 'LIBCLANG_OBJTRACKING',
|
|
|
|
'LIBCLANG_LOGGING', 'LIBCLANG_BGPRIO_INDEX',
|
|
|
|
'LIBCLANG_BGPRIO_EDIT', 'LIBCLANG_NOTHREADS',
|
|
|
|
'LIBCLANG_RESOURCE_USAGE',
|
2012-04-07 09:02:53 +08:00
|
|
|
'LIBCLANG_CODE_COMPLETION_LOGGING']
|
|
|
|
# Clang/Win32 may refer to %INCLUDE%. vsvarsall.bat sets it.
|
|
|
|
if platform.system() != 'Windows':
|
|
|
|
possibly_dangerous_env_vars.append('INCLUDE')
|
2012-04-07 02:14:01 +08:00
|
|
|
for name in possibly_dangerous_env_vars:
|
|
|
|
if name in config.environment:
|
|
|
|
del config.environment[name]
|
|
|
|
|
2009-09-22 13:16:02 +08:00
|
|
|
# Tweak the PATH to include the tools dir and the scripts dir.
|
|
|
|
if clang_obj_root is not None:
|
|
|
|
llvm_tools_dir = getattr(config, 'llvm_tools_dir', None)
|
|
|
|
if not llvm_tools_dir:
|
2013-08-09 22:43:04 +08:00
|
|
|
lit_config.fatal('No LLVM tools dir set!')
|
2009-09-24 14:31:08 +08:00
|
|
|
path = os.path.pathsep.join((llvm_tools_dir, config.environment['PATH']))
|
2009-09-22 13:16:02 +08:00
|
|
|
config.environment['PATH'] = path
|
2009-09-26 15:36:09 +08:00
|
|
|
llvm_libs_dir = getattr(config, 'llvm_libs_dir', None)
|
|
|
|
if not llvm_libs_dir:
|
2013-08-09 22:43:04 +08:00
|
|
|
lit_config.fatal('No LLVM libs dir set!')
|
2009-09-26 15:36:09 +08:00
|
|
|
path = os.path.pathsep.join((llvm_libs_dir,
|
|
|
|
config.environment.get('LD_LIBRARY_PATH','')))
|
|
|
|
config.environment['LD_LIBRARY_PATH'] = path
|
|
|
|
|
2013-04-04 15:41:20 +08:00
|
|
|
# Propagate path to symbolizer for ASan/MSan.
|
|
|
|
for symbolizer in ['ASAN_SYMBOLIZER_PATH', 'MSAN_SYMBOLIZER_PATH']:
|
|
|
|
if symbolizer in os.environ:
|
|
|
|
config.environment[symbolizer] = os.environ[symbolizer]
|
|
|
|
|
2009-09-22 13:16:02 +08:00
|
|
|
###
|
|
|
|
|
|
|
|
# Check that the object root is known.
|
|
|
|
if config.test_exec_root is None:
|
|
|
|
# Otherwise, we haven't loaded the site specific configuration (the user is
|
|
|
|
# probably trying to run on a test file directly, and either the site
|
|
|
|
# configuration hasn't been created by the build system, or we are in an
|
|
|
|
# out-of-tree build situation).
|
|
|
|
|
2009-11-06 00:36:19 +08:00
|
|
|
# Check for 'clang_site_config' user parameter, and use that if available.
|
2013-08-09 22:43:04 +08:00
|
|
|
site_cfg = lit_config.params.get('clang_site_config', None)
|
2009-11-06 00:36:19 +08:00
|
|
|
if site_cfg and os.path.exists(site_cfg):
|
2013-08-09 22:43:04 +08:00
|
|
|
lit_config.load_config(config, site_cfg)
|
2009-11-06 00:36:19 +08:00
|
|
|
raise SystemExit
|
|
|
|
|
2009-09-22 13:16:02 +08:00
|
|
|
# Try to detect the situation where we are using an out-of-tree build by
|
|
|
|
# looking for 'llvm-config'.
|
|
|
|
#
|
|
|
|
# FIXME: I debated (i.e., wrote and threw away) adding logic to
|
|
|
|
# automagically generate the lit.site.cfg if we are in some kind of fresh
|
2009-11-08 07:53:17 +08:00
|
|
|
# build situation. This means knowing how to invoke the build system though,
|
|
|
|
# and I decided it was too much magic. We should solve this by just having
|
|
|
|
# the .cfg files generated during the configuration step.
|
2009-09-22 13:16:02 +08:00
|
|
|
|
|
|
|
llvm_config = lit.util.which('llvm-config', config.environment['PATH'])
|
|
|
|
if not llvm_config:
|
2013-08-09 22:43:04 +08:00
|
|
|
lit_config.fatal('No site specific configuration available!')
|
2009-09-22 13:16:02 +08:00
|
|
|
|
|
|
|
# Get the source and object roots.
|
|
|
|
llvm_src_root = lit.util.capture(['llvm-config', '--src-root']).strip()
|
|
|
|
llvm_obj_root = lit.util.capture(['llvm-config', '--obj-root']).strip()
|
|
|
|
clang_src_root = os.path.join(llvm_src_root, "tools", "clang")
|
|
|
|
clang_obj_root = os.path.join(llvm_obj_root, "tools", "clang")
|
|
|
|
|
|
|
|
# Validate that we got a tree which points to here, using the standard
|
|
|
|
# tools/clang layout.
|
|
|
|
this_src_root = os.path.dirname(config.test_source_root)
|
|
|
|
if os.path.realpath(clang_src_root) != os.path.realpath(this_src_root):
|
2013-08-09 22:43:04 +08:00
|
|
|
lit_config.fatal('No site specific configuration available!')
|
2009-09-22 13:16:02 +08:00
|
|
|
|
|
|
|
# Check that the site specific configuration exists.
|
|
|
|
site_cfg = os.path.join(clang_obj_root, 'test', 'lit.site.cfg')
|
|
|
|
if not os.path.exists(site_cfg):
|
2013-08-09 22:43:04 +08:00
|
|
|
lit_config.fatal(
|
|
|
|
'No site specific configuration available! You may need to '
|
|
|
|
'run "make test" in your Clang build directory.')
|
2009-09-22 13:16:02 +08:00
|
|
|
|
|
|
|
# Okay, that worked. Notify the user of the automagic, and reconfigure.
|
2013-08-09 22:43:04 +08:00
|
|
|
lit_config.note('using out-of-tree build at %r' % clang_obj_root)
|
|
|
|
lit_config.load_config(config, site_cfg)
|
2009-09-22 13:16:02 +08:00
|
|
|
raise SystemExit
|
|
|
|
|
|
|
|
###
|
|
|
|
|
|
|
|
# Discover the 'clang' and 'clangcc' to use.
|
|
|
|
|
|
|
|
import os
|
|
|
|
|
|
|
|
def inferClang(PATH):
|
|
|
|
# Determine which clang to use.
|
|
|
|
clang = os.getenv('CLANG')
|
|
|
|
|
|
|
|
# If the user set clang in the environment, definitely use that and don't
|
|
|
|
# try to validate.
|
|
|
|
if clang:
|
2009-09-09 00:39:23 +08:00
|
|
|
return clang
|
|
|
|
|
2009-09-22 13:16:02 +08:00
|
|
|
# Otherwise look in the path.
|
|
|
|
clang = lit.util.which('clang', PATH)
|
2009-09-09 00:39:23 +08:00
|
|
|
|
2009-09-22 13:16:02 +08:00
|
|
|
if not clang:
|
2013-08-09 22:43:04 +08:00
|
|
|
lit_config.fatal("couldn't find 'clang' program, try setting "
|
|
|
|
"CLANG in your environment")
|
2009-09-09 00:39:23 +08:00
|
|
|
|
2009-09-22 13:16:02 +08:00
|
|
|
return clang
|
2009-09-09 00:39:23 +08:00
|
|
|
|
2011-03-05 19:16:06 +08:00
|
|
|
config.clang = inferClang(config.environment['PATH']).replace('\\', '/')
|
2013-08-09 22:43:04 +08:00
|
|
|
if not lit_config.quiet:
|
|
|
|
lit_config.note('using clang: %r' % config.clang)
|
Teach Lit to pass the CC1 invocation the builtin include directory. This
is a pretty gross hack, but I don't have any significantly cleaner ideas
for this. There are several things obviously gross about it:
1) Lit shouldn't know that Clang needs this. This really that bad, as
Lit already knows about CC1 and other internal details.
2) This hard codes the '3.0' version number, which is pretty lame.
3) This hard codes every other aspect of the resource dir structure
which is less lame than the version number, but still not great.
However, it should bring the MSVC tests back to life, and it should
unblock the rest of the move from Frontend to Driver, so I think it's
worth a bit of grossness that is isolated in our testing infrastructure
while we figure out the best long term approach. I have the following
ideas, some of which only solve part of the problem (and thus might need
to be combined with other ideas):
a) Create a symlink or other convenience path instead of a version
number.
b) Run 'clang' directly in the lit.cfg, look at its resource dir, and use
that.
c) Switch all the tests to use the driver instead of CC1.
d) Hack the frontend to synthesize builtin include directories when none
are provided by the driver.
I don't like (d) because it feels very hackish and likely to break. We
can only solve a small part of the problem with (a). I wanted to vote
for (c), but lots of the tests in this bucket are really heavily using
internal-only flags like -verify and -triple. I'm loath to complicate
them with the full driver layer. Also, switching them to the driver adds
more than just builtin headers, but all of the rest of the system
headers!
This leaves me with (b). If others like (b), I'll switch to it, but it
felt a bit icky. Nothing concrete, and the other options look
significantly worse, but I felt icky enough that I wanted to start with
a more brain-dead patch to stop the bleeding, and gauge others' feelings
here.
llvm-svn: 143804
2011-11-05 18:15:27 +08:00
|
|
|
|
|
|
|
# Note that when substituting %clang_cc1 also fill in the include directory of
|
|
|
|
# the builtin headers. Those are part of even a freestanding environment, but
|
|
|
|
# Clang relies on the driver to locate them.
|
2011-11-06 07:29:28 +08:00
|
|
|
def getClangBuiltinIncludeDir(clang):
|
2011-11-06 04:55:50 +08:00
|
|
|
# FIXME: Rather than just getting the version, we should have clang print
|
|
|
|
# out its resource dir here in an easy to scrape form.
|
2011-11-06 07:29:28 +08:00
|
|
|
cmd = subprocess.Popen([clang, '-print-file-name=include'],
|
|
|
|
stdout=subprocess.PIPE)
|
|
|
|
if not cmd.stdout:
|
2013-08-09 22:43:04 +08:00
|
|
|
lit_config.fatal("Couldn't find the include dir for Clang ('%s')" % clang)
|
2013-06-26 18:45:20 +08:00
|
|
|
dir = cmd.stdout.read().strip()
|
|
|
|
if sys.platform in ['win32'] and execute_external:
|
|
|
|
# Don't pass dosish path separator to msys bash.exe.
|
|
|
|
dir = dir.replace('\\', '/')
|
2013-08-15 00:32:20 +08:00
|
|
|
# Ensure the result is an ascii string, across Python2.5+ - Python3.
|
|
|
|
return str(dir.decode('ascii'))
|
2011-11-06 04:55:50 +08:00
|
|
|
|
2011-11-07 17:17:31 +08:00
|
|
|
config.substitutions.append( ('%clang_cc1', '%s -cc1 -internal-isystem %s'
|
2011-11-06 07:29:28 +08:00
|
|
|
% (config.clang,
|
|
|
|
getClangBuiltinIncludeDir(config.clang))) )
|
2013-07-19 04:29:38 +08:00
|
|
|
config.substitutions.append( ('%clang_cpp', ' ' + config.clang +
|
|
|
|
' --driver-mode=cpp '))
|
2013-07-20 04:33:20 +08:00
|
|
|
config.substitutions.append( ('%clang_cl', ' ' + config.clang +
|
|
|
|
' --driver-mode=cl '))
|
2010-06-30 00:52:24 +08:00
|
|
|
config.substitutions.append( ('%clangxx', ' ' + config.clang +
|
2013-07-19 04:29:38 +08:00
|
|
|
' --driver-mode=g++ '))
|
2009-12-16 06:01:24 +08:00
|
|
|
config.substitutions.append( ('%clang', ' ' + config.clang + ' ') )
|
2010-09-14 04:46:23 +08:00
|
|
|
config.substitutions.append( ('%test_debuginfo', ' ' + config.llvm_src_root + '/utils/test_debuginfo.pl ') )
|
2009-12-16 06:01:24 +08:00
|
|
|
|
|
|
|
# FIXME: Find nicer way to prohibit this.
|
|
|
|
config.substitutions.append(
|
|
|
|
(' clang ', """*** Do not use 'clang' in tests, use '%clang'. ***""") )
|
2010-02-18 04:31:01 +08:00
|
|
|
config.substitutions.append(
|
2011-01-04 01:28:52 +08:00
|
|
|
(' clang\+\+ ', """*** Do not use 'clang++' in tests, use '%clangxx'. ***"""))
|
2009-12-16 06:01:24 +08:00
|
|
|
config.substitutions.append(
|
|
|
|
(' clang-cc ',
|
|
|
|
"""*** Do not use 'clang-cc' in tests, use '%clang_cc1'. ***""") )
|
|
|
|
config.substitutions.append(
|
|
|
|
(' clang -cc1 ',
|
|
|
|
"""*** Do not use 'clang -cc1' in tests, use '%clang_cc1'. ***""") )
|
2010-06-30 00:52:24 +08:00
|
|
|
config.substitutions.append(
|
|
|
|
(' %clang-cc1 ',
|
|
|
|
"""*** invalid substitution, use '%clang_cc1'. ***""") )
|
2013-07-19 04:29:38 +08:00
|
|
|
config.substitutions.append(
|
|
|
|
(' %clang-cpp ',
|
|
|
|
"""*** invalid substitution, use '%clang_cpp'. ***""") )
|
2013-07-20 04:33:20 +08:00
|
|
|
config.substitutions.append(
|
|
|
|
(' %clang-cl ',
|
|
|
|
"""*** invalid substitution, use '%clang_cl'. ***""") )
|
2010-08-25 05:39:55 +08:00
|
|
|
|
|
|
|
###
|
|
|
|
|
|
|
|
# Set available features we allow tests to conditionalize on.
|
2011-08-27 06:46:31 +08:00
|
|
|
#
|
|
|
|
# As of 2011.08, crash-recovery tests still do not pass on FreeBSD.
|
|
|
|
if platform.system() not in ['FreeBSD']:
|
|
|
|
config.available_features.add('crash-recovery')
|
2011-02-28 17:41:07 +08:00
|
|
|
|
|
|
|
# Shell execution
|
2013-04-11 21:34:18 +08:00
|
|
|
if execute_external:
|
2011-02-28 17:41:07 +08:00
|
|
|
config.available_features.add('shell')
|
2011-06-04 02:36:30 +08:00
|
|
|
|
2013-01-16 14:10:16 +08:00
|
|
|
# Exclude MSYS due to transforming '/' to 'X:/mingwroot/'.
|
2013-08-06 04:14:43 +08:00
|
|
|
if not platform.system() in ['Windows'] or not execute_external:
|
2013-01-16 14:10:16 +08:00
|
|
|
config.available_features.add('shell-preserves-root')
|
|
|
|
|
2012-09-12 18:38:03 +08:00
|
|
|
# ANSI escape sequences in non-dumb terminal
|
2012-07-11 19:44:00 +08:00
|
|
|
if platform.system() not in ['Windows']:
|
|
|
|
config.available_features.add('ansi-escape-sequences')
|
|
|
|
|
2013-09-13 19:02:31 +08:00
|
|
|
# Native compilation: host arch == target arch
|
|
|
|
if config.host_arch in config.target_triple:
|
|
|
|
config.available_features.add("native")
|
|
|
|
|
2012-11-01 04:59:50 +08:00
|
|
|
# Case-insensitive file system
|
|
|
|
def is_filesystem_case_insensitive():
|
2012-11-01 08:59:15 +08:00
|
|
|
handle, path = tempfile.mkstemp(prefix='case-test', dir=config.test_exec_root)
|
2013-07-01 17:51:55 +08:00
|
|
|
isInsensitive = os.path.exists(
|
|
|
|
os.path.join(
|
|
|
|
os.path.dirname(path),
|
|
|
|
os.path.basename(path).upper()
|
|
|
|
))
|
2012-11-01 04:59:50 +08:00
|
|
|
os.close(handle)
|
|
|
|
os.remove(path)
|
|
|
|
return isInsensitive
|
|
|
|
|
|
|
|
if is_filesystem_case_insensitive():
|
|
|
|
config.available_features.add('case-insensitive-filesystem')
|
|
|
|
|
2012-11-16 04:06:10 +08:00
|
|
|
# Tests that require the /dev/fd filesystem.
|
2012-11-27 13:25:41 +08:00
|
|
|
if os.path.exists("/dev/fd/0") and sys.platform not in ['cygwin']:
|
2012-11-16 04:06:10 +08:00
|
|
|
config.available_features.add('dev-fd-fs')
|
|
|
|
|
2012-09-12 18:45:40 +08:00
|
|
|
# [PR8833] LLP64-incompatible tests
|
|
|
|
if not re.match(r'^x86_64.*-(win32|mingw32)$', config.target_triple):
|
|
|
|
config.available_features.add('LP64')
|
|
|
|
|
2012-12-11 15:06:09 +08:00
|
|
|
# [PR12920] "clang-driver" -- set if gcc driver is not used.
|
|
|
|
if not re.match(r'.*-(cygwin|mingw32)$', config.target_triple):
|
|
|
|
config.available_features.add('clang-driver')
|
|
|
|
|
2011-06-04 02:36:30 +08:00
|
|
|
# Registered Targets
|
2011-11-28 13:09:42 +08:00
|
|
|
def get_llc_props(tool):
|
2011-06-04 02:36:30 +08:00
|
|
|
set_of_targets = set()
|
2011-11-28 13:09:42 +08:00
|
|
|
enable_assertions = False
|
2011-06-04 02:36:30 +08:00
|
|
|
|
|
|
|
cmd = subprocess.Popen([tool, '-version'], stdout=subprocess.PIPE)
|
|
|
|
|
|
|
|
# Parse the stdout to get the list of registered targets.
|
|
|
|
parse_targets = False
|
|
|
|
for line in cmd.stdout:
|
2013-08-09 08:45:18 +08:00
|
|
|
line = line.decode('ascii')
|
2011-06-04 02:36:30 +08:00
|
|
|
if parse_targets:
|
|
|
|
m = re.match( r'(.*) - ', line)
|
|
|
|
if m is not None:
|
|
|
|
set_of_targets.add(m.group(1).strip() + '-registered-target')
|
|
|
|
else:
|
|
|
|
break
|
|
|
|
elif "Registered Targets:" in line:
|
|
|
|
parse_targets = True
|
|
|
|
|
2011-11-28 13:09:42 +08:00
|
|
|
if re.search(r'with assertions', line):
|
|
|
|
enable_assertions = True
|
2011-06-04 02:36:30 +08:00
|
|
|
|
2011-11-28 13:09:42 +08:00
|
|
|
return {"set_of_targets": set_of_targets,
|
|
|
|
"enable_assertions": enable_assertions}
|
|
|
|
|
|
|
|
llc_props = get_llc_props(os.path.join(llvm_tools_dir, 'llc'))
|
|
|
|
if len(llc_props['set_of_targets']) > 0:
|
|
|
|
config.available_features.update(llc_props['set_of_targets'])
|
2011-06-04 02:36:30 +08:00
|
|
|
else:
|
2013-08-09 22:43:04 +08:00
|
|
|
lit_config.fatal('No Targets Registered with the LLVM Tools!')
|
2011-11-28 13:09:42 +08:00
|
|
|
|
check-clang: Introduce get_llvm_config_props in clang/test/lit.cfg.
In trunk, we can use features as below:
aarch64-registered-target
hexagon-registered-target
msp430-registered-target
r600-registered-target
systemz-registered-target
xcore-registered-target
Each of them, as below, implies corresponding subtargets:
arm-registered-target -- arm, thumb
mips-registered-target -- mips, mips64, mips64el, mipsel
nvptx-registered-target -- nvptx, nvptx64
sparc-registered-target -- sparc, sparcv9
x86-registered-target -- x86, x86-64
They will be renamed:
cppbackend-registered-target -- was "cpp". Unused in trunk.
powerpc-registered-target -- was "ppc32", "ppc64" and "ppc64le".
The feature "asserts" is also taken from llvm-config.
llvm-svn: 196347
2013-12-04 11:40:56 +08:00
|
|
|
# Returns set of available features, registered-target(s) and asserts.
|
|
|
|
def get_llvm_config_props():
|
|
|
|
set_of_features = set()
|
|
|
|
|
|
|
|
cmd = subprocess.Popen(
|
|
|
|
[
|
|
|
|
os.path.join(llvm_tools_dir, 'llvm-config'),
|
|
|
|
'--assertion-mode',
|
|
|
|
'--targets-built',
|
|
|
|
],
|
|
|
|
stdout=subprocess.PIPE
|
|
|
|
)
|
|
|
|
# 1st line corresponds to --assertion-mode, "ON" or "OFF".
|
|
|
|
line = cmd.stdout.readline().strip().decode('ascii')
|
|
|
|
if line == "ON":
|
|
|
|
set_of_features.add('asserts')
|
|
|
|
|
|
|
|
# 2nd line corresponds to --targets-built, like;
|
|
|
|
# AArch64 ARM CppBackend X86
|
|
|
|
for arch in cmd.stdout.readline().decode('ascii').split():
|
|
|
|
set_of_features.add(arch.lower() + '-registered-target')
|
|
|
|
|
|
|
|
return set_of_features
|
|
|
|
|
|
|
|
config.available_features.update(get_llvm_config_props())
|
2012-08-08 01:54:38 +08:00
|
|
|
|
|
|
|
if lit.util.which('xmllint'):
|
|
|
|
config.available_features.add('xmllint')
|
|
|
|
|
2013-03-26 16:28:18 +08:00
|
|
|
# Sanitizers.
|
|
|
|
if config.llvm_use_sanitizer == "Address":
|
|
|
|
config.available_features.add("asan")
|
|
|
|
if (config.llvm_use_sanitizer == "Memory" or
|
|
|
|
config.llvm_use_sanitizer == "MemoryWithOrigins"):
|
|
|
|
config.available_features.add("msan")
|
2013-06-20 07:23:49 +08:00
|
|
|
|
|
|
|
# Check if we should run long running tests.
|
2013-08-09 22:43:04 +08:00
|
|
|
if lit_config.params.get("run_long_tests", None) == "true":
|
2013-06-20 07:23:49 +08:00
|
|
|
config.available_features.add("long_tests")
|
2013-07-12 07:37:50 +08:00
|
|
|
|
|
|
|
# Check if we should use gmalloc.
|
2013-08-09 22:43:04 +08:00
|
|
|
use_gmalloc_str = lit_config.params.get('use_gmalloc', None)
|
2013-07-12 07:37:50 +08:00
|
|
|
if use_gmalloc_str is not None:
|
|
|
|
if use_gmalloc_str.lower() in ('1', 'true'):
|
|
|
|
use_gmalloc = True
|
|
|
|
elif use_gmalloc_str.lower() in ('', '0', 'false'):
|
|
|
|
use_gmalloc = False
|
|
|
|
else:
|
2013-08-09 22:43:04 +08:00
|
|
|
lit_config.fatal('user parameter use_gmalloc should be 0 or 1')
|
2013-07-12 07:37:50 +08:00
|
|
|
else:
|
|
|
|
# Default to not using gmalloc
|
|
|
|
use_gmalloc = False
|
|
|
|
|
|
|
|
# Allow use of an explicit path for gmalloc library.
|
|
|
|
# Will default to '/usr/lib/libgmalloc.dylib' if not set.
|
2013-08-09 22:43:04 +08:00
|
|
|
gmalloc_path_str = lit_config.params.get('gmalloc_path',
|
|
|
|
'/usr/lib/libgmalloc.dylib')
|
2013-07-12 07:37:50 +08:00
|
|
|
if use_gmalloc:
|
|
|
|
config.environment.update({'DYLD_INSERT_LIBRARIES' : gmalloc_path_str})
|
2013-11-07 05:44:54 +08:00
|
|
|
|
|
|
|
# On Darwin, support relocatable SDKs by providing Clang with a
|
|
|
|
# default system root path.
|
|
|
|
if 'darwin' in config.target_triple:
|
2013-11-15 07:18:08 +08:00
|
|
|
try:
|
|
|
|
cmd = subprocess.Popen(['xcrun', '--show-sdk-path'],
|
|
|
|
stdout=subprocess.PIPE, stderr=subprocess.PIPE)
|
|
|
|
out, err = cmd.communicate()
|
|
|
|
out = out.strip()
|
|
|
|
res = cmd.wait()
|
|
|
|
except OSError:
|
|
|
|
res = -1
|
2013-11-07 05:44:54 +08:00
|
|
|
if res == 0 and out:
|
|
|
|
sdk_path = out
|
|
|
|
lit_config.note('using SDKROOT: %r' % sdk_path)
|
|
|
|
config.environment['SDKROOT'] = sdk_path
|