[PLEASE IGNORE] compiler-rt: Local patch for debugging weird profile bugs.

lib/profile/InstrProfilingFile.c

  * 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) {
   parseAndSetFilename(FilenamePat, PNS_runtime_api, 1);
 }
 
+// int __sanitizer_print_stack_trace(void);
+
 /* The public API for writing profile data into the file with name
  * set by previous calls to __llvm_profile_set_filename or
  * __llvm_profile_override_default_filename or
  * __llvm_profile_initialize_file. */
 COMPILER_RT_VISIBILITY
 int __llvm_profile_write_file(void) {
   int rc, Length;
   const char *Filename;
   char *FilenameBuf;
   int PDeathSig = 0;
-
+//   __sanitizer_print_stack_trace();
   if (lprofProfileDumped()) {
+    myLog("WRITE FILE CALLED FROM pid: %lu\tfilename: %s\n", getpid(), "CALLED TWICE, BAIL OUT!");
     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);
-
+  myLog("WRITE FILE CALLED FROM pid: %lu\tfilename: %s\n", getpid(), Filename);
   /* Check the filename. */
   if (!Filename) {
     PROF_ERR("Failed to write file : %s\n", "Filename not set");
     return -1;
   }
 
   /* Check if there is llvm/runtime version mismatch.  */
   if (GET_VERSION(__llvm_profile_get_version()) != INSTR_PROF_RAW_VERSION) {
     PROF_ERR("Runtime and instrumentation version mismatch : "
              "expected %d, but get %d\n",
              INSTR_PROF_RAW_VERSION,
              (int)GET_VERSION(__llvm_profile_get_version()));
     return -1;
   }
 
   // Temporarily suspend getting SIGKILL when the parent exits.
   PDeathSig = lprofSuspendSigKill();
 
+  // Let's inspect counts in memory before writing the file.
+  __llvm_profile_data *DataBegin = (__llvm_profile_data *)__llvm_profile_begin_data();
+  __llvm_profile_data *DataEnd = (__llvm_profile_data *)__llvm_profile_end_data();
+  for (__llvm_profile_data *DataPtr = DataBegin; DataPtr < DataEnd; ++DataPtr) {
+    if (DataPtr->NameRef == 0x321408bd58d4c346 || DataPtr->NameRef == 0xf96b1fa6f8205ca0) {
+      uint64_t *Counters = (uint64_t *)DataPtr->CounterPtr;
+      unsigned NC = DataPtr->NumCounters;
+      for (unsigned I = 0; I < NC; ++I) {
+        myLog2("Index %lu of %lu\n", I, NC);
+        myLog3("In-Memory Counter [pid: %lu] @ %llx holding Value: %lu\n", getpid(), &Counters[I], Counters[I]);
+      }
+    }
+  }
+
   /* Write profile data to the file. */
   rc = writeFile(Filename);
   if (rc)
     PROF_ERR("Failed to write file \"%s\": %s\n", Filename, strerror(errno));
 
   // Restore SIGKILL.
   if (PDeathSig == 1)
     lprofRestoreSigKill();
 
   return rc;
 }
 
 COMPILER_RT_VISIBILITY
 int __llvm_profile_dump(void) {
+  myLog2("DUMP  FILE CALLED FROM pid: %lu\tisProfileDumped: %lu\n", getpid(), lprofProfileDumped());
   if (!doMerging())
     PROF_WARN("Later invocation of __llvm_profile_dump can lead to clobbering "
               " of previously dumped profile data : %s. Either use %%m "
               "in profile name or change profile name before dumping.\n",
               "online profile merging is not on");
   int rc = __llvm_profile_write_file();
   lprofSetProfileDumped();
   return rc;

lib/profile/InstrProfilingMerge.c

if (Header->Magic != __llvm_profile_get_magic() ||
       Header->ValueKindLast != IPVK_Last)
     return 1;
 
   if (ProfileSize < sizeof(__llvm_profile_header) +
                         Header->DataSize * sizeof(__llvm_profile_data) +
                         Header->NamesSize + Header->CountersSize)
     return 1;
 
+  uint64_t *SrcCountersStart = (uint64_t*)SrcDataEnd;
+
   for (SrcData = SrcDataStart,
        DstData = (__llvm_profile_data *)__llvm_profile_begin_data();
        SrcData < SrcDataEnd; ++SrcData, ++DstData) {
     if (SrcData->NameRef != DstData->NameRef ||
         SrcData->FuncHash != DstData->FuncHash ||
         SrcData->NumCounters != DstData->NumCounters)
       return 1;
+      // Let's inspect counts in file before merging.
+//    __llvm_profile_data *DataBegin = (__llvm_profile_data *)__llvm_profile_begin_data();
+//    __llvm_profile_data *DataEnd = (__llvm_profile_data *)__llvm_profile_end_data();
+//    for (__llvm_profile_data *DataPtr = DataBegin; DataPtr < DataEnd; ++DataPtr) {
+      if (SrcData->NameRef == 0x321408bd58d4c346 || SrcData->NameRef == 0xf96b1fa6f8205ca0) {
+        // uint64_t *Counters = (uint64_t *)SrcData->CounterPtr;
+        uint64_t *Counters = SrcCountersStart +
+                  ((size_t)SrcData->CounterPtr - Header->CountersDelta) /
+                      sizeof(uint64_t);
+        myLog3("In-File  SrcCountersStart: %llx, SrcData->CounterPtr: %llx, Header->CountersDelta: %llx\n",
+               SrcCountersStart, SrcData->CounterPtr, Header->CountersDelta);
+        myLog2("In-File Calculation [pid: %lu], Counters: %llx\n", getpid(), Counters);
+        myLog3("In-Sanity-File  SrcData: %llx, DstData: %llx, SrcData - SrcDataStart: %lld\n",
+               SrcData, DstData, SrcData - SrcDataStart);
+        unsigned NC = SrcData->NumCounters;
+        for (unsigned I = 0; I < NC; ++I) {
+          myLog3("In-File  Counter [pid: %lu] @ %llx holding Value: %lu\n", getpid(), &Counters[I], Counters[I]);
+        }
+      }
+//    }
   }
 
   /* Matched! */
   return 0;
 }
 
 COMPILER_RT_VISIBILITY
 void __llvm_profile_merge_from_buffer(const char *ProfileData,

lib/profile/InstrProfilingUtil.h

 /* Temporarily suspend SIGKILL. Return value of 1 means a restore is needed.
  * Other return values mean no restore is needed.
  */
 int lprofSuspendSigKill();
 
 /* Restore previously suspended SIGKILL. */
 void lprofRestoreSigKill();
 
+int myLog(const char *format, const uint64_t pid, const char* name);
+
+int myLog2(const char *format, uint64_t pid, uint64_t name);
+
+int myLog3(const char *format, uint64_t pid, uint64_t name, uint64_t value);
+
+int myLog4(const char *format, const uint64_t pid, const uint64_t sign, const char* name);
+
 #endif /* PROFILE_INSTRPROFILINGUTIL_H */

lib/profile/InstrProfilingUtil.c

 #endif
   return Sep;
 }
 
 COMPILER_RT_VISIBILITY int lprofSuspendSigKill() {
 #if defined(__linux__)
   int PDeachSig = 0;
   /* Temporarily suspend getting SIGKILL upon exit of the parent process. */
-  if (prctl(PR_GET_PDEATHSIG, &PDeachSig) == 0 && PDeachSig == SIGKILL)
+  if (prctl(PR_GET_PDEATHSIG, &PDeachSig) == 0 && (PDeachSig == SIGKILL || PDeachSig == SIGTERM))
     prctl(PR_SET_PDEATHSIG, 0);
-  return (PDeachSig == SIGKILL);
+  if (PDeachSig == SIGKILL)
+    myLog("GOT SIGNAL IN pid: %lu\t SIGNAL: %s\n", getpid(), "SIGKILL");
+  else if (PDeachSig == SIGTERM)
+    myLog("GOT SIGNAL IN pid: %lu\t SIGNAL: %s\n", getpid(), "SIGTERM");
+
+  return (PDeachSig == SIGKILL || PDeachSig == SIGTERM);
 #else
   return 0;
 #endif
 }
 
 COMPILER_RT_VISIBILITY void lprofRestoreSigKill() {
 #if defined(__linux__)
   prctl(PR_SET_PDEATHSIG, SIGKILL);
 #endif
 }
