(Reland with changes) Adding a function for setting coverage output file.

[sajjadm]

Summary

User code can open a file on its own and pass it to the runtime, rather than
specifying a name and having the runtime open the file. This supports the use
case where a process cannot open a file on its own but can receive a file
descriptor from another process.

Relanding https://reviews.llvm.org/D62541. The original revision unlocked
the file before calling flush, this revision fixes that.

[sajjadm]

Ran clang-format.

[Dor1s]

LGTM, thanks @sajjadm !

compiler-rt/lib/profile/InstrProfilingFile.c

301

Looks like only this part has changed compared to https://reviews.llvm.org/D62541 + the tests.

compiler-rt/lib/profile/InstrProfiling.h

 /*===- InstrProfiling.h- Support library for PGO instrumentation ----------===*\
 |*
 |* 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
 |*
 \*===----------------------------------------------------------------------===*/
 
 #ifndef PROFILE_INSTRPROFILING_H_
 #define PROFILE_INSTRPROFILING_H_
 
 #include "InstrProfilingPort.h"
+#include <stdio.h>
 
 #define INSTR_PROF_VISIBILITY COMPILER_RT_VISIBILITY
 #include "InstrProfData.inc"
 
 enum ValueKind {
 #define VALUE_PROF_KIND(Enumerator, Value, Descr) Enumerator = Value,
 #include "InstrProfData.inc"
 };

  * or if that's not set,  \c "default.profraw".
  */
 int __llvm_profile_write_file(void);
 
 int __llvm_orderfile_write_file(void);
 /*!
  * \brief this is a wrapper interface to \c __llvm_profile_write_file.
  * After this interface is invoked, a arleady dumped flag will be set
- * so that profile won't be dumped again during program exit. 
+ * so that profile won't be dumped again during program exit.
  * Invocation of interface __llvm_profile_reset_counters will clear
  * the flag. This interface is designed to be used to collect profile
  * data from user selected hot regions. The use model is
  *      __llvm_profile_reset_counters();
  *      ... hot region 1
  *      __llvm_profile_dump();
  *      .. some other code
  *      __llvm_profile_reset_counters();

  * Sets the filename to be used for subsequent calls to
  * \a __llvm_profile_write_file().
  *
  * \c Name is not copied, so it must remain valid.  Passing NULL resets the
  * filename logic to the default behaviour.
  */
 void __llvm_profile_set_filename(const char *Name);
 
+/*!
+ * \brief Set the FILE object for writing instrumentation data.
+ *
+ * Sets the FILE object to be used for subsequent calls to
+ * \a __llvm_profile_write_file(). The profile file name set by environment
+ * variable, command-line option, or calls to \a  __llvm_profile_set_filename
+ * will be ignored.
+ *
+ * \c File will not be closed after a call to \a __llvm_profile_write_file() but
+ * it may be flushed. Passing NULL restores default behavior.
+ *
+ * If \c EnableMerge is nonzero, the runtime will always merge profiling data
+ * with the contents of the profiling file. If EnableMerge is zero, the runtime
+ * may still merge the data if it would have merged for another reason (for
+ * example, because of a %m specifier in the file name).
+ */
+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 Return path prefix (excluding the base filename) of the profile data.

compiler-rt/lib/profile/InstrProfilingFile.c

 
 #include "InstrProfiling.h"
 #include "InstrProfilingInternal.h"
 #include "InstrProfilingUtil.h"
 
 /* From where is profile name specified.
  * The order the enumerators define their
  * precedence. Re-order them may lead to
- * runtime behavior change. */ 
+ * runtime behavior change. */
 typedef enum ProfileNameSpecifier {
   PNS_unknown = 0,
   PNS_default,
   PNS_command_line,
   PNS_environment,
   PNS_runtime_api
 } ProfileNameSpecifier;
 
typedef struct lprofFilename {
    * can only appear once at the end of the name pattern. */
   unsigned MergePoolSize;
   ProfileNameSpecifier PNS;
 } lprofFilename;
 
 COMPILER_RT_WEAK lprofFilename lprofCurFilename = {0,   0, 0, 0, {0},
                                                    {0}, 0, 0, 0, PNS_unknown};
 
+static int ProfileMergeRequested = 0;
+static int isProfileMergeRequested() { return ProfileMergeRequested; }
+static void setProfileMergeRequested(int EnableMerge) {
+  ProfileMergeRequested = EnableMerge;
+}
+
+static FILE *ProfileFile = NULL;
+static FILE *getProfileFile() { return ProfileFile; }
+static void setProfileFile(FILE *File) { ProfileFile = File; }
+
+COMPILER_RT_VISIBILITY void __llvm_profile_set_file_object(FILE *File,
+                                                           int EnableMerge) {
+  setProfileFile(File);
+  setProfileMergeRequested(EnableMerge);
+}
+
 static int getCurFilenameLength();
 static const char *getCurFilename(char *FilenameBuf, int ForceUseBuf);
