[CMake] Fix building unit tests on Darwin

[beanz]

Summary

There are a number of issues with unit tests on Darwin. These patches address the following:

• Unit tests should be passed -arch (-m32/-m64 isn't sufficient)
• Unit tests should be passed ${DARWIN_osx_CFLAGS} because they're being built for OS X
• Test architectures should be filtered based on base system capabilities (i.e. don't try running x86_64h tests on pre-haswell hardware).

[filcab]

Thanks a lot!

cmake/Modules/CompilerRTDarwinUtils.cmake

83 ↗

(On Diff #32632)

Since this function is Darwin-specific, maybe we want to add the darwin_ prefix, to avoid name clashes.

test/asan/CMakeLists.txt

49 ↗

(On Diff #32632)

Could this be done in get_target_flags_for_arch?

test/sanitizer_common/CMakeLists.txt

38 ↗

(On Diff #32632)

Same as for test/asan/CMakeLists.txt.

[beanz]

I'll send updated patches shortly. I'm testing them now.

cmake/Modules/CompilerRTDarwinUtils.cmake

83 ↗

(On Diff #32632)

Sure.

test/asan/CMakeLists.txt

49 ↗

(On Diff #32632)

Looking at this it does seem like get_target_flags_for_arch is only used when building tests, so yes. I originally didn't want to do that because I was populating Darwin OS-specific flags, not arch-specific flags.

[beanz]

Fixing patches based on filcab's feedback.

[beanz]

Marking as accepted per bogner's email on llvm-commits. I will address his nit and commit shortly.

[filcab]

It seems you left some conditions on the if that shouldn't be there. At least for now (when OS X is the only OS where we run unit tests).

cmake/config-ix.cmake

245 ↗

(On Diff #32643)

Should we add the DARWIN_osx_CFLAGS here too, for now? That would minimize the number of places where you have to add Apple-specific conditions.
Eventually we might want to also run the tests for iOS, but for now, if you're on APPLE, then you know you're compiling for OS X. Might as well just add all the flags now.

lib/asan/tests/CMakeLists.txt

120 ↗

(On Diff #32643)

Didn't you already add -arch ${arch} in get_target_flags_for_arch?

test/asan/CMakeLists.txt

45 ↗

(On Diff #32643)

Why the NOT APPLE? Shouldn't you do the same for APPLE too?

test/sanitizer_common/CMakeLists.txt

34 ↗

(On Diff #32643)

Same as test/asan/CMakeLists.txt.

[beanz]

filcab,

I've just committed r245582 to adapt to this feedback. Let me know if there are other concerns.

Thanks,
-Chris

cmake/config-ix.cmake

245 ↗

(On Diff #32643)

For building tests DARWIN_osx_CFLAGS isn't needed, so I was trying to avoid more platform-specific hacking. Not really sure what this is going to look like yet once we fix it.

lib/asan/tests/CMakeLists.txt

120 ↗

(On Diff #32643)

I think I can actually remove this whole block. I just missed it.

test/asan/CMakeLists.txt

45 ↗

(On Diff #32643)

Yep, this is just another part of the patches I missed cleaning up. Will fix.

compiler-rt/trunk/cmake/Modules/CompilerRTDarwinUtils.cmake

try_compile(CAN_TARGET_${os}_${arch} ${CMAKE_BINARY_DIR} ${SIMPLE_CPP}
                 CMAKE_FLAGS "-DCMAKE_EXE_LINKER_FLAGS=${arch_linker_flags}"
                 OUTPUT_VARIABLE TEST_OUTPUT)
     if(${CAN_TARGET_${os}_${arch}})
       list(APPEND working_archs ${arch})
     endif()
   endforeach()
   set(${valid_archs} ${working_archs} PARENT_SCOPE)
 endfunction()
+
+# This function checks the host cpusubtype to see if it is post-haswell. Haswell
+# and later machines can run x86_64h binaries. Haswell is cpusubtype 8.
+function(darwin_filter_host_archs input output)
+  list_union(tmp_var DARWIN_osx_ARCHS ${input})
+  execute_process(
+    COMMAND sysctl hw.cpusubtype
+    OUTPUT_VARIABLE SUBTYPE)
+
+  string(REGEX MATCH "hw.cpusubtype: ([0-9]*)"
+         SUBTYPE_MATCHED "${SUBTYPE}")
+  set(HASWELL_SUPPORTED Off)
+  if(ARCHES_MATCHED)
+    if(CMAKE_MATCH_1 GREATER_OR_EQUAL_TO 8)
+      set(HASWELL_SUPPORTED On)
+    endif()
+  endif()
+  if(NOT HASWELL_SUPPORTED)
+    list(REMOVE_ITEM tmp_var x86_64h)
+  endif()
+  set(${output} ${tmp_var} PARENT_SCOPE)
+endfunction()

compiler-rt/trunk/cmake/config-ix.cmake

 endfunction()
 
 # Returns a list of architecture specific target cflags in @out_var list.
 function(get_target_flags_for_arch arch out_var)
   list(FIND COMPILER_RT_SUPPORTED_ARCH ${arch} ARCH_INDEX)
   if(ARCH_INDEX EQUAL -1)
     message(FATAL_ERROR "Unsupported architecture: ${arch}")
   else()
+    if (NOT APPLE)
       set(${out_var} ${TARGET_${arch}_CFLAGS} PARENT_SCOPE)
+    else()
+      # This is only called in constructing cflags for tests executing on the
+      # host. This will need to all be cleaned up to support building tests
+      # for cross-targeted hardware (i.e. iOS).
+      set(${out_var} -arch ${arch} PARENT_SCOPE)
+    endif()
   endif()
 endfunction()
 
 set(ARM64 aarch64)
 set(ARM32 arm)
 set(X86_64 x86_64)
 if(APPLE)
   set(ARM64 arm64)

compiler-rt/trunk/lib/asan/tests/CMakeLists.txt

 append_list_if(ANDROID atomic ASAN_UNITTEST_NOINST_LIBS)
 
 # Compile source for the given architecture, using compiler
 # options in ${ARGN}, and add it to the object list.
 macro(asan_compile obj_list source arch kind)
   get_filename_component(basename ${source} NAME)
   set(output_obj "${obj_list}.${basename}.${arch}${kind}.o")
   get_target_flags_for_arch(${arch} TARGET_CFLAGS)
+  if(APPLE)
+    set(TARGET_CFLAGS ${DARWIN_osx_CFLAGS} -arch ${arch})
+  endif()
   set(COMPILE_DEPS ${ASAN_UNITTEST_HEADERS} ${ASAN_BLACKLIST_FILE})
   if(NOT COMPILER_RT_STANDALONE_BUILD)
     list(APPEND COMPILE_DEPS gtest asan)
   endif()
   clang_compile(${output_obj} ${source}
                 CFLAGS ${ARGN} ${TARGET_CFLAGS}
                 DEPS ${COMPILE_DEPS})
   list(APPEND ${obj_list} ${output_obj})
macro(add_asan_tests_for_arch_and_kind arch kind)
   endforeach()
   add_asan_test(AsanBenchmarks "Asan-${arch}${kind}-Benchmark"
                 ${arch} ${kind} SUBDIR "default"
                 OBJECTS ${ASAN_BENCHMARKS_OBJECTS}
                 LINKFLAGS ${ASAN_UNITTEST_INSTRUMENTED_LINKFLAGS})
 endmacro()
 
 if(COMPILER_RT_CAN_EXECUTE_TESTS AND NOT ANDROID)
-  foreach(arch ${ASAN_SUPPORTED_ARCH})
+  set(ASAN_TEST_ARCH ${ASAN_SUPPORTED_ARCH})
+  if(APPLE)
+    darwin_filter_host_archs(ASAN_SUPPORTED_ARCH ASAN_TEST_ARCH)
+  endif()
+  foreach(arch ${ASAN_TEST_ARCH})
     add_asan_tests_for_arch_and_kind(${arch} "-inline")
     add_asan_tests_for_arch_and_kind(${arch} "-with-calls"
       -mllvm -asan-instrumentation-with-call-threshold=0)
   endforeach()
 endif()
 
 if(ANDROID)
   foreach(arch ${ASAN_SUPPORTED_ARCH})

compiler-rt/trunk/lib/sanitizer_common/tests/CMakeLists.txt

 include(CompilerRTCompile)
 
 clang_compiler_add_cxx_check()
 
 # FIXME: use SANITIZER_COMMON_SUPPORTED_ARCH here
 filter_available_targets(SANITIZER_UNITTEST_SUPPORTED_ARCH x86_64 i386 mips64 mips64el)
+if(APPLE)
+  darwin_filter_host_archs(SANITIZER_UNITTEST_SUPPORTED_ARCH SANITIZER_COMMON_SUPPORTED_ARCH)
+endif()
 
 set(SANITIZER_UNITTESTS
   sanitizer_allocator_test.cc
   sanitizer_atomic_test.cc
   sanitizer_bitvector_test.cc
   sanitizer_bvgraph_test.cc
   sanitizer_common_test.cc
   sanitizer_deadlock_detector_test.cc

compiler-rt/trunk/test/asan/CMakeLists.txt

if(NOT COMPILER_RT_STANDALONE_BUILD)
   if(WIN32 AND COMPILER_RT_HAS_LLD_SOURCES)
     list(APPEND ASAN_TEST_DEPS
       lld
     )
   endif()
 endif()
 set(ASAN_DYNAMIC_TEST_DEPS ${ASAN_TEST_DEPS})
 
-foreach(arch ${ASAN_SUPPORTED_ARCH})
+set(ASAN_TEST_ARCH ${ASAN_SUPPORTED_ARCH})
+if(APPLE)
+  darwin_filter_host_archs(ASAN_SUPPORTED_ARCH ASAN_TEST_ARCH)
+endif()
+
+foreach(arch ${ASAN_TEST_ARCH})
   if(ANDROID)
     set(ASAN_TEST_TARGET_ARCH ${arch}-android)
   else()
     set(ASAN_TEST_TARGET_ARCH ${arch})
   endif()
   string(TOLOWER "-${arch}-${OS_NAME}" ASAN_TEST_CONFIG_SUFFIX)
   get_bits_for_arch(${arch} ASAN_TEST_BITS)
   if(ANDROID OR ${arch} MATCHES "arm|aarch64")
     # This is only true if we are cross-compiling.
     # Build all tests with host compiler and use host tools.
     set(ASAN_TEST_TARGET_CC ${COMPILER_RT_TEST_COMPILER})
     set(ASAN_TEST_TARGET_CFLAGS ${COMPILER_RT_TEST_COMPILER_CFLAGS})
-  else()
+  elseif(NOT APPLE)
     get_target_flags_for_arch(${arch} ASAN_TEST_TARGET_CFLAGS)
     string(REPLACE ";" " " ASAN_TEST_TARGET_CFLAGS "${ASAN_TEST_TARGET_CFLAGS}")
   endif()
   if(ANDROID)
     set(ASAN_TEST_DYNAMIC True)
   else()
     set(ASAN_TEST_DYNAMIC False)
   endif()

compiler-rt/trunk/test/sanitizer_common/CMakeLists.txt

 endif()
 
 # Create a separate config for each tool we support.
 foreach(tool ${SUPPORTED_TOOLS})
   string(TOUPPER ${tool} tool_toupper)
   if(${tool_toupper}_SUPPORTED_ARCH AND NOT COMPILER_RT_STANDALONE_BUILD)
     list(APPEND SANITIZER_COMMON_TEST_DEPS ${tool})
   endif()
-  foreach(arch ${${tool_toupper}_SUPPORTED_ARCH})
+  set(TEST_ARCH ${${tool_toupper}_SUPPORTED_ARCH})
+  if(APPLE)
+    darwin_filter_host_archs(${tool_toupper}_SUPPORTED_ARCH TEST_ARCH)
+  endif()
+
+  foreach(arch ${TEST_ARCH})
     set(SANITIZER_COMMON_LIT_TEST_MODE ${tool})
     set(SANITIZER_COMMON_TEST_TARGET_ARCH ${arch})
     if(${arch} MATCHES "arm|aarch64")
       # This is only true if we're cross-compiling.
       set(SANITIZER_COMMON_TEST_TARGET_CFLAGS
           ${COMPILER_RT_TEST_COMPILER_CFLAGS})
-    else()
+    elseif(NOT APPLE)
       get_target_flags_for_arch(${arch} SANITIZER_COMMON_TEST_TARGET_CFLAGS)
       string(REPLACE ";" " " SANITIZER_COMMON_TEST_TARGET_CFLAGS "${SANITIZER_COMMON_TEST_TARGET_CFLAGS}")
     endif()
     set(CONFIG_NAME ${tool}-${arch}-${OS_NAME})
     configure_lit_site_cfg(
       ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.in
       ${CMAKE_CURRENT_BINARY_DIR}/${CONFIG_NAME}/lit.site.cfg)
     list(APPEND SANITIZER_COMMON_TESTSUITES