Temp local change for dumping coverage features.

lib/fuzzer/FuzzerDriver.cpp

 #include "FuzzerIO.h"
 #include "FuzzerInterface.h"
 #include "FuzzerInternal.h"
 #include "FuzzerMutate.h"
 #include "FuzzerRandom.h"
 #include "FuzzerShmem.h"
 #include "FuzzerTracePC.h"
 #include <algorithm>
+#include <array>
 #include <atomic>
 #include <chrono>
 #include <cstdlib>
 #include <cstring>
 #include <mutex>
 #include <string>
 #include <thread>
 

 }
 
 static void StartRssThread(Fuzzer *F, size_t RssLimitMb) {
   if (!RssLimitMb) return;
   std::thread T(RssThread, F, RssLimitMb);
   T.detach();
 }
 
+static size_t kMaxFeature = (1 << 17) + (1 << 15);
+
+static void DumpCoverageFeature(
+    const char *InputFilePath,
+    const std::array<uint8_t, kMaxFeature / 8> &Features) {
+  std::string FilePath(InputFilePath);
+
+  FILE *Out = fopen(FilePath.c_str(), "w");
+  if (!Out) return;
+  fwrite(Features.data(), sizeof(Features[0]), Features.size(), Out);
+}
+
 int RunOneTest(Fuzzer *F, const char *InputFilePath, size_t MaxLen) {
   Unit U = FileToVector(InputFilePath);
   if (MaxLen && MaxLen < U.size())
     U.resize(MaxLen);
   F->ExecuteCallback(U.data(), U.size());
-  F->TryDetectingAMemoryLeak(U.data(), U.size(), true);
+  // F->TryDetectingAMemoryLeak(U.data(), U.size(), true);
+  std::array<uint8_t, kMaxFeature / 8> Features;
+  TPC.CollectFeatures([&](size_t Feature) {
+      size_t position = Feature / 8;
+      size_t power = Feature % 8;
+      Features[position] |= 1 << power;
+    });
+  DumpCoverageFeature(InputFilePath, Features);
   return 0;
 }
 
 static bool AllInputsAreFiles() {
   if (Inputs->empty()) return false;
   for (auto &Path : *Inputs)
     if (!IsFile(Path))
       return false;

lib/fuzzer/FuzzerLoop.cpp

void Fuzzer::PrintPulseAndReportSlowInput(const uint8_t *Data, size_t Size) {
   if (TimeOfUnit > TimeOfLongestUnitInSeconds * 1.1 &&
       TimeOfUnit >= Options.ReportSlowUnits) {
     TimeOfLongestUnitInSeconds = TimeOfUnit;
     Printf("Slowest unit: %zd s:\n", TimeOfLongestUnitInSeconds);
     WriteUnitToFileWithPrefix({Data, Data + Size}, "slow-unit-");
   }
 }
 
+// static size_t kMaxFeature = 0;
+
 bool Fuzzer::RunOne(const uint8_t *Data, size_t Size, bool MayDeleteFile,
                     InputInfo *II, bool *FoundUniqFeatures) {
   if (!Size)
     return false;
 
   ExecuteCallback(Data, Size);
 
   UniqFeatureSetTmp.clear();
   size_t FoundUniqFeaturesOfII = 0;
   size_t NumUpdatesBefore = Corpus.NumFeatureUpdates();
   TPC.CollectFeatures([&](size_t Feature) {
     if (Options.UseFeatureFrequency)
       Corpus.UpdateFeatureFrequency(Feature);
     if (Corpus.AddFeature(Feature, Size, Options.Shrink))
       UniqFeatureSetTmp.push_back(Feature);
     if (Options.ReduceInputs && II)
       if (std::binary_search(II->UniqFeatureSet.begin(),
                              II->UniqFeatureSet.end(), Feature))
         FoundUniqFeaturesOfII++;
   });
+  // Vector<size_t> Features;
+  // TPC.CollectFeatures([&](size_t Feature) {
+  //     Features.push_back(Feature);
+  //   });
+  // if (Features.back() > kMaxFeature)
+  //   kMaxFeature = Features.back();
   if (FoundUniqFeatures)
     *FoundUniqFeatures = FoundUniqFeaturesOfII;
   PrintPulseAndReportSlowInput(Data, Size);
   size_t NumNewFeatures = Corpus.NumFeatureUpdates() - NumUpdatesBefore;
   if (NumNewFeatures) {
     TPC.UpdateObservedPCs();
     Corpus.AddToCorpus({Data, Data + Size}, NumNewFeatures, MayDeleteFile,
                        UniqFeatureSetTmp);
if (Options.DoCrossOver)
     MD.SetCorpus(&Corpus);
   while (true) {
     auto Now = system_clock::now();
     if (duration_cast<seconds>(Now - LastCorpusReload).count() >=
         Options.ReloadIntervalSec) {
       RereadOutputCorpus(MaxInputLen);
       LastCorpusReload = system_clock::now();
     }
-    if (TotalNumberOfRuns >= Options.MaxNumberOfRuns)
+    if (TotalNumberOfRuns >= Options.MaxNumberOfRuns) {
+//      Printf("Max feature: %zd\n", kMaxFeature);
       break;
+    }
     if (TimedOut())
       break;
 
     // Update TmpMaxMutationLen
     if (Options.LenControl) {
       if (TmpMaxMutationLen < MaxMutationLen &&
           TotalNumberOfRuns - LastCorpusUpdateRun >
               Options.LenControl * Log(TmpMaxMutationLen)) {