[XRay][compiler-rt][Darwin] Minimal XRay build support in Darwin

[dberris]

Summary

This change is the first in a series of changes to get the XRay runtime
building on macOS. This first allows us to build the minimal parts of
XRay to get us started on supporting macOS development. These include:

• CMake changes to allow targeting x86_64 initially.
• Allowing for building the initialisation routines without .preinit_array support.
• Use __sanitizer::SleepForMillis() to work around the lack of clock_nanosleep on macOS.
• Deprecate the xray_fdr_log_grace_period_us flag, and introduce the xray_fdr_log_grace_period_ms flag instead, to use milliseconds across platforms.

[dberris]

@kubamracek -- if you don't mind having a look at this, I'm looking for thoughts/feedback on how we can address the "blockers":

• Assembly for Darwin x86_64 and how we avoid the ELF'isms (do we need to implement darwin-specific assembly for MachO?)
• Syscalls, testing, etc. -- whether we need to do anything special here for making it work on macOS.

[kubamracek]

Hi and sorry for replying so late! All of the changes LGTM with a few nits.

Assembly for Darwin x86_64 and how we avoid the ELF'isms (do we need to implement darwin-specific assembly for MachO?)

This should be actually easily solvable by #include'ing sanitizer_common/sanitizer_asm.h and then using the macros from there (perhaps introducing some new macros or generalizing the existing ones). Take a look at what was done in lib/tsan/rtl/tsan_rtl_amd64.S. Names of symbols should use a macro like ASM_SYMBOL which will add an underscore on macOS. .type directives should use ASM_TYPE_FUNCTION. And so on. It should be possible to reuse almost all of the assembly instructions unchanged. I think I have an ugly old patch for this somewhere, I can send it to you if you want.

Syscalls, testing, etc. -- whether we need to do anything special here for making it work on macOS.

We should try to move most of the tests in the Linux directory to a common tests directory. I don't see anything particularly Linux-y there.

Regarding syscalls, I'm not sure I understand the problem. Is XRay doing any syscall interception or something like that?

compiler-rt/cmake/config-ix.cmake

419–425 ↗

