[Profile] Support __llvm_profile_set_file_object in continuous mode.

[zequanwu]

Summary

Replace D107203, because __llvm_profile_set_file_object is usually used when the
process doesn't have permission to open/create file. That patch trying to copy
from old profile to new profile contradicts with the usage.

[vsk]

@zequanwu I apologize for the delay in reviews. I've skimmed this change, and think it's in the right direction. I will try to respond with an in-depth review by the end of this week, if no one beats me to it.

[vsk]

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

25

Should this also verify that /profdir/<hash>profraw.old exists? IIUC it should, but counter_test() should have 0 coverage.

[zequanwu]

Check zero count on old profile.

[vsk]

Thanks, lgtm with one concern (see inline).

compiler-rt/lib/profile/InstrProfilingFile.c

1167

You might already be aware of this limitation, but a heads-up just in case: the continuous sync mode does not handle keeping VP data up-to-date. While it's fine to write it out in the ProfileFileSize = 0 case, in general this is not a well-supported path (yet).

[zequanwu]

Address comment.

[DavidSpickett]

@zequanwu We've been seeing this test fail seemingly randomly on our bots and I think the use of posix_spawn without then waiting for the children to finish might be the cause.

https://lab.llvm.org/buildbot/#/builders/179/builds/942/steps/12/logs/FAIL__Profile-aarch64__set-file-object_c

/home/tcwg-buildslave/worker/clang-aarch64-full-2stage/llvm/compiler-rt/test/profile/ContinuousSyncMode/set-file-object.c:25:11: error: MERGE: expected string not found in input
// MERGE: Function count: 32

And we get:
check:25'0                 X error: no match found
           10:  Function count: 31 
check:25'0     ~~~~~~~~~~~~~~~~~~~~

I think there may be a situation where on a heavily loaded system (we have a large server with many bots) where the last child doesn't write to the file before the llvm-profdata commands run.

I'm trying to reproduce locally to prove it but that's going to be tricky. Would it make sense to wait ("join", I think) on the children anyway to be safe here?

[DavidSpickett]

Posted https://reviews.llvm.org/D109222 to do this.

[desaikevin]

My framework project is hitting this error case in XC13 if (CounterMmap != CountersBegin) {....
Is there any troubleshooting I can perform on my end to resolve this? Code coverage shows at 0% for only one module.

compiler-rt/lib/profile/InstrProfiling.h

  * __llvm_profile_is_continuous_mode_enabled) is on. The reason for this is
  * that in continuous mode, profile counters are mmap()'d to the profile at
  * program initialization time. Support for transferring the mmap'd profile
  * counts to a new file has not been implemented.
  */
 void __llvm_profile_set_filename(const char *Name);
 
 /*!
- * \brief Set the FILE object for writing instrumentation data.
+ * \brief Set the FILE object for writing instrumentation data. Return 0 if set
+ * successfully or return 1 if failed.
  *
  * 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).
  *
  * Note: There may be multiple copies of the profile runtime (one for each
  * instrumented image/DSO). This API only modifies the file object within the
  * copy of the runtime available to the calling image.
  *
- * Warning: This is a no-op if continuous mode (\ref
- * __llvm_profile_is_continuous_mode_enabled) is on. The reason for this is
- * that in continuous mode, profile counters are mmap()'d to the profile at
- * program initialization time. Support for transferring the mmap'd profile
- * counts to a new file has not been implemented.
+ * Warning: This is a no-op if EnableMerge is 0 in continuous mode (\ref
+ * __llvm_profile_is_continuous_mode_enabled), because disable merging requires
+ * copying the old profile file to new profile file and this function is usually
+ * used when the proess doesn't have permission to open file.
  */
-void __llvm_profile_set_file_object(FILE *File, int EnableMerge);
+int __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. */

compiler-rt/lib/profile/InstrProfilingFile.c

