Testing diff file contexts

lib/fuzzer/FuzzerDefs.h

 //===- FuzzerDefs.h - Internal header for the Fuzzer ------------*- C++ -* ===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 // Basic definitions.
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_FUZZER_DEFS_H
 #define LLVM_FUZZER_DEFS_H
 
+#include <array>
 #include <cassert>
 #include <cstddef>
 #include <cstdint>
 #include <cstring>
+#include <memory>
+#include <set>
 #include <string>
-#include <array>
+#include <unordered_map>
 #include <vector>
-#include <map>
-#include <set>
-#include <memory>
 
 // Platform detection.
 #ifdef __linux__
 #define LIBFUZZER_APPLE 0
 #define LIBFUZZER_FUCHSIA 0
 #define LIBFUZZER_LINUX 1
 #define LIBFUZZER_NETBSD 0
 #define LIBFUZZER_FREEBSD 0

lib/fuzzer/FuzzerFlags.def

FUZZER_FLAG_STRING(exit_on_src_pos, "Exit if a newly found PC originates"
     "Used primarily for testing libFuzzer itself.")
 FUZZER_FLAG_STRING(exit_on_item, "Exit if an item with a given sha1 sum"
     " was added to the corpus. "
     "Used primarily for testing libFuzzer itself.")
 FUZZER_FLAG_INT(ignore_remaining_args, 0, "If 1, ignore all arguments passed "
                 "after this one. Useful for fuzzers that need to do their own "
                 "argument parsing.")
 FUZZER_FLAG_STRING(focus_function, "Experimental. "
      "Fuzzing will focus on inputs that trigger calls to this function")
 
 FUZZER_DEPRECATED_FLAG(run_equivalence_server)
 FUZZER_DEPRECATED_FLAG(use_equivalence_server)
 FUZZER_FLAG_INT(analyze_dict, 0, "Experimental")
 FUZZER_DEPRECATED_FLAG(use_clang_coverage)
 FUZZER_FLAG_STRING(data_flow_trace, "Experimental: use the data flow trace")
 FUZZER_FLAG_INT(print_mutation_stats, 0, "Experimental")

lib/fuzzer/FuzzerMutate.h

public:
   void SetCorpus(const InputCorpus *Corpus) { this->Corpus = Corpus; }
 
   Random &GetRand() { return Rand; }
 
   void CountCurrentMutatorSequence();
 
   struct Mutator {
     size_t (MutationDispatcher::*Fn)(uint8_t *Data, size_t Size, size_t Max);
-    int Identifier;
+    MutationType Identifier;
   };
 
 
 private:
 
   size_t AddWordFromDictionary(Dictionary &D, uint8_t *Data, size_t Size,
                                size_t MaxSize);
   size_t MutateImpl(uint8_t *Data, size_t Size, size_t MaxSize,
private:
   // CustomCrossOver needs its own buffer as a custom implementation may call
   // LLVMFuzzerMutate, which in turn may resize MutateInPlaceHere.
   Vector<uint8_t> CustomCrossOverInPlaceHere;
 
   Vector<Mutator> Mutators;
   Vector<Mutator> DefaultMutators;
 };
 
-const std::map<int, std::string> kMutationNames = {
-  {0, "AddWordFromManualDictionaryCount"},
-  {1, "AddWordFromPersistentAutoDictionaryCount"},
-  {2, "AddWordFromTORCCount"},
-  {3, "ChangeASCIIIntegerCount"},
-  {4, "ChangeBinaryIntegerCount"},
-  {5, "ChangeBitCount"},
-  {6, "CopyPartCount"},
-  {7, "ChangeByteCount"},
-  {8, "CrossOverCount"},
-  {9, "CustomCrossoverCount"},
-  {10, "CustomMutationCount"},
-  {11, "EraseBytesCount"},
-  {12, "InsertByteCount"},
-  {13, "InsertRepeatedBytesCount"},
-  {14, "ShuffleBytesCount"}
+const std::unordered_map<MutationType, std::string> kMutationNames = {
+  {ManualDict, "AddWordFromManualDictionaryCount"},
+  {PersAutoDict, "AddWordFromPersistentAutoDictionaryCount"},
+  {CMP, "AddWordFromTORCCount"},
+  {ChangeAsciiInt, "ChangeASCIIIntegerCount"},
+  {ChangeBinInt, "ChangeBinaryIntegerCount"},
+  {ChangeBit, "ChangeBitCount"},
+  {CopyPart, "CopyPartCount"},
+  {ChangeByte, "ChangeByteCount"},
+  {CrossOver, "CrossOverCount"},
+  {CustomCrossOver, "CustomCrossOverCount"},
+  {CustomMutation, "CustomMutationCount"},
+  {EraseBytes, "EraseBytesCount"},
+  {InsertByte, "InsertByteCount"},
+  {InsertRepeatedBytes, "InsertRepeatedBytesCount"},
+  {ShuffleBytes, "ShuffleBytesCount"}
 };
 
 }  // namespace fuzzer
 
 #endif  // LLVM_FUZZER_MUTATE_H

