[TSan][libdispatch] Ensure TSan dylib works on old systems

[yln]

Summary

dispatch_async_and_wait() was introduced in macOS 10.14, which is
greater than our minimal deployment target. We need to forward declare
it as a "weak import" to ensure we generate a weak reference so the TSan
dylib continues to work on older systems. We cannot simply `#include
<dispatch.h>` or use the Darwin availability macros since this file is
multi-platform.

Before:

➤ dyldinfo -bind ./lib/clang/12.0.0/lib/darwin/libclang_rt.tsan_osx_dynamic.dylib | grep dispatch_async_and_wait
__DATA  __interpose      0x000F5E68    pointer      0 libSystem        _dispatch_async_and_wait_f

After:

➤ dyldinfo -bind ./lib/clang/12.0.0/lib/darwin/libclang_rt.tsan_osx_dynamic.dylib | grep dispatch_async_and_wait
__DATA  __got            0x000EC0A8    pointer      0 libSystem        _dispatch_async_and_wait (weak import)
__DATA  __interpose      0x000F5E78    pointer      0 libSystem        _dispatch_async_and_wait (weak import)

This is a follow-up to D85854 and should fix:
https://reviews.llvm.org/D85854#2221529

[yln]

@dmajor: do you have a quick way to check if this unbreaks your builds?
Another follow-up might be required to make the test work: https://reviews.llvm.org/D85995

[dmajor]

In D86103#2222302, @yln wrote:

@dmajor: do you have a quick way to check if this unbreaks your builds?
Another follow-up might be required to make the test work: https://reviews.llvm.org/D85995

Not immediate, it will take me a few hours to check the builds, and we don't run the tests on this platform.

[delcypher]

compiler-rt/lib/tsan/rtl/tsan_dispatch_defs.h

60

Is this not defined elsewhere in sanitizer_common?

[yln]

I just discovered that this is still not enough; linking still fails with SDK < 10.14. Only options left are:

• Raise required SDK for building (deployment target remains unchanged)
• #ifdef out these interceptors when building with older SDKs

compiler-rt/lib/tsan/rtl/tsan_dispatch_defs.h

60

No, we have weak, but not weak_import.
https://developer.apple.com/library/archive/documentation/MacOSX/Conceptual/BPFrameworks/Concepts/WeakLinking.html

[dmajor]

In D86103#2222585, @yln wrote:

I just discovered that this is still not enough; linking still fails with SDK < 10.14.