typedef struct lprofFilename {
   unsigned MergePoolSize;
   ProfileNameSpecifier PNS;
 } lprofFilename;
 
 static lprofFilename lprofCurFilename = {0,   0, 0, {0}, NULL,
                                          {0}, 0, 0, 0,   PNS_unknown};
 
 static int ProfileMergeRequested = 0;
+static int getProfileFileSizeForMerging(FILE *ProfileFile,
+                                        uint64_t *ProfileFileSize);
 
 #if defined(__APPLE__)
 static const int ContinuousModeSupported = 1;
 static const int UseBiasVar = 0;
 static const char *FileOpenMode = "a+b";
-static intptr_t INSTR_PROF_PROFILE_COUNTER_BIAS_VAR;
 static void *BiasAddr = NULL;
 static void *BiasDefaultAddr = NULL;
-static int MmapFlags = MAP_FIXED | MAP_SHARED;
+static int mmapForContinuousMode(uint64_t CurrentFileOffset, FILE *File) {
+  /* 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();
+  const uint64_t *CountersBegin = __llvm_profile_begin_counters();
+  const uint64_t *CountersEnd = __llvm_profile_end_counters();
+  const char *NamesBegin = __llvm_profile_begin_names();
+  const char *NamesEnd = __llvm_profile_end_names();
+  const uint64_t NamesSize = (NamesEnd - NamesBegin) * sizeof(char);
+  uint64_t DataSize = __llvm_profile_get_data_size(DataBegin, DataEnd);
+  uint64_t CountersSize = CountersEnd - CountersBegin;
+
+  /* Check that the counter and data sections in this image are
+   * page-aligned. */
+  unsigned PageSize = getpagesize();
+  if ((intptr_t)CountersBegin % PageSize != 0) {
+    PROF_ERR("Counters section not page-aligned (start = %p, pagesz = %u).\n",
+             CountersBegin, PageSize);
+    return 1;
+  }
+  if ((intptr_t)DataBegin % PageSize != 0) {
+    PROF_ERR("Data section not page-aligned (start = %p, pagesz = %u).\n",
+             DataBegin, PageSize);
+    return 1;
+  }
+  int Fileno = fileno(File);
+  /* Determine how much padding is needed before/after the counters and
+   * after the names. */
+  uint64_t PaddingBytesBeforeCounters, PaddingBytesAfterCounters,
+      PaddingBytesAfterNames;
+  __llvm_profile_get_padding_sizes_for_counters(
+      DataSize, CountersSize, NamesSize, &PaddingBytesBeforeCounters,
+      &PaddingBytesAfterCounters, &PaddingBytesAfterNames);
+
+  uint64_t PageAlignedCountersLength =
+      (CountersSize * sizeof(uint64_t)) + PaddingBytesAfterCounters;
+  uint64_t FileOffsetToCounters =
+      CurrentFileOffset + sizeof(__llvm_profile_header) +
+      (DataSize * sizeof(__llvm_profile_data)) + PaddingBytesBeforeCounters;
+  uint64_t *CounterMmap = (uint64_t *)mmap(
+      (void *)CountersBegin, PageAlignedCountersLength, PROT_READ | PROT_WRITE,
+      MAP_FIXED | MAP_SHARED, Fileno, FileOffsetToCounters);
+  if (CounterMmap != CountersBegin) {
+    PROF_ERR(
+        "Continuous counter sync mode is enabled, but mmap() failed (%s).\n"
+        "  - CountersBegin: %p\n"
+        "  - PageAlignedCountersLength: %" PRIu64 "\n"
+        "  - Fileno: %d\n"
+        "  - FileOffsetToCounters: %" PRIu64 "\n",
+        strerror(errno), CountersBegin, PageAlignedCountersLength, Fileno,
+        FileOffsetToCounters);
+    return 1;
+  }
+  return 0;
+}
 #elif defined(__ELF__) || defined(_WIN32)
 
 #define INSTR_PROF_PROFILE_COUNTER_BIAS_DEFAULT_VAR                            \
   INSTR_PROF_CONCAT(INSTR_PROF_PROFILE_COUNTER_BIAS_VAR, _default)
 intptr_t INSTR_PROF_PROFILE_COUNTER_BIAS_DEFAULT_VAR = 0;
 
 /* This variable is a weak external reference which could be used to detect
  * whether or not the compiler defined this symbol. */

 static const int UseBiasVar = 1;
 /* TODO: If there are two DSOs, the second DSO initilization will truncate the
  * first profile file. */
 static const char *FileOpenMode = "w+b";
 /* This symbol is defined by the compiler when runtime counter relocation is
  * used and runtime provides a weak alias so we can check if it's defined. */
 static void *BiasAddr = &INSTR_PROF_PROFILE_COUNTER_BIAS_VAR;
 static void *BiasDefaultAddr = &INSTR_PROF_PROFILE_COUNTER_BIAS_DEFAULT_VAR;
