[sanitizer] Unify and generalize Apple platforms in CMake and lit test configs

[kubamracek]

Summary

There's more platforms than just "ios" and "iossim" that we should support, and adding more lit config variables for each platform isn't great. Let's generalize and have a single value that determines what the platform under test is.

[delcypher]

Overall looks very good. I have a few comments on some changes I'd like to see. The only one I think is essential is renaming the ios lit feature. However I think this could be done in a separate commit.

test/lit.common.cfg

111

We should really fix the name of the ios lit configuration feature. The feature is added for any ios-like platform (i.e. Apple platform that is not macos) but it is really not obvious from the name. It could also be confused with config.apple_platform being set to ios which means something different. At some point in the future we might add the value config.apple_platform as a feature i.e.

config.available_features.add(config.apple_platform)

This would write tests that can be enabled/disabled based on config.apple_platform. However we can't do this if the ios feature means something else.

A possible new name for the ios feature could be apple_embedded_platform and the logic for setting this feature would simply be

if config.host_os == 'Darwin' and config.apple_platform != 'osx':
  config.available_features.add('apple_embedded_platform')

The feature name is a little long so I'd like to hear other ideas but its name should not match any of the possible values for config.apple_platform.

I realise this would be a very invasive change that would require changing lots of tests so if we do this I suggest this is done separately as a follow up commit.

119

We could consider changing this to

"SANITIZER_" + config.apple.platform.upper() + "_TEST_DEVICE_IDENTIFIER"

I'm not sure if it's worth it. It would potentially be useful if in future if we wanted to test multiple devices in a single lit invocation.

120

These scripts are named based on the old naming scheme and really should be fixed. E.g.

ios_run.py -> device_run.py
iossim_run.py -> device_sim_run.py

similarly for the _prepare, _env and _compile suffixed scripts too.

This would also allow you to rename the ios_or_iossim variable.

Side note the ios_commands directory also could do with a rename at some point.

130

Should we have more error checking here?

132

We should probably check that the JSON data is what we expect before trying to use it.

assert 'env' in prepare_output
assert isinstance(prepare_output['env'], dict)

Or something similar.

[kubamracek]

For the whole "ios/iossim" naming and ios_or_iossim: Let's not try to fix that in this patch. But in general, I don't think this is too terrible. The rule simply is: All embedded platforms claim they are also "ios" because they are derivatives of iOS. Maybe this could be greatly improved with just a bit more documentation? I like the fact that you can disable a test for all embedded platforms with just "DISABLE: ios" and you don't have to list all of them.

test/lit.common.cfg

130

check_output will abort if the exit code isn' 0.

132

Hm, this seems very non-Python-y. Just using prepare_output["env"] implicitly checks for these things as well.

[kubamracek]

Adding a comment explaining available features.

[george.karpenkov]

Looks good to me, I think suggestions from @delcypher should be done in subsequent patches.

test/lit.common.cfg

111

@delcypher while I don't disagree, shouldn't this be done in another review?

120

Again could be done in a subsequent review?

125

newline after colon

[kubamracek]

Adding a newline.

[kubamracek]

@delcypher Is there anything else you think needs to be addressed as part of this patch?

[delcypher]

In D48309#1136545, @kubamracek wrote:

For the whole "ios/iossim" naming and ios_or_iossim: Let's not try to fix that in this patch. But in general, I don't think this is too terrible. The rule simply is: All embedded platforms claim they are also "ios" because they are derivatives of iOS. Maybe this could be greatly improved with just a bit more documentation? I like the fact that you can disable a test for all embedded platforms with just "DISABLE: ios" and you don't have to list all of them.

I really don't think using ios to mean ios and ios derivatives is a good convention to follow because it can be easily confused with ios being the config.apple_platform. What I proposed is to use a lit feature name like apple_embedded_platform (needs bikeshedding to be shorter) to mean any ios or ios derivative. With that you can still disable tests for all apple embedded platforms (i.e. replace UNSUPPORTED: ios with UNSUPPORTED: apple_embedded_platform in tests). With this change that then means we can use ios as the feature name to identify the ios platform (as opposed to watchos, tvos, etc.). In your current scheme you'd have to write something like UNSUPPORTED: ios && !(iossim || watchos || watchossim || tvos || tvossim) to mark a test as not support for the ios platform but okay for other platforms, which is very clumsy.

