[XRay][compiler-rt] Disable XRay instrumentation of the XRay runtime.

[dberris]

Summary

Adds a CMake check for whether the compiler used to build the XRay
library supports XRay-instrumentation. If the compiler we're using does
support the -fxray-instrument flag (i.e. recently-built Clang), we
define the XRAY_NEVER_INSTRUMENT macro that then makes sure that the
XRay runtime functions never get XRay-instrumented.

This prevents potential weirdness involved with building the XRay
library with a Clang that supports XRay-instrumentation, and is
attempting to XRay-instrument the build of compiler-rt.

[rSerge]

cmake/builtin-config-ix.cmake

15

Is this a check that the host compiler (not the one being compiled) supports XRay instrumentation? A comment would help.

lib/xray/xray_arm.cc

74–77

The function header could take only 2 lines if the second line starts after a single indentation (2 spaces). Is it a LLVM requirement to indent so much when a function header doesn't fit 1 line?

[rSerge]

lib/xray/xray_defs.h

17

I prefer to avoid double negation because it's harder to read. Can you change this to ifdef and swap the bodies?

[dberris]

• Address review comments

[dberris]

PTAL

cmake/builtin-config-ix.cmake

15

Is this a check that the host compiler (not the one being compiled) supports XRay instrumentation? A comment would help.

It's exactly the same as the ones it's grouped with, documentation on the builtin_check_c_compiler_flag macro says this too.

lib/xray/xray_arm.cc

74–77

I just follow what clang-format does. :)

cmake/builtin-config-ix.cmake

 include(BuiltinTests)
 include(CheckCSourceCompiles)
 
 # Make all the tests only check the compiler
 set(TEST_COMPILE_ONLY On)
 
+# Check host compiler support for certain flags
 builtin_check_c_compiler_flag(-fPIC                 COMPILER_RT_HAS_FPIC_FLAG)
 builtin_check_c_compiler_flag(-fPIE                 COMPILER_RT_HAS_FPIE_FLAG)
 builtin_check_c_compiler_flag(-fno-builtin          COMPILER_RT_HAS_FNO_BUILTIN_FLAG)
 builtin_check_c_compiler_flag(-std=c99              COMPILER_RT_HAS_STD_C99_FLAG)
 builtin_check_c_compiler_flag(-fvisibility=hidden   COMPILER_RT_HAS_VISIBILITY_HIDDEN_FLAG)
 builtin_check_c_compiler_flag(-fomit-frame-pointer  COMPILER_RT_HAS_OMIT_FRAME_POINTER_FLAG)
 builtin_check_c_compiler_flag(-ffreestanding        COMPILER_RT_HAS_FREESTANDING_FLAG)
+builtin_check_c_compiler_flag(-fxray-instrument     COMPILER_RT_HAS_XRAY_COMPILER_FLAG)
 
 builtin_check_c_compiler_source(COMPILER_RT_HAS_ATOMIC_KEYWORD
 "
 int foo(int x, int y) {
  _Atomic int result = x * y;
  return result;
 }
 ")

lib/xray/CMakeLists.txt

 # Build for the XRay runtime support library.
 
 set(XRAY_SOURCES
   xray_init.cc
-  xray_interface.cc
-  xray_flags.cc
+  xray_interface.cc
+  xray_flags.cc
   xray_inmemory_log.cc
 )
 
 set(x86_64_SOURCES
-    xray_x86_64.cc
-    xray_trampoline_x86_64.S
-    ${XRAY_SOURCES})
+    xray_x86_64.cc
+    xray_trampoline_x86_64.S
+    ${XRAY_SOURCES})
 
 set(arm_SOURCES
-    xray_arm.cc
-    xray_trampoline_arm.S
-    ${XRAY_SOURCES})
+    xray_arm.cc
+    xray_trampoline_arm.S
+    ${XRAY_SOURCES})
 
 set(armhf_SOURCES ${arm_SOURCES})
 
 include_directories(..)
 include_directories(../../include)
 
 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)
 
 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
-    RTSanitizerCommon
-    RTSanitizerCommonLibc)
+    RTSanitizerCommon
+    RTSanitizerCommonLibc)
 
 foreach (arch ${XRAY_SUPPORTED_ARCH})
-    if (CAN_TARGET_${arch})
-        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 ()
+    if (CAN_TARGET_${arch})
+        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()