-static int MmapFlags = MAP_SHARED;
+static int mmapForContinuousMode(uint64_t CurrentFileOffset, FILE *File) {
+  /* 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();
+  const uint64_t *CountersBegin = __llvm_profile_begin_counters();
+  const uint64_t *CountersEnd = __llvm_profile_end_counters();
+  uint64_t DataSize = __llvm_profile_get_data_size(DataBegin, DataEnd);
+  /* Get the file size. */
+  uint64_t FileSize = 0;
+  if (getProfileFileSizeForMerging(File, &FileSize))
+    return 1;
+
+  /* Map the profile. */
+  char *Profile = (char *)mmap(NULL, FileSize, PROT_READ | PROT_WRITE,
+                               MAP_SHARED, fileno(File), 0);
+  if (Profile == MAP_FAILED) {
+    PROF_ERR("Unable to mmap profile: %s\n", strerror(errno));
+    return 1;
+  }
+  const uint64_t CountersOffsetInBiasMode =
+      sizeof(__llvm_profile_header) + __llvm_write_binary_ids(NULL) +
+      (DataSize * sizeof(__llvm_profile_data));
+  /* Update the profile fields based on the current mapping. */
+  INSTR_PROF_PROFILE_COUNTER_BIAS_VAR =
+      (intptr_t)Profile - (uintptr_t)CountersBegin + CountersOffsetInBiasMode;
+
+  /* Return the memory allocated for counters to OS. */
+  lprofReleaseMemoryPagesToOS((uintptr_t)CountersBegin, (uintptr_t)CountersEnd);
+  return 0;
+}
 #else
 static const int ContinuousModeSupported = 0;
 static const int UseBiasVar = 0;
 static const char *FileOpenMode = "a+b";
-static intptr_t INSTR_PROF_PROFILE_COUNTER_BIAS_VAR;
 static void *BiasAddr = NULL;
 static void *BiasDefaultAddr = NULL;
-static int MmapFlags = MAP_SHARED;
+static int mmapForContinuousMode(uint64_t CurrentFileOffset, FILE *File) {
+  return 0;
+}
 #endif
 
 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) {
-  if (__llvm_profile_is_continuous_mode_enabled()) {
-    PROF_WARN("__llvm_profile_set_file_object(fd=%d) not supported, because "
-              "continuous sync mode (%%c) is enabled",
-              fileno(File));
-    return;
-  }
-  setProfileFile(File);
-  setProfileMergeRequested(EnableMerge);
-}
-
 static int getCurFilenameLength();
 static const char *getCurFilename(char *FilenameBuf, int ForceUseBuf);
 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,