The fact that we use ios as a lit feature to mean ios or any ios derivative is just a historical holdover from ios being the only apple device platform we supported in testing. This isn't true anymore and I don't think adding some documentation to explain our (now odd ) convention is the right thing to do. It's simpler to just do the rename so that config.apple_platform == ios corresponds to the lit feature named ios.

I realise this would require quite a large change to the tests so I'm happy for this to change happen in a separate review.

test/lit.common.cfg

111

I'm fine with that.

[delcypher]

test/lit.common.cfg

132

Not quite. Python is duck typed so as long as prepare_output['env'] acts enough like a dict python is happy. You're right though that it probably isn't python-y, so I'll drop this point.

test/asan/CMakeLists.txt

 
 foreach(arch ${ASAN_TEST_ARCH})
   if(ANDROID)
     set(ASAN_TEST_TARGET_ARCH ${arch}-android)
   else()
     set(ASAN_TEST_TARGET_ARCH ${arch})
   endif()
 
-  set(ASAN_TEST_IOS "0")
-  pythonize_bool(ASAN_TEST_IOS)
-  set(ASAN_TEST_IOSSIM "0")
-  pythonize_bool(ASAN_TEST_IOSSIM)
+  set(ASAN_TEST_APPLE_PLATFORM "osx")
 
   string(TOLOWER "-${arch}-${OS_NAME}" ASAN_TEST_CONFIG_SUFFIX)
   get_bits_for_arch(${arch} ASAN_TEST_BITS)
   get_test_cc_for_arch(${arch} ASAN_TEST_TARGET_CC ASAN_TEST_TARGET_CFLAGS)
   if(ANDROID)
     set(ASAN_TEST_DYNAMIC True)
   else()
     set(ASAN_TEST_DYNAMIC False)

 # These are not added into "check-all", in order to run these tests, use
 # "check-asan-iossim-x86_64" and similar. They also require that an extra env
 # variable to select which iOS device or simulator to use, e.g.:
 # SANITIZER_IOSSIM_TEST_DEVICE_IDENTIFIER="iPhone 6"
 if(APPLE)
   set(EXCLUDE_FROM_ALL ON)
 
   set(ASAN_TEST_TARGET_CC ${COMPILER_RT_TEST_COMPILER})
-  set(ASAN_TEST_IOS "1")
-  pythonize_bool(ASAN_TEST_IOS)
   set(ASAN_TEST_DYNAMIC True)
 
   foreach(arch ${DARWIN_iossim_ARCHS})
-    set(ASAN_TEST_IOSSIM "1")
-    pythonize_bool(ASAN_TEST_IOSSIM)
+    set(ASAN_TEST_APPLE_PLATFORM "iossim")
     set(ASAN_TEST_TARGET_ARCH ${arch})
     set(ASAN_TEST_TARGET_CFLAGS "-arch ${arch} -isysroot ${DARWIN_iossim_SYSROOT} ${COMPILER_RT_TEST_COMPILER_CFLAGS}")
-    set(ASAN_TEST_CONFIG_SUFFIX "-${arch}-iossim")
+    set(ASAN_TEST_CONFIG_SUFFIX "-${arch}-${ASAN_TEST_APPLE_PLATFORM}")
     get_bits_for_arch(${arch} ASAN_TEST_BITS)
     string(TOUPPER ${arch} ARCH_UPPER_CASE)
     set(CONFIG_NAME "IOSSim${ARCH_UPPER_CASE}Config")
     configure_lit_site_cfg(
       ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.in
       ${CMAKE_CURRENT_BINARY_DIR}/${CONFIG_NAME}/lit.site.cfg
       )
     add_lit_testsuite(check-asan-iossim-${arch} "AddressSanitizer iOS Simulator ${arch} tests"
       ${CMAKE_CURRENT_BINARY_DIR}/${CONFIG_NAME}/
       DEPENDS ${ASAN_TEST_DEPS})
   endforeach()
 
   foreach (arch ${DARWIN_ios_ARCHS})
