[profile] Support profiling runtime on Fuchsia

[phosek]

Summary

This ports the profiling runtime on Fuchsia and enables the
instrumentation. Unlike on other platforms, Fuchsia doesn't use
files to dump the instrumentation data since on Fuchsia, filesystem
may not be accessible to the instrumented process. We instead use
the data sink to pass the profiling data to the system the same
sanitizer runtimes do.

[phosek]

compiler-rt/lib/profile/InstrProfilingPlatformFuchsia.c

31 ↗

(On Diff #148052)

This is only needed because runtime registration invokes it: https://reviews.llvm.org/diffusion/L/browse/compiler-rt/trunk/lib/profile/InstrProfilingRuntime.cc;333007$24, if we did our own registration we could avoid this function altogether and we could also name __llvm_profile_register_write_file_atexit more appropriately (since there're no files involved) but I'm not sure whether it's worth the duplication?

compiler-rt/lib/profile/InstrProfilingPlatformLinux.c

10 ↗

(On Diff #148052)

This file seems more related to the file format and linker support than platform. Would there be any objections against renaming InstrProfilingPlatformLinux.c to InstrProfilingPlatformELF.c and similarly InstrProfilingPlatformDarwin.c to InstrProfilingPlatformMachO.c?

[vsk]

This looks good at a high level. How is it tested?

compiler-rt/lib/profile/InstrProfilingPlatformFuchsia.c

31 ↗

(On Diff #148052)

Having an imperfect name sounds a bit better to me than copying the code for the static initializer.

compiler-rt/lib/profile/InstrProfilingPlatformLinux.c

10 ↗

(On Diff #148052)

No objection here.

[davidxl]

compiler-rt/lib/profile/InstrProfilingPlatformFuchsia.c

37 ↗

(On Diff #148052)

Info notes out of date?

55 ↗

(On Diff #148052)

Add a comment here.

102 ↗

(On Diff #148052)

Probably don't need this. In fact, buffer API does not yet support value profile data dump, so value profiling can be turned off by default for Fusia.

compiler-rt/lib/profile/InstrProfilingPlatformLinux.c

10 ↗

(On Diff #148052)

if you want to do this, please do it in a separate patch.

[phosek]

compiler-rt/lib/profile/InstrProfilingPlatformFuchsia.c

102 ↗

(On Diff #148052)

Is it just the matter of extending the buffer API implementation? I'd be happy to look into it (in a separate patch).

compiler-rt/lib/profile/InstrProfilingPlatformLinux.c

10 ↗

(On Diff #148052)

D47212

[krytarowski]

compiler-rt/lib/profile/InstrProfilingPlatformLinux.c

10 ↗

(On Diff #148052)

There are no other MachO platforms other than Darwin anyway.

[davidxl]

lgtm

compiler-rt/lib/profile/InstrProfilingPlatformFuchsia.c

102 ↗

(On Diff #148052)

The problem is builds that only depend on buffer APIs can not depend on libc (for dynamic memory allocation). Value profiling dump requires dynamically allocated memory.

[mcgrathr]

I don't have enough context on how the profiling runtime works to properly review this implementation strategy for Fuchsia. Perhaps adequate comments here would tell me enough. Certainly it needs a lot more comments.
But probably we just need to talk through the implementation plan in person first.

clang/lib/Driver/ToolChains/Fuchsia.cpp

106 ↗

(On Diff #148783)

addSanitizerRuntimes should also be after AddLinkerInputs.

compiler-rt/lib/profile/InstrProfilingPlatformFuchsia.c

1 ↗

(On Diff #148783)

s/Linux/Fuchsia/

9 ↗

(On Diff #148783)

This needs an overview comment explaining the implementation scheme. Overall the code needs a lot more comments.
See sanitizer_coverage_fuchsia.cc for examples.

14 ↗

(On Diff #148783)

Why are these needed? stdlib.h is for atexit. <sys/types.h> should never be used in new code that is not POSIXy.
stdio.h should not be used here.

24 ↗

(On Diff #148783)

This needs comments explaining why this is a reliable upper bound.

25 ↗

(On Diff #148783)

This should be static.
The sink name should be something less generic, since it needs to identify the file format unambiguously.
Maybe "llvm-profile"?

36 ↗

(On Diff #148783)

C does not require such casts from void *. If LLVM C style does require them, you can leave it.

37 ↗

(On Diff #148783)

Use C99 style: declare only at first initialization.

47 ↗

(On Diff #148783)

You should use only the _zx_* entry points.

92 ↗

(On Diff #148783)

Move decls to first use.

109 ↗

(On Diff #148783)

%zu is for size_t. KOIDs are uint64_t, so use "%" PRIu64 (<inttypes.h>).

[davidxl]

compiler-rt/lib/profile/InstrProfilingPlatformFuchsia.c

31 ↗

(On Diff #148783)

This needs more documentation.

70 ↗

(On Diff #148783)

BufferWriter --> This to make the naming consistent.

147 ↗

(On Diff #148783)

Perhaps emit a PROF_ERR here.

[phosek]

compiler-rt/lib/profile/InstrProfilingPlatformFuchsia.c

147 ↗

(On Diff #148783)

I cannot do that since this function is always invoked by RegisterRuntime() during initialization (https://reviews.llvm.org/source/compiler-rt/browse/compiler-rt/trunk/lib/profile/InstrProfilingRuntime.cc;333870$24), otherwise I'd avoid providing this function altogether.

[krytarowski]

compiler-rt/lib/profile/CMakeLists.txt

62 ↗

(On Diff #155070)

Can we add these .c files unconditionally and just handle it with global __Fuchsia__ preprocessor switch? This is already a common practice in compiler-rt.

[mcgrathr]

LGTM with these few substantive nits and then a whole lot more comments (mostly a more thorough overview covering linkage and output model).

clang/lib/Driver/ToolChains/Fuchsia.cpp

106 ↗

(On Diff #148783)

still relevant, though could be an unrelated change

compiler-rt/lib/profile/InstrProfilingPlatformFuchsia.c

33 ↗

(On Diff #155095)

Each symbol defined in this file without static or COMPILER_RT_VISIBILITY (hidden) needs to have an explicit comment clearly saying that this symbol is exported in each dynamic executable and DSO that statically links in the profiling runtime, and why that is desireable and what the protocol is for sharing a single set of definitions from one of those at runtime.

I think the VMO and offset are the only things we actually want to share.
Each instrumented module can have its own runtime version's implementation of data_write() as long as they cooperate in the simple append-to-VMO protocol using just those two globals.
I think the data_write() function here should be static.

I think it is exactly just those two symbols that should be exported, so they can have a short comment here and a longer explanatory comment about the whole inter-module sharing model can be part of the overview comment at the top of the file.

34 ↗

(On Diff #155095)

s/should written to/should be written next/

70 ↗

(On Diff #155095)

So, this needs some overall comments on the methodology of this function and when/how it's called.
I'll now guess what's going on and the comments here should be both clearer than my guess and also actually accurate. :-)

The first time through, it will allocate the VMO and use llvm_profile_get_size_for_buffer() as the initial size.
What size does this represent? I think maybe it's the lower bound on the data this module (i.e. what statically links in this runtime) will need to write to the VMO, perhaps the exact total of the primary data not including the value-profiling data or something like that. Please be explicit about what why it's a useful number to use as the initial VMO size given that you always resize it to cover the data in this writer call.
It's presumed that when llvm_profile_vmo is set, __llvm_profile_offset remains 0.

After that, and also on any subsequent calls, it will resize the VMO to cover the incoming __llvm_profile_offset value plus the total being written in this call. So, each call from the first onwards serially appends an arbitrary amount to the VMO, which has been published on creation.

But actually "first call" and "subsequent calls" are misnomers. Each incarnation of this function will only ever be called once. Each module (executable or DSO) statically links in the whole profile runtime to satisfy the calls from its instrumented code. Several modules in the same program might be separately compiled and even use different versions of the instrumentation ABI and data format. All they share in common is the VMO and the offset, which live in exported globals so that exactly one definition will be shared across all modules. (Ideally they'd be exported as STB_GNU_UNIQUE even, so that multiple isolated modules loaded by dlopen into a program with no global-scope modules exporting these two globals would still share a VMO. But that case is unlikely, and Fuchsia's dynamic linker doesn't usefully support STB_GNU_UNIQUE so far.) Each module has its own independent runtime that registers its own atexit hook to write its own data. The data format is sufficiently chunked and self-describing that simply concatenating the data streams from several unrelated incarnations of the runtime (that might even be from different versions of the compiler instrumentation) is sufficient to sort the data out easily offline later.

The alternative to the shared globals approach is that each module's atexit hook is totally unaware of the others and each creates its own VMO and does its own __sanitizer_publish_data call. That wouldn't be the worst thing, and that's the "failure mode" of the pathological dlopen case mentioned in the aside above. It just means that the data sink receiver has to be ready to handle multiple VMOs for the same sink name that originate from the same process. As things stand, that means multiple VMOs with the same name. I think that should actually be fine and there's no need for this code to try to mitigate it (e.g. by also putting the VMO KOID into the name). Rather, every implementation of the data sink service ought to be prepared for arbitrary (or no) names in the VMOs, so e.g. ones that write files might always choose the file name to be "${sink_name}.${vmo_koid}.${vmo_name}" so as to be guaranteed unique (by dint of the VMO KOID) as well as informative.

Most of this background belongs in the overview comment at the top of the file. Comments within this function should be clear about how multiple incarnations of this function are interacting in the "first time" if branch and later.

86 ↗

(On Diff #155095)

Make sure to always use the _zx_* names.

109 ↗

(On Diff #155095)

PROF_NOTE and PROF_ERR and PROF_WARN are fortunately so far confinsed to InstrProfilingFile.c, which is code not used for Fuchsia.
I think the macros (and a few more related to file stuff) should be moved from InstrProfilingPort.h to inside InstrProfilingFile.c if possible.
There should be a big comment at the top of this file saying that on Fuchsia we never use stdio (fprintf to stderr is what PROT_NOTE/PROF_ERR are). Instead always write whole lines (or multiple lines) with __sanitizer_log_write. You can make a local helper that uses vsnprintf into a temporary buffer and calls __sanitizer_log_write, if your messages have need of formatting.
(Actually we might well make libc provide __sanitizer_{v,}printf or even just FILE*__sanitizer_fopenlog(void), but you shouldn't wait for that.)

149 ↗

(On Diff #155095)

I'd use <stdbool.h> bool here (and in general C11, or at least C99, freely and modern style preferentially), unless there's a C portability constraint I don't know about for lib/profile.

[mcgrathr]

compiler-rt/lib/profile/InstrProfilingPlatformFuchsia.c

19 ↗

(On Diff #156909)

typo: "provided"

67 ↗

(On Diff #156909)

This should log a message including a sanitizer markup dumpfile element that refers to the VMO name.
Before that, it should set the VMO name.
See sanitizer_common/sanitizer_coverage_fuchsia.cc for an example.

120 ↗

(On Diff #156909)

s/get/got/

[mcgrathr]

lgtm

cfe/trunk/lib/Driver/ToolChains/Fuchsia.cpp

if (D.isUsingLTO()) {
     assert(!Inputs.empty() && "Must have at least one input.");
     AddGoldPlugin(ToolChain, Args, CmdArgs, Output, Inputs[0],
                   D.getLTOMode() == LTOK_Thin);
   }
 
   addSanitizerRuntimes(ToolChain, Args, CmdArgs);
 
   AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs, JA);
+  ToolChain.addProfileRTLibs(Args, CmdArgs);
 
   if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
     if (Args.hasArg(options::OPT_static))
       CmdArgs.push_back("-Bdynamic");
 
     if (D.CCCIsCXX()) {
       if (ToolChain.ShouldLinkCXXStdlib(Args)) {
         bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) &&

compiler-rt/trunk/cmake/config-ix.cmake

 if (COMPILER_RT_HAS_SANITIZER_COMMON AND HWASAN_SUPPORTED_ARCH AND
     OS_NAME MATCHES "Linux|Android")
   set(COMPILER_RT_HAS_HWASAN TRUE)
 else()
   set(COMPILER_RT_HAS_HWASAN FALSE)
 endif()
 
 if (PROFILE_SUPPORTED_ARCH AND NOT LLVM_USE_SANITIZER AND
-    OS_NAME MATCHES "Darwin|Linux|FreeBSD|Windows|Android|SunOS")
+    OS_NAME MATCHES "Darwin|Linux|FreeBSD|Windows|Android|Fuchsia|SunOS")
   set(COMPILER_RT_HAS_PROFILE TRUE)
 else()
   set(COMPILER_RT_HAS_PROFILE FALSE)
 endif()
 
 if (COMPILER_RT_HAS_SANITIZER_COMMON AND TSAN_SUPPORTED_ARCH AND
     OS_NAME MATCHES "Darwin|Linux|FreeBSD|Android|NetBSD")
   set(COMPILER_RT_HAS_TSAN TRUE)

compiler-rt/trunk/lib/profile/CMakeLists.txt

set(PROFILE_SOURCES
   InstrProfilingValue.c
   InstrProfilingBuffer.c
   InstrProfilingFile.c
   InstrProfilingMerge.c
   InstrProfilingMergeFile.c
   InstrProfilingNameVar.c
   InstrProfilingWriter.c
   InstrProfilingPlatformDarwin.c
+  InstrProfilingPlatformFuchsia.c
   InstrProfilingPlatformLinux.c
   InstrProfilingPlatformOther.c
   InstrProfilingRuntime.cc
   InstrProfilingUtil.c)
 
 set(PROFILE_HEADERS
   InstrProfData.inc
   InstrProfiling.h

compiler-rt/trunk/lib/profile/GCDAProfiling.c

 |* are only close enough that LCOV will happily parse them. Anything that lcov
 |* ignores is missing.
 |*
 |* TODO: gcov is multi-process safe by having each exit open the existing file
 |* and append to it. We'd like to achieve that and be thread-safe too.
 |*
 \*===----------------------------------------------------------------------===*/
 
+#if !defined(__Fuchsia__)
+
 #include <errno.h>
 #include <fcntl.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 #if defined(_WIN32)
 #include "WindowsMMap.h"
if (atexit_ran == 0) {
     atexit_ran = 1;
 
     /* Make sure we write out the data and delete the data structures. */
     atexit(llvm_delete_flush_function_list);
     atexit(llvm_delete_writeout_function_list);
     atexit(llvm_writeout_files);
   }
 }
+
+#endif

compiler-rt/trunk/lib/profile/InstrProfilingFile.c

 /*===- InstrProfilingFile.c - Write instrumentation to a file -------------===*\
 |*
 |*                     The LLVM Compiler Infrastructure
 |*
 |* This file is distributed under the University of Illinois Open Source
 |* License. See LICENSE.TXT for details.
 |*
 \*===----------------------------------------------------------------------===*/
 
+#if !defined(__Fuchsia__)
+
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #ifdef _MSC_VER
 /* For _alloca. */
 #include <malloc.h>
 #endif
int __llvm_profile_register_write_file_atexit(void) {
   if (HasBeenRegistered)
     return 0;
 
   lprofSetupValueProfiler();
 
   HasBeenRegistered = 1;
   return atexit(writeFileWithoutReturn);
 }
+
+#endif

compiler-rt/trunk/lib/profile/InstrProfilingMergeFile.c

 /*===- InstrProfilingMergeFile.c - Profile in-process Merging  ------------===*\
 |*
 |*                     The LLVM Compiler Infrastructure
 |*
 |* This file is distributed under the University of Illinois Open Source
 |* License. See LICENSE.TXT for details.
 |*
 |*===----------------------------------------------------------------------===
 |* This file defines APIs needed to support in-process merging for profile data
 |* stored in files.
 \*===----------------------------------------------------------------------===*/
 
+#if !defined(__Fuchsia__)
+
 #include "InstrProfiling.h"
 #include "InstrProfilingInternal.h"
 #include "InstrProfilingUtil.h"
 
 #define INSTR_PROF_VALUE_PROF_DATA
 #include "InstrProfData.inc"
 
 /* Merge value profile data pointed to by SrcValueProfData into
for (S = 0; S < VR->NumValueSites; S++) {
                                                DstIndex, VData[SrcIndex].Count);
         ++SrcIndex;
       }
       ++DstIndex;
     }
     VR = getValueProfRecordNext(VR);
   }
 }
+
+#endif

compiler-rt/trunk/lib/profile/InstrProfilingPlatformFuchsia.c

+/*===- InstrProfilingPlatformFuchsia.c - Profile data Fuchsia platform ----===*\
+|*
+|*                     The LLVM Compiler Infrastructure
+|*
+|* This file is distributed under the University of Illinois Open Source
+|* License. See LICENSE.TXT for details.
+|*
+\*===----------------------------------------------------------------------===*/
+/*
+ * This file implements the profiling runtime for Fuchsia and defines the
+ * shared profile runtime interface. Each module (executable or DSO) statically
+ * links in the whole profile runtime to satisfy the calls from its
+ * instrumented code. Several modules in the same program might be separately
+ * compiled and even use different versions of the instrumentation ABI and data
+ * format. All they share in common is the VMO and the offset, which live in
+ * exported globals so that exactly one definition will be shared across all
+ * modules. Each module has its own independent runtime that registers its own
+ * atexit hook to append its own data into the shared VMO which is published
+ * via the data sink hook provided by Fuchsia's dynamic linker.
+ */
+
+#if defined(__Fuchsia__)
+
+#include <inttypes.h>
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdlib.h>
+
+#include <zircon/process.h>
+#include <zircon/sanitizer.h>
+#include <zircon/syscalls.h>
+
+#include "InstrProfiling.h"
+#include "InstrProfilingInternal.h"
+#include "InstrProfilingUtil.h"
+
+/* VMO that contains the coverage data shared across all modules. This symbol
+ * has default visibility and is exported in each module (executable or DSO)
+ * that statically links in the profiling runtime.
+ */
+zx_handle_t __llvm_profile_vmo;
+/* Current offset within the VMO where data should be written next. This symbol
+ * has default visibility and is exported in each module (executable or DSO)
+ * that statically links in the profiling runtime.
+ */
+uint64_t __llvm_profile_offset;
+
+static const char ProfileSinkName[] = "llvm-profile";
+
+static inline void lprofWrite(const char *fmt, ...) {
+  char s[256];
+
+  va_list ap;
+  va_start(ap, fmt);
+  int ret = vsnprintf(s, sizeof(s), fmt, ap);
+  va_end(ap);
+
+  __sanitizer_log_write(s, ret + 1);
+}
+
+static uint32_t lprofVMOWriter(ProfDataWriter *This, ProfDataIOVec *IOVecs,
+                               uint32_t NumIOVecs) {
+  /* Allocate VMO if it hasn't been created yet. */
+  if (__llvm_profile_vmo == ZX_HANDLE_INVALID) {
+    /* Get information about the current process. */
+    zx_info_handle_basic_t Info;
+    zx_status_t Status =
+        _zx_object_get_info(_zx_process_self(), ZX_INFO_HANDLE_BASIC, &Info,
+                            sizeof(Info), NULL, NULL);
+    if (Status != ZX_OK)
+      return -1;
+
+    /* Create VMO to hold the profile data. */
+    Status = _zx_vmo_create(0, 0, &__llvm_profile_vmo);
+    if (Status != ZX_OK)
+      return -1;
+
+    /* Give the VMO a name including our process KOID so it's easy to spot. */
+    char VmoName[ZX_MAX_NAME_LEN];
+    snprintf(VmoName, sizeof(VmoName), "%s.%" PRIu64, ProfileSinkName,
+             Info.koid);
+    _zx_object_set_property(__llvm_profile_vmo, ZX_PROP_NAME, VmoName,
+                            strlen(VmoName));
+
+    /* Duplicate the handle since __sanitizer_publish_data consumes it. */
+    zx_handle_t Handle;
+    Status =
+        _zx_handle_duplicate(__llvm_profile_vmo, ZX_RIGHT_SAME_RIGHTS, &Handle);
+    if (Status != ZX_OK)
+      return -1;
+
+    /* Publish the VMO which contains profile data to the system. */
+    __sanitizer_publish_data(ProfileSinkName, Handle);
+
+    /* Use the dumpfile symbolizer markup element to write the name of VMO. */
+    lprofWrite("LLVM Profile: {{{dumpfile:%s:%s}}}\n",
+               ProfileSinkName, VmoName);
+  }
+
+  /* Compute the total length of data to be written. */
+  size_t Length = 0;
+  for (uint32_t I = 0; I < NumIOVecs; I++)
+    Length += IOVecs[I].ElmSize * IOVecs[I].NumElm;
+
+  /* Resize the VMO to ensure there's sufficient space for the data. */
+  zx_status_t Status =
+      _zx_vmo_set_size(__llvm_profile_vmo, __llvm_profile_offset + Length);
+  if (Status != ZX_OK)
+    return -1;
+
+  /* Copy the data into VMO. */
+  for (uint32_t I = 0; I < NumIOVecs; I++) {
+    size_t Length = IOVecs[I].ElmSize * IOVecs[I].NumElm;
+    if (IOVecs[I].Data) {
+      Status = _zx_vmo_write(__llvm_profile_vmo, IOVecs[I].Data,
+                             __llvm_profile_offset, Length);
+      if (Status != ZX_OK)
+        return -1;
+    }
+    __llvm_profile_offset += Length;
+  }
+
+  return 0;
+}
+
+static void initVMOWriter(ProfDataWriter *This) {
+  This->Write = lprofVMOWriter;
+  This->WriterCtx = NULL;
+}
+
+static int dump(void) {
+  if (lprofProfileDumped()) {
+    lprofWrite("Profile data not published: already written.\n");
+    return 0;
+  }
+
+  /* Check if there is llvm/runtime version mismatch. */
+  if (GET_VERSION(__llvm_profile_get_version()) != INSTR_PROF_RAW_VERSION) {
+    lprofWrite("Runtime and instrumentation version mismatch : "
+               "expected %d, but got %d\n",
+               INSTR_PROF_RAW_VERSION,
+               (int)GET_VERSION(__llvm_profile_get_version()));
+    return -1;
+  }
+
+  /* Write the profile data into the mapped region. */
+  ProfDataWriter VMOWriter;
+  initVMOWriter(&VMOWriter);
+  if (lprofWriteData(&VMOWriter, lprofGetVPDataReader(), 0) != 0)
+    return -1;
+
+  return 0;
+}
+
+COMPILER_RT_VISIBILITY
+int __llvm_profile_dump(void) {
+  int rc = dump();
+  lprofSetProfileDumped();
+  return rc;
+}
+
+static void dumpWithoutReturn(void) { dump(); }
+
+/* This method is invoked by the runtime initialization hook
+ * InstrProfilingRuntime.o if it is linked in.
+ */
+COMPILER_RT_VISIBILITY
+void __llvm_profile_initialize_file(void) {}
+
+COMPILER_RT_VISIBILITY
+int __llvm_profile_register_write_file_atexit(void) {
+  static bool HasBeenRegistered = false;
+
+  if (HasBeenRegistered)
+    return 0;
+
+  lprofSetupValueProfiler();
+
+  HasBeenRegistered = true;
+  return atexit(dumpWithoutReturn);
+}
+
+#endif

compiler-rt/trunk/lib/profile/InstrProfilingPlatformLinux.c

 /*===- InstrProfilingPlatformLinux.c - Profile data Linux platform ------===*\
 |*
 |*                     The LLVM Compiler Infrastructure
 |*
 |* This file is distributed under the University of Illinois Open Source
 |* License. See LICENSE.TXT for details.
 |*
 \*===----------------------------------------------------------------------===*/
 
-#if defined(__linux__) || defined(__FreeBSD__) || \
+#if defined(__linux__) || defined(__FreeBSD__) || defined(__Fuchsia__) || \
     (defined(__sun__) && defined(__svr4__))
 
 #include <stdlib.h>
 
 #include "InstrProfiling.h"
 
 #define PROF_DATA_START INSTR_PROF_SECT_START(INSTR_PROF_DATA_SECT_NAME)
 #define PROF_DATA_STOP INSTR_PROF_SECT_STOP(INSTR_PROF_DATA_SECT_NAME)

llvm/trunk/lib/Transforms/Instrumentation/InstrProfiling.cpp

 static bool needsRuntimeRegistrationOfSectionRange(const Module &M) {
   // Don't do this for Darwin.  compiler-rt uses linker magic.
   if (Triple(M.getTargetTriple()).isOSDarwin())
     return false;
 
   // Use linker script magic to get data/cnts/name start/end.
   if (Triple(M.getTargetTriple()).isOSLinux() ||
       Triple(M.getTargetTriple()).isOSFreeBSD() ||
+      Triple(M.getTargetTriple()).isOSFuchsia() ||
       Triple(M.getTargetTriple()).isPS4CPU())
     return false;
 
   return true;
 }
 
 GlobalVariable *
 InstrProfiling::getOrCreateRegionCounters(InstrProfIncrementInst *Inc) {