Support for __asan_apply_to_globals in ASAN runtime library

[rgov]

Summary

These are the changes to the ASAN runtime library that are needed for D16737: Support for dead code stripping on Mach-O platforms.

[samsonov]

Please update ASan ABI version in lib/asan/asan_init_version.h. See the comment about test you might want to add in http://reviews.llvm.org/D16737

[rgov]

Update ABI version per @samsonov.

[rgov]

Add a test case.

[rgov]

Update comment in test case to be more accurate.

[glider]

LGTM

[glider]

Um, by the way, does the test pass without the LLVM-side change? I suspect no.

[rgov]

Thanks for reviewing. It does need the LLVM change first. So I will wait to commit until after D16737: Support for dead code stripping on Mach-O platforms is approved.

[samsonov]

LGTM

lib/asan/asan_init_version.h

33

This will be v8.

test/asan/TestCases/Darwin/dead-strip.c

21 ↗

(On Diff #47092)

You can avoid using custom pragmas by smth. like

int main(int argc, char *argv[]) {

alive[argc] = 0;
return 0;

}

[rgov]

I discovered that this change was incomplete due to duplicate registration of globals. I've changed this to use a per-library flag that indicates whether globals have been registered already, and ignores duplicate calls.

In the future I'd like to investigate simply eliding the unnecessary ctors, but this fix basically makes them harmless, in the same way that multiple calls to __asan_init do not cause problems.

This also happens to resolve the expected failure of the initialization-bug.cc test case. I do not know if a pathological binary could still execute a ctor that accesses globals before they are registered.

[samsonov]

lib/asan/asan_globals.cc

220

Let's just make two functions instead of passing one or the other callback here.
I agree that you can use the same "flag" here: first function will set it from false to true, another one - from true to false.

WDYT?

[rgov]

lib/asan/asan_globals.cc

220

I have no preference, other than that it is already written as-is :)

I'm not sure about calling it register_module_globals since module seems to mean translation unit and not shared object—unless I'm mistaken.

[samsonov]

lib/asan/asan_globals.cc

220

Yes, "module" has way too many meanings :), "library"?
I'd actually prefer to have two different functions, as this would make the intent cleaner. Sorry for bringing it up that late in the review process :/

[rgov]

Split into two functions per @samsonov's request. Just went with asan_register_module_globals and we can decide to rename it later if we care to.

[samsonov]

lib/asan/asan_init_version.h

31–33

Please fix a comment

lib/asan/asan_internal.h

84

It's not really a flag, it's a library/executable marker. You may clarify the way it's used here. E.g. why is it uptr*, not void*?

test/asan/TestCases/Darwin/dead-strip.c

22 ↗

(On Diff #50130)

So, is it possible to make this test pragma-less? In this way we will also ensure that this invalid load will not be optimized away by the compiler (i.e. run this test with -O3 in addition to -O0).

[rgov]

Committed as r264644.

lib/asan/asan_globals.cc

void StopInitOrderChecking() {
   }
 }
 
 } // namespace __asan
 
 // ---------------------- Interface ---------------- {{{1
 using namespace __asan;  // NOLINT
 