-    set(ASAN_TEST_IOSSIM "0")
-    pythonize_bool(ASAN_TEST_IOSSIM)
+    set(ASAN_TEST_APPLE_PLATFORM "ios")
     set(ASAN_TEST_TARGET_ARCH ${arch})
     set(ASAN_TEST_TARGET_CFLAGS "-arch ${arch} -isysroot ${DARWIN_ios_SYSROOT} ${COMPILER_RT_TEST_COMPILER_CFLAGS}")
-    set(ASAN_TEST_CONFIG_SUFFIX "-${arch}-ios")
+    set(ASAN_TEST_CONFIG_SUFFIX "-${arch}-${ASAN_TEST_APPLE_PLATFORM}")
     get_bits_for_arch(${arch} ASAN_TEST_BITS)
     string(TOUPPER ${arch} ARCH_UPPER_CASE)
     set(CONFIG_NAME "IOS${ARCH_UPPER_CASE}Config")
     configure_lit_site_cfg(
       ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.in
       ${CMAKE_CURRENT_BINARY_DIR}/${CONFIG_NAME}/lit.site.cfg
       )
     add_lit_testsuite(check-asan-ios-${arch} "AddressSanitizer iOS ${arch} tests"

test/asan/lit.cfg

 
 # Only run the tests on supported OSs.
 if config.host_os not in ['Linux', 'Darwin', 'FreeBSD', 'SunOS', 'Windows', 'NetBSD']:
   config.unsupported = True
 
 if config.host_os == 'Darwin':
   if config.target_arch in ["x86_64", "x86_64h"]:
     config.parallelism_group = "darwin-64bit-sanitizer"
-  elif config.ios and not config.iossim:
+  elif config.apple_platform != "osx" and not config.apple_platform.endswith("sim"):
     config.parallelism_group = "darwin-ios-device-sanitizer"

test/asan/lit.site.cfg.in

 @LIT_SITE_CFG_IN_HEADER@
 
 # Tool-specific config options.
 config.name_suffix = "@ASAN_TEST_CONFIG_SUFFIX@"
 config.target_cflags = "@ASAN_TEST_TARGET_CFLAGS@"
 config.clang = "@ASAN_TEST_TARGET_CC@"
 config.bits = "@ASAN_TEST_BITS@"
-config.ios = @ASAN_TEST_IOS_PYBOOL@
-config.iossim = @ASAN_TEST_IOSSIM_PYBOOL@
+config.apple_platform = "@ASAN_TEST_APPLE_PLATFORM@"
 config.asan_dynamic = @ASAN_TEST_DYNAMIC@
 config.target_arch = "@ASAN_TEST_TARGET_ARCH@"
 
 # Load common config for all compiler-rt lit tests.
 lit_config.load_config(config, "@COMPILER_RT_BINARY_DIR@/test/lit.common.configured")
 
 # Load tool-specific config that would do the real work.
 lit_config.load_config(config, "@ASAN_LIT_SOURCE_DIR@/lit.cfg")

test/fuzzer/CMakeLists.txt

 set(LIBFUZZER_TEST_DEPS ${SANITIZER_COMMON_LIT_TEST_DEPS})
 if (NOT COMPILER_RT_STANDALONE_BUILD)
   list(APPEND LIBFUZZER_TEST_DEPS fuzzer asan ubsan)
 endif()
 
 if(COMPILER_RT_INCLUDE_TESTS)
   list(APPEND LIBFUZZER_TEST_DEPS FuzzerUnitTests)
 endif()
 
 set(EXCLUDE_FROM_ALL ON)
 
 add_custom_target(check-fuzzer)
-set(LIBFUZZER_TEST_IOS "0")
-pythonize_bool(LIBFUZZER_TEST_IOS)
 
 if(COMPILER_RT_INCLUDE_TESTS)
   # libFuzzer unit tests.
   configure_lit_site_cfg(
     ${CMAKE_CURRENT_SOURCE_DIR}/unit/lit.site.cfg.in
     ${CMAKE_CURRENT_BINARY_DIR}/unit/lit.site.cfg)
   add_lit_testsuite(check-fuzzer-unit "Running Fuzzer unit tests"
     ${CMAKE_CURRENT_BINARY_DIR}/unit
foreach(part IN LISTS stdlib_list)
     string(TOUPPER ${first_letter} first_letter)
     string(REGEX REPLACE "^.(.*)" "${first_letter}\\1" part "${part}")
     set(STDLIB_CAPITALIZED "${STDLIB_CAPITALIZED}${part}")
   endforeach()
   foreach(arch ${FUZZER_SUPPORTED_ARCH})
     set(LIBFUZZER_TEST_COMPILER ${COMPILER_RT_TEST_COMPILER})
     get_test_cc_for_arch(${arch} LIBFUZZER_TEST_COMPILER LIBFUZZER_TEST_FLAGS)
 
+    set(LIBFUZZER_TEST_APPLE_PLATFORM "osx")
+
     set(LIBFUZZER_TEST_STDLIB ${stdlib})
 
     string(TOUPPER ${arch} ARCH_UPPER_CASE)
     set(CONFIG_NAME ${ARCH_UPPER_CASE}${STDLIB_CAPITALIZED}${OS_NAME}Config)
 
     # LIT-based libFuzzer tests.
     configure_lit_site_cfg(
       ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.in
if(TARGET cxx_static)
     test_fuzzer("static-libc++" DEPS cxx_static)
   endif()
 endif()
 
 if (APPLE)
   set(EXCLUDE_FROM_ALL ON)
 
   foreach(arch ${DARWIN_ios_ARCHS})
-    set(LIBFUZZER_TEST_IOS "1")
-    pythonize_bool(LIBFUZZER_TEST_IOS)
+    set(LIBFUZZER_TEST_APPLE_PLATFORM "ios")
     set(LIBFUZZER_TEST_TARGET_ARCH ${arch})
     set(LIBFUZZER_TEST_FLAGS "-arch ${arch} -isysroot ${DARWIN_ios_SYSROOT} ${COMPILER_RT_TEST_COMPILER_CFLAGS}")
-    set(LIBFUZZER_TEST_CONFIG_SUFFIX "-${arch}-ios")
+    set(LIBFUZZER_TEST_CONFIG_SUFFIX "-${arch}-${LIBFUZZER_TEST_APPLE_PLATFORM}")
     string(TOUPPER ${arch} ARCH_UPPER_CASE)
     set(CONFIG_NAME "IOS${ARCH_UPPER_CASE}Config")
     configure_lit_site_cfg(
       ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.in
       ${CMAKE_CURRENT_BINARY_DIR}/${CONFIG_NAME}/lit.site.cfg
       )
     add_lit_testsuite(check-fuzzer-ios-${arch} "libFuzzer iOS ${arch} tests"
       ${CMAKE_CURRENT_BINARY_DIR}/${CONFIG_NAME}/
       DEPENDS ${LIBFUZZER_TEST_DEPS})
 
   endforeach()
 
   set(EXCLUDE_FROM_ALL OFF)
 endif()

test/fuzzer/lit.cfg

 
 config.substitutions.append(('%no_fuzzer_c_compiler',
       generate_compiler_cmd(is_cpp=False, fuzzer_enabled=False)
       ))
 
 if config.host_os == 'Darwin':
   if config.target_arch in ["x86_64", "x86_64h"]:
     config.parallelism_group = "darwin-64bit-sanitizer"
-  elif config.ios and not config.iossim:
+  elif config.apple_platform != "osx" and not config.apple_platform.endswith("sim"):
     config.parallelism_group = "darwin-ios-device-sanitizer"

test/fuzzer/lit.site.cfg.in

 @LIT_SITE_CFG_IN_HEADER@
 
 config.test_exec_root = "@CMAKE_CURRENT_BINARY_DIR@"
 
 config.cpp_compiler = "@LIBFUZZER_TEST_COMPILER@"
 config.target_flags = "@LIBFUZZER_TEST_FLAGS@"
 config.c_compiler = "@LIBFUZZER_TEST_COMPILER@"
 config.stdlib = "@LIBFUZZER_TEST_STDLIB@"
-config.ios = @LIBFUZZER_TEST_IOS_PYBOOL@
+config.apple_platform = "@LIBFUZZER_TEST_APPLE_PLATFORM@"
 config.name_suffix = "@LIBFUZZER_TEST_CONFIG_SUFFIX@"
 
 config.osx_sysroot_flag = "@OSX_SYSROOT_FLAG@"
 config.cmake_binary_dir = "@CMAKE_BINARY_DIR@"
 config.llvm_library_dir = "@LLVM_LIBRARY_DIR@"
 config.target_triple = "@TARGET_TRIPLE@"
 
 # Load common config for all compiler-rt lit tests.
 lit_config.load_config(config,
     "@COMPILER_RT_BINARY_DIR@/test/lit.common.configured")
 
 lit_config.load_config(config, "@CMAKE_CURRENT_SOURCE_DIR@/lit.cfg")

test/lit.common.cfg

 # -*- Python -*-
 
 # Configuration file for 'lit' test runner.
 # This file contains common rules for various compiler-rt testsuites.
 # It is mostly copied from lit.cfg 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:
config.substitutions.append(
     (' clang', """\n\n*** Do not use 'clangXXX' in tests,
      instead define '%clangXXX' substitution in lit config. ***\n\n""") )
 
 # Allow tests to be executed on a simulator or remotely.
 if config.emulator:
   config.substitutions.append( ('%run', config.emulator) )
   config.substitutions.append( ('%env ', "env ") )
   config.compile_wrapper = ""
-elif config.ios:
+elif config.host_os == 'Darwin' and config.apple_platform != "osx":
+  ios_or_iossim = "iossim" if config.apple_platform.endswith("sim") else "ios"
+
   config.available_features.add('ios')
-  device_id_env = "SANITIZER_IOSSIM_TEST_DEVICE_IDENTIFIER" if config.iossim else "SANITIZER_IOS_TEST_DEVICE_IDENTIFIER"
-  if device_id_env in os.environ: config.environment[device_id_env] = os.environ[device_id_env]
+  if ios_or_iossim == "iossim":
+    config.available_features.add('iossim')
+  if config.apple_platform != "ios":
+    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, "iossim_run.py" if config.iossim else "ios_run.py")
+
+  device_id_env = "SANITIZER_" + ios_or_iossim.upper() + "_TEST_DEVICE_IDENTIFIER"
+  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))
-  env_wrapper = os.path.join(ios_commands_dir, "iossim_env.py" if config.iossim else "ios_env.py")
   config.substitutions.append(('%env ', env_wrapper + " "))
