[XRay] Support for Fuchsia

[phosek]

Summary

This extends XRay to support Fuchsia.

[dberris]

LGTM -- while I think there might be an opportunity for further cleaning up and isolating the platform-specific bits into different files/directories, in the meantime I suspect adding these preprocessor directives is sufficient.

[mcgrathr]

compiler-rt/lib/xray/xray_allocator.h

54

Need _zx_handle_close(Vmo); here (before the error check but after the use).

96

Be consistent: either "VMO" or "VM object" in all messages.
s/%d/%zu/

104

Need _zx_handle_close(Vmo); here (before the error check but after the use).

106

s/%d/%zu/

131

It wouldn't hurt to just define internal_munmap this way for Fuchsia if it reduces the #if load.

compiler-rt/lib/xray/xray_buffer_queue.cc

19

These are unused in this file. Just use #if !SANITIZER_FUCHSIA around the #include "sanitizer_common/sanitizer_posix.h"

compiler-rt/lib/xray/xray_init.cc

20 ↗

(On Diff #165709)

unused

compiler-rt/lib/xray/xray_interface.cc

291

Just make MProtectHelper do this itself.

compiler-rt/lib/xray/xray_profile_collector.cc

21 ↗

(On Diff #165709)

unused

compiler-rt/lib/xray/xray_utils.cc

43

I'd use inline constexpr const char* ProfileSinkName = "llvm-xray";.
That makes the string constant mergeable.

59

You can save the syscall when Offset % PAGE_SIZE == (Offset + TotalBytes) % PAGE_SIZE.

75

Comment: // Nothing to do here since WriteAll writes directly into the VMO.

78

Since this is just for the PID, I'd move it down next to where that's used and change the comment to say "Get the KOID of the current process to use in the VMO name."

84

I think it's more useful if this message says zx_object_get_info(_zx_process_self(), ZX_INFO_HANDLE_BASIC) failed: %s.

103

... and LogWriter needs to hold onto it.

107

s/VMO/& handle/

111

// Publish the VMO that receives the logging. Note the VMO's contents can grow and change after publication. The contents won't be read out until after the process exits.

115

Put "{{{dumpfile:%s:%s}}}" into a macro in sanitizer_symbolizer_fuchsia.h and make sanitizer_coverage_fuchsia.cc and this both use it.
Unfortunately it can't be a constexpr like the others there because you need string concatenation with it.

126

Comment after #else and #endif below.

compiler-rt/lib/xray/xray_x86_64.cc

112

This shouldn't be here. On Fuchsia, all of this logic to read the TSC and so forth should not be used.
Instead, on all machines it should call _zx_ticks_get() to sample and _zx_ticks_per_second() to set CycleFrequency.

[phosek]

compiler-rt/lib/xray/xray_utils.cc

43

compiler-rt uses C++11 but inline constexpr is a C++17 construct.

[mcgrathr]

compiler-rt/lib/xray/xray_allocator.h

56

This needs to be outside (before) the if.

106

ditto

compiler-rt/lib/xray/xray_utils.cc

43

Since this is not inside a class, I don't think inline actually makes a difference. The advice to use a string literal rather than a const array stands.

45

This function is actually dead. Just remove it.

136

dead

compiler-rt/lib/xray/xray_x86_64.cc

113

Drop the cast. zx_ticks_t is just uint64_t and if it changed so this conversion did something, we'd want the warnings about it.
Use _zx_* names.

[mcgrathr]

compiler-rt/lib/xray/xray_tsc.h

32

Why not make this an inline like the clock_gettime case below does?

34

Likewise.

compiler-rt/lib/xray/xray_utils.cc

180

s/of/of the/

compiler-rt/lib/xray/xray_x86_64.cc

334

This code is wrong for Fuchsia. There's nothing to do here but return true.

[mcgrathr]

lgtm

compiler-rt/cmake/config-ix.cmake

 if (COMPILER_RT_HAS_SANITIZER_COMMON AND SCUDO_SUPPORTED_ARCH AND
     OS_NAME MATCHES "Linux|Android|Fuchsia")
   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 "Darwin|Linux|FreeBSD|NetBSD|OpenBSD")
+    OS_NAME MATCHES "Darwin|Linux|FreeBSD|NetBSD|OpenBSD|Fuchsia")
   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 "Android|Darwin|Linux|NetBSD|FreeBSD|OpenBSD|Fuchsia|Windows" AND
     # TODO: Support builds with MSVC.

