mirror of
https://github.com/llvm/llvm-project.git
synced 2025-04-29 12:36:07 +00:00
b6099fa515
Added a lit test that finds its corresponding crash log and checks to make sure it has asn output under `Application Specific Information`. This required adding two python commands: - `get_pid_from_output`: takes the output from the asan instrumentation and parses out the process ID - `print_crashreport_for_pid`: takes in the pid of the process and the file name of the binary that was run and prints the contents of the corresponding crash log. This test was added in preparation for changing the integration with crash reporter from the old api to the new api, which is implemented in a subsequent commit. rdar://69767688 Reviewed By: delcypher Commited by Dan Liew on behalf of Emily Shi. Differential Revision: https://reviews.llvm.org/D96737
622 lines
25 KiB
Python
622 lines
25 KiB
Python
# -*- Python -*-
|
|
|
|
# Configuration file for 'lit' test runner.
|
|
# This file contains common rules for various compiler-rt testsuites.
|
|
# It is mostly copied from lit.cfg.py used by Clang.
|
|
import os
|
|
import platform
|
|
import re
|
|
import subprocess
|
|
import json
|
|
|
|
import lit.formats
|
|
import lit.util
|
|
|
|
# Get shlex.quote if available (added in 3.3), and fall back to pipes.quote if
|
|
# it's not available.
|
|
try:
|
|
import shlex
|
|
sh_quote = shlex.quote
|
|
except:
|
|
import pipes
|
|
sh_quote = pipes.quote
|
|
|
|
# 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'])
|
|
|
|
# Allow expanding substitutions that are based on other substitutions
|
|
config.recursiveExpansionLimit = 10
|
|
|
|
# Setup test format.
|
|
config.test_format = lit.formats.ShTest(execute_external)
|
|
if execute_external:
|
|
config.available_features.add('shell')
|
|
|
|
compiler_id = getattr(config, 'compiler_id', None)
|
|
if compiler_id == "Clang":
|
|
if platform.system() != 'Windows':
|
|
config.cxx_mode_flags = ["--driver-mode=g++"]
|
|
else:
|
|
config.cxx_mode_flags = []
|
|
# We assume that sanitizers should provide good enough error
|
|
# reports and stack traces even with minimal debug info.
|
|
config.debug_info_flags = ["-gline-tables-only"]
|
|
if platform.system() == 'Windows':
|
|
# On Windows, use CodeView with column info instead of DWARF. Both VS and
|
|
# windbg do not behave well when column info is enabled, but users have
|
|
# requested it because it makes ASan reports more precise.
|
|
config.debug_info_flags.append("-gcodeview")
|
|
config.debug_info_flags.append("-gcolumn-info")
|
|
elif compiler_id == 'GNU':
|
|
config.cxx_mode_flags = ["-x c++"]
|
|
config.debug_info_flags = ["-g"]
|
|
else:
|
|
lit_config.fatal("Unsupported compiler id: %r" % compiler_id)
|
|
# Add compiler ID to the list of available features.
|
|
config.available_features.add(compiler_id)
|
|
|
|
# If needed, add cflag for shadow scale.
|
|
if config.asan_shadow_scale != '':
|
|
config.target_cflags += " -mllvm -asan-mapping-scale=" + config.asan_shadow_scale
|
|
if config.memprof_shadow_scale != '':
|
|
config.target_cflags += " -mllvm -memprof-mapping-scale=" + config.memprof_shadow_scale
|
|
|
|
config.environment = dict(os.environ)
|
|
|
|
# Clear some environment variables that might affect Clang.
|
|
possibly_dangerous_env_vars = ['ASAN_OPTIONS', 'DFSAN_OPTIONS', 'LSAN_OPTIONS',
|
|
'MSAN_OPTIONS', 'UBSAN_OPTIONS',
|
|
'COMPILER_PATH', 'RC_DEBUG_OPTIONS',
|
|
'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',
|
|
'LIBCLANG_CODE_COMPLETION_LOGGING',
|
|
'XRAY_OPTIONS']
|
|
# Clang/Win32 may refer to %INCLUDE%. vsvarsall.bat sets it.
|
|
if platform.system() != 'Windows':
|
|
possibly_dangerous_env_vars.append('INCLUDE')
|
|
for name in possibly_dangerous_env_vars:
|
|
if name in config.environment:
|
|
del config.environment[name]
|
|
|
|
# Tweak PATH to include llvm tools dir.
|
|
if (not config.llvm_tools_dir) or (not os.path.exists(config.llvm_tools_dir)):
|
|
lit_config.fatal("Invalid llvm_tools_dir config attribute: %r" % config.llvm_tools_dir)
|
|
path = os.path.pathsep.join((config.llvm_tools_dir, config.environment['PATH']))
|
|
config.environment['PATH'] = path
|
|
|
|
# Help MSVS link.exe find the standard libraries.
|
|
# Make sure we only try to use it when targetting Windows.
|
|
if platform.system() == 'Windows' and '-win' in config.target_triple:
|
|
config.environment['LIB'] = os.environ['LIB']
|
|
|
|
config.available_features.add(config.host_os.lower())
|
|
|
|
if re.match(r'^x86_64.*-linux', config.target_triple):
|
|
config.available_features.add("x86_64-linux")
|
|
|
|
config.available_features.add("host-byteorder-" + sys.byteorder + "-endian")
|
|
|
|
if config.have_zlib == "1":
|
|
config.available_features.add("zlib")
|
|
|
|
# Use ugly construction to explicitly prohibit "clang", "clang++" etc.
|
|
# in RUN lines.
|
|
config.substitutions.append(
|
|
(' clang', """\n\n*** Do not use 'clangXXX' in tests,
|
|
instead define '%clangXXX' substitution in lit config. ***\n\n""") )
|
|
|
|
if config.host_os == 'NetBSD':
|
|
nb_commands_dir = os.path.join(config.compiler_rt_src_root,
|
|
"test", "sanitizer_common", "netbsd_commands")
|
|
config.netbsd_noaslr_prefix = ('sh ' +
|
|
os.path.join(nb_commands_dir, 'run_noaslr.sh'))
|
|
config.netbsd_nomprotect_prefix = ('sh ' +
|
|
os.path.join(nb_commands_dir,
|
|
'run_nomprotect.sh'))
|
|
config.substitutions.append( ('%run_nomprotect',
|
|
config.netbsd_nomprotect_prefix) )
|
|
else:
|
|
config.substitutions.append( ('%run_nomprotect', '%run') )
|
|
|
|
# Copied from libcxx's config.py
|
|
def get_lit_conf(name, default=None):
|
|
# Allow overriding on the command line using --param=<name>=<val>
|
|
val = lit_config.params.get(name, None)
|
|
if val is None:
|
|
val = getattr(config, name, None)
|
|
if val is None:
|
|
val = default
|
|
return val
|
|
|
|
emulator = get_lit_conf('emulator', None)
|
|
|
|
def get_ios_commands_dir():
|
|
return os.path.join(config.compiler_rt_src_root, "test", "sanitizer_common", "ios_commands")
|
|
|
|
# Allow tests to be executed on a simulator or remotely.
|
|
if emulator:
|
|
config.substitutions.append( ('%run', emulator) )
|
|
config.substitutions.append( ('%env ', "env ") )
|
|
# TODO: Implement `%device_rm` to perform removal of files in the emulator.
|
|
# For now just make it a no-op.
|
|
lit_config.warning('%device_rm is not implemented')
|
|
config.substitutions.append( ('%device_rm', 'echo ') )
|
|
config.compile_wrapper = ""
|
|
elif config.host_os == 'Darwin' and config.apple_platform != "osx":
|
|
# Darwin tests can be targetting macOS, a device or a simulator. All devices
|
|
# are declared as "ios", even for iOS derivatives (tvOS, watchOS). Similarly,
|
|
# all simulators are "iossim". See the table below.
|
|
#
|
|
# =========================================================================
|
|
# Target | Feature set
|
|
# =========================================================================
|
|
# macOS | darwin
|
|
# iOS device | darwin, ios
|
|
# iOS simulator | darwin, ios, iossim
|
|
# tvOS device | darwin, ios, tvos
|
|
# tvOS simulator | darwin, ios, iossim, tvos, tvossim
|
|
# watchOS device | darwin, ios, watchos
|
|
# watchOS simulator | darwin, ios, iossim, watchos, watchossim
|
|
# =========================================================================
|
|
|
|
ios_or_iossim = "iossim" if config.apple_platform.endswith("sim") else "ios"
|
|
|
|
config.available_features.add('ios')
|
|
device_id_env = "SANITIZER_" + ios_or_iossim.upper() + "_TEST_DEVICE_IDENTIFIER"
|
|
if ios_or_iossim == "iossim":
|
|
config.available_features.add('iossim')
|
|
if device_id_env not in os.environ:
|
|
lit_config.fatal(
|
|
'{} must be set in the environment when running iossim tests'.format(
|
|
device_id_env))
|
|
if config.apple_platform != "ios" and config.apple_platform != "iossim":
|
|
config.available_features.add(config.apple_platform)
|
|
|
|
ios_commands_dir = get_ios_commands_dir()
|
|
|
|
run_wrapper = os.path.join(ios_commands_dir, ios_or_iossim + "_run.py")
|
|
env_wrapper = os.path.join(ios_commands_dir, ios_or_iossim + "_env.py")
|
|
compile_wrapper = os.path.join(ios_commands_dir, ios_or_iossim + "_compile.py")
|
|
prepare_script = os.path.join(ios_commands_dir, ios_or_iossim + "_prepare.py")
|
|
|
|
if device_id_env in os.environ:
|
|
config.environment[device_id_env] = os.environ[device_id_env]
|
|
config.substitutions.append(('%run', run_wrapper))
|
|
config.substitutions.append(('%env ', env_wrapper + " "))
|
|
# Current implementation of %device_rm uses the run_wrapper to do
|
|
# the work.
|
|
config.substitutions.append(('%device_rm', '{} rm '.format(run_wrapper)))
|
|
config.compile_wrapper = compile_wrapper
|
|
|
|
try:
|
|
prepare_output = subprocess.check_output([prepare_script, config.apple_platform, config.clang]).decode().strip()
|
|
except subprocess.CalledProcessError as e:
|
|
print("Command failed:")
|
|
print(e.output)
|
|
raise e
|
|
if len(prepare_output) > 0: print(prepare_output)
|
|
prepare_output_json = prepare_output.split("\n")[-1]
|
|
prepare_output = json.loads(prepare_output_json)
|
|
config.environment.update(prepare_output["env"])
|
|
elif config.android:
|
|
config.available_features.add('android')
|
|
compile_wrapper = os.path.join(config.compiler_rt_src_root, "test", "sanitizer_common", "android_commands", "android_compile.py") + " "
|
|
config.compile_wrapper = compile_wrapper
|
|
config.substitutions.append( ('%run', "") )
|
|
config.substitutions.append( ('%env ', "env ") )
|
|
else:
|
|
config.substitutions.append( ('%run', "") )
|
|
config.substitutions.append( ('%env ', "env ") )
|
|
# When running locally %device_rm is a no-op.
|
|
config.substitutions.append( ('%device_rm', 'echo ') )
|
|
config.compile_wrapper = ""
|
|
|
|
# Define CHECK-%os to check for OS-dependent output.
|
|
config.substitutions.append( ('CHECK-%os', ("CHECK-" + config.host_os)))
|
|
|
|
# Define %arch to check for architecture-dependent output.
|
|
config.substitutions.append( ('%arch', (config.host_arch)))
|
|
|
|
if config.host_os == 'Windows':
|
|
# FIXME: This isn't quite right. Specifically, it will succeed if the program
|
|
# does not crash but exits with a non-zero exit code. We ought to merge
|
|
# KillTheDoctor and not --crash to make the latter more useful and remove the
|
|
# need for this substitution.
|
|
config.expect_crash = "not KillTheDoctor "
|
|
else:
|
|
config.expect_crash = "not --crash "
|
|
|
|
config.substitutions.append( ("%expect_crash ", config.expect_crash) )
|
|
|
|
target_arch = getattr(config, 'target_arch', None)
|
|
if target_arch:
|
|
config.available_features.add(target_arch + '-target-arch')
|
|
if target_arch in ['x86_64', 'i386']:
|
|
config.available_features.add('x86-target-arch')
|
|
config.available_features.add(target_arch + '-' + config.host_os.lower())
|
|
|
|
compiler_rt_debug = getattr(config, 'compiler_rt_debug', False)
|
|
if not compiler_rt_debug:
|
|
config.available_features.add('compiler-rt-optimized')
|
|
|
|
libdispatch = getattr(config, 'compiler_rt_intercept_libdispatch', False)
|
|
if libdispatch:
|
|
config.available_features.add('libdispatch')
|
|
|
|
sanitizer_can_use_cxxabi = getattr(config, 'sanitizer_can_use_cxxabi', True)
|
|
if sanitizer_can_use_cxxabi:
|
|
config.available_features.add('cxxabi')
|
|
|
|
if config.has_lld:
|
|
config.available_features.add('lld-available')
|
|
|
|
if config.use_lld:
|
|
config.available_features.add('lld')
|
|
|
|
if config.can_symbolize:
|
|
config.available_features.add('can-symbolize')
|
|
|
|
if config.gwp_asan:
|
|
config.available_features.add('gwp_asan')
|
|
|
|
lit.util.usePlatformSdkOnDarwin(config, lit_config)
|
|
|
|
min_macos_deployment_target_substitutions = [
|
|
(10, 11),
|
|
(10, 12),
|
|
]
|
|
# TLS requires watchOS 3+
|
|
config.substitutions.append( ('%darwin_min_target_with_tls_support', '%min_macos_deployment_target=10.12') )
|
|
|
|
if config.host_os == 'Darwin':
|
|
osx_version = (10, 0, 0)
|
|
try:
|
|
osx_version = subprocess.check_output(["sw_vers", "-productVersion"],
|
|
universal_newlines=True)
|
|
osx_version = tuple(int(x) for x in osx_version.split('.'))
|
|
if len(osx_version) == 2: osx_version = (osx_version[0], osx_version[1], 0)
|
|
if osx_version >= (10, 11):
|
|
config.available_features.add('osx-autointerception')
|
|
config.available_features.add('osx-ld64-live_support')
|
|
except subprocess.CalledProcessError:
|
|
pass
|
|
|
|
config.darwin_osx_version = osx_version
|
|
|
|
# Detect x86_64h
|
|
try:
|
|
output = subprocess.check_output(["sysctl", "hw.cpusubtype"])
|
|
output_re = re.match("^hw.cpusubtype: ([0-9]+)$", output)
|
|
if output_re:
|
|
cpu_subtype = int(output_re.group(1))
|
|
if cpu_subtype == 8: # x86_64h
|
|
config.available_features.add('x86_64h')
|
|
except:
|
|
pass
|
|
|
|
# 32-bit iOS simulator is deprecated and removed in latest Xcode.
|
|
if config.apple_platform == "iossim":
|
|
if config.target_arch == "i386":
|
|
config.unsupported = True
|
|
|
|
def get_macos_aligned_version(macos_vers):
|
|
platform = config.apple_platform
|
|
if platform == 'osx':
|
|
return macos_vers
|
|
|
|
macos_major, macos_minor = macos_vers
|
|
assert macos_major >= 10
|
|
|
|
if macos_major == 10: # macOS 10.x
|
|
major = macos_minor
|
|
minor = 0
|
|
else: # macOS 11+
|
|
major = macos_major + 5
|
|
minor = macos_minor
|
|
|
|
assert major >= 11
|
|
|
|
if platform.startswith('ios') or platform.startswith('tvos'):
|
|
major -= 2
|
|
elif platform.startswith('watch'):
|
|
major -= 9
|
|
else:
|
|
lit_config.fatal("Unsupported apple platform '{}'".format(platform))
|
|
|
|
return (major, minor)
|
|
|
|
for vers in min_macos_deployment_target_substitutions:
|
|
flag = config.apple_platform_min_deployment_target_flag
|
|
major, minor = get_macos_aligned_version(vers)
|
|
config.substitutions.append( ('%%min_macos_deployment_target=%s.%s' % vers, '{}={}.{}'.format(flag, major, minor)) )
|
|
else:
|
|
for vers in min_macos_deployment_target_substitutions:
|
|
config.substitutions.append( ('%%min_macos_deployment_target=%s.%s' % vers, '') )
|
|
|
|
if config.android:
|
|
env = os.environ.copy()
|
|
if config.android_serial:
|
|
env['ANDROID_SERIAL'] = config.android_serial
|
|
config.environment['ANDROID_SERIAL'] = config.android_serial
|
|
|
|
adb = os.environ.get('ADB', 'adb')
|
|
|
|
# These are needed for tests to upload/download temp files, such as
|
|
# suppression-files, to device.
|
|
config.substitutions.append( ('%device_rundir', "/data/local/tmp/Output") )
|
|
config.substitutions.append( ('%push_to_device', "%s -s '%s' push " % (adb, env['ANDROID_SERIAL']) ) )
|
|
config.substitutions.append( ('%pull_from_device', "%s -s '%s' pull " % (adb, env['ANDROID_SERIAL']) ) )
|
|
config.substitutions.append( ('%adb_shell ', "%s -s '%s' shell " % (adb, env['ANDROID_SERIAL']) ) )
|
|
config.substitutions.append( ('%device_rm', "%s -s '%s' shell 'rm ' " % (adb, env['ANDROID_SERIAL']) ) )
|
|
|
|
try:
|
|
android_api_level_str = subprocess.check_output([adb, "shell", "getprop", "ro.build.version.sdk"], env=env).rstrip()
|
|
android_api_codename = subprocess.check_output([adb, "shell", "getprop", "ro.build.version.codename"], env=env).rstrip().decode("utf-8")
|
|
except (subprocess.CalledProcessError, OSError):
|
|
lit_config.fatal("Failed to read ro.build.version.sdk (using '%s' as adb)" % adb)
|
|
try:
|
|
android_api_level = int(android_api_level_str)
|
|
except ValueError:
|
|
lit_config.fatal("Failed to read ro.build.version.sdk (using '%s' as adb): got '%s'" % (adb, android_api_level_str))
|
|
android_api_level = min(android_api_level, int(config.android_api_level))
|
|
for required in [26, 28, 30]:
|
|
if android_api_level >= required:
|
|
config.available_features.add('android-%s' % required)
|
|
# FIXME: Replace with appropriate version when availible.
|
|
if android_api_level > 30 or (android_api_level == 30 and android_api_codename == 'S'):
|
|
config.available_features.add('android-thread-properties-api')
|
|
|
|
# Prepare the device.
|
|
android_tmpdir = '/data/local/tmp/Output'
|
|
subprocess.check_call([adb, "shell", "mkdir", "-p", android_tmpdir], env=env)
|
|
for file in config.android_files_to_push:
|
|
subprocess.check_call([adb, "push", file, android_tmpdir], env=env)
|
|
else:
|
|
config.substitutions.append( ('%device_rundir', "") )
|
|
config.substitutions.append( ('%push_to_device', "echo ") )
|
|
config.substitutions.append( ('%pull_from_device', "echo ") )
|
|
config.substitutions.append( ('%adb_shell', "echo ") )
|
|
|
|
if config.host_os == 'Linux':
|
|
# detect whether we are using glibc, and which version
|
|
# NB: 'ldd' is just one of the tools commonly installed as part of glibc/musl
|
|
ldd_ver_cmd = subprocess.Popen(['ldd', '--version'],
|
|
stdout=subprocess.PIPE,
|
|
stderr=subprocess.DEVNULL,
|
|
env={'LANG': 'C'})
|
|
sout, _ = ldd_ver_cmd.communicate()
|
|
ver_lines = sout.splitlines()
|
|
if not config.android and len(ver_lines) and ver_lines[0].startswith(b"ldd "):
|
|
from distutils.version import LooseVersion
|
|
ver = LooseVersion(ver_lines[0].split()[-1].decode())
|
|
for required in ["2.27", "2.30"]:
|
|
if ver >= LooseVersion(required):
|
|
config.available_features.add("glibc-" + required)
|
|
|
|
sancovcc_path = os.path.join(config.llvm_tools_dir, "sancov")
|
|
if os.path.exists(sancovcc_path):
|
|
config.available_features.add("has_sancovcc")
|
|
config.substitutions.append( ("%sancovcc ", sancovcc_path) )
|
|
|
|
def is_darwin_lto_supported():
|
|
return os.path.exists(os.path.join(config.llvm_shlib_dir, 'libLTO.dylib'))
|
|
|
|
def is_binutils_lto_supported():
|
|
if not os.path.exists(os.path.join(config.llvm_shlib_dir, 'LLVMgold.so')):
|
|
return False
|
|
|
|
# We require both ld.bfd and ld.gold exist and support plugins. They are in
|
|
# the same repository 'binutils-gdb' and usually built together.
|
|
for exe in (config.gnu_ld_executable, config.gold_executable):
|
|
ld_cmd = subprocess.Popen([exe, '--help'], stdout=subprocess.PIPE, env={'LANG': 'C'})
|
|
ld_out = ld_cmd.stdout.read().decode()
|
|
ld_cmd.wait()
|
|
if not '-plugin' in ld_out:
|
|
return False
|
|
|
|
return True
|
|
|
|
def is_windows_lto_supported():
|
|
return os.path.exists(os.path.join(config.llvm_tools_dir, 'lld-link.exe'))
|
|
|
|
if config.host_os == 'Darwin' and is_darwin_lto_supported():
|
|
config.lto_supported = True
|
|
config.lto_launch = ["env", "DYLD_LIBRARY_PATH=" + config.llvm_shlib_dir]
|
|
config.lto_flags = []
|
|
elif config.host_os in ['Linux', 'FreeBSD', 'NetBSD']:
|
|
config.lto_supported = False
|
|
if config.use_lld:
|
|
config.lto_supported = True
|
|
if is_binutils_lto_supported():
|
|
config.available_features.add('binutils_lto')
|
|
config.lto_supported = True
|
|
|
|
if config.lto_supported:
|
|
config.lto_launch = []
|
|
if config.use_lld:
|
|
config.lto_flags = ["-fuse-ld=lld"]
|
|
else:
|
|
config.lto_flags = ["-fuse-ld=gold"]
|
|
elif config.host_os == 'Windows' and is_windows_lto_supported():
|
|
config.lto_supported = True
|
|
config.lto_launch = []
|
|
config.lto_flags = ["-fuse-ld=lld"]
|
|
else:
|
|
config.lto_supported = False
|
|
|
|
if config.lto_supported:
|
|
config.available_features.add('lto')
|
|
if config.use_thinlto:
|
|
config.available_features.add('thinlto')
|
|
config.lto_flags += ["-flto=thin"]
|
|
else:
|
|
config.lto_flags += ["-flto"]
|
|
if config.use_newpm:
|
|
config.lto_flags += ["-fexperimental-new-pass-manager"]
|
|
|
|
if config.have_rpc_xdr_h:
|
|
config.available_features.add('sunrpc')
|
|
|
|
# Ask llvm-config about assertion mode.
|
|
try:
|
|
llvm_config_cmd = subprocess.Popen(
|
|
[os.path.join(config.llvm_tools_dir, 'llvm-config'), '--assertion-mode'],
|
|
stdout = subprocess.PIPE,
|
|
env=config.environment)
|
|
except OSError as e:
|
|
print("Could not launch llvm-config in " + config.llvm_tools_dir)
|
|
print(" Failed with error #{0}: {1}".format(e.errno, e.strerror))
|
|
exit(42)
|
|
|
|
if re.search(r'ON', llvm_config_cmd.stdout.read().decode('ascii')):
|
|
config.available_features.add('asserts')
|
|
llvm_config_cmd.wait()
|
|
|
|
# Sanitizer tests tend to be flaky on Windows due to PR24554, so add some
|
|
# retries. We don't do this on otther platforms because it's slower.
|
|
if platform.system() == 'Windows':
|
|
config.test_retry_attempts = 2
|
|
|
|
# No throttling on non-Darwin platforms.
|
|
lit_config.parallelism_groups['shadow-memory'] = None
|
|
|
|
if platform.system() == 'Darwin':
|
|
ios_device = config.apple_platform != 'osx' and not config.apple_platform.endswith('sim')
|
|
# Force sequential execution when running tests on iOS devices.
|
|
if ios_device:
|
|
lit_config.warning('Forcing sequential execution for iOS device tests')
|
|
lit_config.parallelism_groups['ios-device'] = 1
|
|
config.parallelism_group = 'ios-device'
|
|
|
|
# Only run up to 3 processes that require shadow memory simultaneously on
|
|
# 64-bit Darwin. Using more scales badly and hogs the system due to
|
|
# inefficient handling of large mmap'd regions (terabytes) by the kernel.
|
|
elif config.target_arch in ['x86_64', 'x86_64h']:
|
|
lit_config.warning('Throttling sanitizer tests that require shadow memory on Darwin 64bit')
|
|
lit_config.parallelism_groups['shadow-memory'] = 3
|
|
|
|
# Multiple substitutions are necessary to support multiple shared objects used
|
|
# at once.
|
|
# Note that substitutions with numbers have to be defined first to avoid
|
|
# being subsumed by substitutions with smaller postfix.
|
|
for postfix in ["2", "1", ""]:
|
|
if config.host_os == 'Darwin':
|
|
config.substitutions.append( ("%ld_flags_rpath_exe" + postfix, '-Wl,-rpath,@executable_path/ %dynamiclib' + postfix) )
|
|
config.substitutions.append( ("%ld_flags_rpath_so" + postfix, '-install_name @rpath/`basename %dynamiclib{}`'.format(postfix)) )
|
|
elif config.host_os in ('FreeBSD', 'NetBSD', 'OpenBSD'):
|
|
config.substitutions.append( ("%ld_flags_rpath_exe" + postfix, "-Wl,-z,origin -Wl,-rpath,\$ORIGIN -L%T -l%xdynamiclib_namespec" + postfix) )
|
|
config.substitutions.append( ("%ld_flags_rpath_so" + postfix, '') )
|
|
elif config.host_os == 'Linux':
|
|
config.substitutions.append( ("%ld_flags_rpath_exe" + postfix, "-Wl,-rpath,\$ORIGIN -L%T -l%xdynamiclib_namespec" + postfix) )
|
|
config.substitutions.append( ("%ld_flags_rpath_so" + postfix, '') )
|
|
elif config.host_os == 'SunOS':
|
|
config.substitutions.append( ("%ld_flags_rpath_exe" + postfix, "-Wl,-R\$ORIGIN -L%T -l%xdynamiclib_namespec" + postfix) )
|
|
config.substitutions.append( ("%ld_flags_rpath_so" + postfix, '') )
|
|
|
|
# Must be defined after the substitutions that use %dynamiclib.
|
|
config.substitutions.append( ("%dynamiclib" + postfix, '%T/%xdynamiclib_filename' + postfix) )
|
|
config.substitutions.append( ("%xdynamiclib_filename" + postfix, 'lib%xdynamiclib_namespec{}.so'.format(postfix)) )
|
|
config.substitutions.append( ("%xdynamiclib_namespec", '%basename_t.dynamic') )
|
|
|
|
# Provide a substituion that can be used to tell Clang to use a static libstdc++.
|
|
# The substitution expands to nothing on non Linux platforms.
|
|
# FIXME: This should check the target OS, not the host OS.
|
|
if config.host_os == 'Linux':
|
|
config.substitutions.append( ("%linux_static_libstdcplusplus", "-stdlib=libstdc++ -static-libstdc++") )
|
|
else:
|
|
config.substitutions.append( ("%linux_static_libstdcplusplus", "") )
|
|
|
|
config.default_sanitizer_opts = []
|
|
if config.host_os == 'Darwin':
|
|
# On Darwin, we default to `abort_on_error=1`, which would make tests run
|
|
# much slower. Let's override this and run lit tests with 'abort_on_error=0'.
|
|
config.default_sanitizer_opts += ['abort_on_error=0']
|
|
config.default_sanitizer_opts += ['log_to_syslog=0']
|
|
if lit.util.which('log'):
|
|
# Querying the log can only done by a privileged user so
|
|
# so check if we can query the log.
|
|
exit_code = -1
|
|
with open('/dev/null', 'r') as f:
|
|
# Run a `log show` command the should finish fairly quickly and produce very little output.
|
|
exit_code = subprocess.call(['log', 'show', '--last', '1m', '--predicate', '1 == 0'], stdout=f, stderr=f)
|
|
if exit_code == 0:
|
|
config.available_features.add('darwin_log_cmd')
|
|
else:
|
|
lit_config.warning('log command found but cannot queried')
|
|
else:
|
|
lit_config.warning('log command not found. Some tests will be skipped.')
|
|
elif config.android:
|
|
config.default_sanitizer_opts += ['abort_on_error=0']
|
|
|
|
# Allow tests to use REQUIRES=stable-runtime. For use when you cannot use XFAIL
|
|
# because the test hangs or fails on one configuration and not the other.
|
|
if config.android or (config.target_arch not in ['arm', 'armhf', 'aarch64']):
|
|
config.available_features.add('stable-runtime')
|
|
|
|
if config.asan_shadow_scale:
|
|
config.available_features.add("shadow-scale-%s" % config.asan_shadow_scale)
|
|
else:
|
|
config.available_features.add("shadow-scale-3")
|
|
|
|
if config.memprof_shadow_scale:
|
|
config.available_features.add("memprof-shadow-scale-%s" % config.memprof_shadow_scale)
|
|
else:
|
|
config.available_features.add("memprof-shadow-scale-3")
|
|
|
|
if config.expensive_checks:
|
|
config.available_features.add("expensive_checks")
|
|
|
|
# Propagate the LLD/LTO into the clang config option, so nothing else is needed.
|
|
run_wrapper = []
|
|
target_cflags = [getattr(config, 'target_cflags', None)]
|
|
extra_cflags = []
|
|
|
|
if config.use_lto and config.lto_supported:
|
|
run_wrapper += config.lto_launch
|
|
extra_cflags += config.lto_flags
|
|
elif config.use_lto and (not config.lto_supported):
|
|
config.unsupported = True
|
|
|
|
if config.use_lld and config.has_lld and not config.use_lto:
|
|
extra_cflags += ["-fuse-ld=lld"]
|
|
elif config.use_lld and (not config.has_lld):
|
|
config.unsupported = True
|
|
|
|
# Append any extra flags passed in lit_config
|
|
append_target_cflags = lit_config.params.get('append_target_cflags', None)
|
|
if append_target_cflags:
|
|
lit_config.note('Appending to extra_cflags: "{}"'.format(append_target_cflags))
|
|
extra_cflags += [append_target_cflags]
|
|
|
|
config.clang = " " + " ".join(run_wrapper + [config.compile_wrapper, config.clang]) + " "
|
|
config.target_cflags = " " + " ".join(target_cflags + extra_cflags) + " "
|
|
|
|
if config.host_os == 'Darwin':
|
|
config.substitutions.append((
|
|
"%get_pid_from_output",
|
|
"{} {}/get_pid_from_output.py".format(
|
|
sh_quote(config.python_executable),
|
|
sh_quote(get_ios_commands_dir())
|
|
))
|
|
)
|
|
config.substitutions.append(
|
|
("%print_crashreport_for_pid",
|
|
"{} {}/print_crashreport_for_pid.py".format(
|
|
sh_quote(config.python_executable),
|
|
sh_quote(get_ios_commands_dir())
|
|
))
|
|
)
|