[profile] Make atexit hook a no-op on Fuchsia

[phosek]

Summary

On Fuchsia, we always use the continuous mode with runtime counter
relocation, so there's no need for atexit hook or support for dumping
the profile manually.

[phosek]

compiler-rt/lib/profile/InstrProfilingPlatformFuchsia.c

195–196

To remove this function altogether, we would need to wrap its invocation in https://github.com/llvm/llvm-project/blob/master/compiler-rt/lib/profile/InstrProfilingRuntime.cpp#L24 in #if !defined(__Fuchsia__), I'm not sure if that's better than defining an empty function?

[mcgrathr]

compiler-rt/lib/profile/InstrProfilingPlatformFuchsia.c

195–196

Some other runtimes (e.g. hwasan) have an OS-specific InstallAtExitHandler() called by the common initialization function, so we can define that as a no-op.

[mcgrathr]

compiler-rt/lib/profile/InstrProfilingFile.c

39

Can we make this a function defined in File.c to return a static variable kept there and in Fuchsia.c to return constant 1?
Then at least in an LTO future it will fold away for Fuchsia, and not add a data word.

compiler-rt/lib/profile/InstrProfilingPlatformFuchsia.c

104

This function is responsible for initializing before return and the link-time initializer in BiasVar.c is -1 so this will always be true at startup.

[phosek]

compiler-rt/lib/profile/InstrProfilingPlatformFuchsia.c

104

It's defined as -1 in https://github.com/llvm/llvm-project/blob/master/compiler-rt/lib/profile/InstrProfilingBiasVar.c#L15 which is a weak definition, but compiler will generate a strong definition with the default value 0 when runtime counter relocation is enabled (default on Fuchsia), so this should only kick in when someone accidentally disables runtime counter relocation on Fuchsia? I'm happy to omit this check if you think it's unnecessary.

[mcgrathr]

lgtm with comment and nits

compiler-rt/lib/profile/InstrProfilingInternal.h

188

C functions need (void).

compiler-rt/lib/profile/InstrProfilingPlatformFuchsia.c

37

C functions need (void).

104

I see. That makes sense but there should be a comment here explaining the compiler's semantics for this symbol.

compiler-rt/lib/profile/InstrProfiling.h

 void __llvm_profile_set_file_object(FILE *File, int EnableMerge);
 
 /*! \brief Register to write instrumentation data to file at exit. */
 int __llvm_profile_register_write_file_atexit(void);
 
 /*! \brief Initialize file handling. */
 void __llvm_profile_initialize_file(void);
 
+/*! \brief Initialize the profile runtime. */
+void __llvm_profile_initialize(void);
+
 /*!
  * \brief Return path prefix (excluding the base filename) of the profile data.
  * This is useful for users using \c -fprofile-generate=./path_prefix who do
  * not care about the default raw profile name. It is also useful to collect
  * more than more profile data files dumped in the same directory (Online
  * merge mode is turned on for instrumented programs with shared libs).
  * Side-effect: this API call will invoke malloc with dynamic memory allocation.
  */

compiler-rt/lib/profile/InstrProfilingBuffer.c

 /*===- InstrProfilingBuffer.c - Write instrumentation to a memory buffer --===*\
 |*
 |* Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 |* See https://llvm.org/LICENSE.txt for license information.
 |* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 |*
 \*===----------------------------------------------------------------------===*/
 
 #include "InstrProfiling.h"
 #include "InstrProfilingInternal.h"
 #include "InstrProfilingPort.h"
 
