[libFuzzer] Generalize libFuzzer build and tests to multiple architectures

[jfb]

lib/fuzzer/tests/CMakeLists.txt

29–61

Is the intent to skip ARM64 here? It seems like you'd be better off keeping the loop and doing an early continue if ARM64 instead.

test/fuzzer/lit.cfg

54–55

Is this change OK?

[george.karpenkov]

lib/fuzzer/tests/CMakeLists.txt

29–61

Not really, the intent is to only run it on host machine, which is assumed to be x86_64.

test/fuzzer/lit.cfg

54–55

yes

[jfb]

lib/fuzzer/tests/CMakeLists.txt

29–61

It would be useful to at least have a comment to that effect.

[jfb]

lgtm, though of course someone like @kcc should sign off.

[delcypher]

test/fuzzer/lit.cfg

55

The naming isn't great here. You're using cflags but you're passing them to a C++ compiler. Normally the name cxxflags is used for C++ compiler flags and cflags for C compiler flags.

57

I'm not a fan of the old style python string interpolation. I'd rather you used the .format() method on python strings.

79

I realise that -O2 was there before but why are we passing that. Shouldn't the test case decide the optimization level?

Also this looks similar to the ASan/TSan compiler invocation. Could we perhaps do a refactor some common flags shared by all tests types are set in one place?

test/fuzzer/merge-posix.test

1

Any reason for XFAIL instead of UNSUPPORTED?

Also for each test that you marked as XFAIL it would nice to have a short comment explaining why its XFAIL for ios.

[george.karpenkov]

test/fuzzer/lit.cfg

55

yeah, i guess _flags might make more sense

57

sorry, let's only post comments specific to this change. old-style python string interpolation was there before, change to .format can be done in a separate patch

79

again, let's only discuss changes in this patch. both change to the compiler level, and extracting out the common code is orthogonal.

test/fuzzer/merge-posix.test

1

I think we don't do ulimit properly for device testing yet. My goal is to bring up something workable fast, and then further changes might be incrementally made to de-XFAILify more tests

[george.karpenkov]

OK let's try to split it further.

cmake/config-ix.cmake

if(APPLE)
   set(X86_64 x86_64 x86_64h)
 endif()
 
 set(ALL_SANITIZER_COMMON_SUPPORTED_ARCH ${X86} ${X86_64} ${PPC64}
     ${ARM32} ${ARM64} ${MIPS32} ${MIPS64} ${S390X})
 set(ALL_ASAN_SUPPORTED_ARCH ${X86} ${X86_64} ${ARM32} ${ARM64}
     ${MIPS32} ${MIPS64} ${PPC64} ${S390X})
 set(ALL_DFSAN_SUPPORTED_ARCH ${X86_64} ${MIPS64} ${ARM64})
-set(ALL_FUZZER_SUPPORTED_ARCH x86_64)
+set(ALL_FUZZER_SUPPORTED_ARCH ${X86_64} ${ARM64})
 
 if(APPLE)
   set(ALL_LSAN_SUPPORTED_ARCH ${X86} ${X86_64} ${MIPS64} ${ARM64})
 else()
   set(ALL_LSAN_SUPPORTED_ARCH ${X86} ${X86_64} ${MIPS64} ${ARM64} ${ARM32} ${PPC64})
 endif()
 set(ALL_MSAN_SUPPORTED_ARCH ${X86_64} ${MIPS64} ${ARM64} ${PPC64})
 set(ALL_HWASAN_SUPPORTED_ARCH ${X86_64} ${ARM64})
