[PLEASE IGNORE] Local patch for debugging weird profile bugs.

lib/ProfileData/InstrProf.cpp

void InstrProfValueSiteRecord::merge(InstrProfValueSiteRecord &Input,
   auto IE = ValueData.end();
   for (auto J = Input.ValueData.begin(), JE = Input.ValueData.end(); J != JE;
        ++J) {
     while (I != IE && I->Value < J->Value)
       ++I;
     if (I != IE && I->Value == J->Value) {
       bool Overflowed;
       I->Count = SaturatingMultiplyAdd(J->Count, Weight, I->Count, &Overflowed);
-      if (Overflowed)
+      if (Overflowed) {
+        outs() << "Warn from InstrProf:497\n";
         Warn(instrprof_error::counter_overflow);
+      }
       ++I;
       continue;
     }
     ValueData.insert(I, *J);
   }
 }
 
 void InstrProfValueSiteRecord::scale(uint64_t Weight,
                                      function_ref<void(instrprof_error)> Warn) {
   for (auto I = ValueData.begin(), IE = ValueData.end(); I != IE; ++I) {
     bool Overflowed;
     I->Count = SaturatingMultiply(I->Count, Weight, &Overflowed);
-    if (Overflowed)
+    if (Overflowed) {
+      outs() << "Warn from InstrProf:513\n";
       Warn(instrprof_error::counter_overflow);
     }
   }
+}
 
 // Merge Value Profile data from Src record to this record for ValueKind.
 // Scale merged value counts by \p Weight.
 void InstrProfRecord::mergeValueProfData(
     uint32_t ValueKind, InstrProfRecord &Src, uint64_t Weight,
     function_ref<void(instrprof_error)> Warn) {
   uint32_t ThisNumValueSites = getNumValueSites(ValueKind);
   uint32_t OtherNumValueSites = Src.getNumValueSites(ValueKind);
for (uint32_t I = 0; I < ThisNumValueSites; I++)
     ThisSiteRecords[I].merge(OtherSiteRecords[I], Weight, Warn);
 }
 
 void InstrProfRecord::merge(InstrProfRecord &Other, uint64_t Weight,
                             function_ref<void(instrprof_error)> Warn) {
   // If the number of counters doesn't match we either have bad data
   // or a hash collision.
   if (Counts.size() != Other.Counts.size()) {
+    // outs() << "Warn from InstrProf.cpp:545 which is a hard error like.\n";
     Warn(instrprof_error::count_mismatch);
     return;
   }
 
   for (size_t I = 0, E = Other.Counts.size(); I < E; ++I) {
     bool Overflowed;
     Counts[I] =
         SaturatingMultiplyAdd(Other.Counts[I], Weight, Counts[I], &Overflowed);
-    if (Overflowed)
+    if (Overflowed) {
       Warn(instrprof_error::counter_overflow);
+      //outs() << reinterpret_cast<NamedInstrProfRecord*>(&Other)->Name;
+      // outs() << Other.Counts[I] << " + " << Counts[I] << " * " << Weight;
+      // outs() << " Warn from InstrProf.cpp:556.\n";
+    }
   }
 
   for (uint32_t Kind = IPVK_First; Kind <= IPVK_Last; ++Kind)
     mergeValueProfData(Kind, Other, Weight, Warn);
 }
 
 void InstrProfRecord::scaleValueProfData(
     uint32_t ValueKind, uint64_t Weight,

lib/ProfileData/InstrProfReader.cpp

Error RawInstrProfReader<IntPtrT>::readHeader(
 
   auto *Start = reinterpret_cast<const char *>(&Header);
   if (Start + ValueDataOffset > DataBuffer->getBufferEnd())
     return error(instrprof_error::bad_header);
 
   Data = reinterpret_cast<const RawInstrProf::ProfileData<IntPtrT> *>(
       Start + DataOffset);
   DataEnd = Data + DataSize;
+  outs() << "Start = " << reinterpret_cast<uint64_t>(Start) << "\n";
+  outs() << "Data start = " << reinterpret_cast<uint64_t>(Start + DataOffset) << "\n";
+  outs() << "Data end = " << reinterpret_cast<uint64_t>(Start + DataOffset + DataSize) << "\n";
   CountersStart = reinterpret_cast<const uint64_t *>(Start + CountersOffset);
   NamesStart = Start + NamesOffset;
   ValueDataStart = reinterpret_cast<const uint8_t *>(Start + ValueDataOffset);
 
   std::unique_ptr<InstrProfSymtab> NewSymtab = make_unique<InstrProfSymtab>();
   if (Error E = createSymtab(*NewSymtab.get()))
     return E;
 
Error RawInstrProfReader<IntPtrT>::readFuncHash(NamedInstrProfRecord &Record) {
   return success();
 }
 
 template <class IntPtrT>
 Error RawInstrProfReader<IntPtrT>::readRawCounts(
     InstrProfRecord &Record) {
   uint32_t NumCounters = swap(Data->NumCounters);
   IntPtrT CounterPtr = Data->CounterPtr;
+  if (((NamedInstrProfRecord*)&Record)->Name == "sqlite3.c:vdbeFreeOpArray") {
+    outs() << "Data = " << Data << "\n";
+    // outs() << "XXXXXXXXXXXXXXXXXXXXXX\n";
+    outs() << "CounterPtr = " << (uint64_t*)CounterPtr << "\n";
+  }
   if (NumCounters == 0)
     return error(instrprof_error::malformed);
 
   auto RawCounts = makeArrayRef(getCounter(CounterPtr), NumCounters);
+  if (((NamedInstrProfRecord*)&Record)->Name == "vdbeFreeOpArray") {
+    for (uint64_t Count : RawCounts) {
+      outs() << Count << "\n";
+    }
+  }
   auto *NamesStartAsCounter = reinterpret_cast<const uint64_t *>(NamesStart);
 
   // Check bounds.
   if (RawCounts.data() < CountersStart ||
       RawCounts.data() + RawCounts.size() > NamesStartAsCounter)
     return error(instrprof_error::malformed);
 
   if (ShouldSwapBytes) {

lib/ProfileData/InstrProfWriter.cpp

void InstrProfWriter::addRecord(StringRef Name, uint64_t Hash,
 
   bool NewFunc;
   ProfilingData::iterator Where;
   std::tie(Where, NewFunc) =
       ProfileDataMap.insert(std::make_pair(Hash, InstrProfRecord()));
   InstrProfRecord &Dest = Where->second;
 
   auto MapWarn = [&](instrprof_error E) {
+    outs() << Name << "\n";
+    // outs() << Name << " in InstrProfWriter.cpp:199\n";
     Warn(make_error<InstrProfError>(E));
   };
 
   if (NewFunc) {
     // We've never seen a function with this name and hash, add it.
     Dest = std::move(I);
     if (Weight > 1)
       Dest.scale(Weight, MapWarn);

tools/llvm-profdata/llvm-profdata.cpp

static void mergeWriterContexts(WriterContext *Dst, WriterContext *Src) {
 
   bool Reported = false;
   Dst->Writer.mergeRecordsFromWriter(std::move(Src->Writer), [&](Error E) {
     if (Reported) {
       consumeError(std::move(E));
       return;
     }
     Reported = true;
+    // outs() << "Reported an error in llvm-profdata.cpp:228\n";
     Dst->Err = std::move(E);
   });
 }
 
 static void mergeInstrProfile(const WeightedFileVector &Inputs,
                               StringRef OutputFilename,
                               ProfileFormat OutputFormat, bool OutputSparse,
                               unsigned NumThreads) {
for (std::unique_ptr<WriterContext> &WC : Contexts) {
     if (!WC->Err)
       continue;
     if (!WC->Err.isA<InstrProfError>())
       exitWithError(std::move(WC->Err), WC->ErrWhence);
 
     instrprof_error IPE = InstrProfError::take(std::move(WC->Err));
     if (isFatalError(IPE))
       exitWithError(make_error<InstrProfError>(IPE), WC->ErrWhence);
-    else
+    else {
+      // outs() << "warning from llvm-profdata.cpp:305\n";
       warn(toString(make_error<InstrProfError>(IPE)),
            WC->ErrWhence);
     }
+  }
 
   InstrProfWriter &Writer = Contexts[0]->Writer;
   if (OutputFormat == PF_Text) {
     if (Error E = Writer.writeText(Output))
       exitWithError(std::move(E));
   } else {
     Writer.write(Output);
   }