-/* When counters are being relocated at runtime, this parameter is set to 1. */
-COMPILER_RT_VISIBILITY int RuntimeCounterRelocation = 0;
-
 /* When continuous mode is enabled (%c), this parameter is set to 1.
  *
  * This parameter is defined here in InstrProfilingBuffer.o, instead of in
  * InstrProfilingFile.o, to sequester all libc-dependent code in
  * InstrProfilingFile.o. The test `instrprof-without-libc` will break if this
  * layering is violated. */
 static int ContinuouslySyncProfile = 0;
 

 }
 
 COMPILER_RT_VISIBILITY
 void __llvm_profile_get_padding_sizes_for_counters(
     uint64_t DataSize, uint64_t CountersSize, uint64_t NamesSize,
     uint64_t *PaddingBytesBeforeCounters, uint64_t *PaddingBytesAfterCounters,
     uint64_t *PaddingBytesAfterNames) {
   if (!__llvm_profile_is_continuous_mode_enabled() ||
-      RuntimeCounterRelocation) {
+      lprofRuntimeCounterRelocation()) {
     *PaddingBytesBeforeCounters = 0;
     *PaddingBytesAfterCounters = 0;
     *PaddingBytesAfterNames = __llvm_profile_get_num_padding_bytes(NamesSize);
     return;
   }
 
   // In continuous mode, the file offsets for headers and for the start of
   // counter sections need to be page-aligned.

compiler-rt/lib/profile/InstrProfilingFile.c

 #endif
 #endif
 
 #include "InstrProfiling.h"
 #include "InstrProfilingInternal.h"
 #include "InstrProfilingPort.h"
 #include "InstrProfilingUtil.h"
 
+static int RuntimeCounterRelocation = 0;
+
+COMPILER_RT_VISIBILITY unsigned lprofRuntimeCounterRelocation() {
+  return RuntimeCounterRelocation;
+}
+
+COMPILER_RT_VISIBILITY void lprofSetRuntimeCounterRelocation() {
+  RuntimeCounterRelocation = 1;
+}
+
 /* From where is profile name specified.
  * The order the enumerators define their
  * precedence. Re-order them may lead to
  * runtime behavior change. */
 typedef enum ProfileNameSpecifier {
   PNS_unknown = 0,
   PNS_default,
   PNS_command_line,
if (*Profile == MAP_FAILED) {
     PROF_ERR("Unable to mmap profile: %s\n", strerror(errno));
     return -1;
   }
 
   return 0;
 }
 
 static void relocateCounters(void) {
-  if (!__llvm_profile_is_continuous_mode_enabled() || !RuntimeCounterRelocation)
+  if (!__llvm_profile_is_continuous_mode_enabled() ||
+      !lprofRuntimeCounterRelocation())
     return;
 
   /* Get the sizes of various profile data sections. Taken from
    * __llvm_profile_get_size_for_buffer(). */
   const __llvm_profile_data *DataBegin = __llvm_profile_begin_data();
   const __llvm_profile_data *DataEnd = __llvm_profile_end_data();
   uint64_t DataSize = __llvm_profile_get_data_size(DataBegin, DataEnd);
   const uint64_t CountersOffset = sizeof(__llvm_profile_header) +
if (!OldFilenamePat) {
     if (getenv("LLVM_PROFILE_VERBOSE"))
       PROF_NOTE("Override old profile path \"%s\" via %s to \"%s\" via %s.\n",
                 OldFilenamePat, getPNSStr(OldPNS), lprofCurFilename.FilenamePat,
                 getPNSStr(PNS));
   }
 
   truncateCurrentFile();
   if (__llvm_profile_is_continuous_mode_enabled()) {
-    if (RuntimeCounterRelocation)
+    if (lprofRuntimeCounterRelocation())
       relocateCounters();
     else
       initializeProfileForContinuousMode();
   }
 }
 
 /* Return buffer length that is required to store the current profile
  * filename with PID and hostname substitutions. */
const char *__llvm_profile_get_filename(void) {
   }
   Filename = getCurFilename(FilenameBuf, 1);
   if (!Filename)
     return "\0";
 
   return FilenameBuf;
 }
 
-/* This method is invoked by the runtime initialization hook
- * InstrProfilingRuntime.o if it is linked in. Both user specified
+/* This API initializes the file handling, both user specified
  * profile path via -fprofile-instr-generate= and LLVM_PROFILE_FILE
- * environment variable can override this default value. */
+ * environment variable can override this default value.
+ */
 COMPILER_RT_VISIBILITY
 void __llvm_profile_initialize_file(void) {
   const char *EnvFilenamePat;
   const char *SelectedPat = NULL;
   ProfileNameSpecifier PNS = PNS_unknown;
   int hasCommandLineOverrider = (INSTR_PROF_PROFILE_NAME_VAR[0] != 0);
 
   if (__llvm_profile_counter_bias != -1)
-    RuntimeCounterRelocation = 1;
+    lprofSetRuntimeCounterRelocation();
 
   EnvFilenamePat = getFilenamePatFromEnv();
   if (EnvFilenamePat) {
     /* Pass CopyFilenamePat = 1, to ensure that the filename would be valid
        at the  moment when __llvm_profile_write_file() gets executed. */
     parseAndSetFilename(EnvFilenamePat, PNS_environment, 1);
     return;
   } else if (hasCommandLineOverrider) {
     SelectedPat = INSTR_PROF_PROFILE_NAME_VAR;
     PNS = PNS_command_line;
   } else {
     SelectedPat = NULL;
     PNS = PNS_default;
   }
 
   parseAndSetFilename(SelectedPat, PNS, 0);
 }
 
