Add cmake build support for lsan on OS X

[fjricci]

Summary

Adds a new cmake flag 'COMPILER_RT_ENABLE_LSAN_OSX', which enables lsan
compilation and is turned off by default. Patches to fix build errors
when this flag is enabled will be uploaded soon.

This is part of an effort to port LSan to OS X, but LSan on OS X does not
currently work or pass tests currently.

[kubamracek]

cmake/config-ix.cmake

167–171

Why exactly do we need this change? Will the 32-bit x86 slice fail to build?

lib/lsan/CMakeLists.txt

19–21

How about we just unconditionally propagate CAN_SANITIZE_LEAKS (no _MAC) and remove that ugly ifdef in lsan_common.h?

Doesn't this also need to go to lib/asan/CMakeLists.txt?

[fjricci]

cmake/config-ix.cmake

167–171

Yeah, __thread is only supported on 64-bit darwin targets.

lib/lsan/CMakeLists.txt

19–21

Well, the issue with that is that we build LSanCommon for 32-bit architectures (since asan builds for 32-bit), so we still need the architecture check in lsan_common.h to make sure that it's an empty stub if we're building for 32-bit.

This doesn't need to go into lib/asan/CMakeLists.txt because that just pulls in RTLSanCommon, not the individual sources, and RTLsanCommon will already have the flag.

[kubamracek]

cmake/config-ix.cmake

167–171

Are you sure?

$ uname
Darwin
$ echo "__thread int hello; int main() { hello = 42; }" | clang -x c -arch i386 -
$ ./a.out
$ # works fine

lib/lsan/CMakeLists.txt

19–21

Ok, can we add a FIXME comment here saying that this will be removed once LSan is fully working on Darwin?

Right, the LSan sources will always have CAN_SANITIZE_LEAKS_MAC. But ASan does include headers from lsan/, and I don't see how they have have CAN_SANITIZE_LEAKS_MAC. Can you verify that ASan files have are able to see CAN_SANITIZE_LEAKS == 1?

[fjricci]

cmake/config-ix.cmake

167–171

$ echo "__thread int hello; int main() { hello = 42; }" | clang -x c -arch i386 -miphoneos-version-min=8.0 -
<stdin>:1:1: error: thread-local storage is not supported for the current target
__thread int hello; int main() { hello = 42; }
^

It looks like i386 support isn't added until -miphoneos-version-min=9.0, and I'm not sure that we want to bump the version that high.

lib/lsan/CMakeLists.txt

19–21

Ahh I see. You're right, it's not propogated to the asan sources.

[fjricci]

Add CAN_SANITIZE_LEAKS_MAC workaround to asan sources

[kubamracek]

cmake/config-ix.cmake

167–171

Okay, please add a comment explaining this.

[fjricci]

Add comment explaining 32-bit thread local support on ios

[kubamracek]

LGTM.

Could the __thread on 32-bit iOS be solved with the same trick as D29786? No need to do it now, though.

[fjricci]

I'll look into that going forward. My main hesitation would be adding complexity and perhaps a performance hit from using pthreads.

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})
+if(APPLE)
+  set(ALL_LSAN_SUPPORTED_ARCH ${X86_64} ${ARM64})
+else()
   set(ALL_LSAN_SUPPORTED_ARCH ${X86} ${X86_64} ${MIPS64} ${ARM64})
+endif()
 set(ALL_MSAN_SUPPORTED_ARCH ${X86_64} ${MIPS64} ${ARM64} ${PPC64})
 set(ALL_PROFILE_SUPPORTED_ARCH ${X86} ${X86_64} ${ARM32} ${ARM64} ${PPC64}
     ${MIPS32} ${MIPS64} ${S390X})
 set(ALL_TSAN_SUPPORTED_ARCH ${X86_64} ${MIPS64} ${ARM64} ${PPC64})
 set(ALL_UBSAN_SUPPORTED_ARCH ${X86} ${X86_64} ${ARM32} ${ARM64}
     ${MIPS32} ${MIPS64} ${PPC64} ${S390X})
 set(ALL_SAFESTACK_SUPPORTED_ARCH ${X86} ${X86_64} ${ARM64} ${MIPS32} ${MIPS64})
 set(ALL_CFI_SUPPORTED_ARCH ${X86} ${X86_64} ${MIPS64})

 
 if (COMPILER_RT_HAS_SANITIZER_COMMON AND LSAN_SUPPORTED_ARCH AND
     OS_NAME MATCHES "Linux|FreeBSD")
   set(COMPILER_RT_HAS_LSAN TRUE)
 else()
   set(COMPILER_RT_HAS_LSAN FALSE)
 endif()
 