if(APPLE)
   list_intersect(ESAN_SUPPORTED_ARCH
     ALL_ESAN_SUPPORTED_ARCH
     SANITIZER_COMMON_SUPPORTED_ARCH)
   list_intersect(SCUDO_SUPPORTED_ARCH
     ALL_SCUDO_SUPPORTED_ARCH
     SANITIZER_COMMON_SUPPORTED_ARCH)
   list_intersect(FUZZER_SUPPORTED_ARCH
     ALL_FUZZER_SUPPORTED_ARCH
-    ALL_SANITIZER_COMMON_SUPPORTED_ARCH)
+    SANITIZER_COMMON_SUPPORTED_ARCH)
   list_intersect(XRAY_SUPPORTED_ARCH
     ALL_XRAY_SUPPORTED_ARCH
     SANITIZER_COMMON_SUPPORTED_ARCH)
   list_intersect(SHADOWCALLSTACK_SUPPORTED_ARCH
     ALL_SHADOWCALLSTACK_SUPPORTED_ARCH
     SANITIZER_COMMON_SUPPORTED_ARCH)
 
 else()

lib/fuzzer/CMakeLists.txt

 if (CMAKE_CXX_FLAGS MATCHES "fsanitize-coverage")
   list(APPEND LIBFUZZER_CFLAGS -fno-sanitize-coverage=trace-pc-guard,edge,trace-cmp,indirect-calls,8bit-counters)
 endif()
 
 if(NOT HAS_THREAD_LOCAL)
   list(APPEND LIBFUZZER_CFLAGS -Dthread_local=__thread)
 endif()
 
