# -*- 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 # 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== 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) # 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 = os.path.join(config.compiler_rt_src_root, "test", "sanitizer_common", "ios_commands") 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 ldd_ver_cmd = subprocess.Popen(['ldd', '--version'], stdout=subprocess.PIPE, env={'LANG': 'C'}) sout, _ = ldd_ver_cmd.communicate() ver_line = sout.splitlines()[0] if not config.android and ver_line.startswith(b"ldd "): from distutils.version import LooseVersion ver = LooseVersion(ver_line.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) + " "