-  compile_wrapper = os.path.join(ios_commands_dir, "iossim_compile.py" if config.iossim else "ios_compile.py")
   config.compile_wrapper = compile_wrapper
+
+  prepare_output_json = subprocess.check_output([prepare_script, config.apple_platform, config.clang]).strip().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', "") )
if output_re:
       cpu_subtype = int(output_re.group(1))
       if cpu_subtype == 8: # x86_64h
         config.available_features.add('x86_64h')
   except:
     pass
 
   config.substitutions.append( ("%macos_min_target_10_11", "-mmacosx-version-min=10.11") )
 
-  isIOS = getattr(config, 'ios', False)
+  isIOS = config.apple_platform != "osx"
   # rdar://problem/22207160
   config.substitutions.append( ("%darwin_min_target_with_full_runtime_arc_support",
       "-miphoneos-version-min=9.0" if isIOS else "-mmacosx-version-min=10.11") )
 else:
   config.substitutions.append( ("%macos_min_target_10_11", "") )
   config.substitutions.append( ("%darwin_min_target_with_full_runtime_arc_support", "") )
 
 if config.android:

 # Using more scales badly and hogs the system due to inefficient handling
 # of large mmap'd regions (terabytes) by the kernel.
 if platform.system() == 'Darwin':
   lit_config.parallelism_groups["darwin-64bit-sanitizer"] = 3
 
 # The current implementation of the tools in sanitizer_common/ios_comamnds
 # do not support parallel execution so force sequential execution of the
 # tests on iOS devices.