+
+// Apply __asan_(un)register_globals to all globals found in the same loaded
+// shared object as `needle'. This implementation is platform-specific.
+void __asan_apply_to_globals(globals_op_fptr op, void *needle) {
+  AsanApplyToGlobals(op, needle);
+}
+
 // Register an array of globals.
 void __asan_register_globals(__asan_global *globals, uptr n) {
   if (!flags()->report_globals) return;
   GET_STACK_TRACE_MALLOC;
   u32 stack_id = StackDepotPut(stack);
   BlockingMutexLock lock(&mu_for_globals);
   if (!global_registration_site_vector)
     global_registration_site_vector =

lib/asan/asan_init_version.h

 
 extern "C" {
   // Every time the ASan ABI changes we also change the version number in the
   // __asan_init function name.  Objects built with incompatible ASan ABI
   // versions will not link with run-time.
   // Changes between ABI versions:
   // v1=>v2: added 'module_name' to __asan_global
   // v2=>v3: stack frame description (created by the compiler)
-  //         contains the function PC as the 3-rd field (see
+  //         contains the function PC as the 3rd field (see
   //         DescribeAddressIfStack).
   // v3=>v4: added '__asan_global_source_location' to __asan_global.
   // v4=>v5: changed the semantics and format of __asan_stack_malloc_ and
   //         __asan_stack_free_ functions.
   // v5=>v6: changed the name of the version check symbol
-  #define __asan_version_mismatch_check __asan_version_mismatch_check_v6
+  // v6=>v7: added '__asan_apply_to_globals' function (for dead stripping
+  //         support on Mach-O platforms)
+  #define __asan_version_mismatch_check __asan_version_mismatch_check_v7
 }
 
 #endif  // ASAN_INIT_VERSION_H

lib/asan/asan_interface_internal.h

struct __asan_global {
     const char *name;        // Name as a C string.
     const char *module_name; // Module name as a C string. This pointer is a
                              // unique identifier of a module.
     uptr has_dynamic_init;   // Non-zero if the global has dynamic initializer.
     __asan_global_source_location *location;  // Source location of a global,
                                               // or NULL if it is unknown.
   };
 
+  // This function can be called on some platforms to find globals in the same
+  // loaded shared object as `needle' and apply __asan_(un)register_globals
+  // to them.
+  typedef void (*globals_op_fptr)(__asan_global *, uptr);
+  SANITIZER_INTERFACE_ATTRIBUTE
+  void __asan_apply_to_globals(globals_op_fptr op, void *needle);
+
   // These two functions should be called by the instrumented code.
   // 'globals' is an array of structures describing 'n' globals.
   SANITIZER_INTERFACE_ATTRIBUTE
   void __asan_register_globals(__asan_global *globals, uptr n);
   SANITIZER_INTERFACE_ATTRIBUTE
   void __asan_unregister_globals(__asan_global *globals, uptr n);
 
   // These two functions should be called before and after dynamic initializers

lib/asan/asan_internal.h

 
 // asan_malloc_linux.cc / asan_malloc_mac.cc
 void ReplaceSystemMalloc();
 
 // asan_linux.cc / asan_mac.cc / asan_win.cc
 void *AsanDoesNotSupportStaticLinkage();
 void AsanCheckDynamicRTPrereqs();
 void AsanCheckIncompatibleRT();
+void AsanApplyToGlobals(globals_op_fptr op, void *needle);
 
 void AsanOnDeadlySignal(int, void *siginfo, void *context);
 
 void ReadContextStack(void *context, uptr *stack, uptr *ssize);
 void StopInitOrderChecking();
 
 // Wrapper for TLS/TSD.
 void AsanTSDInit(void (*destructor)(void *tsd));
 void *AsanTSDGet();
 void AsanTSDSet(void *tsd);
 void PlatformTSDDtor(void *tsd);

lib/asan/asan_linux.cc

 
 void InitializePlatformInterceptors() {}
 
 void *AsanDoesNotSupportStaticLinkage() {
   // This will fail to link with -static.
   return &_DYNAMIC;  // defined in link.h
 }
 
+void AsanApplyToGlobals(globals_op_fptr op, void *needle) {
+  UNIMPLEMENTED();
+}
+
 #if SANITIZER_ANDROID
 // FIXME: should we do anything for Android?
 void AsanCheckDynamicRTPrereqs() {}
 void AsanCheckIncompatibleRT() {}
 #else
 static int FindFirstDSOCallback(struct dl_phdr_info *info, size_t size,
                                 void *data) {
   // Continue until the first dynamic library is found

lib/asan/asan_mac.cc

 #include "asan_internal.h"
 #include "asan_mapping.h"
 #include "asan_stack.h"
 #include "asan_thread.h"
 #include "sanitizer_common/sanitizer_atomic.h"
 #include "sanitizer_common/sanitizer_libc.h"
 #include "sanitizer_common/sanitizer_mac.h"
 
+#include <dlfcn.h>
 #include <fcntl.h>
 #include <libkern/OSAtomic.h>
 #include <mach-o/dyld.h>
+#include <mach-o/getsect.h>
 #include <mach-o/loader.h>
 #include <pthread.h>
 #include <stdlib.h>  // for free()
 #include <sys/mman.h>
 #include <sys/resource.h>
 #include <sys/sysctl.h>
 #include <sys/ucontext.h>
 #include <unistd.h>

 }
 
 // No-op. Mac does not support static linkage anyway.
 void AsanCheckDynamicRTPrereqs() {}
 
 // No-op. Mac does not support static linkage anyway.
 void AsanCheckIncompatibleRT() {}
 
+void AsanApplyToGlobals(globals_op_fptr op, void *needle) {
+  // Find the Mach-O header for the image containing the needle
+  Dl_info info;
+  int err = dladdr(needle, &info);
+  if (err == 0) return;
+
+#if __LP64__
+  const struct mach_header_64 *mh = (struct mach_header_64 *)info.dli_fbase;
+#else
+  const struct mach_header *mh = (struct mach_header *)info.dli_fbase;
+#endif
+
+  // Look up the __asan_globals section in that image and register its globals
+  unsigned long size = 0;
+  __asan_global *globals = (__asan_global *)getsectiondata(
+      mh,
+      "__DATA", "__asan_globals",
+      &size);
+
+  if (!globals) return;
+  if (size % sizeof(__asan_global) != 0) return;
+  op(globals, size / sizeof(__asan_global));
+}
+
 void ReadContextStack(void *context, uptr *stack, uptr *ssize) {
   UNIMPLEMENTED();
 }
 
 // Support for the following functions from libdispatch on Mac OS:
 //   dispatch_async_f()
 //   dispatch_async()
 //   dispatch_sync_f()

lib/asan/asan_win.cc

void InitializePlatformInterceptors() {
 
   // NtWaitForWorkViaWorkerFactory is always linked dynamically.
   CHECK(::__interception::OverrideFunction(
       "NtWaitForWorkViaWorkerFactory",
       (uptr)WRAP(NtWaitForWorkViaWorkerFactory),
       (uptr *)&REAL(NtWaitForWorkViaWorkerFactory)));
 }
 
+void AsanApplyToGlobals(globals_op_fptr op, void *needle) {
+  UNIMPLEMENTED();
+}
+
 // ---------------------- TSD ---------------- {{{
 static bool tsd_key_inited = false;
 
 static __declspec(thread) void *fake_tsd = 0;
 
 void AsanTSDInit(void (*destructor)(void *tsd)) {
   // FIXME: we're ignoring the destructor for now.
   tsd_key_inited = true;