+
+COMPILER_RT_VISIBILITY int myLog(const char *format, const uint64_t pid, const char* name) {
+  // va_list args;
+  // va_start(args, format);
+
+  FILE *f = lprofOpenFileEx("mylog.txt");
+  if (!f)
+    return 123 / ((uint64_t)format - (uint64_t)format);
+
+  fseek(f, 0, SEEK_END);
+
+  fprintf(f, format, pid, name);
+//  va_end(args);
+
+  return fclose(f);  
+}
+
+COMPILER_RT_VISIBILITY int myLog2(const char *format, uint64_t pid, uint64_t name) {
+  FILE *f = lprofOpenFileEx("mylog.txt");
+  if (!f)
+    return 123 / ((uint64_t)format - (uint64_t)format);
+
+  fseek(f, 0, SEEK_END);
+
+  fprintf(f, format, pid, name);
+
+  return fclose(f);  
+}
+
+COMPILER_RT_VISIBILITY int myLog3(const char *format, uint64_t pid, uint64_t name, uint64_t value) {
+  FILE *f = lprofOpenFileEx("mylog.txt");
+  if (!f)
+    return 123 / ((uint64_t)format - (uint64_t)format);
+
+  fseek(f, 0, SEEK_END);
+
+  fprintf(f, format, pid, name, value);
+
+  return fclose(f);  
+}
+
+COMPILER_RT_VISIBILITY int myLog4(const char *format, const uint64_t pid, const uint64_t sign, const char* name) {
+   FILE *f = lprofOpenFileEx("mylog.txt");
+  if (!f)
+    return 123 / ((uint64_t)format - (uint64_t)format);
+
+  fseek(f, 0, SEEK_END);
+
+  fprintf(f, format, pid, sign, name);
+
+  return fclose(f);   
+}