+if(APPLE)
+  option(COMPILER_RT_ENABLE_LSAN_OSX "Enable building LSan for OS X - Experimental" Off)
+  if(COMPILER_RT_ENABLE_LSAN_OSX)
+    set(COMPILER_RT_HAS_LSAN TRUE)
+  endif()
+endif()
+
 if (COMPILER_RT_HAS_SANITIZER_COMMON AND MSAN_SUPPORTED_ARCH AND
     OS_NAME MATCHES "Linux")
   set(COMPILER_RT_HAS_MSAN TRUE)
 else()
   set(COMPILER_RT_HAS_MSAN FALSE)
 endif()
 
 if (PROFILE_SUPPORTED_ARCH AND NOT LLVM_USE_SANITIZER AND

lib/asan/CMakeLists.txt

add_compiler_rt_object_libraries(RTAsan_dynamic_version_script_dummy
     DEFS ${ASAN_DYNAMIC_DEFINITIONS})
 endif()
 
 # Build ASan runtimes shipped with Clang.
 add_compiler_rt_component(asan)
 
 if(APPLE)
   add_weak_symbols("asan" WEAK_SYMBOL_LINK_FLAGS)
+  add_weak_symbols("lsan" WEAK_SYMBOL_LINK_FLAGS)
   add_weak_symbols("ubsan" WEAK_SYMBOL_LINK_FLAGS)
   add_weak_symbols("sanitizer_common" WEAK_SYMBOL_LINK_FLAGS)
 
   add_compiler_rt_runtime(clang_rt.asan
     SHARED
     OS ${SANITIZER_COMMON_SUPPORTED_OS}
     ARCHS ${ASAN_SUPPORTED_ARCH}
     OBJECT_LIBS RTAsan_dynamic

lib/lsan/CMakeLists.txt

set(LSAN_SOURCES
   lsan.cc
   lsan_allocator.cc
   lsan_interceptors.cc
   lsan_preinit.cc
   lsan_thread.cc)
 
 set(LSAN_SRC_DIR ${CMAKE_CURRENT_SOURCE_DIR})
 
+if(APPLE AND COMPILER_RT_HAS_LSAN)
+  set(LSAN_CFLAGS ${LSAN_CFLAGS} -DCAN_SANITIZE_LEAKS_MAC=1)
+endif()
 add_compiler_rt_object_libraries(RTLSanCommon
     OS ${SANITIZER_COMMON_SUPPORTED_OS}
     ARCHS ${LSAN_COMMON_SUPPORTED_ARCH}
     SOURCES ${LSAN_COMMON_SOURCES}
     CFLAGS ${LSAN_CFLAGS})
 
 if(COMPILER_RT_HAS_LSAN)
   add_compiler_rt_component(lsan)
+  if(APPLE)
+    add_weak_symbols("lsan" WEAK_SYMBOL_LINK_FLAGS)
+    add_weak_symbols("sanitizer_common" WEAK_SYMBOL_LINK_FLAGS)
+
+    add_compiler_rt_runtime(clang_rt.lsan
+      SHARED
+      OS ${SANITIZER_COMMON_SUPPORTED_OS}
+      ARCHS ${LSAN_SUPPORTED_ARCH}
+      SOURCES ${LSAN_SOURCES}
+      OBJECT_LIBS RTLSanCommon
+                  RTInterception
+                  RTSanitizerCommon
+                  RTSanitizerCommonLibc
+      CFLAGS ${LSAN_CFLAGS}
+      LINK_FLAGS ${WEAK_SYMBOL_LINK_FLAGS}
+      PARENT_TARGET lsan)
+  else()
     foreach(arch ${LSAN_SUPPORTED_ARCH})
       add_compiler_rt_runtime(clang_rt.lsan
         STATIC
         ARCHS ${arch}
         SOURCES ${LSAN_SOURCES}
                 $<TARGET_OBJECTS:RTInterception.${arch}>
                 $<TARGET_OBJECTS:RTSanitizerCommon.${arch}>
                 $<TARGET_OBJECTS:RTSanitizerCommonLibc.${arch}>
                 $<TARGET_OBJECTS:RTLSanCommon.${arch}>
         CFLAGS ${LSAN_CFLAGS}
         PARENT_TARGET lsan)
     endforeach()
   endif()
+endif()

lib/lsan/lsan_common.h

 // LeakSanitizer relies on some Glibc's internals (e.g. TLS machinery) thus
 // supported for Linux only. Also, LSan doesn't like 32 bit architectures
 // because of "small" (4 bytes) pointer size that leads to high false negative
 // ratio on large leaks. But we still want to have it for some 32 bit arches
 // (e.g. x86), see https://github.com/google/sanitizers/issues/403.
 // To enable LeakSanitizer on new architecture, one need to implement
 // internal_clone function as well as (probably) adjust TLS machinery for
 // new architecture inside sanitizer library.
-#if (SANITIZER_LINUX && !SANITIZER_ANDROID) && (SANITIZER_WORDSIZE == 64) \
-     && (defined(__x86_64__) ||  defined(__mips64) ||  defined(__aarch64__))
+#if (SANITIZER_LINUX && !SANITIZER_ANDROID || CAN_SANITIZE_LEAKS_MAC) \
+     && (SANITIZER_WORDSIZE == 64) && (defined(__x86_64__) \
+     ||  defined(__mips64) ||  defined(__aarch64__))
 #define CAN_SANITIZE_LEAKS 1
 #elif SANITIZER_LINUX && !SANITIZER_ANDROID && defined(__i386__)
 #define CAN_SANITIZE_LEAKS 1
 #else
 #define CAN_SANITIZE_LEAKS 0
 #endif
 
 namespace __sanitizer {

lib/lsan/weak_symbols.txt

+___lsan_default_suppressions
+___lsan_is_turned_off