if (!ContinuousModeSupported) {
     PROF_ERR("%s\n", "continuous mode is unsupported on this platform");
     return;
   }
   if (UseBiasVar && BiasAddr == BiasDefaultAddr) {
     PROF_ERR("%s\n", "__llvm_profile_counter_bias is undefined");
     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();
+  /* Get the sizes of counter section. */
   const uint64_t *CountersBegin = __llvm_profile_begin_counters();
   const uint64_t *CountersEnd = __llvm_profile_end_counters();
-  const char *NamesBegin = __llvm_profile_begin_names();
-  const char *NamesEnd = __llvm_profile_end_names();
-  const uint64_t NamesSize = (NamesEnd - NamesBegin) * sizeof(char);
-  uint64_t DataSize = __llvm_profile_get_data_size(DataBegin, DataEnd);
   uint64_t CountersSize = CountersEnd - CountersBegin;
 
   int Length = getCurFilenameLength();
   char *FilenameBuf = (char *)COMPILER_RT_ALLOCA(Length + 1);
   const char *Filename = getCurFilename(FilenameBuf, 0);
   if (!Filename)
     return;
 
if (doMerging()) {
     if (writeProfileWithFileObject(Filename, File) != 0) {
       fclose(File);
       return;
     }
   }
 
   /* mmap() the profile counters so long as there is at least one counter.
    * If there aren't any counters, mmap() would fail with EINVAL. */
-  if (CountersSize > 0) {
-    int Fileno = fileno(File);
-    if (UseBiasVar) {
-      /* Get the file size. */
-      uint64_t FileSize = ftell(File);
-
-      /* Map the profile. */
-      char *Profile = (char *)mmap(NULL, FileSize, PROT_READ | PROT_WRITE,
-                                   MmapFlags, Fileno, 0);
-      if (Profile == MAP_FAILED) {
-        PROF_ERR("Unable to mmap profile: %s\n", strerror(errno));
-        return;
-      }
-      const uint64_t CountersOffsetInBiasMode =
-          sizeof(__llvm_profile_header) + __llvm_write_binary_ids(NULL) +
-          (DataSize * sizeof(__llvm_profile_data));
-      /* Update the profile fields based on the current mapping. */
-      INSTR_PROF_PROFILE_COUNTER_BIAS_VAR = (intptr_t)Profile -
-                                            (uintptr_t)CountersBegin +
-                                            CountersOffsetInBiasMode;
-
-      /* Return the memory allocated for counters to OS. */
-      lprofReleaseMemoryPagesToOS((uintptr_t)CountersBegin,
-                                  (uintptr_t)CountersEnd);
-    } else {
-      /* Check that the counter and data sections in this image are
-       * page-aligned. */
-      unsigned PageSize = getpagesize();
-      if ((intptr_t)CountersBegin % PageSize != 0) {
-        PROF_ERR(
-            "Counters section not page-aligned (start = %p, pagesz = %u).\n",
-            CountersBegin, PageSize);
-        return;
-      }
-      if ((intptr_t)DataBegin % PageSize != 0) {
-        PROF_ERR("Data section not page-aligned (start = %p, pagesz = %u).\n",
-                 DataBegin, PageSize);
-        return;
-      }
-      /* Determine how much padding is needed before/after the counters and
-       * after the names. */
-      uint64_t PaddingBytesBeforeCounters, PaddingBytesAfterCounters,
-          PaddingBytesAfterNames;
-      __llvm_profile_get_padding_sizes_for_counters(
-          DataSize, CountersSize, NamesSize, &PaddingBytesBeforeCounters,
-          &PaddingBytesAfterCounters, &PaddingBytesAfterNames);
-
-      uint64_t PageAlignedCountersLength =
-          (CountersSize * sizeof(uint64_t)) + PaddingBytesAfterCounters;
-      uint64_t FileOffsetToCounters =
-          CurrentFileOffset + sizeof(__llvm_profile_header) +
-          (DataSize * sizeof(__llvm_profile_data)) + PaddingBytesBeforeCounters;
-
-      uint64_t *CounterMmap =
-          (uint64_t *)mmap((void *)CountersBegin, PageAlignedCountersLength,
-                           PROT_READ | PROT_WRITE, MmapFlags,
-                           Fileno, FileOffsetToCounters);
-      if (CounterMmap != CountersBegin) {
-        PROF_ERR(
-            "Continuous counter sync mode is enabled, but mmap() failed (%s).\n"
-            "  - CountersBegin: %p\n"
-            "  - PageAlignedCountersLength: %" PRIu64 "\n"
-            "  - Fileno: %d\n"
-            "  - FileOffsetToCounters: %" PRIu64 "\n",
-            strerror(errno), CountersBegin, PageAlignedCountersLength, Fileno,
-            FileOffsetToCounters);
-      }
-    }
-  }
+  if (CountersSize > 0)
+    mmapForContinuousMode(CurrentFileOffset, File);
 
   if (doMerging()) {
     lprofUnlockFileHandle(File);
     fclose(File);
   }
 }
 
 static const char *DefaultProfileName = "default.profraw";
