1 files changed, 17 insertions, 15 deletions

diff --git a/lib/xray/xray_init.cc b/lib/xray/xray_init.cc
index 11892cb8b7a3..b4e069795195 100644
--- a/lib/xray/xray_init.cc
+++ b/lib/xray/xray_init.cc
@@ -38,32 +38,29 @@ using namespace __xray;
 //
 // FIXME: Support DSO instrumentation maps too. The current solution only works
 // for statically linked executables.
-__sanitizer::atomic_uint8_t XRayInitialized{0};
+atomic_uint8_t XRayInitialized{0};
 
 // This should always be updated before XRayInitialized is updated.
-__sanitizer::SpinMutex XRayInstrMapMutex;
+SpinMutex XRayInstrMapMutex;
 XRaySledMap XRayInstrMap;
 
 // Global flag to determine whether the flags have been initialized.
-__sanitizer::atomic_uint8_t XRayFlagsInitialized{0};
+atomic_uint8_t XRayFlagsInitialized{0};
 
 // A mutex to allow only one thread to initialize the XRay data structures.
-__sanitizer::SpinMutex XRayInitMutex;
+SpinMutex XRayInitMutex;
 
 // __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() XRAY_NEVER_INSTRUMENT {
-  __sanitizer::SpinMutexLock Guard(&XRayInitMutex);
+  SpinMutexLock Guard(&XRayInitMutex);
   // Short-circuit if we've already initialized XRay before.
-  if (__sanitizer::atomic_load(&XRayInitialized,
-                               __sanitizer::memory_order_acquire))
+  if (atomic_load(&XRayInitialized, memory_order_acquire))
     return;
 
-  if (!__sanitizer::atomic_load(&XRayFlagsInitialized,
-                                __sanitizer::memory_order_acquire)) {
+  if (!atomic_load(&XRayFlagsInitialized, memory_order_acquire)) {
     initializeFlags();
-    __sanitizer::atomic_store(&XRayFlagsInitialized, true,
-                              __sanitizer::memory_order_release);
+    atomic_store(&XRayFlagsInitialized, true, memory_order_release);
   }
 
   if (__start_xray_instr_map == nullptr) {
@@ -73,14 +70,13 @@ void __xray_init() XRAY_NEVER_INSTRUMENT {
   }
 
   {
-    __sanitizer::SpinMutexLock Guard(&XRayInstrMapMutex);
+    SpinMutexLock Guard(&XRayInstrMapMutex);
     XRayInstrMap.Sleds = __start_xray_instr_map;
     XRayInstrMap.Entries = __stop_xray_instr_map - __start_xray_instr_map;
     XRayInstrMap.SledsIndex = __start_xray_fn_idx;
     XRayInstrMap.Functions = __stop_xray_fn_idx - __start_xray_fn_idx;
   }
-  __sanitizer::atomic_store(&XRayInitialized, true,
-                            __sanitizer::memory_order_release);
+  atomic_store(&XRayInitialized, true, memory_order_release);
 
 #ifndef XRAY_NO_PREINIT
   if (flags()->patch_premain)
@@ -88,7 +84,13 @@ void __xray_init() XRAY_NEVER_INSTRUMENT {
 #endif
 }
 
-#if !defined(XRAY_NO_PREINIT) && SANITIZER_CAN_USE_PREINIT_ARRAY
+// FIXME: Make check-xray tests work on FreeBSD without
+// SANITIZER_CAN_USE_PREINIT_ARRAY.
+// See sanitizer_internal_defs.h where the macro is defined.
+// Calling unresolved PLT functions in .preinit_array can lead to deadlock on
+// FreeBSD but here it seems benign.
+#if !defined(XRAY_NO_PREINIT) &&                                               \
+    (SANITIZER_CAN_USE_PREINIT_ARRAY || SANITIZER_FREEBSD)
 // Only add the preinit array initialization if the sanitizers can.
 __attribute__((section(".preinit_array"),
                used)) void (*__local_xray_preinit)(void) = __xray_init;