[XRay] [compiler-rt] [macosx] Add getTSCFrequency implementation for macOS.

[nglevin]

Summary

Use mach_absolute_time and mach_timebase as an alternative to clock_gettime(2) on macOS platforms, to support earlier versions of the OS.

[dberris]

Just one suggestion below.

Thanks, @nglevin!

lib/xray/xray_x86_64.cc

103–105

You can turn this into an "assured once" initialisation by doing something like:

static const mach_timebase_info_data_t TI = [] {
  mach_timebase_info_data_t LocalTI;
  mach_timebase_info(&LocalTI);
  return LocalTI;
}();

This way you let the compiler do the ensuring that the object is initialised once, and only on the first time it's invoked, in a thread-safe manner.

[kubamracek]

lib/xray/xray_x86_64.cc

109

Why are we returning "current time" when the function is supposed to return "TSC frequency"? How is a current timestamp a frequency value?

[nglevin]

Transform mach_timebase_info_data_t into an "assured once" initialisation, per feedback.

[nglevin]

Add Mac-specific fallback logic to readTSC, retrieve "getTSCFrequency" via sysctlbyname using the XNU specific name of "machdep.tsc.frequency".

[nglevin]

Correct Mac sysctl name.

[nglevin]

lib/xray/xray_x86_64.cc

109

That was supposed to be the fallback logic that I had discussed earlier with Dean.

My fault for putting this in the wrong file, where here, I should be using sysctl directly instead of a clock_gettime()-like workaround. As was previously done in the *BSD code path.

Corrected.

[dberris]

lib/xray/xray_x86_64.cc

85

Please follow the naming convention around this file -- local variables are TitleCased.

Also, use a function-local static constexpr character array instead of a non-const pointer.

static constexpr char SysCtlTSCName[] = "...";

lib/xray/xray_tsc.h

 //   To get the measurements per second, we scale this by the number of
 //   nanoseconds per second, pretending that the TSC frequency is 1GHz and
 //   one TSC tick is 1 nanosecond.
 #include "sanitizer_common/sanitizer_common.h"
 #include "sanitizer_common/sanitizer_internal_defs.h"
 #include "xray_defs.h"
 #include <cerrno>
 #include <cstdint>
+#if SANITIZER_MAC
+#include <mach/mach_time.h>
+#else
 #include <time.h>
+#endif
 
 namespace __xray {
 
 inline bool probeRequiredCPUFeatures() XRAY_NEVER_INSTRUMENT { return true; }
 
 ALWAYS_INLINE uint64_t readTSC(uint8_t &CPU) XRAY_NEVER_INSTRUMENT {
+#if SANITIZER_MAC
+  static const mach_timebase_info_data_t TI = [] {
+    mach_timebase_info_data_t LocalTI;
+    mach_timebase_info(&LocalTI);
+    return LocalTI;
+  }();
+  uint64_t currentTime = mach_absolute_time();
+  currentTime *= TI.numer;
+  currentTime /= TI.denom;
+  CPU = 0;
+  return currentTime;
+#else
   timespec TS;
   int result = clock_gettime(CLOCK_REALTIME, &TS);
   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;
+#endif
 }
 
 inline uint64_t getTSCFrequency() XRAY_NEVER_INSTRUMENT {
   return NanosecondsPerSecond;
 }
 
 } // namespace __xray
 
 #else
 #error Target architecture is not supported.
 #endif // CPU architecture
 
 #endif // XRAY_EMULATE_TSC_H

lib/xray/xray_x86_64.cc

 #include "cpuid.h"
 #include "sanitizer_common/sanitizer_common.h"
 #include "xray_defs.h"
 #include "xray_interface_internal.h"
 
-#if SANITIZER_FREEBSD || SANITIZER_NETBSD
+#if SANITIZER_FREEBSD || SANITIZER_NETBSD || SANITIZER_MAC
 #include <sys/types.h>
 #include <sys/sysctl.h>
 #endif
 
 #include <atomic>
 #include <cstdint>
 #include <errno.h>
 #include <fcntl.h>
TSCFrequency *= 1000;
                  "/sys/devices/system/cpu/cpu0/cpufreq/cpuinfo_max_freq",
                  &TSCFrequency)) {
     TSCFrequency *= 1000;
   } else {
     Report("Unable to determine CPU frequency for TSC accounting.\n");
   }
   return TSCFrequency == -1 ? 0 : static_cast<uint64_t>(TSCFrequency);
 }
-#elif SANITIZER_FREEBSD || SANITIZER_NETBSD
+#elif SANITIZER_FREEBSD || SANITIZER_NETBSD || SANITIZER_MAC
 uint64_t getTSCFrequency() XRAY_NEVER_INSTRUMENT {
     long long TSCFrequency = -1;
     size_t tscfreqsz = sizeof(TSCFrequency);
-
-    if (sysctlbyname("machdep.tsc_freq", &TSCFrequency, &tscfreqsz,
+#ifdef SANITIZER_MAC
+    const char* sysctltscname = "machdep.tsc_freq";
+#else
+    const char* sysctltscname = "machdep.tsc.frequency";
+#endif
+    if (sysctlbyname(sysctltscname, &TSCFrequency, &tscfreqsz,
         NULL, 0) != -1) {
         return static_cast<uint64_t>(TSCFrequency);
     } else {
       Report("Unable to determine CPU frequency for TSC accounting.\n");
     }
 
     return 0;
     
 }
 #else
 uint64_t getTSCFrequency() XRAY_NEVER_INSTRUMENT {
     /* Not supported */
     return 0;
 }
 #endif
 
 static constexpr uint8_t CallOpCode = 0xe8;
 static constexpr uint16_t MovR10Seq = 0xba41;
 static constexpr uint16_t Jmp9Seq = 0x09eb;
 static constexpr uint16_t Jmp20Seq = 0x14eb;
 static constexpr uint16_t Jmp15Seq = 0x0feb;
 static constexpr uint8_t JmpOpCode = 0xe9;
 static constexpr uint8_t RetOpCode = 0xc3;
 static constexpr uint16_t NopwSeq = 0x9066;
 
 static constexpr int64_t MinOffset{std::numeric_limits<int32_t>::min()};
 static constexpr int64_t MaxOffset{std::numeric_limits<int32_t>::max()};