(On Diff #119635)

Instead of this change, please do something similar like we do for ALL_LSAN_SUPPORTED_ARCH above (line 200).

compiler-rt/lib/xray/CMakeLists.txt

82 ↗

(On Diff #119635)

STATIC is okay for now, but we have much better experience with dynamic libraries for runtimes. Is there some reason to use a static library?

compiler-rt/test/xray/TestCases/Darwin/always-never-instrument.cc

12 ↗

(On Diff #119635)

Should this REQUIRES be here?

Similarly, in all the tests in the Linux/ directory, we should change REQUIRES: x86_64-linux to just REQUIRES: x86_64.

[kubamracek]

Also, please make sure this builds and tests pass before actually landing this patch. FYI, there are bots that run on older macOS versions (10.11 for sure, probably even older).

[dberris]

• fixup: Use ASM macros for darwin assembly
• fixup: support weak symbols for Darwin linkage

[dberris]

In D39114#914098, @kubamracek wrote:

Hi and sorry for replying so late! All of the changes LGTM with a few nits.

All good, thanks for having a look!

Assembly for Darwin x86_64 and how we avoid the ELF'isms (do we need to implement darwin-specific assembly for MachO?)

This should be actually easily solvable by #include'ing sanitizer_common/sanitizer_asm.h and then using the macros from there (perhaps introducing some new macros or generalizing the existing ones). Take a look at what was done in lib/tsan/rtl/tsan_rtl_amd64.S. Names of symbols should use a macro like ASM_SYMBOL which will add an underscore on macOS. .type directives should use ASM_TYPE_FUNCTION. And so on. It should be possible to reuse almost all of the assembly instructions unchanged. I think I have an ugly old patch for this somewhere, I can send it to you if you want.

Thanks for the hints, that was easy enough!

Syscalls, testing, etc. -- whether we need to do anything special here for making it work on macOS.

We should try to move most of the tests in the Linux directory to a common tests directory. I don't see anything particularly Linux-y there.

Agreed. Let me make a few of those changes.

Regarding syscalls, I'm not sure I understand the problem. Is XRay doing any syscall interception or something like that?

Nope, just calling mmap and mprotect -- which should just be available on macOS. :)

compiler-rt/lib/xray/CMakeLists.txt

82 ↗

(On Diff #119635)

Let me try with a SHARED build, and report back.

compiler-rt/test/xray/TestCases/Darwin/always-never-instrument.cc

12 ↗

(On Diff #119635)

Not anymore, let me change that next.

[dberris]

• fixup: Use ASM macros for darwin assembly
• fixup: support weak symbols for Darwin linkage
• fixup: qualify symbols, use macros, limit weak symbols
• fixup: move test cases from Linux up one directory
• fixup: make clang link the needed runtime bits in osx
• fixup: update tests to run on x86_64 on both Darwin and Linux

[dberris]

Got some good progress on finally being able to make this work... here's the current state:

• When linking the final binary, the XRay runtime can't seem to find the __{start,stop}_xray_{fn_idx,instr_map} symbols. I've marked them weak, but they seem to either not be resolved when statically linking the binary. The dynamic lib version of the XRay runtime isn't quite ready yet, but I'm willing to try some things there.

• There are also missing symbols from the sanitizer_common library that's linked to from the libclang_rt.xray_osx.a produced by the compiler-rt XRay build configuration.

For example, when we're building some of the tests, I see errors like:

********************
FAIL: XRay-x86_64-darwin :: TestCases/func-id-utils.cc (18 of 18)
******************** TEST 'XRay-x86_64-darwin :: TestCases/func-id-utils.cc' FAILED ********************
Script:
--
/Users/dberris/Source/llvm-project-build/./bin/clang --driver-mode=g++ -fxray-instrument -arch x86_64 -stdlib=libc++ -mmacosx-version-min=10.9 -isysroot /Applications/Xcode.
app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.12.sdk  -std=c++11 /Users/dberris/Source/llvm-project/compiler-rt/test/xray/TestCases/func-id-utils.
cc -o /Users/dberris/Source/llvm-project-build/projects/compiler-rt/test/xray/X86_64DarwinConfig/TestCases/Output/func-id-utils.cc.tmp
XRAY_OPTIONS="patch_premain=false xray_naive_log=false"  /Users/dberris/Source/llvm-project-build/projects/compiler-rt/test/xray/X86_64DarwinConfig/TestCases/Output/func-id-
utils.cc.tmp
--
Exit Code: 1

Command Output (stderr):
--
Undefined symbols for architecture x86_64:
  "___sanitizer_symbolize_code", referenced from:
      __sanitizer::Symbolizer::PlatformInit() in libclang_rt.xray_osx.a(sanitizer_symbolizer_posix_libcdep.cc.o)
      __sanitizer::InternalSymbolizer::SymbolizePC(unsigned long, __sanitizer::SymbolizedStack*) in libclang_rt.xray_osx.a(sanitizer_symbolizer_posix_libcdep.cc.o)
  "___sanitizer_symbolize_data", referenced from:
      __sanitizer::Symbolizer::PlatformInit() in libclang_rt.xray_osx.a(sanitizer_symbolizer_posix_libcdep.cc.o)
      __sanitizer::InternalSymbolizer::SymbolizeData(unsigned long, __sanitizer::DataInfo*) in libclang_rt.xray_osx.a(sanitizer_symbolizer_posix_libcdep.cc.o)
  "___sanitizer_symbolize_demangle", referenced from:
      __sanitizer::InternalSymbolizer::Demangle(char const*) in libclang_rt.xray_osx.a(sanitizer_symbolizer_posix_libcdep.cc.o)
  "___sanitizer_symbolize_flush", referenced from:
      __sanitizer::InternalSymbolizer::Flush() in libclang_rt.xray_osx.a(sanitizer_symbolizer_posix_libcdep.cc.o)
  "___start_xray_fn_idx", referenced from:
      ___xray_init in libclang_rt.xray_osx.a(xray_init.cc.o)
  "___start_xray_instr_map", referenced from:
      ___xray_init in libclang_rt.xray_osx.a(xray_init.cc.o)
  "___stop_xray_fn_idx", referenced from:
      ___xray_init in libclang_rt.xray_osx.a(xray_init.cc.o)
  "___stop_xray_instr_map", referenced from:
      ___xray_init in libclang_rt.xray_osx.a(xray_init.cc.o)
ld: symbol(s) not found for architecture x86_64
clang-6.0: error: linker command failed with exit code 1 (use -v to see invocation)

--

Any further hints/thoughts on this would be great, @kubamracek (cc @pelikan and @echristo)

[kubamracek]

Thanks for working on this! Can we split the patch and land parts that are LGTM? It's getting a bit crowded here. I think the ASM changes should be a separate patch, and the test changes as well, probably.

[kubamracek]

When linking the final binary, the XRay runtime can't seem to find the __{start,stop}_xray_{fn_idx,instr_map} symbols. I've marked them weak, but they seem to either not be resolved when statically linking the binary. The dynamic lib version of the XRay runtime isn't quite ready yet, but I'm willing to try some things there.
There are also missing symbols from the sanitizer_common library that's linked to from the libclang_rt.xray_osx.a produced by the compiler-rt XRay build configuration.
Any further hints/thoughts on this would be great, @kubamracek (cc @pelikan and @echristo)

This is one of the reasons why a dynamic shared library works better. Using a dynamic library should solve this. What are the problems with that?

[dberris]

In D39114#920591, @kubamracek wrote:

When linking the final binary, the XRay runtime can't seem to find the __{start,stop}_xray_{fn_idx,instr_map} symbols. I've marked them weak, but they seem to either not be resolved when statically linking the binary. The dynamic lib version of the XRay runtime isn't quite ready yet, but I'm willing to try some things there.
There are also missing symbols from the sanitizer_common library that's linked to from the libclang_rt.xray_osx.a produced by the compiler-rt XRay build configuration.
Any further hints/thoughts on this would be great, @kubamracek (cc @pelikan and @echristo)

This is one of the reasons why a dynamic shared library works better. Using a dynamic library should solve this. What are the problems with that?

Nothing fundamentally wrong with doing that, except for the clang changes to link correctly (which I still need to experiment with). Let me go that route and report back.

I'll also split the patch up into smaller bits. The changes to the tests can be a separate change. I'll back those out and re-upload.

Thanks!

[dberris]

Re-title, back out test changes to a different patch.

[kubamracek]

compiler-rt/trunk/lib/xray/xray_trampoline_x86_64.S

75

Since we want to use ASM_TSAN_SYMBOL outside of TSan, can we rename it to just ASM_SYMBOL (or something like that)?

[dberris]

Landing now, will deal with the test and dynamic/

compiler-rt/trunk/lib/xray/xray_trampoline_x86_64.S

75

Probably. I was thinking about doing that, but then ended up deciding against it.

I can make a change later to migrate all uses in compiler-rt (if someone doesn't beat me to it). :)

[dberris]

Reverted in rL317877 -- I'm going to try again next week instead.

[dberris]

Hi @kubamracek -- do you know how to work around the lack of clock_gettime from the 10.11 SDK?

The build bots will complain again if this lands, and it'd be a real shame if we didn't get this working even just for 10.12. Is there something we can do in the CMake builds to ignore 10.11? Or maybe have an implementation of clock_gettime just for that platform?

[kubamracek]

Can we just not use clock_gettime on Darwin and instead use mach_absolute_time?

[dberris]

In D39114#929706, @kubamracek wrote:

Can we just not use clock_gettime on Darwin and instead use mach_absolute_time?

That's a good suggestion. Let me make that change.

Thanks!

[dberris]

Remove some uses of clock_gettime from XRay naive mode logging and some support libraries.

Up next should be the FDR mode calls to clock_gettime.

[dberris]

The FDR mode calls to clock_gettime needs a bit more attention, let me try and isolate those before attempting to land again.

[kubamracek]

Hi, can you split the patch and send individual changes as separate patches? It's getting hard to follow. And I think we should land the parts that are "safe to land", e.g. the ASM changes or some of the NFC whitespace changes. The Darwin-specific changes in tests can also be landed (but don't enable the tests on Darwin, yet).

[kubamracek]

And we should probably introduce files named xray_linux.cc and xray_mac.cc to contain platform-specific functions.

[krytarowski]

compiler-rt/lib/xray/xray_x86_64.cc

25 ↗

(On Diff #123529)

Is it OK for you to call here internally malloc(3)? At least the NetBSD version calls it.

[dberris]

In D39114#930461, @kubamracek wrote:

Hi, can you split the patch and send individual changes as separate patches? It's getting hard to follow. And I think we should land the parts that are "safe to land", e.g. the ASM changes or some of the NFC whitespace changes. The Darwin-specific changes in tests can also be landed (but don't enable the tests on Darwin, yet).

Yes, I'm going to be breaking this up into smaller parts -- just trying to see where it's going at this point.

I've just finally gotten to the point where I can get back to this again. :)

In D39114#930477, @kubamracek wrote:

And we should probably introduce files named xray_linux.cc and xray_mac.cc to contain platform-specific functions.

I fully agree. That should happen in smaller steps.

Expect smaller reviews coming soon, from breaking this patch up. :D

compiler-rt/lib/xray/xray_x86_64.cc

25 ↗

(On Diff #123529)

Good point. We should be caching this information earlier on in the process (i.e. before we start tracing) to avoid deadlocks in case we have an instrumented malloc implementation. Let me put a TODO or at least make sure we're calling this at a point that is safe (probably at initialisation time).

[dberris]

Retitle and reduce patch to smaller bits.

[dberris]

Update description to not use tabs.

[dberris]

Landing this now and seeing whether there's fallout from the build bots.

[Hahnfeld]

I'm getting "multiple definition" errors on powerpc64le when linking the unit tests, for example XRayBufferQueueTest:

src/projects/compiler-rt/lib/xray/xray_utils.cc:34: multiple definition of `__xray::retryingWriteAll(int, char*, char*)'
src/projects/compiler-rt/lib/xray/xray_utils.cc:73: multiple definition of `__xray::readValueFromFile(char const*, long long*)'
src/projects/compiler-rt/lib/xray/xray_utils.cc:95: multiple definition of `__xray::getLogFD()'

to name a few of the errors.

(related note: Why aren't the unit tests rebuilt if the libclang_rt.xray-powerpc64le.a changes?!? After reverting this commit locally for testing, the unit test built just fine. After reapplying the test wasn't rebuilt and I saw no problems...)

[dberris]

In D39114#938134, @Hahnfeld wrote:

I'm getting "multiple definition" errors on powerpc64le when linking the unit tests, for example XRayBufferQueueTest:

src/projects/compiler-rt/lib/xray/xray_utils.cc:34: multiple definition of `__xray::retryingWriteAll(int, char*, char*)'
src/projects/compiler-rt/lib/xray/xray_utils.cc:73: multiple definition of `__xray::readValueFromFile(char const*, long long*)'
src/projects/compiler-rt/lib/xray/xray_utils.cc:95: multiple definition of `__xray::getLogFD()'

to name a few of the errors.

Fixed in rL319241.

(related note: Why aren't the unit tests rebuilt if the libclang_rt.xray-powerpc64le.a changes?!? After reverting this commit locally for testing, the unit test built just fine. After reapplying the test wasn't rebuilt and I saw no problems...)

Yeah, that one I still haven't figured out yet. :/

[dberris]

• [XRay][compiler-rt][Darwin] Use dynamic initialisation as an alternative

[dberris]

Already commited; closing this revision out now.

cfe/trunk/include/clang/Driver/XRayArgs.h

class XRayArgs {
   bool XRayInstrument = false;
   int InstructionThreshold = 200;
 
 public:
   /// Parses the XRay arguments from an argument list.
   XRayArgs(const ToolChain &TC, const llvm::opt::ArgList &Args);
   void addArgs(const ToolChain &TC, const llvm::opt::ArgList &Args,
                llvm::opt::ArgStringList &CmdArgs, types::ID InputType) const;
+  bool needsXRayRt() const { return XRayInstrument; }
 };
 
 } // namespace driver
 } // namespace clang
 
 #endif // LLVM_CLANG_DRIVER_XRAYARGS_H

cfe/trunk/lib/Driver/ToolChains/Darwin.cpp

 #include "clang/Basic/AlignedAllocation.h"
 #include "clang/Basic/ObjCRuntime.h"
 #include "clang/Basic/VirtualFileSystem.h"
 #include "clang/Driver/Compilation.h"
 #include "clang/Driver/Driver.h"
 #include "clang/Driver/DriverDiagnostic.h"
 #include "clang/Driver/Options.h"
 #include "clang/Driver/SanitizerArgs.h"
+#include "clang/Driver/XRayArgs.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/ScopedPrinter.h"
 #include "llvm/Support/TargetParser.h"
 #include <cstdlib> // ::getenv
 
 using namespace clang::driver;
if (Sanitize.needsStatsRt()) {
     AddLinkRuntimeLib(Args, CmdArgs,
                       (Twine("libclang_rt.stats_client_") + OS + ".a").str(),
                       RLO_AlwaysLink);
     AddLinkSanitizerLibArgs(Args, CmdArgs, "stats");
   }
   if (Sanitize.needsEsanRt())
     AddLinkSanitizerLibArgs(Args, CmdArgs, "esan");
 
+  const XRayArgs& XRay = getXRayArgs();
+  if (XRay.needsXRayRt() && isTargetMacOS()) {
+    AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.xray_osx.a", RLO_AlwaysLink);
+  }
+
   // Otherwise link libSystem, then the dynamic runtime library, and finally any
   // target specific static runtime library.
   CmdArgs.push_back("-lSystem");
 
   // Select the dynamic runtime library and the target specific static library.
   if (isTargetWatchOSBased()) {
     // We currently always need a static runtime library for watchOS.
     AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.watchos.a");

cfe/trunk/lib/Driver/XRayArgs.cpp

if (Triple.getOS() == llvm::Triple::Linux)
       case llvm::Triple::mipsel:
       case llvm::Triple::mips64:
       case llvm::Triple::mips64el:
         break;
       default:
         D.Diag(diag::err_drv_clang_unsupported)
             << (std::string(XRayInstrumentOption) + " on " + Triple.str());
       }
+    else if (Triple.getOS() == llvm::Triple::Darwin)
+      // Experimental support for macos.
+      switch (Triple.getArch()) {
+      case llvm::Triple::x86_64:
+        break;
+      default:
+        D.Diag(diag::err_drv_clang_unsupported)
+            << (std::string(XRayInstrumentOption) + " on " + Triple.str());
+      }
     else
       D.Diag(diag::err_drv_clang_unsupported)
           << (std::string(XRayInstrumentOption) + " on non-Linux target OS");
     XRayInstrument = true;
     if (const Arg *A =
             Args.getLastArg(options::OPT_fxray_instruction_threshold_,
                             options::OPT_fxray_instruction_threshold_EQ)) {
       StringRef S = A->getValue();

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

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} ${ARM32} ${ARM64} ${MIPS64})
 set(ALL_ESAN_SUPPORTED_ARCH ${X86_64} ${MIPS64})
 set(ALL_SCUDO_SUPPORTED_ARCH ${X86} ${X86_64} ${ARM32} ${ARM64} ${MIPS32} ${MIPS64})
+if(APPLE)
+set(ALL_XRAY_SUPPORTED_ARCH ${X86_64})
+else()
 set(ALL_XRAY_SUPPORTED_ARCH ${X86_64} ${ARM32} ${ARM64} ${MIPS32} ${MIPS64} powerpc64le)
+endif()
 
 if(APPLE)
   include(CompilerRTDarwinUtils)
 
   find_darwin_sdk_dir(DARWIN_osx_SYSROOT macosx)
   find_darwin_sdk_dir(DARWIN_iossim_SYSROOT iphonesimulator)
   find_darwin_sdk_dir(DARWIN_ios_SYSROOT iphoneos)
   find_darwin_sdk_dir(DARWIN_watchossim_SYSROOT watchsimulator)
set(DARWIN_tvos_SANITIZER_MIN_VER_FLAG
       ${DARWIN_tvos_MIN_VER_FLAG}=9.0)
   endif()
 
   # Note: In order to target x86_64h on OS X the minimum deployment target must
   # be 10.8 or higher.
   set(SANITIZER_COMMON_SUPPORTED_OS osx)
   set(PROFILE_SUPPORTED_OS osx)
   set(TSAN_SUPPORTED_OS osx)
+  set(XRAY_SUPPORTED_OS osx)
   if(NOT SANITIZER_MIN_OSX_VERSION)
     string(REGEX MATCH "-mmacosx-version-min=([.0-9]+)"
            MACOSX_VERSION_MIN_FLAG "${CMAKE_CXX_FLAGS}")
     if(MACOSX_VERSION_MIN_FLAG)
       set(SANITIZER_MIN_OSX_VERSION "${CMAKE_MATCH_1}")
     elseif(CMAKE_OSX_DEPLOYMENT_TARGET)
       set(SANITIZER_MIN_OSX_VERSION ${CMAKE_OSX_DEPLOYMENT_TARGET})
     else()
list_intersect(CFI_SUPPORTED_ARCH
     ALL_CFI_SUPPORTED_ARCH
     SANITIZER_COMMON_SUPPORTED_ARCH)
   list_intersect(ESAN_SUPPORTED_ARCH
     ALL_ESAN_SUPPORTED_ARCH
     SANITIZER_COMMON_SUPPORTED_ARCH)
   list_intersect(SCUDO_SUPPORTED_ARCH
     ALL_SCUDO_SUPPORTED_ARCH
     SANITIZER_COMMON_SUPPORTED_ARCH)
-  list_intersect(XRAY_SUPPORTED_ARCH
-    ALL_XRAY_SUPPORTED_ARCH
-    SANITIZER_COMMON_SUPPORTED_ARCH)
   list_intersect(FUZZER_SUPPORTED_ARCH
     ALL_FUZZER_SUPPORTED_ARCH
     ALL_SANITIZER_COMMON_SUPPORTED_ARCH)
+  list_intersect(XRAY_SUPPORTED_ARCH
+    ALL_XRAY_SUPPORTED_ARCH
+    SANITIZER_COMMON_SUPPORTED_ARCH)
 
 else()
   # Architectures supported by compiler-rt libraries.
   filter_available_targets(SANITIZER_COMMON_SUPPORTED_ARCH
     ${ALL_SANITIZER_COMMON_SUPPORTED_ARCH})
   # LSan and UBSan common files should be available on all architectures
   # supported by other sanitizers (even if they build into dummy object files).
   filter_available_targets(LSAN_COMMON_SUPPORTED_ARCH

 if (COMPILER_RT_HAS_SANITIZER_COMMON AND SCUDO_SUPPORTED_ARCH AND
     OS_NAME MATCHES "Linux|Android")
   set(COMPILER_RT_HAS_SCUDO TRUE)
 else()
   set(COMPILER_RT_HAS_SCUDO FALSE)
 endif()
 
 if (COMPILER_RT_HAS_SANITIZER_COMMON AND XRAY_SUPPORTED_ARCH AND
-    OS_NAME MATCHES "Linux")
+    OS_NAME MATCHES "Darwin|Linux")
   set(COMPILER_RT_HAS_XRAY TRUE)
 else()
   set(COMPILER_RT_HAS_XRAY FALSE)
 endif()
 
 if (COMPILER_RT_HAS_SANITIZER_COMMON AND FUZZER_SUPPORTED_ARCH AND
       OS_NAME MATCHES "Darwin|Linux|NetBSD")
   set(COMPILER_RT_HAS_FUZZER TRUE)
 else()
   set(COMPILER_RT_HAS_FUZZER FALSE)
 endif()

compiler-rt/trunk/lib/xray/CMakeLists.txt

 
 set(XRAY_CFLAGS ${SANITIZER_COMMON_CFLAGS})
 set(XRAY_COMMON_DEFINITIONS XRAY_HAS_EXCEPTIONS=1)
 append_list_if(
   COMPILER_RT_HAS_XRAY_COMPILER_FLAG XRAY_SUPPORTED=1 XRAY_COMMON_DEFINITIONS)
 append_list_if(
   COMPILER_RT_BUILD_XRAY_NO_PREINIT XRAY_NO_PREINIT XRAY_COMMON_DEFINITIONS)
 
-add_compiler_rt_object_libraries(RTXray
-  ARCHS ${XRAY_SUPPORTED_ARCH}
-  SOURCES ${XRAY_SOURCES} CFLAGS ${XRAY_CFLAGS}
-  DEFS ${XRAY_COMMON_DEFINITIONS})
-
 add_compiler_rt_component(xray)
 
 set(XRAY_COMMON_RUNTIME_OBJECT_LIBS
+    RTXray
     RTSanitizerCommon
     RTSanitizerCommonLibc)
 
+if (APPLE)
+  set(XRAY_LINK_LIBS ${SANITIZER_COMMON_LINK_LIBS})
+  set(XRAY_ASM_SOURCES xray_trampoline_x86_64.S)
+
+  if (${CMAKE_GENERATOR} STREQUAL "Xcode")
+    enable_language(ASM)
+  else()
+    set_source_files_properties(${XRAY_ASM_SOURCES} PROPERTIES LANGUAGE C)
+  endif()
+
+  add_weak_symbols("sanitizer_common" WEAK_SYMBOL_LINK_FLAGS)
+  add_weak_symbols("xray" WEAK_SYMBOL_LINK_FLAGS)
+
+  add_compiler_rt_object_libraries(RTXray
+    OS ${XRAY_SUPPORTED_OS}
+    ARCHS ${XRAY_SUPPORTED_ARCH}
+    SOURCES ${x86_64_SOURCES}
+    CFLAGS ${XRAY_CFLAGS}
+    DEFS ${XRAY_COMMON_DEFINITIONS})
+
+  # We only support running on osx for now.
+  add_compiler_rt_runtime(clang_rt.xray
+    STATIC
+    OS ${XRAY_SUPPORTED_OS}
+    ARCHS ${XRAY_SUPPORTED_ARCH}
+    OBJECT_LIBS RTXray
+                RTSanitizerCommon
+                RTSanitizerCommonLibc
+    CFLAGS ${XRAY_CFLAGS}
+    DEFS ${XRAY_COMMON_DEFINITIONS}
+    LINK_FLAGS ${SANITIZER_COMMON_LINK_FLAGS} ${WEAK_SYMBOL_LINK_FLAGS}
+    LINK_LIBS ${XRAY_LINK_LIBS}
+    PARENT_TARGET xray)
+else()
 foreach(arch ${XRAY_SUPPORTED_ARCH})
   if(CAN_TARGET_${arch})
+    add_compiler_rt_object_libraries(RTXray
+      ARCHS ${XRAY_SUPPORTED_ARCH}
+      SOURCES ${XRAY_SOURCES} CFLAGS ${XRAY_CFLAGS}
+      DEFS ${XRAY_COMMON_DEFINITIONS})
     add_compiler_rt_runtime(clang_rt.xray
      STATIC
      ARCHS ${arch}
      SOURCES ${${arch}_SOURCES}
      CFLAGS ${XRAY_CFLAGS}
      DEFS ${XRAY_COMMON_DEFINITIONS}
      OBJECT_LIBS ${XRAY_COMMON_RUNTIME_OBJECT_LIBS}
      PARENT_TARGET xray)
   endif()
 endforeach()
+endif()
 
 if(COMPILER_RT_INCLUDE_TESTS)
   add_subdirectory(tests)
 endif()

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

 include_directories(..)
 
 add_custom_target(XRayUnitTests)
 set_target_properties(XRayUnitTests PROPERTIES FOLDER "XRay unittests")
 
 set(XRAY_UNITTEST_CFLAGS
   ${XRAY_CFLAGS}
   ${COMPILER_RT_UNITTEST_CFLAGS}
   ${COMPILER_RT_GTEST_CFLAGS}
   -I${COMPILER_RT_SOURCE_DIR}/include
   -I${COMPILER_RT_SOURCE_DIR}/lib/xray
   -I${COMPILER_RT_SOURCE_DIR}/lib)
 
 set(XRAY_TEST_ARCH ${XRAY_SUPPORTED_ARCH})
+set(XRAY_LINK_FLAGS)
+append_list_if(COMPILER_RT_HAS_LIBRT -lrt XRAY_LINK_FLAGS)
+append_list_if(COMPILER_RT_HAS_LIBM -lm XRAY_LINK_FLAGS)
+append_list_if(COMPILER_RT_HAS_LIBPTHREAD -lpthread XRAY_LINK_FLAGS)
+
+if (APPLE)
+  list(APPEND XRAY_LINK_FLAGS -lc++)
+  list(APPEND XRAY_LINK_FLAGS ${SANITIZER_COMMON_LINK_FLAGS})
+  set(XRAY_TEST_RUNTIME_OBJECTS
+    $<TARGET_OBJECTS:RTSanitizerCommon.osx>
+    $<TARGET_OBJECTS:RTSanitizerCommonLibc.osx>
+    $<TARGET_OBJECTS:RTXray.osx>)
+  set(XRAY_TEST_RUNTIME RTXRayTest)
+  add_library(${XRAY_TEST_RUNTIME} STATIC ${XRAY_TEST_RUNTIME_OBJECTS})
+  set_target_properties(${XRAY_TEST_RUNTIME} PROPERTIES
+    ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+    FOLDER "Compiler-RT Runtime tests")
+
+  darwin_filter_host_archs(XRAY_SUPPORTED_ARCH XRAY_TEST_ARCH)
+  list(APPEND XRAY_UNITTEST_CFLAGS ${DARWIN_osx_CFLAGS})
+  list(APPEND XRAY_LINK_FLAGS "-lc++")
+  list(APPEND XRAY_LINK_FLAGS "-fxray-instrument")
+  add_weak_symbols("sanitizer_common" XRAY_LINK_FLAGS)
+  add_weak_symbols("xray" XRAY_LINK_FLAGS)
+else()
+  append_list_if(COMPILER_RT_HAS_LIBSTDCXX lstdc++ XRAY_LINK_FLAGS)
+endif()
+
 macro(add_xray_unittest testname)
   cmake_parse_arguments(TEST "" "" "SOURCES;HEADERS" ${ARGN})
-  if(UNIX AND NOT APPLE)
+  if(UNIX)
     foreach(arch ${XRAY_TEST_ARCH})
       set(TEST_OBJECTS)
       generate_compiler_rt_tests(TEST_OBJECTS
         XRayUnitTests "${testname}-${arch}-Test" "${arch}"
         SOURCES ${TEST_SOURCES} ${COMPILER_RT_GTEST_SOURCE}
+        RUNTIME ${XRAY_TEST_RUNTIME}
+        COMPILE_DEPS ${TEST_HEADERS}
         DEPS gtest xray llvm-xray
         CFLAGS ${XRAY_UNITTEST_CFLAGS}
         LINK_FLAGS -fxray-instrument
           ${TARGET_LINK_FLAGS}
-          -lstdc++ -lm ${CMAKE_THREAD_LIBS_INIT}
-          -lpthread
-          -ldl -lrt)
+          ${CMAKE_THREAD_LIBS_INIT}
+          ${XRAY_LINK_FLAGS})
       set_target_properties(XRayUnitTests PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
     endforeach()
   endif()
 endmacro()
 
 if(COMPILER_RT_CAN_EXECUTE_TESTS)
   add_subdirectory(unit)
 endif()

compiler-rt/trunk/lib/xray/weak_symbols.txt

+___start_xray_fn_idx
+___start_xray_instr_map
+___stop_xray_fn_idx
+___stop_xray_instr_map

compiler-rt/trunk/lib/xray/xray_init.cc

__sanitizer::atomic_store(&XRayInitialized, true,
                             __sanitizer::memory_order_release);
 
 #ifndef XRAY_NO_PREINIT
   if (flags()->patch_premain)
     __xray_patch();
 #endif
 }
 
-#ifndef XRAY_NO_PREINIT
+// Only add the preinit array initialization if the sanitizers can.
+#if !defined(XRAY_NO_PREINIT) && SANITIZER_CAN_USE_PREINIT_ARRAY
 __attribute__((section(".preinit_array"),
                used)) void (*__local_xray_preinit)(void) = __xray_init;
 #endif

compiler-rt/trunk/lib/xray/xray_trampoline_x86_64.S

 //===-- xray_trampoline_x86.s -----------------------------------*- ASM -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file is a part of XRay, a dynamic runtime instrumentation system.
 //
 // This implements the X86-specific assembler for the trampolines.
 //
 //===----------------------------------------------------------------------===//
 
 #include "../builtins/assembly.h"
+#include "../sanitizer_common/sanitizer_asm.h"
+
+
 
 .macro SAVE_REGISTERS
   subq $192, %rsp
-  .cfi_def_cfa_offset 200
+  CFI_DEF_CFA_OFFSET(200)
   // At this point, the stack pointer should be aligned to an 8-byte boundary,
   // because any call instructions that come after this will add another 8
   // bytes and therefore align it to 16-bytes.
   movq %rbp, 184(%rsp)
   movupd  %xmm0, 168(%rsp)
   movupd  %xmm1, 152(%rsp)
   movupd  %xmm2, 136(%rsp)
   movupd  %xmm3, 120(%rsp)
.macro RESTORE_REGISTERS
   movq  48(%rsp), %rdi
   movq  40(%rsp), %rax
   movq  32(%rsp), %rdx
   movq  24(%rsp), %rsi
   movq  16(%rsp), %rcx
   movq  8(%rsp), %r8
   movq  0(%rsp), %r9
   addq  $192, %rsp
-  .cfi_def_cfa_offset 8
+  CFI_DEF_CFA_OFFSET(8)
 .endm
 
-  .text
+#if !defined(__APPLE__)
+  .section .text
+#else
+  .section __TEXT,__text
+#endif
   .file "xray_trampoline_x86.S"
 
 //===----------------------------------------------------------------------===//
 
-  .globl __xray_FunctionEntry
+  .globl ASM_TSAN_SYMBOL(__xray_FunctionEntry)
   .align 16, 0x90
-  .type __xray_FunctionEntry,@function
-
-__xray_FunctionEntry:
-  .cfi_startproc
+  ASM_TYPE_FUNCTION(__xray_FunctionEntry)
+ASM_TSAN_SYMBOL(__xray_FunctionEntry):
+  CFI_STARTPROC
   SAVE_REGISTERS
 
   // This load has to be atomic, it's concurrent with __xray_patch().
   // On x86/amd64, a simple (type-aligned) MOV instruction is enough.
-  movq  _ZN6__xray19XRayPatchedFunctionE(%rip), %rax
+  movq  ASM_TSAN_SYMBOL(_ZN6__xray19XRayPatchedFunctionE)(%rip), %rax
   testq %rax, %rax
   je  .Ltmp0
 
   // The patched function prolog puts its xray_instr_map index into %r10d.
   movl  %r10d, %edi
   xor %esi,%esi
   callq *%rax
 .Ltmp0:
   RESTORE_REGISTERS
   retq
-.Ltmp1:
-  .size __xray_FunctionEntry, .Ltmp1-__xray_FunctionEntry
-  .cfi_endproc
+  ASM_SIZE(__xray_FunctionEntry)
+  CFI_ENDPROC
 
 //===----------------------------------------------------------------------===//
 
-  .globl __xray_FunctionExit
+  .globl ASM_TSAN_SYMBOL(__xray_FunctionExit)
   .align 16, 0x90
-  .type __xray_FunctionExit,@function
-__xray_FunctionExit:
-  .cfi_startproc
+  ASM_TYPE_FUNCTION(__xray_FunctionExit)
+ASM_TSAN_SYMBOL(__xray_FunctionExit):
+  CFI_STARTPROC
   // Save the important registers first. Since we're assuming that this
   // function is only jumped into, we only preserve the registers for
   // returning.
   subq  $56, %rsp
-  .cfi_def_cfa_offset 64
+  CFI_DEF_CFA_OFFSET(64)
   movq  %rbp, 48(%rsp)
   movupd  %xmm0, 32(%rsp)
   movupd  %xmm1, 16(%rsp)
   movq  %rax, 8(%rsp)
   movq  %rdx, 0(%rsp)
-  movq  _ZN6__xray19XRayPatchedFunctionE(%rip), %rax
+  movq  ASM_TSAN_SYMBOL(_ZN6__xray19XRayPatchedFunctionE)(%rip), %rax
   testq %rax,%rax
   je  .Ltmp2
 
   movl  %r10d, %edi
   movl  $1, %esi
   callq *%rax
 .Ltmp2:
   // Restore the important registers.
   movq  48(%rsp), %rbp
   movupd  32(%rsp), %xmm0
   movupd  16(%rsp), %xmm1
   movq  8(%rsp), %rax
   movq  0(%rsp), %rdx
   addq  $56, %rsp
-  .cfi_def_cfa_offset 8
+  CFI_DEF_CFA_OFFSET(8)
   retq
-.Ltmp3:
-  .size __xray_FunctionExit, .Ltmp3-__xray_FunctionExit
-  .cfi_endproc
+  ASM_SIZE(__xray_FunctionExit)
+  CFI_ENDPROC
 
 //===----------------------------------------------------------------------===//
 
-  .global __xray_FunctionTailExit
+  .globl ASM_TSAN_SYMBOL(__xray_FunctionTailExit)
   .align 16, 0x90
-  .type __xray_FunctionTailExit,@function
-__xray_FunctionTailExit:
-  .cfi_startproc
+  ASM_TYPE_FUNCTION(__xray_FunctionTailExit)
+ASM_TSAN_SYMBOL(__xray_FunctionTailExit):
+  CFI_STARTPROC
   SAVE_REGISTERS
 
-  movq  _ZN6__xray19XRayPatchedFunctionE(%rip), %rax
+  movq  ASM_TSAN_SYMBOL(_ZN6__xray19XRayPatchedFunctionE)(%rip), %rax
   testq %rax,%rax
   je  .Ltmp4
 
   movl  %r10d, %edi
   movl  $2, %esi
   callq *%rax
 
 .Ltmp4:
   RESTORE_REGISTERS
   retq
-.Ltmp5:
-  .size __xray_FunctionTailExit, .Ltmp5-__xray_FunctionTailExit
-  .cfi_endproc
+  ASM_SIZE(__xray_FunctionTailExit)
+  CFI_ENDPROC
 
 //===----------------------------------------------------------------------===//
 
-  .globl __xray_ArgLoggerEntry
+  .globl ASM_TSAN_SYMBOL(__xray_ArgLoggerEntry)
   .align 16, 0x90
-  .type __xray_ArgLoggerEntry,@function
-__xray_ArgLoggerEntry:
-  .cfi_startproc
+  ASM_TYPE_FUNCTION(__xray_ArgLoggerEntry)
+ASM_TSAN_SYMBOL(__xray_ArgLoggerEntry):
+  CFI_STARTPROC
   SAVE_REGISTERS
 
   // Again, these function pointer loads must be atomic; MOV is fine.
-  movq  _ZN6__xray13XRayArgLoggerE(%rip), %rax
+  movq  ASM_TSAN_SYMBOL(_ZN6__xray13XRayArgLoggerE)(%rip), %rax
   testq %rax, %rax
   jne .Larg1entryLog
 
   // If [arg1 logging handler] not set, defer to no-arg logging.
-  movq  _ZN6__xray19XRayPatchedFunctionE(%rip), %rax
+  movq  ASM_TSAN_SYMBOL(_ZN6__xray19XRayPatchedFunctionE)(%rip), %rax
   testq %rax, %rax
   je  .Larg1entryFail
 
 .Larg1entryLog:
 
   // First argument will become the third
   movq  %rdi, %rdx
 
   // XRayEntryType::LOG_ARGS_ENTRY into the second
   mov $0x3, %esi
 
   // 32-bit function ID becomes the first
   movl  %r10d, %edi
   callq *%rax
 
 .Larg1entryFail:
   RESTORE_REGISTERS
   retq
-
-.Larg1entryEnd:
-  .size __xray_ArgLoggerEntry, .Larg1entryEnd-__xray_ArgLoggerEntry
-  .cfi_endproc
+  ASM_SIZE(__xray_ArgLoggerEntry)
+  CFI_ENDPROC
 
 //===----------------------------------------------------------------------===//
 
-  .global __xray_CustomEvent
+  .global ASM_TSAN_SYMBOL(__xray_CustomEvent)
   .align 16, 0x90
-  .type __xray_CustomEvent,@function
-__xray_CustomEvent:
-  .cfi_startproc
+  ASM_TYPE_FUNCTION(__xray_CustomEvent)
+ASM_TSAN_SYMBOL(__xray_CustomEvent):
+  CFI_STARTPROC
   SAVE_REGISTERS
 
   // We take two arguments to this trampoline, which should be in rdi  and rsi
   // already. We also make sure that we stash %rax because we use that register
   // to call the logging handler.
-  movq _ZN6__xray22XRayPatchedCustomEventE(%rip), %rax
+  movq ASM_TSAN_SYMBOL(_ZN6__xray22XRayPatchedCustomEventE)(%rip), %rax
   testq %rax,%rax
   je .LcustomEventCleanup
 
   // At this point we know that rcx and rdx already has the data, so we just
   // call the logging handler, after aligning the stack to a 16-byte boundary.
   // The approach we're taking here uses additional stack space to stash the
   // stack pointer twice before aligning the pointer to 16-bytes. If the stack
   // was 8-byte aligned, it will become 16-byte aligned -- when restoring the
   // pointer, we can always look -8 bytes from the current position to get
   // either of the values we've stashed in the first place.
   pushq %rsp
   pushq (%rsp)
   andq $-0x10, %rsp
   callq *%rax
   movq 8(%rsp), %rsp
 
 .LcustomEventCleanup:
   RESTORE_REGISTERS
   retq
-
-.Ltmp8:
-  .size __xray_CustomEvent, .Ltmp8-__xray_CustomEvent
-  .cfi_endproc
+  ASM_SIZE(__xray_CustomEvent)
+  CFI_ENDPROC
 
 NO_EXEC_STACK_DIRECTIVE

compiler-rt/trunk/test/xray/TestCases/Darwin/always-never-instrument.cc

+// Test that the always/never instrument lists apply.
+// RUN: echo "fun:main" > %tmp-always.txt
+// RUN: echo "fun:__xray*" > %tmp-never.txt
+// RUN: %clangxx_xray \
+// RUN:     -fxray-never-instrument=%tmp-never.txt \
+// RUN:     -fxray-always-instrument=%tmp-always.txt \
+// RUN:     %s -o %t
+// RUN: %llvm_xray extract -symbolize %t | \
+// RUN:    FileCheck %s --check-prefix NOINSTR
+// RUN: %llvm_xray extract -symbolize %t | \
+// RUN:    FileCheck %s --check-prefix ALWAYSINSTR
+// REQUIRES: x86_64-linux
+// REQUIRES: built-in-llvm-tree
+
+// NOINSTR-NOT: {{.*__xray_NeverInstrumented.*}}
+int __xray_NeverInstrumented() {
+  return 0;
+}
+
+// ALWAYSINSTR: {{.*function-name:.*main.*}}
+int main(int argc, char *argv[]) {
+  return __xray_NeverInstrumented();
+}

compiler-rt/trunk/test/xray/TestCases/Darwin/lit.local.cfg

+def getRoot(config):
+  if not config.parent:
+    return config
+  return getRoot(config.parent)
+
+root = getRoot(config)
+
+if root.host_os not in ['Darwin']:
+  config.unsupported = True

compiler-rt/trunk/test/xray/TestCases/Linux/lit.local.cfg

+def getRoot(config):
+  if not config.parent:
+    return config
+  return getRoot(config.parent)
+
+root = getRoot(config)
+
+if root.host_os not in ['Linux']:
+  config.unsupported = True

compiler-rt/trunk/test/xray/lit.cfg

config.substitutions.append(
     ('%xraylib',
         ('-lm -lpthread -ldl -lrt -L%s '
          '-Wl,-whole-archive -lclang_rt.xray-%s -Wl,-no-whole-archive')
         % (config.compiler_rt_libdir, config.host_arch)))
 
 # Default test suffixes.
 config.suffixes = ['.c', '.cc', '.cpp']
 
-if config.host_os not in ['Linux']:
+if config.host_os not in ['Linux', 'Darwin']:
   config.unsupported = True
 elif '64' not in config.host_arch:
   if 'arm' in config.host_arch:
     if '-mthumb' in config.target_cflags:
       config.unsupported = True
   else:
     config.unsupported = True