-if config.host_os == 'Darwin' and config.ios and not config.iossim:
+if config.host_os == 'Darwin' and config.apple_platform != "osx" and not config.apple_platform.endswith("sim"):
   lit_config.warning("iOS device test cases being run sequentially")
   lit_config.parallelism_groups["darwin-ios-device-sanitizer"] = 1
 
 # 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", ""]:

test/lit.common.configured.in

 set_default("gold_executable", "@GOLD_EXECUTABLE@")
 set_default("clang", "@COMPILER_RT_RESOLVED_TEST_COMPILER@")
 set_default("compiler_id", "@COMPILER_RT_TEST_COMPILER_ID@")
 set_default("python_executable", "@PYTHON_EXECUTABLE@")
 set_default("compiler_rt_debug", @COMPILER_RT_DEBUG_PYBOOL@)
 set_default("compiler_rt_libdir", "@COMPILER_RT_RESOLVED_LIBRARY_OUTPUT_DIR@")
 set_default("emulator", "@COMPILER_RT_EMULATOR@")
 set_default("asan_shadow_scale", "@COMPILER_RT_ASAN_SHADOW_SCALE@")
-set_default("ios", False)
-set_default("iossim", False)
+set_default("apple_platform", None)
 set_default("sanitizer_can_use_cxxabi", @SANITIZER_CAN_USE_CXXABI_PYBOOL@)
 set_default("has_lld", @COMPILER_RT_HAS_LLD_PYBOOL@)
 set_default("can_symbolize", @CAN_SYMBOLIZE@)
 set_default("use_lld", False)
 set_default("use_thinlto", False)
 set_default("use_lto", config.use_thinlto)
 set_default("android", @ANDROID_PYBOOL@)
 config.available_features.add('target-is-%s' % config.target_arch)