Yeah, my bots just reported back with the same results. I also tried changing __attribute(( to __attribute__(( just in case, but no change.

Only options left are:

• Raise required SDK for building (deployment target remains unchanged)
• #ifdef out these interceptors when building with older SDKs

Is there harm in going the ifdef route? We only just recently managed to adapt to the 10.12 requirement from D74501 and it'd be nice to have a bit of a break before going through that again. :-)

[yln]

Clarification: the problem is *building* with SDK < 10.14. *Running* on macOS < 10.14 works (with this patch).

I will try to go the #ifdef route. The downside is that the resulting runtime, provides (or doesn't provide) certain interceptors depending on the SDK that was used to build the runtime.

[yln]

Guard compilation of interceptors with #ifdef, in addition to forcing weak references.
This means we are not building those when compiling with older SDKs.

I verified that both building with SDK < 10.14 and running on macOS < 10.14 works.

[kubamracek]

If we use #if !SANITIZER_MAC || defined(__MAC_10_14), do we still need the forward declarations and weak_import stuff?

[yln]

In D86103#2222957, @kubamracek wrote:

If we use #if !SANITIZER_MAC || defined(__MAC_10_14), do we still need the forward declarations and weak_import stuff?

Unfortunately, yes.

The #if !SANITIZER_MAC || defined(__MAC_10_14) skips building the interceptors when older SDKs is used to build to avoid a linker error.
The SANITIZER_WEAK_IMPORT declarations make sure we emit a weak reference so we can run on older systems. (We can't include the libdispatch header to accomplish this, because this is a multi-platform file.)

compiler-rt/lib/tsan/rtl/tsan_dispatch_defs.h

 extern const dispatch_block_t _dispatch_data_destructor_munmap;
 } // extern "C"
 
 #define DISPATCH_DATA_DESTRUCTOR_DEFAULT nullptr
 #define DISPATCH_DATA_DESTRUCTOR_FREE    _dispatch_data_destructor_free
 #define DISPATCH_DATA_DESTRUCTOR_MUNMAP  _dispatch_data_destructor_munmap
 
 #if __has_attribute(noescape)
-  #define DISPATCH_NOESCAPE __attribute__((__noescape__))
+# define DISPATCH_NOESCAPE __attribute__((__noescape__))
 #else
-  #define DISPATCH_NOESCAPE
+# define DISPATCH_NOESCAPE
 #endif
 
+#if SANITIZER_MAC
+# define SANITIZER_WEAK_IMPORT extern "C" __attribute((weak_import))
+#else
+# define SANITIZER_WEAK_IMPORT extern "C" __attribute((weak))
+#endif
+
+
 // Data types used in dispatch APIs
 typedef unsigned long size_t;
 typedef unsigned long uintptr_t;
 typedef __sanitizer::s64 off_t;
 typedef __sanitizer::u16 mode_t;
 typedef long long_t;
 
 #endif  // TSAN_DISPATCH_DEFS_H

compiler-rt/lib/tsan/rtl/tsan_interceptors_libdispatch.cpp

 #include "sanitizer_common/sanitizer_common.h"
 #include "interception/interception.h"
 #include "tsan_interceptors.h"
 #include "tsan_rtl.h"
 
 #include "BlocksRuntime/Block.h"
 #include "tsan_dispatch_defs.h"
 
+#if SANITIZER_MAC
+# include <Availability.h>
+#endif
+
 namespace __tsan {
   typedef u16 uint16_t;
 
 typedef struct {
   dispatch_queue_t queue;
   void *orig_context;
   dispatch_function_t orig_work;
   bool free_context_in_callback;

 
 // We wrap dispatch_async, dispatch_sync and friends where we allocate a new
 // context, which is used to synchronize (we release the context before
 // submitting, and the callback acquires it before executing the original
 // callback).
 DISPATCH_INTERCEPT(dispatch, false)
 DISPATCH_INTERCEPT(dispatch_barrier, true)
 
-DISPATCH_INTERCEPT_SYNC_F(dispatch_async_and_wait_f, false)
+// dispatch_async_and_wait() and friends were introduced in macOS 10.14.
+// Linking of these interceptors fails when using an older SDK.
+#if !SANITIZER_MAC || defined(__MAC_10_14)
+// macOS 10.14 is greater than our minimal deployment target.  To ensure we
+// generate a weak reference so the TSan dylib continues to work on older
+// systems, we need to forward declare the intercepted functions as "weak
+// imports".   Note that this file is multi-platform, so we cannot include the
+// actual header file (#include <dispatch/dispatch.h>).
+SANITIZER_WEAK_IMPORT void dispatch_async_and_wait(
+    dispatch_queue_t queue, DISPATCH_NOESCAPE dispatch_block_t block);
+SANITIZER_WEAK_IMPORT void dispatch_async_and_wait_f(
+    dispatch_queue_t queue, void *context, dispatch_function_t work);
+
 DISPATCH_INTERCEPT_SYNC_B(dispatch_async_and_wait, false)
+DISPATCH_INTERCEPT_SYNC_F(dispatch_async_and_wait_f, false)
+#endif
+
 
 DECLARE_REAL(void, dispatch_after_f, dispatch_time_t when,
              dispatch_queue_t queue, void *context, dispatch_function_t work)
 
 TSAN_INTERCEPTOR(void, dispatch_after, dispatch_time_t when,
                  dispatch_queue_t queue, dispatch_block_t block) {
   SCOPED_TSAN_INTERCEPTOR(dispatch_after, when, queue, block);
   SCOPED_TSAN_INTERCEPTOR_USER_CALLBACK_START();