-static unsigned doMerging() { return lprofCurFilename.MergePoolSize; }
+static unsigned doMerging() {
+  return lprofCurFilename.MergePoolSize || isProfileMergeRequested();
+}
 
 /* Return 1 if there is an error, otherwise return  0.  */
 static uint32_t fileWriter(ProfDataWriter *This, ProfDataIOVec *IOVecs,
                            uint32_t NumIOVecs) {
   uint32_t I;
   FILE *File = (FILE *)This->WriterCtx;
   for (I = 0; I < NumIOVecs; I++) {
     if (IOVecs[I].Data) {

  * file locking.  If the file has content which is compatible with the
  * current process, it also reads in the profile data in the file and merge
  * it with in-memory counters. After the profile data is merged in memory,
  * the original profile data is truncated and gets ready for the profile
  * dumper. With profile merging enabled, each executable as well as any of
  * its instrumented shared libraries dump profile data into their own data file.
 */
 static FILE *openFileForMerging(const char *ProfileFileName, int *MergeDone) {
-  FILE *ProfileFile;
+  FILE *ProfileFile = NULL;
   int rc;
 
+  ProfileFile = getProfileFile();
+  if (ProfileFile) {
+    lprofLockFileHandle(ProfileFile);
+  } else {
     createProfileDir(ProfileFileName);
     ProfileFile = lprofOpenFileEx(ProfileFileName);
+  }
   if (!ProfileFile)
     return NULL;
 
   rc = doProfileMerging(ProfileFile, MergeDone);
   if (rc || (!*MergeDone && COMPILER_RT_FTRUNCATE(ProfileFile, 0L)) ||
       fseek(ProfileFile, 0L, SEEK_SET) == -1) {
     PROF_ERR("Profile Merging of file %s failed: %s\n", ProfileFileName,
              strerror(errno));
     fclose(ProfileFile);
     return NULL;
   }
   return ProfileFile;
 }
 
+static FILE *getFileObject(const char *OutputName) {
+  FILE *File;
+  File = getProfileFile();
+  if (File != NULL) {
+    return File;
+  }
+
+  return fopen(OutputName, "ab");
+}
+
 /* Write profile data to file \c OutputName.  */
 static int writeFile(const char *OutputName) {
   int RetVal;
   FILE *OutputFile;
 
   int MergeDone = 0;
   VPMergeHook = &lprofMergeValueProfData;
-  if (!doMerging())
-    OutputFile = fopen(OutputName, "ab");
-  else
+  if (doMerging())
     OutputFile = openFileForMerging(OutputName, &MergeDone);
+  else
+    OutputFile = getFileObject(OutputName);
 
   if (!OutputFile)
     return -1;
 
   FreeHook = &free;
   setupIOBuffer();
   ProfDataWriter fileWriter;
   initFileWriter(&fileWriter, OutputFile);
   RetVal = lprofWriteData(&fileWriter, lprofGetVPDataReader(), MergeDone);
 
+  if (OutputFile == getProfileFile()) {
+    fflush(OutputFile);
+    if (doMerging()) {
+      lprofUnlockFileHandle(OutputFile);
+    }
+  } else {
     fclose(OutputFile);
+  }
+
   return RetVal;
 }
 
 /* Write order data to file \c OutputName.  */
 static int writeOrderFile(const char *OutputName) {
   int RetVal;
   FILE *OutputFile;
 

 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);
 
   EnvFilenamePat = getFilenamePatFromEnv();
   if (EnvFilenamePat) {
-    /* Pass CopyFilenamePat = 1, to ensure that the filename would be valid 
+    /* 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;

 COMPILER_RT_VISIBILITY
 int __llvm_profile_write_file(void) {
   int rc, Length;
   const char *Filename;
   char *FilenameBuf;
   int PDeathSig = 0;
 
   if (lprofProfileDumped()) {
-    PROF_NOTE("Profile data not written to file: %s.\n", 
-              "already written");
+    PROF_NOTE("Profile data not written to file: %s.\n", "already written");
     return 0;
   }
 
   Length = getCurFilenameLength();
   FilenameBuf = (char *)COMPILER_RT_ALLOCA(Length + 1);
   Filename = getCurFilename(FilenameBuf, 0);
 
   /* Check the filename. */

compiler-rt/lib/profile/InstrProfilingUtil.h

 /*! Set the mode used when creating profile directories. */
 void __llvm_profile_set_dir_mode(unsigned Mode);
 
 /*! Return the directory creation mode. */
 unsigned __llvm_profile_get_dir_mode(void);
 
 int lprofLockFd(int fd);
 int lprofUnlockFd(int fd);
+int lprofLockFileHandle(FILE *F);
+int lprofUnlockFileHandle(FILE *F);
 
 /*! Open file \c Filename for read+write with write
  * lock for exclusive access. The caller will block
  * if the lock is already held by another process. */
 FILE *lprofOpenFileEx(const char *Filename);
 /* PS4 doesn't have getenv. Define a shim. */
 #if __ORBIS__
 static inline char *getenv(const char *name) { return NULL; }

compiler-rt/lib/profile/InstrProfilingUtil.c

#ifdef COMPILER_RT_HAS_FCNTL_LCK
   }
   return 0;
 #else
   flock(fd, LOCK_UN);
   return 0;
 #endif
 }
 
+COMPILER_RT_VISIBILITY int lprofLockFileHandle(FILE *F) {
+  int fd;
+#if defined(_WIN32)
+  fd = _fileno(F);
+#else
+  fd = fileno(F);
+#endif
+  return lprofLockFd(fd);
+}
+
+COMPILER_RT_VISIBILITY int lprofUnlockFileHandle(FILE *F) {
+  int fd;
+#if defined(_WIN32)
+  fd = _fileno(F);
+#else
+  fd = fileno(F);
+#endif
+  return lprofUnlockFd(fd);
+}
+
 COMPILER_RT_VISIBILITY FILE *lprofOpenFileEx(const char *ProfileName) {
   FILE *f;
   int fd;
 #ifdef COMPILER_RT_HAS_FCNTL_LCK
   fd = open(ProfileName, O_RDWR | O_CREAT, 0666);
   if (fd < 0)
     return NULL;
 

compiler-rt/test/profile/instrprof-set-file-object-merging.c

+// Test that the specified output merges the profiling data.
+// Run the program twice so that the counters accumulate.
+// RUN: %clang -fprofile-instr-generate -fcoverage-mapping -o %t %s
+// RUN: %run %t %t.merging.profraw
+// RUN: %run %t %t.merging.profraw
+// RUN: test -f %t.merging.profraw
+// RUN: llvm-profdata merge -o %t.merging.profdata %t.merging.profraw
+// RUN: llvm-cov show -instr-profile %t.merging.profdata %t | FileCheck %s --match-full-lines
+// RUN: rm %t.merging.profdata %t.merging.profraw
+#include <stdio.h>
+
+extern void __llvm_profile_set_file_object(FILE *, int);
+
+int main(int argc, const char *argv[]) {
+  if (argc < 2)
+    return 1;
+
+  FILE *F = fopen(argv[1], "r+b");
+  if (!F) {
+    // File might not exist, try opening with truncation
+    F = fopen(argv[1], "w+b");
+  }
+  __llvm_profile_set_file_object(F, 1);
+
+  return 0;
+}
+// CHECK:   10|       |#include <stdio.h>
+// CHECK:   11|       |
+// CHECK:   12|       |extern void __llvm_profile_set_file_object(FILE *, int);
+// CHECK:   13|       |
+// CHECK:   14|      2|int main(int argc, const char *argv[]) {
+// CHECK:   15|      2|  if (argc < 2)
+// CHECK:   16|      0|    return 1;
+// CHECK:   17|      2|
+// CHECK:   18|      2|  FILE *F = fopen(argv[1], "r+b");
+// CHECK:   19|      2|  if (!F) {
+// CHECK:   20|      1|    // File might not exist, try opening with truncation
+// CHECK:   21|      1|    F = fopen(argv[1], "w+b");
+// CHECK:   22|      1|  }
+// CHECK:   23|      2|  __llvm_profile_set_file_object(F, 1);
+// CHECK:   24|      2|
+// CHECK:   25|      2|  return 0;
+// CHECK:   26|      2|}

compiler-rt/test/profile/instrprof-set-file-object.c

+// Test that the specified output has profiling data.
+// RUN: %clang -fprofile-instr-generate -fcoverage-mapping -o %t %s
+// RUN: %run %t %t.file.profraw
+// RUN: test -f %t.file.profraw
+// RUN: llvm-profdata merge -o %t.file.profdata %t.file.profraw
+// RUN: llvm-cov show -instr-profile %t.file.profdata %t | FileCheck %s --match-full-lines
+// RUN: rm %t.file.profraw %t.file.profdata
+#include <stdio.h>
+
+extern void __llvm_profile_set_file_object(FILE *, int);
+
+int main(int argc, const char *argv[]) {
+  if (argc < 2)
+    return 1;
+
+  FILE *F = fopen(argv[1], "w+b");
+  __llvm_profile_set_file_object(F, 0);
+  return 0;
+}
+// CHECK:    8|       |#include <stdio.h>
+// CHECK:    9|       |
+// CHECK:   10|       |extern void __llvm_profile_set_file_object(FILE *, int);
+// CHECK:   11|       |
+// CHECK:   12|      1|int main(int argc, const char *argv[]) {
+// CHECK:   13|      1|  if (argc < 2)
+// CHECK:   14|      0|    return 1;
+// CHECK:   15|      1|
+// CHECK:   16|      1|  FILE *F = fopen(argv[1], "w+b");
+// CHECK:   17|      1|  __llvm_profile_set_file_object(F, 0);
+// CHECK:   18|      1|  return 0;
+// CHECK:   19|      1|}