compiler-rt/lib/sanitizer_common/sanitizer_coverage_fuchsia.cc

 // data out to somewhere that it can be fed into the sancov tool (where and
 // how is not our problem).
 
 #include "sanitizer_platform.h"
 #if SANITIZER_FUCHSIA
 #include "sanitizer_atomic.h"
 #include "sanitizer_common.h"
 #include "sanitizer_internal_defs.h"
+#include "sanitizer_symbolizer_fuchsia.h"
 
 #include <zircon/process.h>
 #include <zircon/sanitizer.h>
 #include <zircon/syscalls.h>
 
 using namespace __sanitizer;  // NOLINT
 
 namespace __sancov {
if (array_) {
       __sanitizer_publish_data(kSancovSinkName, vmo_);
       vmo_ = ZX_HANDLE_INVALID;
 
       // This will route to __sanitizer_log_write, which will ensure that
       // information about shared libraries is written out.  This message
       // uses the `dumpfile` symbolizer markup element to highlight the
       // dump.  See the explanation for this in:
       // https://fuchsia.googlesource.com/zircon/+/master/docs/symbolizer_markup.md
-      Printf("SanitizerCoverage: {{{dumpfile:%s:%s}}} with up to %u PCs\n",
+      Printf("SanitizerCoverage: " FORMAT_DUMPFILE " with up to %u PCs\n",
              kSancovSinkName, vmo_name_, next_index_ - 1);
     }
   }
 
  private:
   // We map in the largest possible view into the VMO: one word
   // for every possible 32-bit index value.  This avoids the need
   // to change the mapping when increasing the size of the VMO.

compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_fuchsia.h

 constexpr uptr kFormatFunctionMax = 64;  // More than big enough for 64-bit hex.
 
 // Global variable name or equivalent from data memory address.
 constexpr const char *kFormatData = "{{{data:%p}}}";
 
 // One frame in a backtrace (printed on a line by itself).
 constexpr const char *kFormatFrame = "{{{bt:%u:%p}}}";
 
+// Dump trigger element.
+#define FORMAT_DUMPFILE "{{{dumpfile:%s:%s}}}"
+
 }  // namespace __sanitizer
 
 #endif  // SANITIZER_SYMBOLIZER_FUCHSIA_H

compiler-rt/lib/xray/xray_allocator.h

 //
 //===----------------------------------------------------------------------===//
 #ifndef XRAY_ALLOCATOR_H
 #define XRAY_ALLOCATOR_H
 
 #include "sanitizer_common/sanitizer_common.h"
 #include "sanitizer_common/sanitizer_internal_defs.h"
 #include "sanitizer_common/sanitizer_mutex.h"
+#if SANITIZER_FUCHSIA
+#include <zircon/process.h>
+#include <zircon/syscalls.h>
+#include <zircon/status.h>
+#else
 #include "sanitizer_common/sanitizer_posix.h"
