compiler-rt/lib/fuzzer/FuzzerDictionary.h

   1 //===- FuzzerDictionary.h - Internal header for the Fuzzer ------*- C++ -* ===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 // fuzzer::Dictionary
   9 //===----------------------------------------------------------------------===//
  10
  11 #ifndef LLVM_FUZZER_DICTIONARY_H
  12 #define LLVM_FUZZER_DICTIONARY_H
  13
  14 #include "FuzzerDefs.h"
  15 #include "FuzzerIO.h"
  16 #include "FuzzerUtil.h"
  17 #include <algorithm>
  18 #include <limits>
  19
  20 namespace fuzzer {
  21 // A simple POD sized array of bytes.
  22 template <size_t kMaxSizeT> class FixedWord {
  23 public:
  24   static const size_t kMaxSize = kMaxSizeT;
  25   FixedWord() {}
  26   FixedWord(const uint8_t *B, size_t S) { Set(B, S); }
  27
  28   void Set(const uint8_t *B, size_t S) {
  29     static_assert(kMaxSizeT <= std::numeric_limits<uint8_t>::max(),
  30                   "FixedWord::kMaxSizeT cannot fit in a uint8_t.");
  31     assert(S <= kMaxSize);
  32     // memcpy cannot take null pointer arguments even if Size is 0.
  33     if (S)
  34       memcpy(Data, B, S);
  35     Size = static_cast<uint8_t>(S);
  36   }
  37
  38   bool operator==(const FixedWord<kMaxSize> &w) const {
  39     return Size == w.Size && 0 == memcmp(Data, w.Data, Size);
  40   }
  41
  42   static size_t GetMaxSize() { return kMaxSize; }
  43   const uint8_t *data() const { return Data; }
  44   uint8_t size() const { return Size; }
  45
  46 private:
  47   uint8_t Size = 0;
  48   uint8_t Data[kMaxSize];
  49 };
  50
  51 typedef FixedWord<64> Word;
  52
  53 class DictionaryEntry {
  54  public:
  55   DictionaryEntry() {}
  56   DictionaryEntry(Word W) : W(W) {}
  57   DictionaryEntry(Word W, size_t PositionHint)
  58       : W(W), PositionHint(PositionHint) {}
  59   const Word &GetW() const { return W; }
  60
  61   bool HasPositionHint() const {
  62     return PositionHint != std::numeric_limits<size_t>::max();
  63   }
  64   size_t GetPositionHint() const {
  65     assert(HasPositionHint());
  66     return PositionHint;
  67   }
  68   void IncUseCount() { UseCount++; }
  69   void IncSuccessCount() { SuccessCount++; }
  70   size_t GetUseCount() const { return UseCount; }
  71   size_t GetSuccessCount() const {return SuccessCount; }
  72
  73   void Print(const char *PrintAfter = "\n") {
  74     PrintASCII(W.data(), W.size());
  75     if (HasPositionHint())
  76       Printf("@%zd", GetPositionHint());
  77     Printf("%s", PrintAfter);
  78   }
  79
  80 private:
  81   Word W;
  82   size_t PositionHint = std::numeric_limits<size_t>::max();
  83   size_t UseCount = 0;
  84   size_t SuccessCount = 0;
  85 };
  86
  87 class Dictionary {
  88  public:
  89   static const size_t kMaxDictSize = 1 << 14;
  90
  91   bool ContainsWord(const Word &W) const {
  92     return std::any_of(begin(), end(), [&](const DictionaryEntry &DE) {
  93       return DE.GetW() == W;
  94     });
  95   }
  96   const DictionaryEntry *begin() const { return &DE[0]; }
  97   const DictionaryEntry *end() const { return begin() + Size; }
  98   DictionaryEntry & operator[] (size_t Idx) {
  99     assert(Idx < Size);
 100     return DE[Idx];
 101   }
 102   void push_back(DictionaryEntry DE) {
 103     if (Size < kMaxDictSize)
 104       this->DE[Size++] = DE;
 105   }
 106   void clear() { Size = 0; }
 107   bool empty() const { return Size == 0; }
 108   size_t size() const { return Size; }
 109
 110 private:
 111   DictionaryEntry DE[kMaxDictSize];
 112   size_t Size = 0;
 113 };
 114
 115 // Parses one dictionary entry.
 116 // If successful, writes the entry to Unit and returns true,
 117 // otherwise returns false.
 118 bool ParseOneDictionaryEntry(const std::string &Str, Unit *U);
 119 // Parses the dictionary file, fills Units, returns true iff all lines
 120 // were parsed successfully.
 121 bool ParseDictionaryFile(const std::string &Text, std::vector<Unit> *Units);
 122
 123 }  // namespace fuzzer
 124
 125 #endif  // LLVM_FUZZER_DICTIONARY_H