test/sanitizer_common/ios_commands/iossim_prepare.py

+#!/usr/bin/python
+
+import os, sys, subprocess, json
+
+print(json.dumps({"env": {}}))

test/tsan/CMakeLists.txt

 set(TSAN_TESTSUITES)
 
 set(TSAN_TEST_ARCH ${TSAN_SUPPORTED_ARCH})
 if(APPLE)
   darwin_filter_host_archs(TSAN_SUPPORTED_ARCH TSAN_TEST_ARCH)
 endif()
 
 foreach(arch ${TSAN_TEST_ARCH})
-  set(TSAN_TEST_IOS "0")
-  pythonize_bool(TSAN_TEST_IOS)
-  set(TSAN_TEST_IOSSIM "0")
-  pythonize_bool(TSAN_TEST_IOSSIM)
+  set(TSAN_TEST_APPLE_PLATFORM "osx")
 
   set(TSAN_TEST_TARGET_ARCH ${arch})
   string(TOLOWER "-${arch}" TSAN_TEST_CONFIG_SUFFIX)
   get_test_cc_for_arch(${arch} TSAN_TEST_TARGET_CC TSAN_TEST_TARGET_CFLAGS)
 
   string(TOUPPER ${arch} ARCH_UPPER_CASE)
   set(CONFIG_NAME ${ARCH_UPPER_CASE}Config)
 
   configure_lit_site_cfg(
     ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.in
     ${CMAKE_CURRENT_BINARY_DIR}/${CONFIG_NAME}/lit.site.cfg)
   list(APPEND TSAN_TESTSUITES ${CMAKE_CURRENT_BINARY_DIR}/${CONFIG_NAME})
 endforeach()
 
 # iOS and iOS simulator test suites
 # These are not added into "check-all", in order to run these tests, use
 # "check-tsan-iossim-x86_64" and similar. They also require an extra environment
 # variable to select which iOS device or simulator to use, e.g.:
 # SANITIZER_IOSSIM_TEST_DEVICE_IDENTIFIER="iPhone 6"
 if(APPLE)
   set(EXCLUDE_FROM_ALL ON)
 
   set(TSAN_TEST_TARGET_CC ${COMPILER_RT_TEST_COMPILER})
-  set(TSAN_TEST_IOS "1")
-  pythonize_bool(TSAN_TEST_IOS)
 
+  set(TSAN_TEST_APPLE_PLATFORM "iossim")
   set(arch "x86_64")