if (HasBeenRegistered)
     return 0;
 
   lprofSetupValueProfiler();
 
   HasBeenRegistered = 1;
   return atexit(writeFileWithoutReturn);
 }
 
+COMPILER_RT_VISIBILITY int __llvm_profile_set_file_object(FILE *File,
+                                                          int EnableMerge) {
+  if (__llvm_profile_is_continuous_mode_enabled()) {
+    if (!EnableMerge) {
+      PROF_WARN("__llvm_profile_set_file_object(fd=%d) not supported in "
+                "continuous sync mode when merging is disabled\n",
+                fileno(File));
+      return 1;
+    }
+    lprofLockFileHandle(File);
+    uint64_t ProfileFileSize = 0;
+    if (getProfileFileSizeForMerging(File, &ProfileFileSize) == -1) {
+      lprofUnlockFileHandle(File);
+      return 1;
+    }
+    if (ProfileFileSize == 0) {
+      FreeHook = &free;
+      setupIOBuffer();
+      ProfDataWriter fileWriter;
+      initFileWriter(&fileWriter, File);
+      if (lprofWriteData(&fileWriter, 0, 0)) {
+        lprofUnlockFileHandle(File);
+        PROF_ERR("Failed to write file \"%d\": %s\n", fileno(File),
+                 strerror(errno));
+        return 1;
+      }
+    } else {
+      /* The merged profile has a non-zero length. Check that it is compatible
+       * with the data in this process. */
+      char *ProfileBuffer;
+      if (mmapProfileForMerging(File, ProfileFileSize, &ProfileBuffer) == -1) {
+        lprofUnlockFileHandle(File);
+        return 1;
+      }
+      (void)munmap(ProfileBuffer, ProfileFileSize);
+    }
+    mmapForContinuousMode(0, File);
+    lprofUnlockFileHandle(File);
+  } else {
+    setProfileFile(File);
+    setProfileMergeRequested(EnableMerge);
+  }
+  return 0;
+}
+
 #endif

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

-// REQUIRES: darwin
+// REQUIRES: darwin || linux
 
