[XRay] Probe for CPU features that XRay needs

[dberris]

Summary

In llvm.org/PR31756 it's pointed out that sometimes rdtscp isn't
available. We fix it here by checking first whether it's availble before
installing the logging handler. In future commits we can have
alternative implementations, maybe working around some of the
constraints on some systems.

This change enables us to make that determination, but report an error
instead when the features aren't available.

[pelikan]

Nitpick (user-first): When false, the user will only see "Some CPU features are missing", not which ones. I'd do another Report in the amd64 function specifically bragging about RDTSCP. Most of these will be because of people running in too-restrictive VMs and will be resolved by "d'oh!" and fixing the support.

[dberris]

• Add more specific logging for probing errors.

[dberris]

In D29438#664410, @pelikan wrote:

Nitpick (user-first): When false, the user will only see "Some CPU features are missing", not which ones. I'd do another Report in the amd64 function specifically bragging about RDTSCP. Most of these will be because of people running in too-restrictive VMs and will be resolved by "d'oh!" and fixing the support.

All good, that's a good idea anyway. I've made a change, PTAL?

[pelikan]

LGTM.

[jbulow]

probeRequiredCPUFeatures does not detect rdtscp correctly.

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

211–213

1u<<26 == 0x4000000

Changing 26 to 27 solves this problem when running with xray enabled:

==20069==Missing rdtscp support.

[dberris]

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

211–213

Oh wow, that's embarrassing! Good catch, thanks @jbulow!

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

bool patchFunctionExit(const bool Enable, const uint32_t FuncId,
   return patchSled(Enable, FuncId, Sled, __xray_FunctionExit);
 }
 
 bool patchFunctionTailExit(const bool Enable, const uint32_t FuncId,
                            const XRaySledEntry &Sled) XRAY_NEVER_INSTRUMENT {
   return patchSled(Enable, FuncId, Sled, __xray_FunctionTailExit);
 }
 
+// FIXME: Maybe implement this better?
+bool probeRequiredCPUFeatures() XRAY_NEVER_INSTRUMENT { return true; }
+
 } // namespace __xray

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

bool patchFunctionExit(const bool Enable, const uint32_t FuncId,
   return patchSled(Enable, FuncId, Sled, __xray_FunctionExit);
 }
 
 bool patchFunctionTailExit(const bool Enable, const uint32_t FuncId,
                            const XRaySledEntry &Sled) XRAY_NEVER_INSTRUMENT {
   return patchSled(Enable, FuncId, Sled, __xray_FunctionTailExit);
 }
 
+// FIXME: Maybe implement this better?
+bool probeRequiredCPUFeatures() XRAY_NEVER_INSTRUMENT { return true; }
+
 } // namespace __xray

compiler-rt/trunk/lib/xray/xray_emulate_tsc.h

ALWAYS_INLINE uint64_t readTSC(uint8_t &CPU) XRAY_NEVER_INSTRUMENT {
   if (result != 0) {
     Report("clock_gettime(2) returned %d, errno=%d.", result, int(errno));
     TS.tv_sec = 0;
     TS.tv_nsec = 0;
   }
   CPU = 0;
   return TS.tv_sec * NanosecondsPerSecond + TS.tv_nsec;
 }
-}
+
+bool probeRequiredCPUFeatures();
+
+} // namespace __xray
 
 #endif // XRAY_EMULATE_TSC_H

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

if (Offset == BuffLen) {
     auto RecordBuffer = reinterpret_cast<__xray::XRayRecord *>(InMemoryBuffer);
     retryingWriteAll(Fd, reinterpret_cast<char *>(RecordBuffer),
                      reinterpret_cast<char *>(RecordBuffer + Offset));
     Offset = 0;
   }
 }
 
 static auto Unused = [] {
+  if (!probeRequiredCPUFeatures()) {
+    Report("Required CPU features missing for XRay instrumentation, not "
+           "installing instrumentation hooks.\n");
+    return false;
+  }
   if (flags()->xray_naive_log)
     __xray_set_handler(__xray_InMemoryRawLog);
   return true;
 }();

compiler-rt/trunk/lib/xray/xray_x86_64.h

 namespace __xray {
 
 ALWAYS_INLINE uint64_t readTSC(uint8_t &CPU) XRAY_NEVER_INSTRUMENT {
   unsigned LongCPU;
   uint64_t TSC = __rdtscp(&LongCPU);
   CPU = LongCPU;
   return TSC;
 }
+
+bool probeRequiredCPUFeatures();
+
 } // namespace __xray
 
 #endif // XRAY_X86_64_H

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

+#include "cpuid.h"
 #include "sanitizer_common/sanitizer_common.h"
 #include "xray_defs.h"
 #include "xray_interface_internal.h"
+
 #include <atomic>
 #include <cstdint>
 #include <errno.h>
 #include <fcntl.h>
 #include <iterator>
 #include <limits>
 #include <tuple>
 #include <unistd.h>

 }
 
 uint64_t cycleFrequency() XRAY_NEVER_INSTRUMENT {
   long long CPUFrequency = -1;
   if (readValueFromFile("/sys/devices/system/cpu/cpu0/tsc_freq_khz",
                         &CPUFrequency)) {
     CPUFrequency *= 1000;
   } else if (readValueFromFile(
                  "/sys/devices/system/cpu/cpu0/cpufreq/cpuinfo_max_freq",
                  &CPUFrequency)) {
     CPUFrequency *= 1000;
   } else {
     Report("Unable to determine CPU frequency for TSC accounting.\n");
   }
   return CPUFrequency == -1 ? 0 : static_cast<uint64_t>(CPUFrequency);
 }
 
 static constexpr uint8_t CallOpCode = 0xe8;
if (Enable) {
     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;
 }
 
+// We determine whether the CPU we're running on has the correct features we
+// need. In x86_64 this will be rdtscp support.
+bool probeRequiredCPUFeatures() XRAY_NEVER_INSTRUMENT {
+  unsigned int EAX, EBX, ECX, EDX;
+
+  // We check whether rdtscp support is enabled. According to the x86_64 manual,
+  // level should be set at 0x80000001, and we should have a look at bit 27 in
+  // EDX. That's 0x8000000 (or 1u << 26).
+  __get_cpuid(0x80000001, &EAX, &EBX, &ECX, &EDX);
+  if (!(EDX & (1u << 26))) {
+    Report("Missing rdtscp support.\n");
+    return false;
+  }
+  return true;
+}
+
 } // namespace __xray