Enable i386 builds for darwin lsan

[fjricci]

Summary

Now that __thread is no longer used for lsan on darwin, i386 builds
can be enabled.

[fjricci]

Fix syntax error

[kubamracek]

Don't we still need to only build this when the CMake option is set? Or are you saying that there are no more build failures? Are the tests still disabled by default on Darwin?

[fjricci]

This still does only build if CAN_SANITIZE_LEAKS_MAC is enabled, I just moved it to a new line for clarity. There aren't any build errors, given the two dependent pthreads patches, but the test suite will still fail if it's enabled by default.

[kubamracek]

Ah, I didn't notice this relies on the other patch (I though it's a standalone patch).

Right. Once we get this to build cleanly, let's turn the CMake switch to "On" and disable running the tests. That will make sure other patches won't break the build.

[fjricci]

Update comment

[fjricci]

Now that the allocator patch is in, this should be good to go. I'll upload the patch to enable builds (but not tests) by default separately.

[kubamracek]

LGTM, assuming this builds everywhere and the tests either pass or they're not run in "check-all"

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})
-
-# Darwin does not support 32-bit thread-local storage on ios versions
-# below 9.0. Until the min ios version is bumped to 9.0, lsan will
-# not build for 32-bit darwin targets.
-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})

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 || CAN_SANITIZE_LEAKS_MAC) \
-     && (SANITIZER_WORDSIZE == 64) && (defined(__x86_64__) \
-     ||  defined(__mips64) ||  defined(__aarch64__))
+#if (SANITIZER_LINUX && !SANITIZER_ANDROID) && (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
+#elif CAN_SANITIZE_LEAKS_MAC && (defined(__x86_64__) ||  defined(__mips64) || \
+      defined(__aarch64__) || defined(__i386__))
+#define CAN_SANITIZE_LEAKS 1
 #else
 #define CAN_SANITIZE_LEAKS 0
 #endif
 
 namespace __sanitizer {
 class FlagParser;
 struct DTLS;
 }

lib/sanitizer_common/sanitizer_stoptheworld_mac.cc

 //===-- sanitizer_stoptheworld_mac.cc -------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // See sanitizer_stoptheworld.h for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "sanitizer_platform.h"
 
-#if SANITIZER_MAC && (defined(__x86_64__) || defined(__aarch64__))
+#if SANITIZER_MAC && (defined(__x86_64__) || defined(__aarch64__) || \
+                      defined(__mips64) || defined(__i386))
 
 #include "sanitizer_stoptheworld.h"
 
 namespace __sanitizer {
 void StopTheWorld(StopTheWorldCallback callback, void *argument) {
   CHECK(0 && "unimplemented");
 }
 
 int SuspendedThreadsList::GetRegistersAndSP(uptr index,
                                             uptr *buffer,
                                             uptr *sp) const {
   CHECK(0 && "unimplemented");
   return 0;
 }
 
 uptr SuspendedThreadsList::RegisterCount() {
   CHECK(0 && "unimplemented");
   return 0;
 }
 } // namespace __sanitizer
 
-#endif  // SANITIZER_MAC && (defined(__x86_64__) || defined(__aarch64__))
+#endif  // SANITIZER_MAC && (defined(__x86_64__) || defined(__aarch64__)) ||
+        //                   defined(__mips64) || defined(__i386))