-  set(TSAN_TEST_IOSSIM "1")
-  pythonize_bool(TSAN_TEST_IOSSIM)
   set(TSAN_TEST_TARGET_ARCH ${arch})
   set(TSAN_TEST_TARGET_CFLAGS "-arch ${arch} -isysroot ${DARWIN_iossim_SYSROOT} ${COMPILER_RT_TEST_COMPILER_CFLAGS}")
-  set(TSAN_TEST_CONFIG_SUFFIX "-${arch}-iossim")
+  set(TSAN_TEST_CONFIG_SUFFIX "-${arch}-${TSAN_TEST_APPLE_PLATFORM}")
   string(TOUPPER ${arch} ARCH_UPPER_CASE)
   set(CONFIG_NAME "IOSSim${ARCH_UPPER_CASE}Config")
   configure_lit_site_cfg(
     ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.in
     ${CMAKE_CURRENT_BINARY_DIR}/${CONFIG_NAME}/lit.site.cfg
     )
   add_lit_testsuite(check-tsan-iossim-${arch} "ThreadSanitizer iOS Simulator ${arch} tests"
     ${CMAKE_CURRENT_BINARY_DIR}/${CONFIG_NAME}/
     DEPENDS ${TSAN_TEST_DEPS})
 
+  set(TSAN_TEST_APPLE_PLATFORM "ios")
   set(arch "arm64")
-  set(TSAN_TEST_IOSSIM "0")
-  pythonize_bool(TSAN_TEST_IOSSIM)
   set(TSAN_TEST_TARGET_ARCH ${arch})
   set(TSAN_TEST_TARGET_CFLAGS "-arch ${arch} -isysroot ${DARWIN_ios_SYSROOT} ${COMPILER_RT_TEST_COMPILER_CFLAGS}")
-  set(TSAN_TEST_CONFIG_SUFFIX "-${arch}-ios")
+  set(TSAN_TEST_CONFIG_SUFFIX "-${arch}-${TSAN_TEST_APPLE_PLATFORM}")
   string(TOUPPER ${arch} ARCH_UPPER_CASE)
   set(CONFIG_NAME "IOS${ARCH_UPPER_CASE}Config")
   configure_lit_site_cfg(
     ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.in
     ${CMAKE_CURRENT_BINARY_DIR}/${CONFIG_NAME}/lit.site.cfg
     )
   add_lit_testsuite(check-tsan-ios-${arch} "ThreadSanitizer iOS Simulator ${arch} tests"
     ${CMAKE_CURRENT_BINARY_DIR}/${CONFIG_NAME}/

test/tsan/lit.cfg

if config.host_os not in ['FreeBSD', 'Linux', 'Darwin', 'NetBSD']:
   config.unsupported = True
 
 if config.android:
   config.unsupported = True
 
 if config.host_os == 'Darwin':
   if config.target_arch in ["x86_64", "x86_64h"]:
     config.parallelism_group = "darwin-64bit-sanitizer"
-  elif config.ios and not config.iossim:
+  elif config.apple_platform != "osx" and not config.apple_platform.endswith("sim"):
     config.parallelism_group = "darwin-ios-device-sanitizer"

test/tsan/lit.site.cfg.in

 @LIT_SITE_CFG_IN_HEADER@
 
 config.name_suffix = "@TSAN_TEST_CONFIG_SUFFIX@"
 config.tsan_lit_source_dir = "@TSAN_LIT_SOURCE_DIR@"
 config.has_libcxx = @TSAN_HAS_LIBCXX@
-config.ios = @TSAN_TEST_IOS_PYBOOL@
-config.iossim = @TSAN_TEST_IOSSIM_PYBOOL@
+config.apple_platform = "@TSAN_TEST_APPLE_PLATFORM@"
 config.target_cflags = "@TSAN_TEST_TARGET_CFLAGS@"
 config.target_arch = "@TSAN_TEST_TARGET_ARCH@"
 
 # Load common config for all compiler-rt lit tests.
 lit_config.load_config(config, "@COMPILER_RT_BINARY_DIR@/test/lit.common.configured")
 
 # Load tool-specific config that would do the real work.
 lit_config.load_config(config, "@CMAKE_CURRENT_SOURCE_DIR@/lit.cfg")