-// RUN: %clang_pgogen -o %t.exe %s
-// RUN: env LLVM_PROFILE_FILE="%c%t.profraw" %run %t.exe %t.bad 2>&1 | FileCheck %s
-
-// CHECK: __llvm_profile_set_file_object(fd={{[0-9]+}}) not supported
-// CHECK: Profile data not written to file: already written.
+// Test using __llvm_profile_set_file_object in continuous mode (%c).
+// Create & cd into a temporary directory.
+// RUN: rm -rf %t.dir && mkdir -p %t.dir && cd %t.dir
+
+// The -mllvm -runtime-counter-relocation=true flag has effect only on linux.
+// RUN: %clang -fprofile-instr-generate -fcoverage-mapping -mllvm -instrprof-atomic-counter-update-all=1 -mllvm -runtime-counter-relocation=true -o main.exe %s
+
+// Test continuous mode with __llvm_profile_set_file_object with mergin disabled.
+// RUN: env LLVM_PROFILE_FILE="%t.dir/profdir/%c%mprofraw.old" %run  %t.dir/main.exe nomerge %t.dir/profdir/profraw.new 2>&1 | FileCheck %s -check-prefix=WARN
+// WARN: LLVM Profile Warning: __llvm_profile_set_file_object(fd={{[0-9]+}}) not supported in continuous sync mode when merging is disabled
+
+// Test continuous mode with __llvm_profile_set_file_object with mergin enabled.
+// RUN: rm -rf %t.dir/profdir/
+// RUN: env LLVM_PROFILE_FILE="%t.dir/profdir/%c%mprofraw.old" %run  %t.dir/main.exe merge %t.dir/profdir/profraw.new 'LLVM_PROFILE_FILE=%t.dir/profdir/%c%m.profraw'
+// RUN: llvm-profdata merge -o %t.dir/profdir/profdata %t.dir/profdir/profraw.new
+// RUN: llvm-profdata show --counts --all-functions %t.dir/profdir/profdata | FileCheck %s -check-prefix=MERGE
+// RUN: llvm-profdata show --counts --all-functions %t.dir/profdir/*profraw.old | FileCheck %s -check-prefix=ZERO
+
+// MERGE: Counters:
+// MERGE:   coverage_test:
+// MERGE:     Hash: {{.*}}
+// MERGE:     Counters: 1
+// MERGE:     Function count: 32
+// MERGE:     Block counts: []
+// MERGE: Instrumentation level: Front-end
+
+// ZERO: Counters:
+// ZERO:   coverage_test:
+// ZERO:     Hash: {{.*}}
+// ZERO:     Counters: 1
+// ZERO:     Function count: 0
+// ZERO:     Block counts: []
+// ZERO: Instrumentation level: Front-end
 
+#include <spawn.h>
 #include <stdio.h>
+#include <string.h>
+
+const int num_child_procs_to_spawn = 32;
 
 extern int __llvm_profile_is_continuous_mode_enabled(void);
-extern void __llvm_profile_set_file_object(FILE *, int);
-extern int __llvm_profile_write_file(void);
+extern int __llvm_profile_set_file_object(FILE *, int);
 
-int main(int argc, char **argv) {
-  if (!__llvm_profile_is_continuous_mode_enabled())
-    return 1;
+int coverage_test() {
+  return 0;
+}
 
-  FILE *f = fopen(argv[1], "a+b");
-  if (!f)
+int main(int argc, char **argv) {
+  char *file_name = argv[2];
+  FILE *file = fopen(file_name, "a+b");
+  if (strcmp(argv[1], "nomerge") == 0)
+    __llvm_profile_set_file_object(file, 0);
+  else if (strcmp(argv[1], "merge") == 0) {
+    // Parent process.
+    int I;
+    pid_t child_pids[num_child_procs_to_spawn];
+    char *const child_argv[] = {argv[0], "set", file_name, NULL};
+    char *const child_envp[] = {argv[3], NULL};
+    for (I = 0; I < num_child_procs_to_spawn; ++I) {
+      int ret =
+          posix_spawn(&child_pids[I], argv[0], NULL, NULL, child_argv, child_envp);
+      if (ret != 0) {
+        fprintf(stderr, "Child %d could not be spawned: ret = %d, msg = %s\n",
+                I, ret, strerror(ret));
         return 1;
-
-  __llvm_profile_set_file_object(f, 0); // Try to set the file to "%t.bad".
-
-  if (__llvm_profile_write_file() != 0)
+      }
+    }
+  } else if (strcmp(argv[1], "set") == 0) {
+    // Child processes.
+    if (!__llvm_profile_is_continuous_mode_enabled()) {
+      fprintf(stderr, "Continuous mode disabled\n");
       return 1;
-
-  f = fopen(argv[1], "r");
-  if (!f)
+    }
+    if (__llvm_profile_set_file_object(file, 1)) {
+      fprintf(stderr, "Call to __llvm_profile_set_file_object failed\n");
       return 1;
-
-  fseek(f, 0, SEEK_END);
-  return ftell(f); // Check that the "%t.bad" is empty.
+    }
+    // After set file object, counter should be written into new file.
+    coverage_test();
+  }
+  return 0;
 }