+#endif
 #include "xray_defs.h"
 #include "xray_utils.h"
 #include <cstddef>
 #include <cstdint>
 #include <sys/mman.h>
 
 namespace __xray {
 
 // We implement our own memory allocation routine which will bypass the
 // internal allocator. This allows us to manage the memory directly, using
 // mmap'ed memory to back the allocators.
 template <class T> T *allocate() XRAY_NEVER_INSTRUMENT {
   uptr RoundedSize = RoundUpTo(sizeof(T), GetPageSizeCached());
+#if SANITIZER_FUCHSIA
+  zx_handle_t Vmo;
+  zx_status_t Status = _zx_vmo_create(RoundedSize, 0, &Vmo);
+  if (Status != ZX_OK) {
+    if (Verbosity())
+      Report("XRay Profiling: Failed to create VMO of size %zu: %s\n",
+             sizeof(T), _zx_status_get_string(Status));
+    return nullptr;
+  }
+  uintptr_t B;
+  Status =
+    _zx_vmar_map(_zx_vmar_root_self(), ZX_VM_PERM_READ | ZX_VM_PERM_WRITE, 0,
+                 Vmo, 0, sizeof(T), &B);
+  if (Status != ZX_OK) {
+    _zx_handle_close(Vmo);
+    if (Verbosity())
+      Report("XRay Profiling: Failed to map VMAR of size %zu: %s\n",
+             sizeof(T), _zx_status_get_string(Status));
+    return nullptr;
+  }
+  return reinterpret_cast<T *>(B);
+#else
   uptr B = internal_mmap(NULL, RoundedSize, PROT_READ | PROT_WRITE,
                          MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
   int ErrNo;
   if (UNLIKELY(internal_iserror(B, &ErrNo))) {
     if (Verbosity())
       Report(
           "XRay Profiling: Failed to allocate memory of size %d; Error = %d.\n",
           RoundedSize, B);
     return nullptr;
   }
+#endif
   return reinterpret_cast<T *>(B);
 }
 
 template <class T> void deallocate(T *B) XRAY_NEVER_INSTRUMENT {
   if (B == nullptr)
     return;
   uptr RoundedSize = RoundUpTo(sizeof(T), GetPageSizeCached());
+#if SANITIZER_FUCHSIA
+  _zx_vmar_unmap(_zx_vmar_root_self(),
+                 reinterpret_cast<uintptr_t>(B), RoundedSize);
+#else
   internal_munmap(B, RoundedSize);
+#endif
 }
 
 template <class T = uint8_t> T *allocateBuffer(size_t S) XRAY_NEVER_INSTRUMENT {
   uptr RoundedSize = RoundUpTo(S * sizeof(T), GetPageSizeCached());
+#if SANITIZER_FUCHSIA
+  zx_handle_t Vmo;
+  zx_status_t Status = _zx_vmo_create(RoundedSize, 0, &Vmo);
+  if (Status != ZX_OK) {
+    if (Verbosity())
+      Report("XRay Profiling: Failed to create VMO of size %zu: %s\n",
+             S, _zx_status_get_string(Status));
+    return nullptr;
+  }
+  uintptr_t B;
+  Status =
+    _zx_vmar_map(_zx_vmar_root_self(), ZX_VM_PERM_READ | ZX_VM_PERM_WRITE, 0,
+                 Vmo, 0, S, &B);
+  if (Status != ZX_OK) {
+    _zx_handle_close(Vmo);
+    if (Verbosity())
+      Report("XRay Profiling: Failed to map VMAR of size %zu: %s\n",
+             S, _zx_status_get_string(Status));
+    return nullptr;
+  }
+#else
   uptr B = internal_mmap(NULL, RoundedSize, PROT_READ | PROT_WRITE,
                          MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
   int ErrNo;
   if (UNLIKELY(internal_iserror(B, &ErrNo))) {
     if (Verbosity())
       Report(
           "XRay Profiling: Failed to allocate memory of size %d; Error = %d.\n",
           RoundedSize, B);
     return nullptr;
   }
+#endif
   return reinterpret_cast<T *>(B);
 }
 
 template <class T> void deallocateBuffer(T *B, size_t S) XRAY_NEVER_INSTRUMENT {
   if (B == nullptr)
     return;
   uptr RoundedSize = RoundUpTo(S * sizeof(T), GetPageSizeCached());
+#if SANITIZER_FUCHSIA
+  _zx_vmar_unmap(_zx_vmar_root_self(), reinterpret_cast<uintptr_t>(B), RoundedSize);
+#else
   internal_munmap(B, RoundedSize);
+#endif
 }
 
 template <class T, class... U>
 T *initArray(size_t N, U &&... Us) XRAY_NEVER_INSTRUMENT {
   auto A = allocateBuffer<T>(N);
   if (A != nullptr)
     while (N > 0)
       new (A + (--N)) T(std::forward<U>(Us)...);

compiler-rt/lib/xray/xray_basic_logging.cc

 // routines for exporting data to files.
 //
 //===----------------------------------------------------------------------===//
 
 #include <errno.h>
 #include <fcntl.h>
 #include <pthread.h>
 #include <sys/stat.h>
+#if SANITIZER_FREEBSD || SANITIZER_NETBSD || SANITIZER_OPENBSD || SANITIZER_MAC
 #include <sys/syscall.h>
+#endif
 #include <sys/types.h>
 #include <time.h>
 #include <unistd.h>
 
 #include "sanitizer_common/sanitizer_allocator_internal.h"
 #include "sanitizer_common/sanitizer_libc.h"
 #include "xray/xray_records.h"
 #include "xray_recursion_guard.h"

compiler-rt/lib/xray/xray_buffer_queue.cc

 // This file is a part of XRay, a dynamic runtime instruementation system.
 //
 // Defines the interface for a buffer queue implementation.
 //
 //===----------------------------------------------------------------------===//
 #include "xray_buffer_queue.h"
 #include "sanitizer_common/sanitizer_common.h"
 #include "sanitizer_common/sanitizer_libc.h"
+#if !SANITIZER_FUCHSIA
 #include "sanitizer_common/sanitizer_posix.h"
+#endif
 #include "xray_allocator.h"
 #include "xray_defs.h"
 #include <memory>
 #include <sys/mman.h>
 
 using namespace __xray;
 using namespace __sanitizer;
 

compiler-rt/lib/xray/xray_fdr_logging.cc

 //
 //===----------------------------------------------------------------------===//
 #include "xray_fdr_logging.h"
 #include <cassert>
 #include <errno.h>
 #include <limits>
 #include <memory>
 #include <pthread.h>
-#include <sys/syscall.h>
 #include <sys/time.h>
 #include <time.h>
 #include <unistd.h>
 
 #include "sanitizer_common/sanitizer_allocator_internal.h"
 #include "sanitizer_common/sanitizer_atomic.h"
 #include "sanitizer_common/sanitizer_common.h"
 #include "xray/xray_interface.h"

compiler-rt/lib/xray/xray_interface.cc

 
 #include <cstdint>
 #include <cstdio>
 #include <errno.h>
 #include <limits>
 #include <string.h>
 #include <sys/mman.h>
 
+#if SANITIZER_FUCHSIA
+#include <zircon/process.h>
+#include <zircon/sanitizer.h>
+#include <zircon/status.h>
+#include <zircon/syscalls.h>
+#endif
+
 #include "sanitizer_common/sanitizer_addrhashmap.h"
 #include "sanitizer_common/sanitizer_common.h"
 
 #include "xray_defs.h"
 #include "xray_flags.h"
 
 extern __sanitizer::SpinMutex XRayInstrMapMutex;
 extern __sanitizer::atomic_uint8_t XRayInitialized;

 // originally read-and-execute only.
 class MProtectHelper {
   void *PageAlignedAddr;
   std::size_t MProtectLen;
   bool MustCleanup;
 
 public:
   explicit MProtectHelper(void *PageAlignedAddr,
-                          std::size_t MProtectLen) XRAY_NEVER_INSTRUMENT
+                          std::size_t MProtectLen,
+                          std::size_t PageSize) XRAY_NEVER_INSTRUMENT
       : PageAlignedAddr(PageAlignedAddr),
         MProtectLen(MProtectLen),
-        MustCleanup(false) {}
+        MustCleanup(false) {
+#if SANITIZER_FUCHSIA
+    MProtectLen = RoundUpTo(MProtectLen, PageSize);
+#endif
+  }
 
   int MakeWriteable() XRAY_NEVER_INSTRUMENT {
+#if SANITIZER_FUCHSIA
+    auto R = __sanitizer_change_code_protection(
+        reinterpret_cast<uintptr_t>(PageAlignedAddr), MProtectLen, true);
+    if (R != ZX_OK) {
+      Report("XRay: cannot change code protection: %s\n",
+             _zx_status_get_string(R));
+      return -1;
+    }
+    MustCleanup = true;
+    return 0;
+#else
     auto R = mprotect(PageAlignedAddr, MProtectLen,
                       PROT_READ | PROT_WRITE | PROT_EXEC);
     if (R != -1)
       MustCleanup = true;
     return R;
+#endif
   }
 
   ~MProtectHelper() XRAY_NEVER_INSTRUMENT {
     if (MustCleanup) {
+#if SANITIZER_FUCHSIA
+      auto R = __sanitizer_change_code_protection(
+          reinterpret_cast<uintptr_t>(PageAlignedAddr), MProtectLen, false);
+      if (R != ZX_OK) {
+        Report("XRay: cannot change code protection: %s\n",
+               _zx_status_get_string(R));
+      }
+#else
       mprotect(PageAlignedAddr, MProtectLen, PROT_READ | PROT_EXEC);
+#endif
     }
   }
 };
 
 namespace {
 
 bool patchSled(const XRaySledEntry &Sled, bool Enable,
                int32_t FuncId) XRAY_NEVER_INSTRUMENT {
if ((PageSize == 0) || ((PageSize & (PageSize - 1)) != 0)) {
     Report("System page size is not a power of two: %lld\n", PageSize);
     return XRayPatchingStatus::FAILED;
   }
 
   void *PageAlignedAddr =
       reinterpret_cast<void *>(MinSled.Address & ~(PageSize - 1));
   size_t MProtectLen =
       (MaxSled.Address - reinterpret_cast<uptr>(PageAlignedAddr)) + cSledLength;
-  MProtectHelper Protector(PageAlignedAddr, MProtectLen);
+  MProtectHelper Protector(PageAlignedAddr, MProtectLen, PageSize);
   if (Protector.MakeWriteable() == -1) {
     Report("Failed mprotect: %d\n", errno);
     return XRayPatchingStatus::FAILED;
   }
 
   for (std::size_t I = 0; I < InstrMap.Entries; ++I) {
     auto &Sled = InstrMap.Sleds[I];
     auto F = Sled.Function;
     if (CurFun == 0)
if (f->Address > MaxSled.Address)
       MaxSled = *f;
     ++f;
   }
 
   void *PageAlignedAddr =
       reinterpret_cast<void *>(MinSled.Address & ~(PageSize - 1));
   size_t MProtectLen =
       (MaxSled.Address - reinterpret_cast<uptr>(PageAlignedAddr)) + cSledLength;
-  MProtectHelper Protector(PageAlignedAddr, MProtectLen);
+  MProtectHelper Protector(PageAlignedAddr, MProtectLen, PageSize);
   if (Protector.MakeWriteable() == -1) {
     Report("Failed mprotect: %d\n", errno);
     return XRayPatchingStatus::FAILED;
   }
   return patchFunction(FuncId, Enable);
 }
 
 } // namespace

compiler-rt/lib/xray/xray_tsc.h

 //===-- xray_tsc.h ----------------------------------------------*- C++ -*-===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
 #ifndef XRAY_EMULATE_TSC_H
 #define XRAY_EMULATE_TSC_H
 
+#include "sanitizer_common/sanitizer_common.h"
+
 namespace __xray {
 static constexpr uint64_t NanosecondsPerSecond = 1000ULL * 1000 * 1000;
 }
 
+#if SANITIZER_FUCHSIA
+#include <zircon/syscalls.h>
+
+namespace __xray {
+
+ALWAYS_INLINE uint64_t readTSC(uint8_t &CPU) XRAY_NEVER_INSTRUMENT {
+  CPU = 0;
+  return _zx_ticks_get();
+}
+
+uint64_t getTSCFrequency();
+
+bool probeRequiredCPUFeatures();
+
+} // namespace __xray
+
+#else // SANITIZER_FUCHSIA
+
 #if defined(__x86_64__)
 #include "xray_x86_64.inc"
 #elif defined(__powerpc64__)
 #include "xray_powerpc64.inc"
 #elif defined(__arm__) || defined(__aarch64__) || defined(__mips__)
 // Emulated TSC.
 // There is no instruction like RDTSCP in user mode on ARM. ARM's CP15 does
 //   not have a constant frequency like TSC on x86(_64), it may go faster
inline uint64_t getTSCFrequency() XRAY_NEVER_INSTRUMENT {
   return NanosecondsPerSecond;
 }
 
 } // namespace __xray
 
 #else
 #error Target architecture is not supported.
 #endif // CPU architecture
+#endif // SANITIZER_FUCHSIA
 
 #endif // XRAY_EMULATE_TSC_H

compiler-rt/lib/xray/xray_utils.h

 #ifndef XRAY_UTILS_H
 #define XRAY_UTILS_H
 
 #include <cstddef>
 #include <cstdint>
 #include <sys/types.h>
 #include <utility>
 
+#include "sanitizer_common/sanitizer_common.h"
+#if SANITIZER_FUCHSIA
+#include <zircon/types.h>
+#endif
+
 namespace __xray {
 
 class LogWriter {
 public:
+#if SANITIZER_FUCHSIA
+ LogWriter(zx_handle_t Vmo) : Vmo(Vmo) {}
+#else
   explicit LogWriter(int Fd) : Fd(Fd) {}
-  ~LogWriter();
+#endif
 
-  // Write a character range into a log.
-  void WriteAll(const char *Begin, const char *End);
 
-  void Flush();
 
-  // Returns a new log instance initialized using the flag-provided values.
-  static LogWriter *Open();
-  // Closes and deallocates the log instance.
-  static void Close(LogWriter *LogWriter);
 
 private:
-  int Fd = -1;
+#if SANITIZER_FUCHSIA
+ zx_handle_t Vmo = ZX_HANDLE_INVALID;
+ uint64_t Offset = 0;
+#else
+#endif
 };
 
 // Default implementation of the reporting interface for sanitizer errors.
 void printToStdErr(const char *Buffer);
 
 constexpr size_t gcd(size_t a, size_t b) {
   return (b == 0) ? a : gcd(b, a % b);
 }

compiler-rt/lib/xray/xray_utils.cc

 #include <fcntl.h>
 #include <iterator>
 #include <stdlib.h>
 #include <sys/types.h>
 #include <tuple>
 #include <unistd.h>
 #include <utility>
 
+#if SANITIZER_FUCHSIA
+#include "sanitizer_common/sanitizer_symbolizer_fuchsia.h"
+
+#include <inttypes.h>
+#include <zircon/process.h>
+#include <zircon/sanitizer.h>
+#include <zircon/status.h>
+#include <zircon/syscalls.h>
+#endif
+
 namespace __xray {
 
+#if SANITIZER_FUCHSIA
+static const char ProfileSinkName[] = "llvm-xray";
+
+void printToStdErr(const char *Buffer) XRAY_NEVER_INSTRUMENT {
+  __sanitizer_log_write(Buffer, strlen(Buffer));
+}
+
+LogWriter::~LogWriter() {
+  _zx_handle_close(Vmo);
+}
+
+void LogWriter::WriteAll(const char *Begin, const char *End) XRAY_NEVER_INSTRUMENT {
+  if (Begin == End)
+    return;
+  auto TotalBytes = std::distance(Begin, End);
+
+  const size_t PageSize = flags()->xray_page_size_override > 0
+                              ? flags()->xray_page_size_override
+                              : GetPageSizeCached();
+  if (RoundUpTo(Offset, PageSize) != RoundUpTo(Offset + TotalBytes, PageSize)) {
+    // Resize the VMO to ensure there's sufficient space for the data.
+    zx_status_t Status = _zx_vmo_set_size(Vmo, Offset + TotalBytes);
+    if (Status != ZX_OK) {
+      Report("Failed to resize VMO: %s\n", _zx_status_get_string(Status));
+      return;
+    }
+  }
+
+  // Write the data into VMO.
+  zx_status_t Status = _zx_vmo_write(Vmo, Begin, Offset, TotalBytes);
+  if (Status != ZX_OK) {
+    Report("Failed to write: %s\n", _zx_status_get_string(Status));
+    return;
+  }
+  Offset += TotalBytes;
+}
+
+void LogWriter::Flush() XRAY_NEVER_INSTRUMENT {
+  // Nothing to do here since WriteAll writes directly into the VMO.
+}
+
+LogWriter *LogWriter::Open() XRAY_NEVER_INSTRUMENT {
+  // Create VMO to hold the profile data.
+  zx_handle_t Vmo;
+  zx_status_t Status = _zx_vmo_create(0, 0, &Vmo);
+  if (Status != ZX_OK) {
+    Report("XRay: cannot create VMO: %s\n", _zx_status_get_string(Status));
+    return nullptr;
+  }
+
+  // Get the KOID of the current process to use in the VMO name.
+  zx_info_handle_basic_t Info;
+  Status = _zx_object_get_info(_zx_process_self(), ZX_INFO_HANDLE_BASIC, &Info,
+                               sizeof(Info), NULL, NULL);
+  if (Status != ZX_OK) {
+    Report("XRay: cannot get basic info about current process handle: %s\n",
+           _zx_status_get_string(Status));
+    return nullptr;
+  }
+
+  // Give the VMO a name including our process KOID so it's easy to spot.
+  char VmoName[ZX_MAX_NAME_LEN];
+  internal_snprintf(VmoName, sizeof(VmoName), "%s.%zu", ProfileSinkName,
+                    Info.koid);
+  _zx_object_set_property(Vmo, ZX_PROP_NAME, VmoName, strlen(VmoName));
+
+  // Duplicate the handle since __sanitizer_publish_data consumes it and
+  // LogWriter needs to hold onto it.
+  zx_handle_t Handle;
+  Status =_zx_handle_duplicate(Vmo, ZX_RIGHT_SAME_RIGHTS, &Handle);
+  if (Status != ZX_OK) {
+    Report("XRay: cannot duplicate VMO handle: %s\n",
+           _zx_status_get_string(Status));
+    return nullptr;
+  }
+
+  // Publish the VMO that receives the logging. Note the VMO's contents can
+  // grow and change after publication. The contents won't be read out until
+  // after the process exits.
+  __sanitizer_publish_data(ProfileSinkName, Handle);
+
+  // Use the dumpfile symbolizer markup element to write the name of VMO.
+  Report("XRay: " FORMAT_DUMPFILE "\n", ProfileSinkName, VmoName);
+
+  LogWriter *LW = reinterpret_cast<LogWriter *>(InternalAlloc(sizeof(LogWriter)));
+  new (LW) LogWriter(Vmo);
+  return LW;
+}
+
+void LogWriter::Close(LogWriter *LW) {
+  LW->~LogWriter();
+  InternalFree(LW);
+}
+#else // SANITIZER_FUCHSIA
 void printToStdErr(const char *Buffer) XRAY_NEVER_INSTRUMENT {
   fprintf(stderr, "%s", Buffer);
 }
 
 LogWriter::~LogWriter() {
   internal_close(Fd);
 }
 
 void LogWriter::WriteAll(const char *Begin, const char *End) XRAY_NEVER_INSTRUMENT {
LogWriter *LogWriter::Open() XRAY_NEVER_INSTRUMENT {
   const char *LastSlash = internal_strrchr(Progname, '/');
 
   if (LastSlash != nullptr)
     Progname = LastSlash + 1;
 
   int NeededLength = internal_snprintf(
       TmpFilename, sizeof(TmpFilename), "%s%s.%s",
       flags()->xray_logfile_base, Progname, TmpWildcardPattern);
   if (NeededLength > int(sizeof(TmpFilename))) {
     Report("XRay log file name too long (%d): %s\n", NeededLength, TmpFilename);
     return nullptr;
   }
   int Fd = mkstemp(TmpFilename);
   if (Fd == -1) {
     Report("XRay: Failed opening temporary file '%s'; not logging events.\n",
            TmpFilename);
     return nullptr;
   }
   if (Verbosity())
     Report("XRay: Log file in '%s'\n", TmpFilename);
 
   LogWriter *LW = allocate<LogWriter>();
   new (LW) LogWriter(Fd);
   return LW;
 }
 
 void LogWriter::Close(LogWriter *LW) {
   LW->~LogWriter();
   deallocate(LW);
 }
+#endif // SANITIZER_FUCHSIA
 
 } // namespace __xray

compiler-rt/lib/xray/xray_x86_64.cc

 #include "cpuid.h"
 #include "sanitizer_common/sanitizer_common.h"
+#if !SANITIZER_FUCHSIA
 #include "sanitizer_common/sanitizer_posix.h"
+#endif
 #include "xray_defs.h"
 #include "xray_interface_internal.h"
 
 #if SANITIZER_FREEBSD || SANITIZER_NETBSD || SANITIZER_OPENBSD || SANITIZER_MAC
 #include <sys/types.h>
 #if SANITIZER_OPENBSD
 #include <sys/time.h>
 #include <machine/cpu.h>
 #endif
 #include <sys/sysctl.h>
+#elif SANITIZER_FUCHSIA
+#include <zircon/syscalls.h>
 #endif
 
 #include <atomic>
 #include <cstdint>
 #include <errno.h>
 #include <fcntl.h>
 #include <iterator>
 #include <limits>

 #endif
         return static_cast<uint64_t>(TSCFrequency);
     } else {
       Report("Unable to determine CPU frequency for TSC accounting.\n");
     }
 
     return 0;
 }
+#elif SANITIZER_FUCHSIA
+uint64_t getTSCFrequency() XRAY_NEVER_INSTRUMENT {
+    return static_cast<uint64_t>(zx_ticks_per_second());
+}
 #else
 uint64_t getTSCFrequency() XRAY_NEVER_INSTRUMENT {
     /* Not supported */
     return 0;
 }
 #endif
 
 static constexpr uint8_t CallOpCode = 0xe8;
std::atomic_store_explicit(
           reinterpret_cast<std::atomic<uint16_t> *>(Sled.Address), Jmp20Seq,
           std::memory_order_release);
   }
   return false;
 }
 
 // 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 << 27).
   __asm__ __volatile__("cpuid" : "=a"(EAX), "=b"(EBX), "=c"(ECX), "=d"(EDX)
     : "0"(0x80000001));
   if (!(EDX & (1u << 27))) {