+/* This method is invoked by the runtime initialization hook
+ * InstrProfilingRuntime.o if it is linked in.
+ */
+COMPILER_RT_VISIBILITY
+void __llvm_profile_initialize(void) {
+  __llvm_profile_initialize_file();
+  if (!__llvm_profile_is_continuous_mode_enabled())
+    __llvm_profile_register_write_file_atexit();
+}
+
 /* This API is directly called by the user application code. It has the
  * highest precedence compared with LLVM_PROFILE_FILE environment variable
  * and command line option -fprofile-instr-generate=<profile_name>.
  */
 COMPILER_RT_VISIBILITY
 void __llvm_profile_set_filename(const char *FilenamePat) {
   if (__llvm_profile_is_continuous_mode_enabled())
     return;

compiler-rt/lib/profile/InstrProfilingInternal.h

 
 /* 
  * Return non zero value if the profile data has already been
  * dumped to the file.
  */
 unsigned lprofProfileDumped();
 void lprofSetProfileDumped();
 
-COMPILER_RT_VISIBILITY extern int RuntimeCounterRelocation;
+/* Return non zero value if counters are being relocated at runtime. */
+unsigned lprofRuntimeCounterRelocation();
+void lprofSetRuntimeCounterRelocation();
+
 COMPILER_RT_VISIBILITY extern void (*FreeHook)(void *);
 COMPILER_RT_VISIBILITY extern uint8_t *DynamicBufferIOBuffer;
 COMPILER_RT_VISIBILITY extern uint32_t VPBufferSize;
 COMPILER_RT_VISIBILITY extern uint32_t VPMaxNumValsPerSite;
 /* Pointer to the start of static value counters to be allocted. */
 COMPILER_RT_VISIBILITY extern ValueProfNode *CurrentVNode;
 COMPILER_RT_VISIBILITY extern ValueProfNode *EndVNode;
 extern void (*VPMergeHook)(struct ValueProfData *, __llvm_profile_data *);
 
 #endif

compiler-rt/lib/profile/InstrProfilingPlatformFuchsia.c

 #include <zircon/sanitizer.h>
 #include <zircon/status.h>
 #include <zircon/syscalls.h>
 
 #include "InstrProfiling.h"
 #include "InstrProfilingInternal.h"
 #include "InstrProfilingUtil.h"
 
-/* VMO that contains the coverage data shared across all modules. */
+COMPILER_RT_VISIBILITY unsigned lprofRuntimeCounterRelocation() {
+  return 1;
+}
+
+/* VMO that contains the profile data for this module. */
 static zx_handle_t __llvm_profile_vmo;
 /* Current offset within the VMO where data should be written next. */
 static uint64_t __llvm_profile_offset;
 
 static const char ProfileSinkName[] = "llvm-profile";
 
 static inline void lprofWrite(const char *fmt, ...) {
   char s[256];
static uint32_t lprofVMOWriter(ProfDataWriter *This, ProfDataIOVec *IOVecs,
   return 0;
 }
 
 static void initVMOWriter(ProfDataWriter *This) {
   This->Write = lprofVMOWriter;
   This->WriterCtx = NULL;
 }
 
-static int dump(void) {
-  if (lprofProfileDumped()) {
-    lprofWrite("LLVM 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("LLVM Profile: 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;
-}
-
+/* This method is invoked by the runtime initialization hook
+ * InstrProfilingRuntime.o if it is linked in.
+ */
 COMPILER_RT_VISIBILITY
-int __llvm_profile_dump(void) {
-  int rc = dump();
-  lprofSetProfileDumped();
-  return rc;
+void __llvm_profile_initialize(void) {
+  if (__llvm_profile_counter_bias == -1) {
+    lprofWrite("LLVM Profile: counter relocation at runtime is required\n");
+    return;
   }
 
-static void dumpWithoutReturn(void) { dump(); }
-
-static void createVMO(void) {
   /* Don't create VMO if it has been alread created. */
-  if (__llvm_profile_vmo != ZX_HANDLE_INVALID)
+  if (__llvm_profile_vmo != ZX_HANDLE_INVALID) {
+    lprofWrite("LLVM Profile: VMO has already been created\n");
     return;
+  }
 
   const __llvm_profile_data *DataBegin = __llvm_profile_begin_data();
   const __llvm_profile_data *DataEnd = __llvm_profile_end_data();
   const uint64_t DataSize = __llvm_profile_get_data_size(DataBegin, DataEnd);
   const uint64_t CountersOffset = sizeof(__llvm_profile_header) +
     (DataSize * sizeof(__llvm_profile_data));
 
   zx_status_t Status;
lprofWrite("LLVM Profile: failed to map the VMO: %s\n",
                _zx_status_get_string(Status));
     return;
   }
 
   /* Update the profile fields based on the current mapping. */
   __llvm_profile_counter_bias = (intptr_t)Mapping -
       (uintptr_t)__llvm_profile_begin_counters() + CountersOffset;
 }
 
-/* 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) { createVMO(); }
-
-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/lib/profile/InstrProfilingRuntime.cpp

 COMPILER_RT_VISIBILITY int INSTR_PROF_PROFILE_RUNTIME_VAR;
 }
 
 namespace {
 
 class RegisterRuntime {
 public:
   RegisterRuntime() {
-    __llvm_profile_initialize_file();
-    if (!__llvm_profile_is_continuous_mode_enabled())
-      __llvm_profile_register_write_file_atexit();
+    __llvm_profile_initialize();
   }
 };
 
 RegisterRuntime Registration;
 
 }