lib/fuzzer/FuzzerMutate.cpp

DefaultMutators.insert(
           {&MutationDispatcher::Mutate_InsertRepeatedBytes,
            InsertRepeatedBytes},
           {&MutationDispatcher::Mutate_ChangeByte, ChangeByte},
           {&MutationDispatcher::Mutate_ChangeBit, ChangeBit},
           {&MutationDispatcher::Mutate_ShuffleBytes, ShuffleBytes},
           {&MutationDispatcher::Mutate_ChangeASCIIInteger, ChangeAsciiInt},
           {&MutationDispatcher::Mutate_ChangeBinaryInteger, ChangeBinInt},
           {&MutationDispatcher::Mutate_CopyPart, CopyPart},
-          {&MutationDispatcher::Mutate_CrossOver, Crossover},
+          {&MutationDispatcher::Mutate_CrossOver, CrossOver},
           {&MutationDispatcher::Mutate_AddWordFromManualDictionary,
            ManualDict},
           {&MutationDispatcher::Mutate_AddWordFromPersistentAutoDictionary,
            PersAutoDict},
       });
   if(Options.UseCmp)
     DefaultMutators.push_back(
         {&MutationDispatcher::Mutate_AddWordFromTORC, CMP});
 
   if (EF->LLVMFuzzerCustomMutator)
     Mutators.push_back({&MutationDispatcher::Mutate_Custom, CustomMutation});
   else
     Mutators = DefaultMutators;
 
   if (EF->LLVMFuzzerCustomCrossOver)
     Mutators.push_back(
-        {&MutationDispatcher::Mutate_CustomCrossOver, CustomCrossover});
+        {&MutationDispatcher::Mutate_CustomCrossOver, CustomCrossOver});
 }
 
 static char RandCh(Random &Rand) {
   if (Rand.RandBool()) return Rand(256);
   const char Special[] = "!*'();:@&=+$,/?%#[]012Az-`~.\xff\x00";
   return Special[Rand(sizeof(Special) - 1)];
 }
 