-if(APPLE)
-  set(FUZZER_SUPPORTED_OS osx)
-endif()
+set(FUZZER_SUPPORTED_OS ${SANITIZER_COMMON_SUPPORTED_OS})
 
 add_compiler_rt_object_libraries(RTfuzzer
   OS ${FUZZER_SUPPORTED_OS}
   ARCHS ${FUZZER_SUPPORTED_ARCH}
   SOURCES ${LIBFUZZER_SOURCES}
   CFLAGS ${LIBFUZZER_CFLAGS})
 
 add_compiler_rt_object_libraries(RTfuzzer_main

lib/fuzzer/tests/CMakeLists.txt

 set(LIBFUZZER_UNITTEST_CFLAGS
   ${COMPILER_RT_UNITTEST_CFLAGS}
   ${COMPILER_RT_GTEST_CFLAGS}
   -I${COMPILER_RT_SOURCE_DIR}/lib/fuzzer
   -fno-rtti
   -Werror
   -O2)
 
+if (APPLE)
+  set(FUZZER_SUPPORTED_OS osx)
+endif()
+
 add_custom_target(FuzzerUnitTests)
 set_target_properties(FuzzerUnitTests PROPERTIES FOLDER "Compiler-RT Tests")
 
 set(LIBFUZZER_UNITTEST_LINK_FLAGS ${COMPILER_RT_UNITTEST_LINK_FLAGS})
 list(APPEND LIBFUZZER_UNITTEST_LINK_FLAGS --driver-mode=g++)
 
 if(APPLE OR CMAKE_SYSTEM_NAME STREQUAL "FreeBSD")
   list(APPEND LIBFUZZER_UNITTEST_LINK_FLAGS -lc++ -lpthread)
 else()
   list(APPEND LIBFUZZER_UNITTEST_LINK_FLAGS -lstdc++ -lpthread)
 endif()
 
 if("${CMAKE_SYSTEM_NAME}" STREQUAL "Linux" AND COMPILER_RT_LIBCXX_PATH)
   list(APPEND LIBFUZZER_UNITTEST_CFLAGS -nostdinc++ -D_LIBCPP_ABI_VERSION=Fuzzer)
 endif()
 
-foreach(arch ${FUZZER_SUPPORTED_ARCH})
-  set(LIBFUZZER_TEST_RUNTIME RTFuzzerTest.${arch})
-  if(APPLE)
-    set(LIBFUZZER_TEST_RUNTIME_OBJECTS
-      $<TARGET_OBJECTS:RTfuzzer.osx>)
-  else()
-    set(LIBFUZZER_TEST_RUNTIME_OBJECTS
-      $<TARGET_OBJECTS:RTfuzzer.${arch}>)
-  endif()
-  add_library(${LIBFUZZER_TEST_RUNTIME} STATIC
-    ${LIBFUZZER_TEST_RUNTIME_OBJECTS})
-  set_target_properties(${LIBFUZZER_TEST_RUNTIME} PROPERTIES
-    ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
-    FOLDER "Compiler-RT Runtime tests")
+# libFuzzer unit tests are only run on the host machine.
+set(arch "x86_64")
+
 
-  if("${CMAKE_SYSTEM_NAME}" STREQUAL "Linux" AND COMPILER_RT_LIBCXX_PATH)
-    set(LIBFUZZER_TEST_RUNTIME_DEPS libcxx_fuzzer_${arch}-build)
-    set(LIBFUZZER_TEST_RUNTIME_CFLAGS -isystem ${COMPILER_RT_LIBCXX_PATH}/include)
-    set(LIBFUZZER_TEST_RUNTIME_LINK_FLAGS ${LIBCXX_${arch}_PREFIX}/lib/libc++.a)
-  endif()
 
-  set(FuzzerTestObjects)
-  generate_compiler_rt_tests(FuzzerTestObjects
-    FuzzerUnitTests "Fuzzer-${arch}-Test" ${arch}
-    SOURCES FuzzerUnittest.cpp ${COMPILER_RT_GTEST_SOURCE}
-    RUNTIME ${LIBFUZZER_TEST_RUNTIME}
-    DEPS gtest ${LIBFUZZER_TEST_RUNTIME_DEPS}
-    CFLAGS ${LIBFUZZER_UNITTEST_CFLAGS} ${LIBFUZZER_TEST_RUNTIME_CFLAGS}
-    LINK_FLAGS ${LIBFUZZER_UNITTEST_LINK_FLAGS} ${LIBFUZZER_TEST_RUNTIME_LINK_FLAGS})
-  set_target_properties(FuzzerUnitTests PROPERTIES
-    RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
-endforeach()

test/fuzzer/CMakeLists.txt

 set(LIBFUZZER_TEST_DEPS ${SANITIZER_COMMON_LIT_TEST_DEPS})
-list(REMOVE_ITEM LIBFUZZER_TEST_DEPS SanitizerLintCheck)
 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(arch ${FUZZER_SUPPORTED_ARCH})
     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
       ${CMAKE_CURRENT_BINARY_DIR}/${CONFIG_NAME}/lit.site.cfg
       )
 
-    add_lit_testsuite(check-fuzzer-${stdlib_name} "Running Fuzzer ${stdlib} tests"
-      ${CMAKE_CURRENT_BINARY_DIR}/${CONFIG_NAME}
+    add_lit_testsuite(check-fuzzer-${stdlib_name}-${arch}
+      "Running Fuzzer ${stdlib} tests"
+      ${CMAKE_CURRENT_BINARY_DIR}/${CONFIG_NAME}/
       DEPENDS ${LIBFUZZER_TEST_DEPS})
     if(TEST_DEPS)
-      add_dependencies(check-fuzzer-${stdlib_name} ${TEST_DEPS})
+      add_dependencies(check-fuzzer-${stdlib_name}-${arch} ${TEST_DEPS})
     endif()
-    set_target_properties(check-fuzzer-${stdlib_name} PROPERTIES FOLDER "Compiler-RT Tests")
-    add_dependencies(check-fuzzer check-fuzzer-${stdlib_name})
+    set_target_properties(check-fuzzer-${stdlib_name}-${arch}
+        PROPERTIES FOLDER "Compiler-RT Tests")
+    add_dependencies(check-fuzzer check-fuzzer-${stdlib_name}-${arch})
   endforeach()
 endmacro()
 
 test_fuzzer("default")
 if("${CMAKE_SYSTEM_NAME}" STREQUAL "Linux")
   if(TARGET cxx_shared)
     test_fuzzer("libc++" DEPS cxx_shared)
   endif()
   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_TARGET_ARCH ${arch})
+    set(LIBFUZZER_TEST_TARGET_CFLAGS "-arch ${arch} -isysroot ${DARWIN_ios_SYSROOT} ${COMPILER_RT_TEST_COMPILER_CFLAGS}")
+    set(LIBFUZZER_TEST_CONFIG_SUFFIX "-${arch}-ios")
+    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/afl-driver-extra-stats.test

+XFAIL: ios
 RUN: %no_fuzzer_cpp_compiler -fno-sanitize-coverage=edge,trace-cmp,indirect-calls,8bit-counters,trace-pc-guard %S/AFLDriverTest.cpp %libfuzzer_src/afl/afl_driver.cpp -o %t-AFLDriverTest
 
 ; Test that not specifying an extra stats file isn't broken.
 RUN: unset AFL_DRIVER_EXTRA_STATS_FILENAME
 RUN: %run %t-AFLDriverTest
 
 ; Test that specifying an invalid extra stats file causes a crash.
 RUN: ASAN_OPTIONS= AFL_DRIVER_EXTRA_STATS_FILENAME=%T not --crash %t-AFLDriverTest

test/fuzzer/afl-driver-stderr.test

+XFAIL: ios
 UNSUPPORTED: freebsd
 RUN: %no_fuzzer_cpp_compiler -fno-sanitize-coverage=edge,trace-cmp,indirect-calls,8bit-counters,trace-pc-guard %S/AFLDriverTest.cpp %libfuzzer_src/afl/afl_driver.cpp -o %t-AFLDriverTest
 
 ; Test that not specifying a stderr file isn't broken.
 RUN: unset AFL_DRIVER_STDERR_DUPLICATE_FILENAME
 RUN: %run %t-AFLDriverTest
 
 ; Test that specifying an invalid file causes a crash.
 RUN: ASAN_OPTIONS= AFL_DRIVER_STDERR_DUPLICATE_FILENAME="%T" not --crash %run %t-AFLDriverTest
 
 ; Test that a file is created when specified as the duplicate stderr.
 RUN: AFL_DRIVER_STDERR_DUPLICATE_FILENAME=%t %run %t-AFLDriverTest
 RUN: stat %t

test/fuzzer/counters.test

+XFAIL: ios
 RUN: %cpp_compiler %S/CounterTest.cpp -o %t-CounterTest
 RUN: not %run %t-CounterTest  -max_len=6 -seed=1 -timeout=15 2>&1 | FileCheck %s --check-prefix=COUNTERS
 
 COUNTERS: INITED {{.*}} {{bits:|ft:}}
 COUNTERS: NEW {{.*}} {{bits:|ft:}} {{[1-9]*}}
 COUNTERS: NEW {{.*}} {{bits:|ft:}} {{[1-9]*}}
 COUNTERS: BINGO

test/fuzzer/dso.test

-RUN: %cpp_compiler %S/DSO1.cpp -fPIC -shared -o %t-DSO1.so
-RUN: %cpp_compiler %S/DSO2.cpp -fPIC -shared -o %t-DSO2.so
-RUN: %cpp_compiler %S/DSOTestMain.cpp %S/DSOTestExtra.cpp -L. %t-DSO1.so %t-DSO2.so -o %t-DSOTest
+RUN: %cpp_compiler %S/DSO1.cpp -fPIC -shared -o %dynamiclib1 %ld_flags_rpath_so1
+RUN: %cpp_compiler %S/DSO2.cpp -fPIC -shared -o %dynamiclib2 %ld_flags_rpath_so2
+RUN: %cpp_compiler %S/DSOTestMain.cpp %S/DSOTestExtra.cpp %ld_flags_rpath_exe1 %ld_flags_rpath_exe2 -o %t-DSOTest
 
 RUN: not %run %t-DSOTest 2>&1 | FileCheck %s --check-prefix=DSO
 DSO: INFO: Loaded 3 modules
 DSO: BINGO

test/fuzzer/dump_coverage.test

 UNSUPPORTED: freebsd
-RUN: %cpp_compiler -fsanitize-coverage=0 -fsanitize-coverage=trace-pc-guard %S/DSO1.cpp -fPIC -shared -o %t-DSO1.so
-RUN: %cpp_compiler -fsanitize-coverage=0 -fsanitize-coverage=trace-pc-guard %S/DSO2.cpp -fPIC -shared -o %t-DSO2.so
-RUN: %cpp_compiler -fsanitize-coverage=0 -fsanitize-coverage=trace-pc-guard %S/DSOTestMain.cpp %S/DSOTestExtra.cpp -L. %t-DSO1.so %t-DSO2.so -o %t-DSOTest
+RUN: %cpp_compiler -fsanitize-coverage=0 -fsanitize-coverage=trace-pc-guard %S/DSO1.cpp -fPIC -shared -o %dynamiclib1 %ld_flags_rpath_so1
+RUN: %cpp_compiler -fsanitize-coverage=0 -fsanitize-coverage=trace-pc-guard %S/DSO2.cpp -fPIC -shared -o %dynamiclib2 %ld_flags_rpath_so2
+RUN: %cpp_compiler -fsanitize-coverage=0 -fsanitize-coverage=trace-pc-guard %S/DSOTestMain.cpp %S/DSOTestExtra.cpp %ld_flags_rpath_exe1 %ld_flags_rpath_exe2 -o %t-DSOTest
 
 RUN: %cpp_compiler -fsanitize-coverage=0 -fsanitize-coverage=trace-pc-guard %S/NullDerefTest.cpp -o %t-NullDerefTest
 
 RUN: rm -rf %t_workdir && mkdir -p %t_workdir
 RUN: env ASAN_OPTIONS=coverage_dir='"%t_workdir"' not %run %t-NullDerefTest -dump_coverage=1 2>&1 | FileCheck %s
 RUN: sancov -covered-functions %t-NullDerefTest* %t_workdir/*.sancov | FileCheck %s --check-prefix=SANCOV
 RUN: env ASAN_OPTIONS=coverage_dir='"%t_workdir"' %run %t-DSOTest -dump_coverage=1 -runs=0 2>&1 | FileCheck %s --check-prefix=DSO
 RUN: env ASAN_OPTIONS=coverage_dir='"%t_workdir"' not %run %t-NullDerefTest -dump_coverage=0 2>&1 | FileCheck %s --check-prefix=NOCOV
 
 CHECK: SanitizerCoverage: {{.*}}NullDerefTest.{{.*}}.sancov: {{.*}} PCs written
 SANCOV: LLVMFuzzerTestOneInput
 
 DSO: SanitizerCoverage: {{.*}}DSOTest.{{.*}}.sancov: {{.*}} PCs written
-DSO-DAG: SanitizerCoverage: {{.*}}DSO1.{{.*}}.sancov: {{.*}} PCs written
-DSO-DAG: SanitizerCoverage: {{.*}}DSO2.{{.*}}.sancov: {{.*}} PCs written
+DSO-DAG: SanitizerCoverage: {{.*}}1.{{.*}}.sancov: {{.*}} PCs written
+DSO-DAG: SanitizerCoverage: {{.*}}2.{{.*}}.sancov: {{.*}} PCs written
 
 NOCOV-NOT: SanitizerCoverage: {{.*}} PCs written

test/fuzzer/fuzzer-fdmask.test

 RUN: %cpp_compiler %S/SpamyTest.cpp -o %t-SpamyTest
 
 RUN: %run %t-SpamyTest -runs=1                  2>&1 | FileCheck %s --check-prefix=FD_MASK_0
 RUN: %run %t-SpamyTest -runs=1 -close_fd_mask=0 2>&1 | FileCheck %s --check-prefix=FD_MASK_0
 RUN: %run %t-SpamyTest -runs=1 -close_fd_mask=1 2>&1 | FileCheck %s --check-prefix=FD_MASK_1
 RUN: %run %t-SpamyTest -runs=1 -close_fd_mask=2 2>&1 | FileCheck %s --check-prefix=FD_MASK_2
 RUN: %run %t-SpamyTest -runs=1 -close_fd_mask=3 2>&1 | FileCheck %s --check-prefix=FD_MASK_3
 
-FD_MASK_0: PRINTF_STDOUT
-FD_MASK_0: PRINTF_STDERR
-FD_MASK_0: STREAM_COUT
-FD_MASK_0: STREAM_CERR
-FD_MASK_0: INITED
+FD_MASK_0-DAG: PRINTF_STDOUT
+FD_MASK_0-DAG: PRINTF_STDERR
+FD_MASK_0-DAG: STREAM_COUT
+FD_MASK_0-DAG: STREAM_CERR
+FD_MASK_0-DAG: INITED
 
 FD_MASK_1-NOT: PRINTF_STDOUT
-FD_MASK_1: PRINTF_STDERR
+FD_MASK_1-DAG: PRINTF_STDERR
 FD_MASK_1-NOT: STREAM_COUT
-FD_MASK_1: STREAM_CERR
-FD_MASK_1: INITED
+FD_MASK_1-DAG: STREAM_CERR
+FD_MASK_1-DAG: INITED
 
-FD_MASK_2: PRINTF_STDOUT
+FD_MASK_2-DAG: PRINTF_STDOUT
+FD_MASK_2-DAG: STREAM_COUT
+FD_MASK_2-DAG: INITED
 FD_MASK_2-NOT: PRINTF_STDERR
-FD_MASK_2: STREAM_COUT
-FD_MASK_2-NOTE: STREAM_CERR
-FD_MASK_2: INITED
+FD_MASK_2-NOT: STREAM_CERR
 
 FD_MASK_3-NOT: PRINTF_STDOUT
 FD_MASK_3-NOT: PRINTF_STDERR
 FD_MASK_3-NOT: STREAM_COUT
 FD_MASK_3-NOT: STREAM_CERR
 FD_MASK_3: INITED
 

test/fuzzer/fuzzer-printcovpcs.test

+XFAIL: ios
 RUN: %cpp_compiler %S/SimpleTest.cpp -o %t-SimpleTest
 RUN: not %run %t-SimpleTest -print_pcs=1 -seed=1 2>&1 | FileCheck %s --check-prefix=PCS
 PCS-NOT: NEW_PC
 PCS:INITED
 PCS:NEW_PC: {{0x[a-f0-9]+}}
 PCS:NEW_PC: {{0x[a-f0-9]+}}
 PCS:NEW
 PCS:BINGO
 

test/fuzzer/lit.cfg

 import lit.formats
 import sys
 import os
 
-config.name = "LLVMFuzzer"
+config.name = "libFuzzer" + config.name_suffix
 config.test_format = lit.formats.ShTest(True)
 config.suffixes = ['.test']
 config.test_source_root = os.path.dirname(__file__)
 
 # 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:
if sys.platform.startswith('linux'):
   # between python 2 and 3, hence the use of ``.startswith()``.
   lit_config.note('linux feature available')
   config.available_features.add('linux')
 else:
   lit_config.note('linux feature unavailable')
 
 config.substitutions.append(('%build_dir', config.cmake_binary_dir))
 libfuzzer_src_root = os.path.join(config.compiler_rt_src_root, "lib", "fuzzer")
+include_root = os.path.join(config.compiler_rt_src_root, "include")
 config.substitutions.append(('%libfuzzer_src', libfuzzer_src_root))
 
 def generate_compiler_cmd(is_cpp=True, fuzzer_enabled=True):
-  compiler_cmd = config.c_compiler
+  compiler_cmd = config.clang
+  extra_cmd = config.target_cflags
   if config.clang and config.stdlib == 'libc++':
-    link_cmd = '-stdlib=libc++ -Wl,-rpath=%s' % config.llvm_library_dir
+    lib_cmd = '-stdlib=libc++ -Wl,-rpath=%s' % config.llvm_library_dir
   elif config.clang and config.stdlib == 'static-libc++':
-    link_cmd = '-stdlib=libc++ -lc++abi -static-libstdc++ -Wl,-rpath=%s' % config.llvm_library_dir
+    lib_cmd = '-stdlib=libc++ -lc++abi -static-libstdc++ -Wl,-rpath=%s' % (
+        config.llvm_library_dir)
+  elif any(x in config.target_triple for x in ('darwin', 'freebsd')):
+    lib_cmd = '-lc++'
   else:
-    link_cmd = '-lc++' if any(x in config.target_triple for x in ('darwin', 'freebsd')) else '-lstdc++'
+    lib_cmd = '-lstdc++'
+
   std_cmd = '--driver-mode=g++ -std=c++11' if is_cpp else ''
-  sanitizers = ['address']
+  sanitizers_cmd = ['address']
   if fuzzer_enabled:
-    sanitizers.append('fuzzer')
-  sanitizers_cmd = ('-fsanitize=%s' % ','.join(sanitizers))
-  isysroot_cmd = config.osx_sysroot_flag if config.osx_sysroot_flag else ''
-  include_cmd = '-I%s' % libfuzzer_src_root
-  return '%s %s %s -O2 -gline-tables-only %s %s %s' % (
-      compiler_cmd, std_cmd, link_cmd, isysroot_cmd, sanitizers_cmd, include_cmd)
+    sanitizers_cmd.append('fuzzer')
+  sanitizers_cmd = ('-fsanitize=%s' % ','.join(sanitizers_cmd))
+  if config.osx_sysroot_flag and not 'isysroot' in extra_cmd:
+    isysroot_cmd = config.osx_sysroot_flag
+  else:
+    isysroot_cmd = ''
+  return " ".join([
+    compiler_cmd,
+    std_cmd,
+    lib_cmd,
+    "-O2 -gline-tables-only",
+    isysroot_cmd,
+    sanitizers_cmd,
+    "-I%s" % libfuzzer_src_root,
+    "-I%s" % include_root,
+    extra_cmd
+  ])
 
 config.substitutions.append(('%cpp_compiler',
       generate_compiler_cmd(is_cpp=True, fuzzer_enabled=True)
       ))
 
 config.substitutions.append(('%c_compiler',
       generate_compiler_cmd(is_cpp=False, fuzzer_enabled=True)
       ))
 
 config.substitutions.append(('%no_fuzzer_cpp_compiler',
       generate_compiler_cmd(is_cpp=True, fuzzer_enabled=False)
       ))
 
 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:
+    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.target_cflags = "@LIBFUZZER_TEST_TARGET_CFLAGS@"
+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/fuzzer/merge-posix.test

+XFAIL: ios
 RUN: %cpp_compiler %S/FullCoverageSetTest.cpp -o %t-FullCoverageSetTest
 
 RUN: rm -rf  %tmp/T1 %tmp/T2
 RUN: mkdir -p %tmp/T1 %tmp/T2
 
 RUN: echo F..... > %tmp/T1/1
 RUN: echo .U.... > %tmp/T1/2
 RUN: echo ..Z... > %tmp/T1/3

test/fuzzer/merge-sigusr.test

 # Check that libFuzzer honors SIGUSR1/SIGUSR2
+XFAIL: ios
 RUN: rm -rf %t
 RUN: mkdir -p %t
 RUN: %cpp_compiler %S/SleepOneSecondTest.cpp -o %t/LFSIGUSR
 
 RUN: mkdir -p %t/C1 %t/C2
 RUN: echo a > %t/C2/a
 RUN: echo b > %t/C2/b
 RUN: echo c > %t/C2/c

test/fuzzer/merge.test

+XFAIL: ios
 CHECK: BINGO
 
 RUN: %cpp_compiler %S/FullCoverageSetTest.cpp -o %t-FullCoverageSetTest
 
 RUN: rm -rf %t/T0 %t/T1 %t/T2
 RUN: mkdir -p %t/T0 %t/T1 %t/T2
 RUN: echo F..... > %t/T0/1
 RUN: echo .U.... > %t/T0/2

test/fuzzer/minimize_crash.test

 RUN: %cpp_compiler %S/NullDerefTest.cpp -o %t-NullDerefTest
 RUN: %cpp_compiler %S/SingleByteInputTest.cpp -o %t-SingleByteInputTest
+RUN: mkdir -p %t.dir
 
-RUN: echo 'Hi!rv349f34t3gg' > not_minimal_crash
-RUN: %run %t-NullDerefTest -minimize_crash=1 not_minimal_crash -max_total_time=2 2>&1 | FileCheck %s
-CHECK: CRASH_MIN: failed to minimize beyond ./minimized-from-{{.*}} (3 bytes), exiting
-RUN: %run %t-NullDerefTest -minimize_crash=1 not_minimal_crash -max_total_time=2 -exact_artifact_path=exact_minimized_path 2>&1 | FileCheck %s --check-prefix=CHECK_EXACT
-CHECK_EXACT: CRASH_MIN: failed to minimize beyond exact_minimized_path (3 bytes), exiting
-RUN: rm not_minimal_crash minimized-from-* exact_minimized_path
+RUN: echo 'Hi!rv349f34t3gg' > %t.dir/not_minimal_crash
+RUN: %run %t-NullDerefTest -minimize_crash=1 %t.dir/not_minimal_crash -max_total_time=2 2>&1 | FileCheck %s
+CHECK: CRASH_MIN: failed to minimize beyond {{.*}} (3 bytes), exiting
+RUN: %run %t-NullDerefTest -minimize_crash=1 %t.dir/not_minimal_crash -max_total_time=2 -exact_artifact_path=%t.exact_minimized_path 2>&1 | FileCheck %s --check-prefix=CHECK_EXACT
+CHECK_EXACT: CRASH_MIN: failed to minimize beyond {{.*}} (3 bytes), exiting
+RUN: rm %t.dir/not_minimal_crash %t.exact_minimized_path
 
-RUN: echo -n 'abcd*xyz' > not_minimal_crash
-RUN: %run %t-SingleByteInputTest -minimize_crash=1 not_minimal_crash -exact_artifact_path=exact_minimized_path 2>&1 | FileCheck %s --check-prefix=MIN1
-MIN1: Test unit written to exact_minimized_path
-MIN1: Test unit written to exact_minimized_path
+RUN: echo -n 'abcd*xyz' > %t.dir/not_minimal_crash
+RUN: %run %t-SingleByteInputTest -minimize_crash=1 %t.dir/not_minimal_crash -exact_artifact_path=%t.exact_minimized_path 2>&1 | FileCheck %s --check-prefix=MIN1
+MIN1: Test unit written to {{.*}}
+MIN1: Test unit written to {{.*}}
 MIN1: INFO: The input is small enough, exiting
-MIN1: CRASH_MIN: failed to minimize beyond exact_minimized_path (1 bytes), exiting
+MIN1: CRASH_MIN: failed to minimize beyond {{.*}} (1 bytes), exiting

test/fuzzer/value-profile-div.test

+XFAIL: ios
 CHECK: AddressSanitizer: {{FPE|int-divide-by-zero}}
 RUN: %cpp_compiler %S/DivTest.cpp -fsanitize-coverage=trace-div -o %t-DivTest
 RUN: not %run %t-DivTest -seed=1 -use_value_profile=1 -runs=10000000 2>&1 | FileCheck %s