lib/xray/xray_arm.cc

 enum class PatchOpcodes : uint32_t {
   PO_PushR0Lr = 0xE92D4001, // PUSH {r0, lr}
   PO_BlxIp = 0xE12FFF3C,    // BLX ip
   PO_PopR0Lr = 0xE8BD4001,  // POP {r0, lr}
   PO_B20 = 0xEA000005       // B #20
 };
 
 // 0xUUUUWXYZ -> 0x000W0XYZ
-inline static uint32_t getMovwMask(const uint32_t Value) {
+inline static uint32_t getMovwMask(const uint32_t Value) XRAY_NEVER_INSTRUMENT {
   return (Value & 0xfff) | ((Value & 0xf000) << 4);
 }
 
 // 0xWXYZUUUU -> 0x000W0XYZ
-inline static uint32_t getMovtMask(const uint32_t Value) {
+inline static uint32_t getMovtMask(const uint32_t Value) XRAY_NEVER_INSTRUMENT {
   return getMovwMask(Value >> 16);
 }
 
 // Writes the following instructions:
 //   MOVW R<regNo>, #<lower 16 bits of the |Value|>
 //   MOVT R<regNo>, #<higher 16 bits of the |Value|>
-inline static uint32_t *write32bitLoadReg(uint8_t regNo, uint32_t *Address,
-                                          const uint32_t Value) {
+inline static uint32_t *
+write32bitLoadReg(uint8_t regNo, uint32_t *Address,
+                  const uint32_t Value) XRAY_NEVER_INSTRUMENT {
   // This is a fatal error: we cannot just report it and continue execution.
   assert(regNo <= 15 && "Register number must be 0 to 15.");
   // MOVW R, #0xWXYZ in machine code is 0xE30WRXYZ
   *Address = (0xE3000000 | (uint32_t(regNo) << 12) | getMovwMask(Value));
   Address++;
   // MOVT R, #0xWXYZ in machine code is 0xE34WRXYZ
   *Address = (0xE3400000 | (uint32_t(regNo) << 12) | getMovtMask(Value));
   return Address + 1;
 }
 
 // Writes the following instructions:
 //   MOVW r0, #<lower 16 bits of the |Value|>
 //   MOVT r0, #<higher 16 bits of the |Value|>
-inline static uint32_t *Write32bitLoadR0(uint32_t *Address,
-                                         const uint32_t Value) {
+inline static uint32_t *
+Write32bitLoadR0(uint32_t *Address,
+                 const uint32_t Value) XRAY_NEVER_INSTRUMENT {
   return write32bitLoadReg(0, Address, Value);
 }
 
 // Writes the following instructions:
 //   MOVW ip, #<lower 16 bits of the |Value|>
 //   MOVT ip, #<higher 16 bits of the |Value|>
-inline static uint32_t *Write32bitLoadIP(uint32_t *Address,
-                                         const uint32_t Value) {
+inline static uint32_t *
+Write32bitLoadIP(uint32_t *Address,
+                 const uint32_t Value) XRAY_NEVER_INSTRUMENT {
   return write32bitLoadReg(12, Address, Value);
 }
 
 inline static bool patchSled(const bool Enable, const uint32_t FuncId,
-                             const XRaySledEntry &Sled, void (*TracingHook)()) {
+                             const XRaySledEntry &Sled,
+                             void (*TracingHook)()) XRAY_NEVER_INSTRUMENT {
   // When |Enable| == true,
   // We replace the following compile-time stub (sled):
   //
   // xray_sled_n:
   //   B #20
   //   6 NOPs (24 bytes)
   //
   // With the following runtime patch:
   //
if (Enable) {
     std::atomic_store_explicit(
         reinterpret_cast<std::atomic<uint32_t> *>(FirstAddress),
         uint32_t(PatchOpcodes::PO_B20), std::memory_order_release);
   }
   return true;
 }
 
 bool patchFunctionEntry(const bool Enable, const uint32_t FuncId,
-                        const XRaySledEntry &Sled) {
+                        const XRaySledEntry &Sled) XRAY_NEVER_INSTRUMENT {
   return patchSled(Enable, FuncId, Sled, __xray_FunctionEntry);
 }
 
 bool patchFunctionExit(const bool Enable, const uint32_t FuncId,
-                       const XRaySledEntry &Sled) {
+                       const XRaySledEntry &Sled) XRAY_NEVER_INSTRUMENT {
   return patchSled(Enable, FuncId, Sled, __xray_FunctionExit);
 }
 
 bool patchFunctionTailExit(const bool Enable, const uint32_t FuncId,
-                           const XRaySledEntry &Sled) {
+                           const XRaySledEntry &Sled) XRAY_NEVER_INSTRUMENT {
   // FIXME: In the future we'd need to distinguish between non-tail exits and
   // tail exits for better information preservation.
   return patchSled(Enable, FuncId, Sled, __xray_FunctionExit);
 }
 
 } // namespace __xray

lib/xray/xray_defs.h

+//===-- xray_defs.h ---------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Common definitions useful for XRay sources.
+//
+//===----------------------------------------------------------------------===//
+#ifndef XRAY_XRAY_DEFS_H
+#define XRAY_XRAY_DEFS_H
+
+#if XRAY_SUPPORTED
+#define XRAY_NEVER_INSTRUMENT __attribute__((xray_never_instrument))
+#else
+#define XRAY_NEVER_INSTRUMENT
+#endif
+
+#endif  // XRAY_XRAY_DEFS_H

lib/xray/xray_flags.cc

 //
 // XRay flag parsing logic.
 //===----------------------------------------------------------------------===//
 
 #include "xray_flags.h"
 #include "sanitizer_common/sanitizer_common.h"
 #include "sanitizer_common/sanitizer_flag_parser.h"
 #include "sanitizer_common/sanitizer_libc.h"
+#include "xray_defs.h"
 
 using namespace __sanitizer;
 
 namespace __xray {
 
 Flags xray_flags_dont_use_directly; // use via flags().
 
-void Flags::SetDefaults() {
+void Flags::SetDefaults() XRAY_NEVER_INSTRUMENT {
 #define XRAY_FLAG(Type, Name, DefaultValue, Description) Name = DefaultValue;
 #include "xray_flags.inc"
 #undef XRAY_FLAG
 }
 
-static void RegisterXRayFlags(FlagParser *P, Flags *F) {
+static void RegisterXRayFlags(FlagParser *P, Flags *F) XRAY_NEVER_INSTRUMENT {
 #define XRAY_FLAG(Type, Name, DefaultValue, Description)                       \
   RegisterFlag(P, #Name, Description, &F->Name);
 #include "xray_flags.inc"
 #undef XRAY_FLAG
 }
 
-void InitializeFlags() {
+void InitializeFlags() XRAY_NEVER_INSTRUMENT {
   SetCommonFlagsDefaults();
   auto *F = flags();
   F->SetDefaults();
 
   FlagParser XRayParser;
   RegisterXRayFlags(&XRayParser, F);
   RegisterCommonFlags(&XRayParser);
 

lib/xray/xray_init.cc

 //===----------------------------------------------------------------------===//
 
 #include <atomic>
 #include <fcntl.h>
 #include <strings.h>
 #include <unistd.h>
 
 #include "sanitizer_common/sanitizer_common.h"
+#include "xray_defs.h"
 #include "xray_flags.h"
 #include "xray_interface_internal.h"
 
 extern "C" {
 void __xray_init();
 extern const XRaySledEntry __start_xray_instr_map[] __attribute__((weak));
 extern const XRaySledEntry __stop_xray_instr_map[] __attribute__((weak));
 }

 // for statically linked executables.
 std::atomic<bool> XRayInitialized{false};
 
 // This should always be updated before XRayInitialized is updated.
 std::atomic<__xray::XRaySledMap> XRayInstrMap{};
 
 // __xray_init() will do the actual loading of the current process' memory map
 // and then proceed to look for the .xray_instr_map section/segment.
-void __xray_init() {
+void __xray_init() XRAY_NEVER_INSTRUMENT {
   InitializeFlags();
   if (__start_xray_instr_map == nullptr) {
     Report("XRay instrumentation map missing. Not initializing XRay.\n");
     return;
   }
 
   // Now initialize the XRayInstrMap global struct with the address of the
   // entries, reinterpreted as an array of XRaySledEntry objects. We use the

lib/xray/xray_inmemory_log.cc

 #elif defined(__arm__)
 static const int64_t NanosecondsPerSecond = 1000LL * 1000 * 1000;
 #else
 #error "Unsupported CPU Architecture"
 #endif /* CPU architecture */
 
 #include "sanitizer_common/sanitizer_libc.h"
 #include "xray/xray_records.h"
+#include "xray_defs.h"
 #include "xray_flags.h"
 #include "xray_interface_internal.h"
 
 // __xray_InMemoryRawLog will use a thread-local aligned buffer capped to a
 // certain size (32kb by default) and use it as if it were a circular buffer for
 // events. We store simple fixed-sized entries in the log for external analysis.
 
 extern "C" {
-void __xray_InMemoryRawLog(int32_t FuncId, XRayEntryType Type);
+void __xray_InMemoryRawLog(int32_t FuncId,
+                           XRayEntryType Type) XRAY_NEVER_INSTRUMENT;
 }
 
 namespace __xray {
 
 std::mutex LogMutex;
 
-static void retryingWriteAll(int Fd, char *Begin, char *End) {
+static void retryingWriteAll(int Fd, char *Begin,
+                             char *End) XRAY_NEVER_INSTRUMENT {
   if (Begin == End)
     return;
   auto TotalBytes = std::distance(Begin, End);
   while (auto Written = write(Fd, Begin, TotalBytes)) {
     if (Written < 0) {
       if (errno == EINTR)
         continue; // Try again.
       Report("Failed to write; errno = %d", errno);
       return;
     }
     TotalBytes -= Written;
     if (TotalBytes == 0)
       break;
     Begin += Written;
   }
 }
 
 #if defined(__x86_64__)
-static std::pair<ssize_t, bool> retryingReadSome(int Fd, char *Begin,
-                                                 char *End) {
+static std::pair<ssize_t, bool>
+retryingReadSome(int Fd, char *Begin, char *End) XRAY_NEVER_INSTRUMENT {
   auto BytesToRead = std::distance(Begin, End);
   ssize_t BytesRead;
   ssize_t TotalBytesRead = 0;
   while (BytesToRead && (BytesRead = read(Fd, Begin, BytesToRead))) {
     if (BytesRead == -1) {
       if (errno == EINTR)
         continue;
       Report("Read error; errno = %d", errno);
       return std::make_pair(TotalBytesRead, false);
     }
 
     TotalBytesRead += BytesRead;
     BytesToRead -= BytesRead;
     Begin += BytesRead;
   }
   return std::make_pair(TotalBytesRead, true);
 }
 
-static bool readValueFromFile(const char *Filename, long long *Value) {
+static bool readValueFromFile(const char *Filename,
+                              long long *Value) XRAY_NEVER_INSTRUMENT {
   int Fd = open(Filename, O_RDONLY | O_CLOEXEC);
   if (Fd == -1)
     return false;
   static constexpr size_t BufSize = 256;
   char Line[BufSize] = {};
   ssize_t BytesRead;
   bool Success;
   std::tie(BytesRead, Success) = retryingReadSome(Fd, Line, Line + BufSize);

 #endif /* CPU architecture */
 
 class ThreadExitFlusher {
   int Fd;
   XRayRecord *Start;
   size_t &Offset;
 
 public:
-  explicit ThreadExitFlusher(int Fd, XRayRecord *Start, size_t &Offset)
-      : Fd(Fd), Start(Start), Offset(Offset) {}
+  explicit ThreadExitFlusher(int Fd, XRayRecord *Start,
+                             size_t &Offset) XRAY_NEVER_INSTRUMENT
+      : Fd(Fd),
+        Start(Start),
+        Offset(Offset) {}
 
-  ~ThreadExitFlusher() {
+  ~ThreadExitFlusher() XRAY_NEVER_INSTRUMENT {
     std::lock_guard<std::mutex> L(LogMutex);
     if (Fd > 0 && Start != nullptr) {
       retryingWriteAll(Fd, reinterpret_cast<char *>(Start),
                        reinterpret_cast<char *>(Start + Offset));
       // Because this thread's exit could be the last one trying to write to the
       // file and that we're not able to close out the file properly, we sync
       // instead and hope that the pending writes are flushed as the thread
       // exits.
       fsync(Fd);
     }
   }
 };
 
 } // namespace __xray
 
 using namespace __xray;
 
-void PrintToStdErr(const char *Buffer) { fprintf(stderr, "%s", Buffer); }
+void PrintToStdErr(const char *Buffer) XRAY_NEVER_INSTRUMENT {
+  fprintf(stderr, "%s", Buffer);
+}
 
-void __xray_InMemoryRawLog(int32_t FuncId, XRayEntryType Type) {
+void __xray_InMemoryRawLog(int32_t FuncId,
+                           XRayEntryType Type) XRAY_NEVER_INSTRUMENT {
   using Buffer =
       std::aligned_storage<sizeof(XRayRecord), alignof(XRayRecord)>::type;
   static constexpr size_t BuffLen = 1024;
   thread_local static Buffer InMemoryBuffer[BuffLen] = {};
   thread_local static size_t Offset = 0;
   static int Fd = [] {
     // FIXME: Figure out how to make this less stderr-dependent.
     SetPrintfAndReportCallback(PrintToStdErr);

lib/xray/xray_interface.cc

 #include <atomic>
 #include <cstdint>
 #include <cstdio>
 #include <errno.h>
 #include <limits>
 #include <sys/mman.h>
 
 #include "sanitizer_common/sanitizer_common.h"
+#include "xray_defs.h"
 
 namespace __xray {
 
 #if defined(__x86_64__)
 // FIXME: The actual length is 11 bytes. Why was length 12 passed to mprotect()
 // ?
 static const int16_t cSledLength = 12;
 #elif defined(__arm__)

 // instrumentation points. This assumes that the executable pages are originally
 // read-and-execute only.
 class MProtectHelper {
   void *PageAlignedAddr;
   std::size_t MProtectLen;
   bool MustCleanup;
 
 public:
-  explicit MProtectHelper(void *PageAlignedAddr, std::size_t MProtectLen)
-      : PageAlignedAddr(PageAlignedAddr), MProtectLen(MProtectLen),
+  explicit MProtectHelper(void *PageAlignedAddr,
+                          std::size_t MProtectLen) XRAY_NEVER_INSTRUMENT
+      : PageAlignedAddr(PageAlignedAddr),
+        MProtectLen(MProtectLen),
         MustCleanup(false) {}
 
-  int MakeWriteable() {
+  int MakeWriteable() XRAY_NEVER_INSTRUMENT {
     auto R = mprotect(PageAlignedAddr, MProtectLen,
                       PROT_READ | PROT_WRITE | PROT_EXEC);
     if (R != -1)
       MustCleanup = true;
     return R;
   }
 
-  ~MProtectHelper() {
+  ~MProtectHelper() XRAY_NEVER_INSTRUMENT {
     if (MustCleanup) {
       mprotect(PageAlignedAddr, MProtectLen, PROT_READ | PROT_EXEC);
     }
   }
 };
 
 } // namespace __xray
 
 extern std::atomic<bool> XRayInitialized;
 extern std::atomic<__xray::XRaySledMap> XRayInstrMap;
 
-int __xray_set_handler(void (*entry)(int32_t, XRayEntryType)) {
+int __xray_set_handler(void (*entry)(int32_t,
+                                     XRayEntryType)) XRAY_NEVER_INSTRUMENT {
   if (XRayInitialized.load(std::memory_order_acquire)) {
     __xray::XRayPatchedFunction.store(entry, std::memory_order_release);
     return 1;
   }
   return 0;
 }
 
-int __xray_remove_handler() { return __xray_set_handler(nullptr); }
+int __xray_remove_handler() XRAY_NEVER_INSTRUMENT {
+  return __xray_set_handler(nullptr);
+}
 
 std::atomic<bool> XRayPatching{false};
 
 using namespace __xray;
 
 // FIXME: Figure out whether we can move this class to sanitizer_common instead
 // as a generic "scope guard".
 template <class Function> class CleanupInvoker {
   Function Fn;
 
 public:
-  explicit CleanupInvoker(Function Fn) : Fn(Fn) {}
-  CleanupInvoker(const CleanupInvoker &) = default;
-  CleanupInvoker(CleanupInvoker &&) = default;
-  CleanupInvoker &operator=(const CleanupInvoker &) = delete;
-  CleanupInvoker &operator=(CleanupInvoker &&) = delete;
-  ~CleanupInvoker() { Fn(); }
+  explicit CleanupInvoker(Function Fn) XRAY_NEVER_INSTRUMENT : Fn(Fn) {}
+  CleanupInvoker(const CleanupInvoker &) XRAY_NEVER_INSTRUMENT = default;
+  CleanupInvoker(CleanupInvoker &&) XRAY_NEVER_INSTRUMENT = default;
+  CleanupInvoker &
+  operator=(const CleanupInvoker &) XRAY_NEVER_INSTRUMENT = delete;
+  CleanupInvoker &operator=(CleanupInvoker &&) XRAY_NEVER_INSTRUMENT = delete;
+  ~CleanupInvoker() XRAY_NEVER_INSTRUMENT { Fn(); }
 };
 
-template <class Function> CleanupInvoker<Function> ScopeCleanup(Function Fn) {
+template <class Function>
+CleanupInvoker<Function> ScopeCleanup(Function Fn) XRAY_NEVER_INSTRUMENT {
   return CleanupInvoker<Function>{Fn};
 }
 
 // ControlPatching implements the common internals of the patching/unpatching
 // implementation. |Enable| defines whether we're enabling or disabling the
 // runtime XRay instrumentation.
-XRayPatchingStatus ControlPatching(bool Enable) {
+XRayPatchingStatus ControlPatching(bool Enable) XRAY_NEVER_INSTRUMENT {
   if (!XRayInitialized.load(std::memory_order_acquire))
     return XRayPatchingStatus::NOT_INITIALIZED; // Not initialized.
 
   static bool NotPatching = false;
   if (!XRayPatching.compare_exchange_strong(NotPatching, true,
                                             std::memory_order_acq_rel,
                                             std::memory_order_acquire)) {
     return XRayPatchingStatus::ONGOING; // Already patching.
for (std::size_t I = 0; I < InstrMap.Entries; I++) {
     }
     (void)Success;
   }
   XRayPatching.store(false, std::memory_order_release);
   PatchingSuccess = true;
   return XRayPatchingStatus::SUCCESS;
 }
 
-XRayPatchingStatus __xray_patch() { return ControlPatching(true); }
+XRayPatchingStatus __xray_patch() XRAY_NEVER_INSTRUMENT {
+  return ControlPatching(true);
+}
 
-XRayPatchingStatus __xray_unpatch() { return ControlPatching(false); }
+XRayPatchingStatus __xray_unpatch() XRAY_NEVER_INSTRUMENT {
+  return ControlPatching(false);
+}

lib/xray/xray_x86_64.cc

 #include "sanitizer_common/sanitizer_common.h"
+#include "xray_defs.h"
 #include "xray_interface_internal.h"
 #include <atomic>
 #include <cstdint>
 #include <limits>
 
 namespace __xray {
 
 static constexpr uint8_t CallOpCode = 0xe8;
 static constexpr uint16_t MovR10Seq = 0xba41;
 static constexpr uint16_t Jmp9Seq = 0x09eb;
 static constexpr uint8_t JmpOpCode = 0xe9;
 static constexpr uint8_t RetOpCode = 0xc3;
 
 static constexpr int64_t MinOffset{std::numeric_limits<int32_t>::min()};
 static constexpr int64_t MaxOffset{std::numeric_limits<int32_t>::max()};
 
 bool patchFunctionEntry(const bool Enable, const uint32_t FuncId,
-                        const XRaySledEntry &Sled) {
+                        const XRaySledEntry &Sled) XRAY_NEVER_INSTRUMENT {
   // Here we do the dance of replacing the following sled:
   //
   // xray_sled_n:
   //   jmp +9
   //   <9 byte nop>
   //
   // With the following:
   //
std::atomic_store_explicit(
         reinterpret_cast<std::atomic<uint16_t> *>(Sled.Address), Jmp9Seq,
         std::memory_order_release);
     // FIXME: Write out the nops still?
   }
   return true;
 }
 
 bool patchFunctionExit(const bool Enable, const uint32_t FuncId,
-                       const XRaySledEntry &Sled) {
+                       const XRaySledEntry &Sled) XRAY_NEVER_INSTRUMENT {
   // Here we do the dance of replacing the following sled:
   //
   // xray_sled_n:
   //   ret
   //   <10 byte nop>
   //
   // With the following:
   //
std::atomic_store_explicit(
         reinterpret_cast<std::atomic<uint8_t> *>(Sled.Address), RetOpCode,
         std::memory_order_release);
     // FIXME: Write out the nops still?
   }
   return true;
 }
 
 bool patchFunctionTailExit(const bool Enable, const uint32_t FuncId,
-                           const XRaySledEntry &Sled) {
+                           const XRaySledEntry &Sled) XRAY_NEVER_INSTRUMENT {
   // Here we do the dance of replacing the tail call sled with a similar
   // sequence as the entry sled, but calls the tail exit sled instead.
   int64_t TrampolineOffset =
       reinterpret_cast<int64_t>(__xray_FunctionTailExit) -
       (static_cast<int64_t>(Sled.Address) + 11);
   if (TrampolineOffset < MinOffset || TrampolineOffset > MaxOffset) {
     Report("XRay Exit trampoline (%p) too far from sled (%p); distance = "
            "%ld\n",