size_t MutationDispatcher::Mutate_CustomCrossOver(uint8_t *Data, size_t Size,
   CustomCrossOverInPlaceHere.resize(MaxSize);
   auto &U = CustomCrossOverInPlaceHere;
   size_t NewSize = EF->LLVMFuzzerCustomCrossOver(
       Data, Size, Other.data(), Other.size(), U.data(), U.size(), Rand.Rand());
   if (!NewSize)
     return 0;
   assert(NewSize <= MaxSize && "CustomCrossOver returned overisized unit");
   memcpy(Data, U.data(), NewSize);
-  MStats->IncrementCount(CustomCrossover, 0);
+  MStats->IncrementCount(CustomCrossOver, 0);
   return NewSize;
 }
 
 size_t MutationDispatcher::Mutate_ShuffleBytes(uint8_t *Data, size_t Size,
                                                size_t MaxSize) {
   if (Size > MaxSize || Size == 0) return 0;
   size_t ShuffleAmount =
       Rand(std::min(Size, (size_t)8)) + 1; // [1,8] and <= Size.
size_t MutationDispatcher::AddWordFromDictionary(Dictionary &D, uint8_t *Data,
                                                  size_t Size, size_t MaxSize) {
   if (Size > MaxSize) return 0;
   if (D.empty()) return 0;
   DictionaryEntry &DE = D[Rand(D.size())];
   Size = ApplyDictionaryEntry(Data, Size, MaxSize, DE);
   if (!Size) return 0;
   DE.IncUseCount();
   CurrentDictionaryEntrySequence.push_back(&DE);
-
   return Size;
 }
 
 // Overwrites part of To[0,ToSize) with a part of From[0,FromSize).
 // Returns ToSize.
 size_t MutationDispatcher::CopyPartOf(const uint8_t *From, size_t FromSize,
                                       uint8_t *To, size_t ToSize) {
   // Copy From[FromBeg, FromBeg + CopySize) into To[ToBeg, ToBeg + CopySize).
switch(Rand(3)) {
     case 2:
       NewSize = CopyPartOf(O.data(), O.size(), U.data(), U.size());
       break;
     default: assert(0);
   }
   assert(NewSize > 0 && "CrossOver returned empty unit");
   assert(NewSize <= MaxSize && "CrossOver returned overisized unit");
   memcpy(Data, U.data(), NewSize);
-  MStats->IncrementCount(Crossover, 0);
+  MStats->IncrementCount(CrossOver, 0);
   return NewSize;
 }
 
 void MutationDispatcher::StartMutationSequence() {
   CurrentMutatorSequence.clear();
   CurrentDictionaryEntrySequence.clear();
 }
 

lib/fuzzer/FuzzerMutationStats.h

 //===- FuzzerMutationStats.h - Header for mutation tracking ----------*- C++ -* ===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 // fuzzer::MutationStats
 //===----------------------------------------------------------------------===//
 
 
 namespace fuzzer {
 
-enum MutatorType {
+enum MutationType {
   ManualDict,
   PersAutoDict,
   CMP,
   ChangeAsciiInt,
   ChangeBinInt,
   ChangeBit,
   ChangeByte,
   CopyPart,
-  Crossover,
-  CustomCrossover,
+  CrossOver,
+  CustomCrossOver,
   CustomMutation,
   EraseBytes,
   InsertByte,
   InsertRepeatedBytes,
   ShuffleBytes,
   MaxNumberOfMutationTypes
 };
 
 class MutationStats {
 public:
   ~MutationStats() {}
   void PrintMutationCounts();
-  void IncrementCount(int mType, int type);
+  void IncTotalMutationCount(MutationType MType);
+  void IncUsefulMutationCount(MutationType MType);
 
 private:
   // A total count of each mutation used in the fuzzing process.
-  std::array<size_t, MaxNumberOfMutationTypes> total;
+  std::array<size_t, MaxNumberOfMutationTypes> TotalMutations;
   // The number of each mutation that resulted in new coverage.
-  std::array<size_t, MaxNumberOfMutationTypes> useful;
+  std::array<size_t, MaxNumberOfMutationTypes> UsefulMutations;
 };
 
 extern MutationStats *MStats;
 
 }

lib/fuzzer/FuzzerMutationStats.cpp

 MutationStats* MStats = new MutationStats();
 
 void MutationStats::PrintMutationCounts() {
   // Outputs the number of each mutation used
 
   Printf("\nTotal Mutations ----------\n");
   for (int i = 0; i < MaxNumberOfMutationTypes; i++) {
     auto current = kMutationNames.find(i);
-    Printf("%s: %d\n", current->second.c_str(), total.at(i));
+    Printf("%s: %d\n", current->second.c_str(), TotalMutations.at(i));
   }
 
   Printf("\nUseful Mutations ----------\n");
   for (int i = 0; i < MaxNumberOfMutationTypes; i++) {
     auto current = kMutationNames.find(i);
-    Printf("%s: %d\n", current->second.c_str(), useful.at(i));
+    Printf("%s: %d\n", current->second.c_str(), UsefulMutations.at(i));
   }
 
 }
 
 // Updates the count of mutations (total/useful) depending on type.
 // Types: (0) Total, (1) Useful
-void MutationStats::IncrementCount(int mType, int type) {
-  switch (type) {
-    case 0:
-      total[mType]++;
-      break;
-    case 1:
-      useful[mType]++;
-      break;
-    default:
-      break;
-  }
+void MutationStats::IncTotalMutationCount(MutationType MType) {
+  if ((MType < 0) || MType >= MaxNumberOfMutationTypes)
+    return;
+  else
+    TotalMutations[MType]++;
+
+void MutationStats::IncTotalMutationCount(MutationType MType) {
+  if ((MType < 0) || MType >= MaxNumberOfMutationTypes)
+    return;
+  else
+    UsefulMutations[MType]++;
 }
 
 }  // namespace fuzzer