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 126