[llvm] r315937 - [libFuzzer] Delete llvm/lib/Fuzzer
Vitaly Buka via llvm-commits
llvm-commits at lists.llvm.org
Mon Oct 16 13:48:20 PDT 2017
Author: vitalybuka
Date: Mon Oct 16 13:48:19 2017
New Revision: 315937
URL: http://llvm.org/viewvc/llvm-project?rev=315937&view=rev
Log:
[libFuzzer] Delete llvm/lib/Fuzzer
Summary: Code is already in compiler-rt
Reviewers: kcc
Subscribers: krytarowski, llvm-commits, hiraditya
Differential Revision: https://reviews.llvm.org/D38912
Removed:
llvm/trunk/lib/Fuzzer/FuzzerClangCounters.cpp
llvm/trunk/lib/Fuzzer/FuzzerCorpus.h
llvm/trunk/lib/Fuzzer/FuzzerCrossOver.cpp
llvm/trunk/lib/Fuzzer/FuzzerDefs.h
llvm/trunk/lib/Fuzzer/FuzzerDictionary.h
llvm/trunk/lib/Fuzzer/FuzzerDriver.cpp
llvm/trunk/lib/Fuzzer/FuzzerExtFunctions.def
llvm/trunk/lib/Fuzzer/FuzzerExtFunctions.h
llvm/trunk/lib/Fuzzer/FuzzerExtFunctionsDlsym.cpp
llvm/trunk/lib/Fuzzer/FuzzerExtFunctionsDlsymWin.cpp
llvm/trunk/lib/Fuzzer/FuzzerExtFunctionsWeak.cpp
llvm/trunk/lib/Fuzzer/FuzzerExtFunctionsWeakAlias.cpp
llvm/trunk/lib/Fuzzer/FuzzerExtraCounters.cpp
llvm/trunk/lib/Fuzzer/FuzzerFlags.def
llvm/trunk/lib/Fuzzer/FuzzerIO.cpp
llvm/trunk/lib/Fuzzer/FuzzerIO.h
llvm/trunk/lib/Fuzzer/FuzzerIOPosix.cpp
llvm/trunk/lib/Fuzzer/FuzzerIOWindows.cpp
llvm/trunk/lib/Fuzzer/FuzzerInterface.h
llvm/trunk/lib/Fuzzer/FuzzerInternal.h
llvm/trunk/lib/Fuzzer/FuzzerLoop.cpp
llvm/trunk/lib/Fuzzer/FuzzerMain.cpp
llvm/trunk/lib/Fuzzer/FuzzerMerge.cpp
llvm/trunk/lib/Fuzzer/FuzzerMerge.h
llvm/trunk/lib/Fuzzer/FuzzerMutate.cpp
llvm/trunk/lib/Fuzzer/FuzzerMutate.h
llvm/trunk/lib/Fuzzer/FuzzerOptions.h
llvm/trunk/lib/Fuzzer/FuzzerRandom.h
llvm/trunk/lib/Fuzzer/FuzzerSHA1.cpp
llvm/trunk/lib/Fuzzer/FuzzerSHA1.h
llvm/trunk/lib/Fuzzer/FuzzerShmem.h
llvm/trunk/lib/Fuzzer/FuzzerShmemPosix.cpp
llvm/trunk/lib/Fuzzer/FuzzerShmemWindows.cpp
llvm/trunk/lib/Fuzzer/FuzzerTracePC.cpp
llvm/trunk/lib/Fuzzer/FuzzerTracePC.h
llvm/trunk/lib/Fuzzer/FuzzerUtil.cpp
llvm/trunk/lib/Fuzzer/FuzzerUtil.h
llvm/trunk/lib/Fuzzer/FuzzerUtilDarwin.cpp
llvm/trunk/lib/Fuzzer/FuzzerUtilLinux.cpp
llvm/trunk/lib/Fuzzer/FuzzerUtilPosix.cpp
llvm/trunk/lib/Fuzzer/FuzzerUtilWindows.cpp
llvm/trunk/lib/Fuzzer/FuzzerValueBitMap.h
llvm/trunk/lib/Fuzzer/afl/
llvm/trunk/lib/Fuzzer/build.sh
llvm/trunk/lib/Fuzzer/cxx.dict
llvm/trunk/lib/Fuzzer/standalone/
Modified:
llvm/trunk/lib/Fuzzer/README.txt
Removed: llvm/trunk/lib/Fuzzer/FuzzerClangCounters.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Fuzzer/FuzzerClangCounters.cpp?rev=315936&view=auto
==============================================================================
--- llvm/trunk/lib/Fuzzer/FuzzerClangCounters.cpp (original)
+++ llvm/trunk/lib/Fuzzer/FuzzerClangCounters.cpp (removed)
@@ -1,49 +0,0 @@
-//===- FuzzerExtraCounters.cpp - Extra coverage counters ------------------===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-// Coverage counters from Clang's SourceBasedCodeCoverage.
-//===----------------------------------------------------------------------===//
-
-// Support for SourceBasedCodeCoverage is experimental:
-// * Works only for the main binary, not DSOs yet.
-// * Works only on Linux.
-// * Does not implement print_pcs/print_coverage yet.
-// * Is not fully evaluated for performance and sensitivity.
-// We expect large performance drop due to 64-bit counters,
-// and *maybe* better sensitivity due to more fine-grained counters.
-// Preliminary comparison on a single benchmark (RE2) shows
-// a bit worse sensitivity though.
-
-#include "FuzzerDefs.h"
-
-#if LIBFUZZER_LINUX
-__attribute__((weak)) extern uint64_t __start___llvm_prf_cnts;
-__attribute__((weak)) extern uint64_t __stop___llvm_prf_cnts;
-namespace fuzzer {
-uint64_t *ClangCountersBegin() { return &__start___llvm_prf_cnts; }
-uint64_t *ClangCountersEnd() { return &__stop___llvm_prf_cnts; }
-} // namespace fuzzer
-#else
-// TODO: Implement on Mac (if the data shows it's worth it).
-//__attribute__((visibility("hidden")))
-//extern uint64_t CountersStart __asm("section$start$__DATA$__llvm_prf_cnts");
-//__attribute__((visibility("hidden")))
-//extern uint64_t CountersEnd __asm("section$end$__DATA$__llvm_prf_cnts");
-namespace fuzzer {
-uint64_t *ClangCountersBegin() { return nullptr; }
-uint64_t *ClangCountersEnd() { return nullptr; }
-} // namespace fuzzer
-#endif
-
-namespace fuzzer {
-ATTRIBUTE_NO_SANITIZE_ALL
-void ClearClangCounters() { // hand-written memset, don't asan-ify.
- for (auto P = ClangCountersBegin(); P < ClangCountersEnd(); P++)
- *P = 0;
-}
-}
Removed: llvm/trunk/lib/Fuzzer/FuzzerCorpus.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Fuzzer/FuzzerCorpus.h?rev=315936&view=auto
==============================================================================
--- llvm/trunk/lib/Fuzzer/FuzzerCorpus.h (original)
+++ llvm/trunk/lib/Fuzzer/FuzzerCorpus.h (removed)
@@ -1,275 +0,0 @@
-//===- FuzzerCorpus.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.
-//
-//===----------------------------------------------------------------------===//
-// fuzzer::InputCorpus
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_FUZZER_CORPUS
-#define LLVM_FUZZER_CORPUS
-
-#include "FuzzerDefs.h"
-#include "FuzzerIO.h"
-#include "FuzzerRandom.h"
-#include "FuzzerSHA1.h"
-#include "FuzzerTracePC.h"
-#include <algorithm>
-#include <numeric>
-#include <random>
-#include <unordered_set>
-
-namespace fuzzer {
-
-struct InputInfo {
- Unit U; // The actual input data.
- uint8_t Sha1[kSHA1NumBytes]; // Checksum.
- // Number of features that this input has and no smaller input has.
- size_t NumFeatures = 0;
- size_t Tmp = 0; // Used by ValidateFeatureSet.
- // Stats.
- size_t NumExecutedMutations = 0;
- size_t NumSuccessfullMutations = 0;
- bool MayDeleteFile = false;
- bool Reduced = false;
- std::vector<uint32_t> UniqFeatureSet;
-};
-
-class InputCorpus {
- static const size_t kFeatureSetSize = 1 << 21;
- public:
- InputCorpus(const std::string &OutputCorpus) : OutputCorpus(OutputCorpus) {
- memset(InputSizesPerFeature, 0, sizeof(InputSizesPerFeature));
- memset(SmallestElementPerFeature, 0, sizeof(SmallestElementPerFeature));
- }
- ~InputCorpus() {
- for (auto II : Inputs)
- delete II;
- }
- size_t size() const { return Inputs.size(); }
- size_t SizeInBytes() const {
- size_t Res = 0;
- for (auto II : Inputs)
- Res += II->U.size();
- return Res;
- }
- size_t NumActiveUnits() const {
- size_t Res = 0;
- for (auto II : Inputs)
- Res += !II->U.empty();
- return Res;
- }
- size_t MaxInputSize() const {
- size_t Res = 0;
- for (auto II : Inputs)
- Res = std::max(Res, II->U.size());
- return Res;
- }
- bool empty() const { return Inputs.empty(); }
- const Unit &operator[] (size_t Idx) const { return Inputs[Idx]->U; }
- void AddToCorpus(const Unit &U, size_t NumFeatures, bool MayDeleteFile,
- const std::vector<uint32_t> &FeatureSet) {
- assert(!U.empty());
- if (FeatureDebug)
- Printf("ADD_TO_CORPUS %zd NF %zd\n", Inputs.size(), NumFeatures);
- Inputs.push_back(new InputInfo());
- InputInfo &II = *Inputs.back();
- II.U = U;
- II.NumFeatures = NumFeatures;
- II.MayDeleteFile = MayDeleteFile;
- II.UniqFeatureSet = FeatureSet;
- std::sort(II.UniqFeatureSet.begin(), II.UniqFeatureSet.end());
- ComputeSHA1(U.data(), U.size(), II.Sha1);
- Hashes.insert(Sha1ToString(II.Sha1));
- UpdateCorpusDistribution();
- PrintCorpus();
- // ValidateFeatureSet();
- }
-
- // Debug-only
- void PrintUnit(const Unit &U) {
- if (!FeatureDebug) return;
- for (uint8_t C : U) {
- if (C != 'F' && C != 'U' && C != 'Z')
- C = '.';
- Printf("%c", C);
- }
- }
-
- // Debug-only
- void PrintFeatureSet(const std::vector<uint32_t> &FeatureSet) {
- if (!FeatureDebug) return;
- Printf("{");
- for (uint32_t Feature: FeatureSet)
- Printf("%u,", Feature);
- Printf("}");
- }
-
- // Debug-only
- void PrintCorpus() {
- if (!FeatureDebug) return;
- Printf("======= CORPUS:\n");
- int i = 0;
- for (auto II : Inputs) {
- if (std::find(II->U.begin(), II->U.end(), 'F') != II->U.end()) {
- Printf("[%2d] ", i);
- Printf("%s sz=%zd ", Sha1ToString(II->Sha1).c_str(), II->U.size());
- PrintUnit(II->U);
- Printf(" ");
- PrintFeatureSet(II->UniqFeatureSet);
- Printf("\n");
- }
- i++;
- }
- }
-
- void Replace(InputInfo *II, const Unit &U) {
- assert(II->U.size() > U.size());
- Hashes.erase(Sha1ToString(II->Sha1));
- DeleteFile(*II);
- ComputeSHA1(U.data(), U.size(), II->Sha1);
- Hashes.insert(Sha1ToString(II->Sha1));
- II->U = U;
- II->Reduced = true;
- }
-
- bool HasUnit(const Unit &U) { return Hashes.count(Hash(U)); }
- bool HasUnit(const std::string &H) { return Hashes.count(H); }
- InputInfo &ChooseUnitToMutate(Random &Rand) {
- InputInfo &II = *Inputs[ChooseUnitIdxToMutate(Rand)];
- assert(!II.U.empty());
- return II;
- };
-
- // Returns an index of random unit from the corpus to mutate.
- // Hypothesis: units added to the corpus last are more likely to be
- // interesting. This function gives more weight to the more recent units.
- size_t ChooseUnitIdxToMutate(Random &Rand) {
- size_t Idx = static_cast<size_t>(CorpusDistribution(Rand));
- assert(Idx < Inputs.size());
- return Idx;
- }
-
- void PrintStats() {
- for (size_t i = 0; i < Inputs.size(); i++) {
- const auto &II = *Inputs[i];
- Printf(" [%zd %s]\tsz: %zd\truns: %zd\tsucc: %zd\n", i,
- Sha1ToString(II.Sha1).c_str(), II.U.size(),
- II.NumExecutedMutations, II.NumSuccessfullMutations);
- }
- }
-
- void PrintFeatureSet() {
- for (size_t i = 0; i < kFeatureSetSize; i++) {
- if(size_t Sz = GetFeature(i))
- Printf("[%zd: id %zd sz%zd] ", i, SmallestElementPerFeature[i], Sz);
- }
- Printf("\n\t");
- for (size_t i = 0; i < Inputs.size(); i++)
- if (size_t N = Inputs[i]->NumFeatures)
- Printf(" %zd=>%zd ", i, N);
- Printf("\n");
- }
-
- void DeleteFile(const InputInfo &II) {
- if (!OutputCorpus.empty() && II.MayDeleteFile)
- RemoveFile(DirPlusFile(OutputCorpus, Sha1ToString(II.Sha1)));
- }
-
- void DeleteInput(size_t Idx) {
- InputInfo &II = *Inputs[Idx];
- DeleteFile(II);
- Unit().swap(II.U);
- if (FeatureDebug)
- Printf("EVICTED %zd\n", Idx);
- }
-
- bool AddFeature(size_t Idx, uint32_t NewSize, bool Shrink) {
- assert(NewSize);
- Idx = Idx % kFeatureSetSize;
- uint32_t OldSize = GetFeature(Idx);
- if (OldSize == 0 || (Shrink && OldSize > NewSize)) {
- if (OldSize > 0) {
- size_t OldIdx = SmallestElementPerFeature[Idx];
- InputInfo &II = *Inputs[OldIdx];
- assert(II.NumFeatures > 0);
- II.NumFeatures--;
- if (II.NumFeatures == 0)
- DeleteInput(OldIdx);
- } else {
- NumAddedFeatures++;
- }
- NumUpdatedFeatures++;
- if (FeatureDebug)
- Printf("ADD FEATURE %zd sz %d\n", Idx, NewSize);
- SmallestElementPerFeature[Idx] = Inputs.size();
- InputSizesPerFeature[Idx] = NewSize;
- return true;
- }
- return false;
- }
-
- size_t NumFeatures() const { return NumAddedFeatures; }
- size_t NumFeatureUpdates() const { return NumUpdatedFeatures; }
-
- void ResetFeatureSet() {
- assert(Inputs.empty());
- memset(InputSizesPerFeature, 0, sizeof(InputSizesPerFeature));
- memset(SmallestElementPerFeature, 0, sizeof(SmallestElementPerFeature));
- }
-
-private:
-
- static const bool FeatureDebug = false;
-
- size_t GetFeature(size_t Idx) const { return InputSizesPerFeature[Idx]; }
-
- void ValidateFeatureSet() {
- if (FeatureDebug)
- PrintFeatureSet();
- for (size_t Idx = 0; Idx < kFeatureSetSize; Idx++)
- if (GetFeature(Idx))
- Inputs[SmallestElementPerFeature[Idx]]->Tmp++;
- for (auto II: Inputs) {
- if (II->Tmp != II->NumFeatures)
- Printf("ZZZ %zd %zd\n", II->Tmp, II->NumFeatures);
- assert(II->Tmp == II->NumFeatures);
- II->Tmp = 0;
- }
- }
-
- // Updates the probability distribution for the units in the corpus.
- // Must be called whenever the corpus or unit weights are changed.
- void UpdateCorpusDistribution() {
- size_t N = Inputs.size();
- assert(N);
- Intervals.resize(N + 1);
- Weights.resize(N);
- std::iota(Intervals.begin(), Intervals.end(), 0);
- for (size_t i = 0; i < N; i++)
- Weights[i] = Inputs[i]->NumFeatures * (i + 1);
- CorpusDistribution = std::piecewise_constant_distribution<double>(
- Intervals.begin(), Intervals.end(), Weights.begin());
- }
- std::piecewise_constant_distribution<double> CorpusDistribution;
-
- std::vector<double> Intervals;
- std::vector<double> Weights;
-
- std::unordered_set<std::string> Hashes;
- std::vector<InputInfo*> Inputs;
-
- size_t NumAddedFeatures = 0;
- size_t NumUpdatedFeatures = 0;
- uint32_t InputSizesPerFeature[kFeatureSetSize];
- uint32_t SmallestElementPerFeature[kFeatureSetSize];
-
- std::string OutputCorpus;
-};
-
-} // namespace fuzzer
-
-#endif // LLVM_FUZZER_CORPUS
Removed: llvm/trunk/lib/Fuzzer/FuzzerCrossOver.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Fuzzer/FuzzerCrossOver.cpp?rev=315936&view=auto
==============================================================================
--- llvm/trunk/lib/Fuzzer/FuzzerCrossOver.cpp (original)
+++ llvm/trunk/lib/Fuzzer/FuzzerCrossOver.cpp (removed)
@@ -1,52 +0,0 @@
-//===- FuzzerCrossOver.cpp - Cross over two test inputs -------------------===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-// Cross over test inputs.
-//===----------------------------------------------------------------------===//
-
-#include "FuzzerDefs.h"
-#include "FuzzerMutate.h"
-#include "FuzzerRandom.h"
-#include <cstring>
-
-namespace fuzzer {
-
-// Cross Data1 and Data2, store the result (up to MaxOutSize bytes) in Out.
-size_t MutationDispatcher::CrossOver(const uint8_t *Data1, size_t Size1,
- const uint8_t *Data2, size_t Size2,
- uint8_t *Out, size_t MaxOutSize) {
- assert(Size1 || Size2);
- MaxOutSize = Rand(MaxOutSize) + 1;
- size_t OutPos = 0;
- size_t Pos1 = 0;
- size_t Pos2 = 0;
- size_t *InPos = &Pos1;
- size_t InSize = Size1;
- const uint8_t *Data = Data1;
- bool CurrentlyUsingFirstData = true;
- while (OutPos < MaxOutSize && (Pos1 < Size1 || Pos2 < Size2)) {
- // Merge a part of Data into Out.
- size_t OutSizeLeft = MaxOutSize - OutPos;
- if (*InPos < InSize) {
- size_t InSizeLeft = InSize - *InPos;
- size_t MaxExtraSize = std::min(OutSizeLeft, InSizeLeft);
- size_t ExtraSize = Rand(MaxExtraSize) + 1;
- memcpy(Out + OutPos, Data + *InPos, ExtraSize);
- OutPos += ExtraSize;
- (*InPos) += ExtraSize;
- }
- // Use the other input data on the next iteration.
- InPos = CurrentlyUsingFirstData ? &Pos2 : &Pos1;
- InSize = CurrentlyUsingFirstData ? Size2 : Size1;
- Data = CurrentlyUsingFirstData ? Data2 : Data1;
- CurrentlyUsingFirstData = !CurrentlyUsingFirstData;
- }
- return OutPos;
-}
-
-} // namespace fuzzer
Removed: llvm/trunk/lib/Fuzzer/FuzzerDefs.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Fuzzer/FuzzerDefs.h?rev=315936&view=auto
==============================================================================
--- llvm/trunk/lib/Fuzzer/FuzzerDefs.h (original)
+++ llvm/trunk/lib/Fuzzer/FuzzerDefs.h (removed)
@@ -1,132 +0,0 @@
-//===- 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 <cassert>
-#include <cstddef>
-#include <cstdint>
-#include <cstring>
-#include <string>
-#include <vector>
-
-// Platform detection.
-#ifdef __linux__
-#define LIBFUZZER_APPLE 0
-#define LIBFUZZER_LINUX 1
-#define LIBFUZZER_WINDOWS 0
-#elif __APPLE__
-#define LIBFUZZER_APPLE 1
-#define LIBFUZZER_LINUX 0
-#define LIBFUZZER_WINDOWS 0
-#elif _WIN32
-#define LIBFUZZER_APPLE 0
-#define LIBFUZZER_LINUX 0
-#define LIBFUZZER_WINDOWS 1
-#else
-#error "Support for your platform has not been implemented"
-#endif
-
-#ifndef __has_attribute
-# define __has_attribute(x) 0
-#endif
-
-#define LIBFUZZER_POSIX LIBFUZZER_APPLE || LIBFUZZER_LINUX
-
-#ifdef __x86_64
-# if __has_attribute(target)
-# define ATTRIBUTE_TARGET_POPCNT __attribute__((target("popcnt")))
-# else
-# define ATTRIBUTE_TARGET_POPCNT
-# endif
-#else
-# define ATTRIBUTE_TARGET_POPCNT
-#endif
-
-
-#ifdef __clang__ // avoid gcc warning.
-# if __has_attribute(no_sanitize)
-# define ATTRIBUTE_NO_SANITIZE_MEMORY __attribute__((no_sanitize("memory")))
-# else
-# define ATTRIBUTE_NO_SANITIZE_MEMORY
-# endif
-# define ALWAYS_INLINE __attribute__((always_inline))
-#else
-# define ATTRIBUTE_NO_SANITIZE_MEMORY
-# define ALWAYS_INLINE
-#endif // __clang__
-
-#define ATTRIBUTE_NO_SANITIZE_ADDRESS __attribute__((no_sanitize_address))
-
-#if defined(__has_feature)
-# if __has_feature(address_sanitizer)
-# define ATTRIBUTE_NO_SANITIZE_ALL ATTRIBUTE_NO_SANITIZE_ADDRESS
-# elif __has_feature(memory_sanitizer)
-# define ATTRIBUTE_NO_SANITIZE_ALL ATTRIBUTE_NO_SANITIZE_MEMORY
-# else
-# define ATTRIBUTE_NO_SANITIZE_ALL
-# endif
-#else
-# define ATTRIBUTE_NO_SANITIZE_ALL
-#endif
-
-#if LIBFUZZER_WINDOWS
-#define ATTRIBUTE_INTERFACE __declspec(dllexport)
-#else
-#define ATTRIBUTE_INTERFACE __attribute__((visibility("default")))
-#endif
-
-namespace fuzzer {
-
-template <class T> T Min(T a, T b) { return a < b ? a : b; }
-template <class T> T Max(T a, T b) { return a > b ? a : b; }
-
-class Random;
-class Dictionary;
-class DictionaryEntry;
-class MutationDispatcher;
-struct FuzzingOptions;
-class InputCorpus;
-struct InputInfo;
-struct ExternalFunctions;
-
-// Global interface to functions that may or may not be available.
-extern ExternalFunctions *EF;
-
-typedef std::vector<uint8_t> Unit;
-typedef std::vector<Unit> UnitVector;
-typedef int (*UserCallback)(const uint8_t *Data, size_t Size);
-
-int FuzzerDriver(int *argc, char ***argv, UserCallback Callback);
-
-struct ScopedDoingMyOwnMemOrStr {
- ScopedDoingMyOwnMemOrStr() { DoingMyOwnMemOrStr++; }
- ~ScopedDoingMyOwnMemOrStr() { DoingMyOwnMemOrStr--; }
- static int DoingMyOwnMemOrStr;
-};
-
-inline uint8_t Bswap(uint8_t x) { return x; }
-inline uint16_t Bswap(uint16_t x) { return __builtin_bswap16(x); }
-inline uint32_t Bswap(uint32_t x) { return __builtin_bswap32(x); }
-inline uint64_t Bswap(uint64_t x) { return __builtin_bswap64(x); }
-
-uint8_t *ExtraCountersBegin();
-uint8_t *ExtraCountersEnd();
-void ClearExtraCounters();
-
-uint64_t *ClangCountersBegin();
-uint64_t *ClangCountersEnd();
-void ClearClangCounters();
-
-} // namespace fuzzer
-
-#endif // LLVM_FUZZER_DEFS_H
Removed: llvm/trunk/lib/Fuzzer/FuzzerDictionary.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Fuzzer/FuzzerDictionary.h?rev=315936&view=auto
==============================================================================
--- llvm/trunk/lib/Fuzzer/FuzzerDictionary.h (original)
+++ llvm/trunk/lib/Fuzzer/FuzzerDictionary.h (removed)
@@ -1,127 +0,0 @@
-//===- FuzzerDictionary.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.
-//
-//===----------------------------------------------------------------------===//
-// fuzzer::Dictionary
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_FUZZER_DICTIONARY_H
-#define LLVM_FUZZER_DICTIONARY_H
-
-#include "FuzzerDefs.h"
-#include "FuzzerIO.h"
-#include "FuzzerUtil.h"
-#include <algorithm>
-#include <limits>
-
-namespace fuzzer {
-// A simple POD sized array of bytes.
-template <size_t kMaxSizeT> class FixedWord {
-public:
- static const size_t kMaxSize = kMaxSizeT;
- FixedWord() {}
- FixedWord(const uint8_t *B, uint8_t S) { Set(B, S); }
-
- void Set(const uint8_t *B, uint8_t S) {
- assert(S <= kMaxSize);
- memcpy(Data, B, S);
- Size = S;
- }
-
- bool operator==(const FixedWord<kMaxSize> &w) const {
- ScopedDoingMyOwnMemOrStr scoped_doing_my_own_mem_os_str;
- return Size == w.Size && 0 == memcmp(Data, w.Data, Size);
- }
-
- bool operator<(const FixedWord<kMaxSize> &w) const {
- ScopedDoingMyOwnMemOrStr scoped_doing_my_own_mem_os_str;
- if (Size != w.Size)
- return Size < w.Size;
- return memcmp(Data, w.Data, Size) < 0;
- }
-
- static size_t GetMaxSize() { return kMaxSize; }
- const uint8_t *data() const { return Data; }
- uint8_t size() const { return Size; }
-
-private:
- uint8_t Size = 0;
- uint8_t Data[kMaxSize];
-};
-
-typedef FixedWord<64> Word;
-
-class DictionaryEntry {
- public:
- DictionaryEntry() {}
- DictionaryEntry(Word W) : W(W) {}
- DictionaryEntry(Word W, size_t PositionHint) : W(W), PositionHint(PositionHint) {}
- const Word &GetW() const { return W; }
-
- bool HasPositionHint() const { return PositionHint != std::numeric_limits<size_t>::max(); }
- size_t GetPositionHint() const {
- assert(HasPositionHint());
- return PositionHint;
- }
- void IncUseCount() { UseCount++; }
- void IncSuccessCount() { SuccessCount++; }
- size_t GetUseCount() const { return UseCount; }
- size_t GetSuccessCount() const {return SuccessCount; }
-
- void Print(const char *PrintAfter = "\n") {
- PrintASCII(W.data(), W.size());
- if (HasPositionHint())
- Printf("@%zd", GetPositionHint());
- Printf("%s", PrintAfter);
- }
-
-private:
- Word W;
- size_t PositionHint = std::numeric_limits<size_t>::max();
- size_t UseCount = 0;
- size_t SuccessCount = 0;
-};
-
-class Dictionary {
- public:
- static const size_t kMaxDictSize = 1 << 14;
-
- bool ContainsWord(const Word &W) const {
- return std::any_of(begin(), end(), [&](const DictionaryEntry &DE) {
- return DE.GetW() == W;
- });
- }
- const DictionaryEntry *begin() const { return &DE[0]; }
- const DictionaryEntry *end() const { return begin() + Size; }
- DictionaryEntry & operator[] (size_t Idx) {
- assert(Idx < Size);
- return DE[Idx];
- }
- void push_back(DictionaryEntry DE) {
- if (Size < kMaxDictSize)
- this->DE[Size++] = DE;
- }
- void clear() { Size = 0; }
- bool empty() const { return Size == 0; }
- size_t size() const { return Size; }
-
-private:
- DictionaryEntry DE[kMaxDictSize];
- size_t Size = 0;
-};
-
-// Parses one dictionary entry.
-// If successfull, write the enty to Unit and returns true,
-// otherwise returns false.
-bool ParseOneDictionaryEntry(const std::string &Str, Unit *U);
-// Parses the dictionary file, fills Units, returns true iff all lines
-// were parsed succesfully.
-bool ParseDictionaryFile(const std::string &Text, std::vector<Unit> *Units);
-
-} // namespace fuzzer
-
-#endif // LLVM_FUZZER_DICTIONARY_H
Removed: llvm/trunk/lib/Fuzzer/FuzzerDriver.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Fuzzer/FuzzerDriver.cpp?rev=315936&view=auto
==============================================================================
--- llvm/trunk/lib/Fuzzer/FuzzerDriver.cpp (original)
+++ llvm/trunk/lib/Fuzzer/FuzzerDriver.cpp (removed)
@@ -1,764 +0,0 @@
-//===- FuzzerDriver.cpp - FuzzerDriver function and flags -----------------===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-// FuzzerDriver and flag parsing.
-//===----------------------------------------------------------------------===//
-
-#include "FuzzerCorpus.h"
-#include "FuzzerIO.h"
-#include "FuzzerInterface.h"
-#include "FuzzerInternal.h"
-#include "FuzzerMutate.h"
-#include "FuzzerRandom.h"
-#include "FuzzerShmem.h"
-#include "FuzzerTracePC.h"
-#include <algorithm>
-#include <atomic>
-#include <chrono>
-#include <cstdlib>
-#include <cstring>
-#include <mutex>
-#include <string>
-#include <thread>
-
-// This function should be present in the libFuzzer so that the client
-// binary can test for its existence.
-extern "C" __attribute__((used)) void __libfuzzer_is_present() {}
-
-namespace fuzzer {
-
-// Program arguments.
-struct FlagDescription {
- const char *Name;
- const char *Description;
- int Default;
- int *IntFlag;
- const char **StrFlag;
- unsigned int *UIntFlag;
-};
-
-struct {
-#define FUZZER_DEPRECATED_FLAG(Name)
-#define FUZZER_FLAG_INT(Name, Default, Description) int Name;
-#define FUZZER_FLAG_UNSIGNED(Name, Default, Description) unsigned int Name;
-#define FUZZER_FLAG_STRING(Name, Description) const char *Name;
-#include "FuzzerFlags.def"
-#undef FUZZER_DEPRECATED_FLAG
-#undef FUZZER_FLAG_INT
-#undef FUZZER_FLAG_UNSIGNED
-#undef FUZZER_FLAG_STRING
-} Flags;
-
-static const FlagDescription FlagDescriptions [] {
-#define FUZZER_DEPRECATED_FLAG(Name) \
- {#Name, "Deprecated; don't use", 0, nullptr, nullptr, nullptr},
-#define FUZZER_FLAG_INT(Name, Default, Description) \
- {#Name, Description, Default, &Flags.Name, nullptr, nullptr},
-#define FUZZER_FLAG_UNSIGNED(Name, Default, Description) \
- {#Name, Description, static_cast<int>(Default), \
- nullptr, nullptr, &Flags.Name},
-#define FUZZER_FLAG_STRING(Name, Description) \
- {#Name, Description, 0, nullptr, &Flags.Name, nullptr},
-#include "FuzzerFlags.def"
-#undef FUZZER_DEPRECATED_FLAG
-#undef FUZZER_FLAG_INT
-#undef FUZZER_FLAG_UNSIGNED
-#undef FUZZER_FLAG_STRING
-};
-
-static const size_t kNumFlags =
- sizeof(FlagDescriptions) / sizeof(FlagDescriptions[0]);
-
-static std::vector<std::string> *Inputs;
-static std::string *ProgName;
-
-static void PrintHelp() {
- Printf("Usage:\n");
- auto Prog = ProgName->c_str();
- Printf("\nTo run fuzzing pass 0 or more directories.\n");
- Printf("%s [-flag1=val1 [-flag2=val2 ...] ] [dir1 [dir2 ...] ]\n", Prog);
-
- Printf("\nTo run individual tests without fuzzing pass 1 or more files:\n");
- Printf("%s [-flag1=val1 [-flag2=val2 ...] ] file1 [file2 ...]\n", Prog);
-
- Printf("\nFlags: (strictly in form -flag=value)\n");
- size_t MaxFlagLen = 0;
- for (size_t F = 0; F < kNumFlags; F++)
- MaxFlagLen = std::max(strlen(FlagDescriptions[F].Name), MaxFlagLen);
-
- for (size_t F = 0; F < kNumFlags; F++) {
- const auto &D = FlagDescriptions[F];
- if (strstr(D.Description, "internal flag") == D.Description) continue;
- Printf(" %s", D.Name);
- for (size_t i = 0, n = MaxFlagLen - strlen(D.Name); i < n; i++)
- Printf(" ");
- Printf("\t");
- Printf("%d\t%s\n", D.Default, D.Description);
- }
- Printf("\nFlags starting with '--' will be ignored and "
- "will be passed verbatim to subprocesses.\n");
-}
-
-static const char *FlagValue(const char *Param, const char *Name) {
- size_t Len = strlen(Name);
- if (Param[0] == '-' && strstr(Param + 1, Name) == Param + 1 &&
- Param[Len + 1] == '=')
- return &Param[Len + 2];
- return nullptr;
-}
-
-// Avoid calling stol as it triggers a bug in clang/glibc build.
-static long MyStol(const char *Str) {
- long Res = 0;
- long Sign = 1;
- if (*Str == '-') {
- Str++;
- Sign = -1;
- }
- for (size_t i = 0; Str[i]; i++) {
- char Ch = Str[i];
- if (Ch < '0' || Ch > '9')
- return Res;
- Res = Res * 10 + (Ch - '0');
- }
- return Res * Sign;
-}
-
-static bool ParseOneFlag(const char *Param) {
- if (Param[0] != '-') return false;
- if (Param[1] == '-') {
- static bool PrintedWarning = false;
- if (!PrintedWarning) {
- PrintedWarning = true;
- Printf("INFO: libFuzzer ignores flags that start with '--'\n");
- }
- for (size_t F = 0; F < kNumFlags; F++)
- if (FlagValue(Param + 1, FlagDescriptions[F].Name))
- Printf("WARNING: did you mean '%s' (single dash)?\n", Param + 1);
- return true;
- }
- for (size_t F = 0; F < kNumFlags; F++) {
- const char *Name = FlagDescriptions[F].Name;
- const char *Str = FlagValue(Param, Name);
- if (Str) {
- if (FlagDescriptions[F].IntFlag) {
- int Val = MyStol(Str);
- *FlagDescriptions[F].IntFlag = Val;
- if (Flags.verbosity >= 2)
- Printf("Flag: %s %d\n", Name, Val);
- return true;
- } else if (FlagDescriptions[F].UIntFlag) {
- unsigned int Val = std::stoul(Str);
- *FlagDescriptions[F].UIntFlag = Val;
- if (Flags.verbosity >= 2)
- Printf("Flag: %s %u\n", Name, Val);
- return true;
- } else if (FlagDescriptions[F].StrFlag) {
- *FlagDescriptions[F].StrFlag = Str;
- if (Flags.verbosity >= 2)
- Printf("Flag: %s %s\n", Name, Str);
- return true;
- } else { // Deprecated flag.
- Printf("Flag: %s: deprecated, don't use\n", Name);
- return true;
- }
- }
- }
- Printf("\n\nWARNING: unrecognized flag '%s'; "
- "use -help=1 to list all flags\n\n", Param);
- return true;
-}
-
-// We don't use any library to minimize dependencies.
-static void ParseFlags(const std::vector<std::string> &Args) {
- for (size_t F = 0; F < kNumFlags; F++) {
- if (FlagDescriptions[F].IntFlag)
- *FlagDescriptions[F].IntFlag = FlagDescriptions[F].Default;
- if (FlagDescriptions[F].UIntFlag)
- *FlagDescriptions[F].UIntFlag =
- static_cast<unsigned int>(FlagDescriptions[F].Default);
- if (FlagDescriptions[F].StrFlag)
- *FlagDescriptions[F].StrFlag = nullptr;
- }
- Inputs = new std::vector<std::string>;
- for (size_t A = 1; A < Args.size(); A++) {
- if (ParseOneFlag(Args[A].c_str())) {
- if (Flags.ignore_remaining_args)
- break;
- continue;
- }
- Inputs->push_back(Args[A]);
- }
-}
-
-static std::mutex Mu;
-
-static void PulseThread() {
- while (true) {
- SleepSeconds(600);
- std::lock_guard<std::mutex> Lock(Mu);
- Printf("pulse...\n");
- }
-}
-
-static void WorkerThread(const std::string &Cmd, std::atomic<unsigned> *Counter,
- unsigned NumJobs, std::atomic<bool> *HasErrors) {
- while (true) {
- unsigned C = (*Counter)++;
- if (C >= NumJobs) break;
- std::string Log = "fuzz-" + std::to_string(C) + ".log";
- std::string ToRun = Cmd + " > " + Log + " 2>&1\n";
- if (Flags.verbosity)
- Printf("%s", ToRun.c_str());
- int ExitCode = ExecuteCommand(ToRun);
- if (ExitCode != 0)
- *HasErrors = true;
- std::lock_guard<std::mutex> Lock(Mu);
- Printf("================== Job %u exited with exit code %d ============\n",
- C, ExitCode);
- fuzzer::CopyFileToErr(Log);
- }
-}
-
-std::string CloneArgsWithoutX(const std::vector<std::string> &Args,
- const char *X1, const char *X2) {
- std::string Cmd;
- for (auto &S : Args) {
- if (FlagValue(S.c_str(), X1) || FlagValue(S.c_str(), X2))
- continue;
- Cmd += S + " ";
- }
- return Cmd;
-}
-
-static int RunInMultipleProcesses(const std::vector<std::string> &Args,
- unsigned NumWorkers, unsigned NumJobs) {
- std::atomic<unsigned> Counter(0);
- std::atomic<bool> HasErrors(false);
- std::string Cmd = CloneArgsWithoutX(Args, "jobs", "workers");
- std::vector<std::thread> V;
- std::thread Pulse(PulseThread);
- Pulse.detach();
- for (unsigned i = 0; i < NumWorkers; i++)
- V.push_back(std::thread(WorkerThread, Cmd, &Counter, NumJobs, &HasErrors));
- for (auto &T : V)
- T.join();
- return HasErrors ? 1 : 0;
-}
-
-static void RssThread(Fuzzer *F, size_t RssLimitMb) {
- while (true) {
- SleepSeconds(1);
- size_t Peak = GetPeakRSSMb();
- if (Peak > RssLimitMb)
- F->RssLimitCallback();
- }
-}
-
-static void StartRssThread(Fuzzer *F, size_t RssLimitMb) {
- if (!RssLimitMb) return;
- std::thread T(RssThread, F, RssLimitMb);
- T.detach();
-}
-
-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);
- return 0;
-}
-
-static bool AllInputsAreFiles() {
- if (Inputs->empty()) return false;
- for (auto &Path : *Inputs)
- if (!IsFile(Path))
- return false;
- return true;
-}
-
-static std::string GetDedupTokenFromFile(const std::string &Path) {
- auto S = FileToString(Path);
- auto Beg = S.find("DEDUP_TOKEN:");
- if (Beg == std::string::npos)
- return "";
- auto End = S.find('\n', Beg);
- if (End == std::string::npos)
- return "";
- return S.substr(Beg, End - Beg);
-}
-
-int CleanseCrashInput(const std::vector<std::string> &Args,
- const FuzzingOptions &Options) {
- if (Inputs->size() != 1 || !Flags.exact_artifact_path) {
- Printf("ERROR: -cleanse_crash should be given one input file and"
- " -exact_artifact_path\n");
- exit(1);
- }
- std::string InputFilePath = Inputs->at(0);
- std::string OutputFilePath = Flags.exact_artifact_path;
- std::string BaseCmd =
- CloneArgsWithoutX(Args, "cleanse_crash", "cleanse_crash");
-
- auto InputPos = BaseCmd.find(" " + InputFilePath + " ");
- assert(InputPos != std::string::npos);
- BaseCmd.erase(InputPos, InputFilePath.size() + 1);
-
- auto LogFilePath = DirPlusFile(
- TmpDir(), "libFuzzerTemp." + std::to_string(GetPid()) + ".txt");
- auto TmpFilePath = DirPlusFile(
- TmpDir(), "libFuzzerTemp." + std::to_string(GetPid()) + ".repro");
- auto LogFileRedirect = " > " + LogFilePath + " 2>&1 ";
-
- auto Cmd = BaseCmd + " " + TmpFilePath + LogFileRedirect;
-
- std::string CurrentFilePath = InputFilePath;
- auto U = FileToVector(CurrentFilePath);
- size_t Size = U.size();
-
- const std::vector<uint8_t> ReplacementBytes = {' ', 0xff};
- for (int NumAttempts = 0; NumAttempts < 5; NumAttempts++) {
- bool Changed = false;
- for (size_t Idx = 0; Idx < Size; Idx++) {
- Printf("CLEANSE[%d]: Trying to replace byte %zd of %zd\n", NumAttempts,
- Idx, Size);
- uint8_t OriginalByte = U[Idx];
- if (ReplacementBytes.end() != std::find(ReplacementBytes.begin(),
- ReplacementBytes.end(),
- OriginalByte))
- continue;
- for (auto NewByte : ReplacementBytes) {
- U[Idx] = NewByte;
- WriteToFile(U, TmpFilePath);
- auto ExitCode = ExecuteCommand(Cmd);
- RemoveFile(TmpFilePath);
- if (!ExitCode) {
- U[Idx] = OriginalByte;
- } else {
- Changed = true;
- Printf("CLEANSE: Replaced byte %zd with 0x%x\n", Idx, NewByte);
- WriteToFile(U, OutputFilePath);
- break;
- }
- }
- }
- if (!Changed) break;
- }
- RemoveFile(LogFilePath);
- return 0;
-}
-
-int MinimizeCrashInput(const std::vector<std::string> &Args,
- const FuzzingOptions &Options) {
- if (Inputs->size() != 1) {
- Printf("ERROR: -minimize_crash should be given one input file\n");
- exit(1);
- }
- std::string InputFilePath = Inputs->at(0);
- auto BaseCmd = SplitBefore(
- "-ignore_remaining_args=1",
- CloneArgsWithoutX(Args, "minimize_crash", "exact_artifact_path"));
- auto InputPos = BaseCmd.first.find(" " + InputFilePath + " ");
- assert(InputPos != std::string::npos);
- BaseCmd.first.erase(InputPos, InputFilePath.size() + 1);
- if (Flags.runs <= 0 && Flags.max_total_time == 0) {
- Printf("INFO: you need to specify -runs=N or "
- "-max_total_time=N with -minimize_crash=1\n"
- "INFO: defaulting to -max_total_time=600\n");
- BaseCmd.first += " -max_total_time=600";
- }
-
- auto LogFilePath = DirPlusFile(
- TmpDir(), "libFuzzerTemp." + std::to_string(GetPid()) + ".txt");
- auto LogFileRedirect = " > " + LogFilePath + " 2>&1 ";
-
- std::string CurrentFilePath = InputFilePath;
- while (true) {
- Unit U = FileToVector(CurrentFilePath);
- Printf("CRASH_MIN: minimizing crash input: '%s' (%zd bytes)\n",
- CurrentFilePath.c_str(), U.size());
-
- auto Cmd = BaseCmd.first + " " + CurrentFilePath + LogFileRedirect + " " +
- BaseCmd.second;
-
- Printf("CRASH_MIN: executing: %s\n", Cmd.c_str());
- int ExitCode = ExecuteCommand(Cmd);
- if (ExitCode == 0) {
- Printf("ERROR: the input %s did not crash\n", CurrentFilePath.c_str());
- exit(1);
- }
- Printf("CRASH_MIN: '%s' (%zd bytes) caused a crash. Will try to minimize "
- "it further\n",
- CurrentFilePath.c_str(), U.size());
- auto DedupToken1 = GetDedupTokenFromFile(LogFilePath);
- if (!DedupToken1.empty())
- Printf("CRASH_MIN: DedupToken1: %s\n", DedupToken1.c_str());
-
- std::string ArtifactPath =
- Flags.exact_artifact_path
- ? Flags.exact_artifact_path
- : Options.ArtifactPrefix + "minimized-from-" + Hash(U);
- Cmd += " -minimize_crash_internal_step=1 -exact_artifact_path=" +
- ArtifactPath;
- Printf("CRASH_MIN: executing: %s\n", Cmd.c_str());
- ExitCode = ExecuteCommand(Cmd);
- CopyFileToErr(LogFilePath);
- if (ExitCode == 0) {
- if (Flags.exact_artifact_path) {
- CurrentFilePath = Flags.exact_artifact_path;
- WriteToFile(U, CurrentFilePath);
- }
- Printf("CRASH_MIN: failed to minimize beyond %s (%d bytes), exiting\n",
- CurrentFilePath.c_str(), U.size());
- break;
- }
- auto DedupToken2 = GetDedupTokenFromFile(LogFilePath);
- if (!DedupToken2.empty())
- Printf("CRASH_MIN: DedupToken2: %s\n", DedupToken2.c_str());
-
- if (DedupToken1 != DedupToken2) {
- if (Flags.exact_artifact_path) {
- CurrentFilePath = Flags.exact_artifact_path;
- WriteToFile(U, CurrentFilePath);
- }
- Printf("CRASH_MIN: mismatch in dedup tokens"
- " (looks like a different bug). Won't minimize further\n");
- break;
- }
-
- CurrentFilePath = ArtifactPath;
- Printf("*********************************\n");
- }
- RemoveFile(LogFilePath);
- return 0;
-}
-
-int MinimizeCrashInputInternalStep(Fuzzer *F, InputCorpus *Corpus) {
- assert(Inputs->size() == 1);
- std::string InputFilePath = Inputs->at(0);
- Unit U = FileToVector(InputFilePath);
- Printf("INFO: Starting MinimizeCrashInputInternalStep: %zd\n", U.size());
- if (U.size() < 2) {
- Printf("INFO: The input is small enough, exiting\n");
- exit(0);
- }
- F->SetMaxInputLen(U.size());
- F->SetMaxMutationLen(U.size() - 1);
- F->MinimizeCrashLoop(U);
- Printf("INFO: Done MinimizeCrashInputInternalStep, no crashes found\n");
- exit(0);
- return 0;
-}
-
-int AnalyzeDictionary(Fuzzer *F, const std::vector<Unit>& Dict,
- UnitVector& Corpus) {
- Printf("Started dictionary minimization (up to %d tests)\n",
- Dict.size() * Corpus.size() * 2);
-
- // Scores and usage count for each dictionary unit.
- std::vector<int> Scores(Dict.size());
- std::vector<int> Usages(Dict.size());
-
- std::vector<size_t> InitialFeatures;
- std::vector<size_t> ModifiedFeatures;
- for (auto &C : Corpus) {
- // Get coverage for the testcase without modifications.
- F->ExecuteCallback(C.data(), C.size());
- InitialFeatures.clear();
- TPC.CollectFeatures([&](size_t Feature) -> bool {
- InitialFeatures.push_back(Feature);
- return true;
- });
-
- for (size_t i = 0; i < Dict.size(); ++i) {
- auto Data = C;
- auto StartPos = std::search(Data.begin(), Data.end(),
- Dict[i].begin(), Dict[i].end());
- // Skip dictionary unit, if the testcase does not contain it.
- if (StartPos == Data.end())
- continue;
-
- ++Usages[i];
- while (StartPos != Data.end()) {
- // Replace all occurrences of dictionary unit in the testcase.
- auto EndPos = StartPos + Dict[i].size();
- for (auto It = StartPos; It != EndPos; ++It)
- *It ^= 0xFF;
-
- StartPos = std::search(EndPos, Data.end(),
- Dict[i].begin(), Dict[i].end());
- }
-
- // Get coverage for testcase with masked occurrences of dictionary unit.
- F->ExecuteCallback(Data.data(), Data.size());
- ModifiedFeatures.clear();
- TPC.CollectFeatures([&](size_t Feature) -> bool {
- ModifiedFeatures.push_back(Feature);
- return true;
- });
-
- if (InitialFeatures == ModifiedFeatures)
- --Scores[i];
- else
- Scores[i] += 2;
- }
- }
-
- Printf("###### Useless dictionary elements. ######\n");
- for (size_t i = 0; i < Dict.size(); ++i) {
- // Dictionary units with positive score are treated as useful ones.
- if (Scores[i] > 0)
- continue;
-
- Printf("\"");
- PrintASCII(Dict[i].data(), Dict[i].size(), "\"");
- Printf(" # Score: %d, Used: %d\n", Scores[i], Usages[i]);
- }
- Printf("###### End of useless dictionary elements. ######\n");
- return 0;
-}
-
-int FuzzerDriver(int *argc, char ***argv, UserCallback Callback) {
- using namespace fuzzer;
- assert(argc && argv && "Argument pointers cannot be nullptr");
- std::string Argv0((*argv)[0]);
- EF = new ExternalFunctions();
- if (EF->LLVMFuzzerInitialize)
- EF->LLVMFuzzerInitialize(argc, argv);
- const std::vector<std::string> Args(*argv, *argv + *argc);
- assert(!Args.empty());
- ProgName = new std::string(Args[0]);
- if (Argv0 != *ProgName) {
- Printf("ERROR: argv[0] has been modified in LLVMFuzzerInitialize\n");
- exit(1);
- }
- ParseFlags(Args);
- if (Flags.help) {
- PrintHelp();
- return 0;
- }
-
- if (Flags.close_fd_mask & 2)
- DupAndCloseStderr();
- if (Flags.close_fd_mask & 1)
- CloseStdout();
-
- if (Flags.jobs > 0 && Flags.workers == 0) {
- Flags.workers = std::min(NumberOfCpuCores() / 2, Flags.jobs);
- if (Flags.workers > 1)
- Printf("Running %u workers\n", Flags.workers);
- }
-
- if (Flags.workers > 0 && Flags.jobs > 0)
- return RunInMultipleProcesses(Args, Flags.workers, Flags.jobs);
-
- const size_t kMaxSaneLen = 1 << 20;
- const size_t kMinDefaultLen = 4096;
- FuzzingOptions Options;
- Options.Verbosity = Flags.verbosity;
- Options.MaxLen = Flags.max_len;
- Options.ExperimentalLenControl = Flags.experimental_len_control;
- Options.UnitTimeoutSec = Flags.timeout;
- Options.ErrorExitCode = Flags.error_exitcode;
- Options.TimeoutExitCode = Flags.timeout_exitcode;
- Options.MaxTotalTimeSec = Flags.max_total_time;
- Options.DoCrossOver = Flags.cross_over;
- Options.MutateDepth = Flags.mutate_depth;
- Options.UseCounters = Flags.use_counters;
- Options.UseIndirCalls = Flags.use_indir_calls;
- Options.UseMemmem = Flags.use_memmem;
- Options.UseCmp = Flags.use_cmp;
- Options.UseValueProfile = Flags.use_value_profile;
- Options.Shrink = Flags.shrink;
- Options.ReduceInputs = Flags.reduce_inputs;
- Options.ShuffleAtStartUp = Flags.shuffle;
- Options.PreferSmall = Flags.prefer_small;
- Options.ReloadIntervalSec = Flags.reload;
- Options.OnlyASCII = Flags.only_ascii;
- Options.DetectLeaks = Flags.detect_leaks;
- Options.TraceMalloc = Flags.trace_malloc;
- Options.RssLimitMb = Flags.rss_limit_mb;
- if (Flags.runs >= 0)
- Options.MaxNumberOfRuns = Flags.runs;
- if (!Inputs->empty() && !Flags.minimize_crash_internal_step)
- Options.OutputCorpus = (*Inputs)[0];
- Options.ReportSlowUnits = Flags.report_slow_units;
- if (Flags.artifact_prefix)
- Options.ArtifactPrefix = Flags.artifact_prefix;
- if (Flags.exact_artifact_path)
- Options.ExactArtifactPath = Flags.exact_artifact_path;
- std::vector<Unit> Dictionary;
- if (Flags.dict)
- if (!ParseDictionaryFile(FileToString(Flags.dict), &Dictionary))
- return 1;
- if (Flags.verbosity > 0 && !Dictionary.empty())
- Printf("Dictionary: %zd entries\n", Dictionary.size());
- bool DoPlainRun = AllInputsAreFiles();
- Options.SaveArtifacts =
- !DoPlainRun || Flags.minimize_crash_internal_step;
- Options.PrintNewCovPcs = Flags.print_pcs;
- Options.PrintFinalStats = Flags.print_final_stats;
- Options.PrintCorpusStats = Flags.print_corpus_stats;
- Options.PrintCoverage = Flags.print_coverage;
- Options.DumpCoverage = Flags.dump_coverage;
- if (Flags.exit_on_src_pos)
- Options.ExitOnSrcPos = Flags.exit_on_src_pos;
- if (Flags.exit_on_item)
- Options.ExitOnItem = Flags.exit_on_item;
-
- unsigned Seed = Flags.seed;
- // Initialize Seed.
- if (Seed == 0)
- Seed =
- std::chrono::system_clock::now().time_since_epoch().count() + GetPid();
- if (Flags.verbosity)
- Printf("INFO: Seed: %u\n", Seed);
-
- Random Rand(Seed);
- auto *MD = new MutationDispatcher(Rand, Options);
- auto *Corpus = new InputCorpus(Options.OutputCorpus);
- auto *F = new Fuzzer(Callback, *Corpus, *MD, Options);
-
- for (auto &U: Dictionary)
- if (U.size() <= Word::GetMaxSize())
- MD->AddWordToManualDictionary(Word(U.data(), U.size()));
-
- StartRssThread(F, Flags.rss_limit_mb);
-
- Options.HandleAbrt = Flags.handle_abrt;
- Options.HandleBus = Flags.handle_bus;
- Options.HandleFpe = Flags.handle_fpe;
- Options.HandleIll = Flags.handle_ill;
- Options.HandleInt = Flags.handle_int;
- Options.HandleSegv = Flags.handle_segv;
- Options.HandleTerm = Flags.handle_term;
- Options.HandleXfsz = Flags.handle_xfsz;
- SetSignalHandler(Options);
-
- std::atexit(Fuzzer::StaticExitCallback);
-
- if (Flags.minimize_crash)
- return MinimizeCrashInput(Args, Options);
-
- if (Flags.minimize_crash_internal_step)
- return MinimizeCrashInputInternalStep(F, Corpus);
-
- if (Flags.cleanse_crash)
- return CleanseCrashInput(Args, Options);
-
- if (auto Name = Flags.run_equivalence_server) {
- SMR.Destroy(Name);
- if (!SMR.Create(Name)) {
- Printf("ERROR: can't create shared memory region\n");
- return 1;
- }
- Printf("INFO: EQUIVALENCE SERVER UP\n");
- while (true) {
- SMR.WaitClient();
- size_t Size = SMR.ReadByteArraySize();
- SMR.WriteByteArray(nullptr, 0);
- const Unit tmp(SMR.GetByteArray(), SMR.GetByteArray() + Size);
- F->ExecuteCallback(tmp.data(), tmp.size());
- SMR.PostServer();
- }
- return 0;
- }
-
- if (auto Name = Flags.use_equivalence_server) {
- if (!SMR.Open(Name)) {
- Printf("ERROR: can't open shared memory region\n");
- return 1;
- }
- Printf("INFO: EQUIVALENCE CLIENT UP\n");
- }
-
- if (DoPlainRun) {
- Options.SaveArtifacts = false;
- int Runs = std::max(1, Flags.runs);
- Printf("%s: Running %zd inputs %d time(s) each.\n", ProgName->c_str(),
- Inputs->size(), Runs);
- for (auto &Path : *Inputs) {
- auto StartTime = system_clock::now();
- Printf("Running: %s\n", Path.c_str());
- for (int Iter = 0; Iter < Runs; Iter++)
- RunOneTest(F, Path.c_str(), Options.MaxLen);
- auto StopTime = system_clock::now();
- auto MS = duration_cast<milliseconds>(StopTime - StartTime).count();
- Printf("Executed %s in %zd ms\n", Path.c_str(), (long)MS);
- }
- Printf("***\n"
- "*** NOTE: fuzzing was not performed, you have only\n"
- "*** executed the target code on a fixed set of inputs.\n"
- "***\n");
- F->PrintFinalStats();
- exit(0);
- }
-
- if (Flags.merge) {
- if (Options.MaxLen == 0)
- F->SetMaxInputLen(kMaxSaneLen);
- if (Flags.merge_control_file)
- F->CrashResistantMergeInternalStep(Flags.merge_control_file);
- else
- F->CrashResistantMerge(Args, *Inputs,
- Flags.load_coverage_summary,
- Flags.save_coverage_summary);
- exit(0);
- }
-
- size_t TemporaryMaxLen = Options.MaxLen ? Options.MaxLen : kMaxSaneLen;
-
- UnitVector InitialCorpus;
- for (auto &Inp : *Inputs) {
- Printf("Loading corpus dir: %s\n", Inp.c_str());
- ReadDirToVectorOfUnits(Inp.c_str(), &InitialCorpus, nullptr,
- TemporaryMaxLen, /*ExitOnError=*/false);
- }
-
- if (Flags.analyze_dict) {
- if (Dictionary.empty() || Inputs->empty()) {
- Printf("ERROR: can't analyze dict without dict and corpus provided\n");
- return 1;
- }
- if (AnalyzeDictionary(F, Dictionary, InitialCorpus)) {
- Printf("Dictionary analysis failed\n");
- exit(1);
- }
- Printf("Dictionary analysis suceeded\n");
- exit(0);
- }
-
- if (Options.MaxLen == 0) {
- size_t MaxLen = 0;
- for (auto &U : InitialCorpus)
- MaxLen = std::max(U.size(), MaxLen);
- F->SetMaxInputLen(std::min(std::max(kMinDefaultLen, MaxLen), kMaxSaneLen));
- }
-
- if (InitialCorpus.empty()) {
- InitialCorpus.push_back(Unit({'\n'})); // Valid ASCII input.
- if (Options.Verbosity)
- Printf("INFO: A corpus is not provided, starting from an empty corpus\n");
- }
- F->ShuffleAndMinimize(&InitialCorpus);
- InitialCorpus.clear(); // Don't need this memory any more.
- F->Loop();
-
- if (Flags.verbosity)
- Printf("Done %zd runs in %zd second(s)\n", F->getTotalNumberOfRuns(),
- F->secondsSinceProcessStartUp());
- F->PrintFinalStats();
-
- exit(0); // Don't let F destroy itself.
-}
-
-// Storage for global ExternalFunctions object.
-ExternalFunctions *EF = nullptr;
-
-} // namespace fuzzer
Removed: llvm/trunk/lib/Fuzzer/FuzzerExtFunctions.def
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Fuzzer/FuzzerExtFunctions.def?rev=315936&view=auto
==============================================================================
--- llvm/trunk/lib/Fuzzer/FuzzerExtFunctions.def (original)
+++ llvm/trunk/lib/Fuzzer/FuzzerExtFunctions.def (removed)
@@ -1,46 +0,0 @@
-//===- FuzzerExtFunctions.def - External functions --------------*- C++ -* ===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-// This defines the external function pointers that
-// ``fuzzer::ExternalFunctions`` should contain and try to initialize. The
-// EXT_FUNC macro must be defined at the point of inclusion. The signature of
-// the macro is:
-//
-// EXT_FUNC(<name>, <return_type>, <function_signature>, <warn_if_missing>)
-//===----------------------------------------------------------------------===//
-
-// Optional user functions
-EXT_FUNC(LLVMFuzzerInitialize, int, (int *argc, char ***argv), false);
-EXT_FUNC(LLVMFuzzerCustomMutator, size_t,
- (uint8_t * Data, size_t Size, size_t MaxSize, unsigned int Seed),
- false);
-EXT_FUNC(LLVMFuzzerCustomCrossOver, size_t,
- (const uint8_t * Data1, size_t Size1,
- const uint8_t * Data2, size_t Size2,
- uint8_t * Out, size_t MaxOutSize, unsigned int Seed),
- false);
-
-// Sanitizer functions
-EXT_FUNC(__lsan_enable, void, (), false);
-EXT_FUNC(__lsan_disable, void, (), false);
-EXT_FUNC(__lsan_do_recoverable_leak_check, int, (), false);
-EXT_FUNC(__sanitizer_install_malloc_and_free_hooks, int,
- (void (*malloc_hook)(const volatile void *, size_t),
- void (*free_hook)(const volatile void *)),
- false);
-EXT_FUNC(__sanitizer_print_memory_profile, int, (size_t, size_t), false);
-EXT_FUNC(__sanitizer_print_stack_trace, void, (), true);
-EXT_FUNC(__sanitizer_symbolize_pc, void,
- (void *, const char *fmt, char *out_buf, size_t out_buf_size), false);
-EXT_FUNC(__sanitizer_get_module_and_offset_for_pc, int,
- (void *pc, char *module_path,
- size_t module_path_len,void **pc_offset), false);
-EXT_FUNC(__sanitizer_set_death_callback, void, (void (*)(void)), true);
-EXT_FUNC(__sanitizer_set_report_fd, void, (void*), false);
-EXT_FUNC(__sanitizer_dump_coverage, void, (const uintptr_t *, uintptr_t),
- false);
Removed: llvm/trunk/lib/Fuzzer/FuzzerExtFunctions.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Fuzzer/FuzzerExtFunctions.h?rev=315936&view=auto
==============================================================================
--- llvm/trunk/lib/Fuzzer/FuzzerExtFunctions.h (original)
+++ llvm/trunk/lib/Fuzzer/FuzzerExtFunctions.h (removed)
@@ -1,35 +0,0 @@
-//===- FuzzerExtFunctions.h - Interface to external functions ---*- C++ -* ===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-// Defines an interface to (possibly optional) functions.
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_FUZZER_EXT_FUNCTIONS_H
-#define LLVM_FUZZER_EXT_FUNCTIONS_H
-
-#include <stddef.h>
-#include <stdint.h>
-
-namespace fuzzer {
-
-struct ExternalFunctions {
- // Initialize function pointers. Functions that are not available will be set
- // to nullptr. Do not call this constructor before ``main()`` has been
- // entered.
- ExternalFunctions();
-
-#define EXT_FUNC(NAME, RETURN_TYPE, FUNC_SIG, WARN) \
- RETURN_TYPE(*NAME) FUNC_SIG = nullptr
-
-#include "FuzzerExtFunctions.def"
-
-#undef EXT_FUNC
-};
-} // namespace fuzzer
-
-#endif
Removed: llvm/trunk/lib/Fuzzer/FuzzerExtFunctionsDlsym.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Fuzzer/FuzzerExtFunctionsDlsym.cpp?rev=315936&view=auto
==============================================================================
--- llvm/trunk/lib/Fuzzer/FuzzerExtFunctionsDlsym.cpp (original)
+++ llvm/trunk/lib/Fuzzer/FuzzerExtFunctionsDlsym.cpp (removed)
@@ -1,52 +0,0 @@
-//===- FuzzerExtFunctionsDlsym.cpp - Interface to external functions ------===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-// Implementation for operating systems that support dlsym(). We only use it on
-// Apple platforms for now. We don't use this approach on Linux because it
-// requires that clients of LibFuzzer pass ``--export-dynamic`` to the linker.
-// That is a complication we don't wish to expose to clients right now.
-//===----------------------------------------------------------------------===//
-#include "FuzzerDefs.h"
-#if LIBFUZZER_APPLE
-
-#include "FuzzerExtFunctions.h"
-#include "FuzzerIO.h"
-#include <dlfcn.h>
-
-using namespace fuzzer;
-
-template <typename T>
-static T GetFnPtr(const char *FnName, bool WarnIfMissing) {
- dlerror(); // Clear any previous errors.
- void *Fn = dlsym(RTLD_DEFAULT, FnName);
- if (Fn == nullptr) {
- if (WarnIfMissing) {
- const char *ErrorMsg = dlerror();
- Printf("WARNING: Failed to find function \"%s\".", FnName);
- if (ErrorMsg)
- Printf(" Reason %s.", ErrorMsg);
- Printf("\n");
- }
- }
- return reinterpret_cast<T>(Fn);
-}
-
-namespace fuzzer {
-
-ExternalFunctions::ExternalFunctions() {
-#define EXT_FUNC(NAME, RETURN_TYPE, FUNC_SIG, WARN) \
- this->NAME = GetFnPtr<decltype(ExternalFunctions::NAME)>(#NAME, WARN)
-
-#include "FuzzerExtFunctions.def"
-
-#undef EXT_FUNC
-}
-
-} // namespace fuzzer
-
-#endif // LIBFUZZER_APPLE
Removed: llvm/trunk/lib/Fuzzer/FuzzerExtFunctionsDlsymWin.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Fuzzer/FuzzerExtFunctionsDlsymWin.cpp?rev=315936&view=auto
==============================================================================
--- llvm/trunk/lib/Fuzzer/FuzzerExtFunctionsDlsymWin.cpp (original)
+++ llvm/trunk/lib/Fuzzer/FuzzerExtFunctionsDlsymWin.cpp (removed)
@@ -1,62 +0,0 @@
-//===- FuzzerExtFunctionsDlsymWin.cpp - Interface to external functions ---===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-// Implementation using dynamic loading for Windows.
-//===----------------------------------------------------------------------===//
-#include "FuzzerDefs.h"
-#if LIBFUZZER_WINDOWS
-
-#include "FuzzerExtFunctions.h"
-#include "FuzzerIO.h"
-#include "Windows.h"
-
-// This must be included after Windows.h.
-#include "Psapi.h"
-
-namespace fuzzer {
-
-ExternalFunctions::ExternalFunctions() {
- HMODULE Modules[1024];
- DWORD BytesNeeded;
- HANDLE CurrentProcess = GetCurrentProcess();
-
- if (!EnumProcessModules(CurrentProcess, Modules, sizeof(Modules),
- &BytesNeeded)) {
- Printf("EnumProcessModules failed (error: %d).\n", GetLastError());
- exit(1);
- }
-
- if (sizeof(Modules) < BytesNeeded) {
- Printf("Error: the array is not big enough to hold all loaded modules.\n");
- exit(1);
- }
-
- for (size_t i = 0; i < (BytesNeeded / sizeof(HMODULE)); i++)
- {
- FARPROC Fn;
-#define EXT_FUNC(NAME, RETURN_TYPE, FUNC_SIG, WARN) \
- if (this->NAME == nullptr) { \
- Fn = GetProcAddress(Modules[i], #NAME); \
- if (Fn == nullptr) \
- Fn = GetProcAddress(Modules[i], #NAME "__dll"); \
- this->NAME = (decltype(ExternalFunctions::NAME)) Fn; \
- }
-#include "FuzzerExtFunctions.def"
-#undef EXT_FUNC
- }
-
-#define EXT_FUNC(NAME, RETURN_TYPE, FUNC_SIG, WARN) \
- if (this->NAME == nullptr && WARN) \
- Printf("WARNING: Failed to find function \"%s\".\n", #NAME);
-#include "FuzzerExtFunctions.def"
-#undef EXT_FUNC
-}
-
-} // namespace fuzzer
-
-#endif // LIBFUZZER_WINDOWS
Removed: llvm/trunk/lib/Fuzzer/FuzzerExtFunctionsWeak.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Fuzzer/FuzzerExtFunctionsWeak.cpp?rev=315936&view=auto
==============================================================================
--- llvm/trunk/lib/Fuzzer/FuzzerExtFunctionsWeak.cpp (original)
+++ llvm/trunk/lib/Fuzzer/FuzzerExtFunctionsWeak.cpp (removed)
@@ -1,54 +0,0 @@
-//===- FuzzerExtFunctionsWeak.cpp - Interface to external functions -------===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-// Implementation for Linux. This relies on the linker's support for weak
-// symbols. We don't use this approach on Apple platforms because it requires
-// clients of LibFuzzer to pass ``-U _<symbol_name>`` to the linker to allow
-// weak symbols to be undefined. That is a complication we don't want to expose
-// to clients right now.
-//===----------------------------------------------------------------------===//
-#include "FuzzerDefs.h"
-#if LIBFUZZER_LINUX
-
-#include "FuzzerExtFunctions.h"
-#include "FuzzerIO.h"
-
-extern "C" {
-// Declare these symbols as weak to allow them to be optionally defined.
-#define EXT_FUNC(NAME, RETURN_TYPE, FUNC_SIG, WARN) \
- __attribute__((weak)) RETURN_TYPE NAME FUNC_SIG
-
-#include "FuzzerExtFunctions.def"
-
-#undef EXT_FUNC
-}
-
-using namespace fuzzer;
-
-static void CheckFnPtr(void *FnPtr, const char *FnName, bool WarnIfMissing) {
- if (FnPtr == nullptr && WarnIfMissing) {
- Printf("WARNING: Failed to find function \"%s\".\n", FnName);
- }
-}
-
-namespace fuzzer {
-
-ExternalFunctions::ExternalFunctions() {
-#define EXT_FUNC(NAME, RETURN_TYPE, FUNC_SIG, WARN) \
- this->NAME = ::NAME; \
- CheckFnPtr(reinterpret_cast<void *>(reinterpret_cast<uintptr_t>(::NAME)), \
- #NAME, WARN);
-
-#include "FuzzerExtFunctions.def"
-
-#undef EXT_FUNC
-}
-
-} // namespace fuzzer
-
-#endif // LIBFUZZER_LINUX
Removed: llvm/trunk/lib/Fuzzer/FuzzerExtFunctionsWeakAlias.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Fuzzer/FuzzerExtFunctionsWeakAlias.cpp?rev=315936&view=auto
==============================================================================
--- llvm/trunk/lib/Fuzzer/FuzzerExtFunctionsWeakAlias.cpp (original)
+++ llvm/trunk/lib/Fuzzer/FuzzerExtFunctionsWeakAlias.cpp (removed)
@@ -1,56 +0,0 @@
-//===- FuzzerExtFunctionsWeakAlias.cpp - Interface to external functions --===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-// Implementation using weak aliases. Works for Windows.
-//===----------------------------------------------------------------------===//
-#include "FuzzerDefs.h"
-#if LIBFUZZER_WINDOWS
-
-#include "FuzzerExtFunctions.h"
-#include "FuzzerIO.h"
-
-using namespace fuzzer;
-
-extern "C" {
-// Declare these symbols as weak to allow them to be optionally defined.
-#define EXT_FUNC(NAME, RETURN_TYPE, FUNC_SIG, WARN) \
- RETURN_TYPE NAME##Def FUNC_SIG { \
- Printf("ERROR: Function \"%s\" not defined.\n", #NAME); \
- exit(1); \
- } \
- RETURN_TYPE NAME FUNC_SIG __attribute__((weak, alias(#NAME "Def")));
-
-#include "FuzzerExtFunctions.def"
-
-#undef EXT_FUNC
-}
-
-template <typename T>
-static T *GetFnPtr(T *Fun, T *FunDef, const char *FnName, bool WarnIfMissing) {
- if (Fun == FunDef) {
- if (WarnIfMissing)
- Printf("WARNING: Failed to find function \"%s\".\n", FnName);
- return nullptr;
- }
- return Fun;
-}
-
-namespace fuzzer {
-
-ExternalFunctions::ExternalFunctions() {
-#define EXT_FUNC(NAME, RETURN_TYPE, FUNC_SIG, WARN) \
- this->NAME = GetFnPtr<decltype(::NAME)>(::NAME, ::NAME##Def, #NAME, WARN);
-
-#include "FuzzerExtFunctions.def"
-
-#undef EXT_FUNC
-}
-
-} // namespace fuzzer
-
-#endif // LIBFUZZER_WINDOWS
Removed: llvm/trunk/lib/Fuzzer/FuzzerExtraCounters.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Fuzzer/FuzzerExtraCounters.cpp?rev=315936&view=auto
==============================================================================
--- llvm/trunk/lib/Fuzzer/FuzzerExtraCounters.cpp (original)
+++ llvm/trunk/lib/Fuzzer/FuzzerExtraCounters.cpp (removed)
@@ -1,41 +0,0 @@
-//===- FuzzerExtraCounters.cpp - Extra coverage counters ------------------===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-// Extra coverage counters defined by user code.
-//===----------------------------------------------------------------------===//
-
-#include "FuzzerDefs.h"
-
-#if LIBFUZZER_LINUX
-__attribute__((weak)) extern uint8_t __start___libfuzzer_extra_counters;
-__attribute__((weak)) extern uint8_t __stop___libfuzzer_extra_counters;
-
-namespace fuzzer {
-uint8_t *ExtraCountersBegin() { return &__start___libfuzzer_extra_counters; }
-uint8_t *ExtraCountersEnd() { return &__stop___libfuzzer_extra_counters; }
-ATTRIBUTE_NO_SANITIZE_ALL
-void ClearExtraCounters() { // hand-written memset, don't asan-ify.
- uintptr_t *Beg = reinterpret_cast<uintptr_t*>(ExtraCountersBegin());
- uintptr_t *End = reinterpret_cast<uintptr_t*>(ExtraCountersEnd());
- for (; Beg < End; Beg++) {
- *Beg = 0;
- __asm__ __volatile__("" : : : "memory");
- }
-}
-
-} // namespace fuzzer
-
-#else
-// TODO: implement for other platforms.
-namespace fuzzer {
-uint8_t *ExtraCountersBegin() { return nullptr; }
-uint8_t *ExtraCountersEnd() { return nullptr; }
-void ClearExtraCounters() {}
-} // namespace fuzzer
-
-#endif
Removed: llvm/trunk/lib/Fuzzer/FuzzerFlags.def
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Fuzzer/FuzzerFlags.def?rev=315936&view=auto
==============================================================================
--- llvm/trunk/lib/Fuzzer/FuzzerFlags.def (original)
+++ llvm/trunk/lib/Fuzzer/FuzzerFlags.def (removed)
@@ -1,139 +0,0 @@
-//===- FuzzerFlags.def - Run-time flags -------------------------*- C++ -* ===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-// Flags. FUZZER_FLAG_INT/FUZZER_FLAG_STRING macros should be defined at the
-// point of inclusion. We are not using any flag parsing library for better
-// portability and independence.
-//===----------------------------------------------------------------------===//
-FUZZER_FLAG_INT(verbosity, 1, "Verbosity level.")
-FUZZER_FLAG_UNSIGNED(seed, 0, "Random seed. If 0, seed is generated.")
-FUZZER_FLAG_INT(runs, -1,
- "Number of individual test runs (-1 for infinite runs).")
-FUZZER_FLAG_INT(max_len, 0, "Maximum length of the test input. "
- "If 0, libFuzzer tries to guess a good value based on the corpus "
- "and reports it. ")
-FUZZER_FLAG_INT(experimental_len_control, 0, "experimental flag")
-FUZZER_FLAG_INT(cross_over, 1, "If 1, cross over inputs.")
-FUZZER_FLAG_INT(mutate_depth, 5,
- "Apply this number of consecutive mutations to each input.")
-FUZZER_FLAG_INT(shuffle, 1, "Shuffle inputs at startup")
-FUZZER_FLAG_INT(prefer_small, 1,
- "If 1, always prefer smaller inputs during the corpus shuffle.")
-FUZZER_FLAG_INT(
- timeout, 1200,
- "Timeout in seconds (if positive). "
- "If one unit runs more than this number of seconds the process will abort.")
-FUZZER_FLAG_INT(error_exitcode, 77, "When libFuzzer itself reports a bug "
- "this exit code will be used.")
-FUZZER_FLAG_INT(timeout_exitcode, 77, "When libFuzzer reports a timeout "
- "this exit code will be used.")
-FUZZER_FLAG_INT(max_total_time, 0, "If positive, indicates the maximal total "
- "time in seconds to run the fuzzer.")
-FUZZER_FLAG_INT(help, 0, "Print help.")
-FUZZER_FLAG_INT(merge, 0, "If 1, the 2-nd, 3-rd, etc corpora will be "
- "merged into the 1-st corpus. Only interesting units will be taken. "
- "This flag can be used to minimize a corpus.")
-FUZZER_FLAG_STRING(merge_control_file, "internal flag")
-FUZZER_FLAG_STRING(save_coverage_summary, "Experimental:"
- " save coverage summary to a given file."
- " Used with -merge=1")
-FUZZER_FLAG_STRING(load_coverage_summary, "Experimental:"
- " load coverage summary from a given file."
- " Treat this coverage as belonging to the first corpus. "
- " Used with -merge=1")
-FUZZER_FLAG_INT(minimize_crash, 0, "If 1, minimizes the provided"
- " crash input. Use with -runs=N or -max_total_time=N to limit "
- "the number attempts."
- " Use with -exact_artifact_path to specify the output."
- " Combine with ASAN_OPTIONS=dedup_token_length=3 (or similar) to ensure that"
- " the minimized input triggers the same crash."
- )
-FUZZER_FLAG_INT(cleanse_crash, 0, "If 1, tries to cleanse the provided"
- " crash input to make it contain fewer original bytes."
- " Use with -exact_artifact_path to specify the output."
- )
-FUZZER_FLAG_INT(minimize_crash_internal_step, 0, "internal flag")
-FUZZER_FLAG_INT(use_counters, 1, "Use coverage counters")
-FUZZER_FLAG_INT(use_indir_calls, 1, "Use indirect caller-callee counters")
-FUZZER_FLAG_INT(use_memmem, 1,
- "Use hints from intercepting memmem, strstr, etc")
-FUZZER_FLAG_INT(use_value_profile, 0,
- "Experimental. Use value profile to guide fuzzing.")
-FUZZER_FLAG_INT(use_cmp, 1, "Use CMP traces to guide mutations")
-FUZZER_FLAG_INT(shrink, 0, "Experimental. Try to shrink corpus inputs.")
-FUZZER_FLAG_INT(reduce_inputs, 1,
- "Try to reduce the size of inputs while preserving their full feature sets")
-FUZZER_FLAG_UNSIGNED(jobs, 0, "Number of jobs to run. If jobs >= 1 we spawn"
- " this number of jobs in separate worker processes"
- " with stdout/stderr redirected to fuzz-JOB.log.")
-FUZZER_FLAG_UNSIGNED(workers, 0,
- "Number of simultaneous worker processes to run the jobs."
- " If zero, \"min(jobs,NumberOfCpuCores()/2)\" is used.")
-FUZZER_FLAG_INT(reload, 1,
- "Reload the main corpus every <N> seconds to get new units"
- " discovered by other processes. If 0, disabled")
-FUZZER_FLAG_INT(report_slow_units, 10,
- "Report slowest units if they run for more than this number of seconds.")
-FUZZER_FLAG_INT(only_ascii, 0,
- "If 1, generate only ASCII (isprint+isspace) inputs.")
-FUZZER_FLAG_STRING(dict, "Experimental. Use the dictionary file.")
-FUZZER_FLAG_STRING(artifact_prefix, "Write fuzzing artifacts (crash, "
- "timeout, or slow inputs) as "
- "$(artifact_prefix)file")
-FUZZER_FLAG_STRING(exact_artifact_path,
- "Write the single artifact on failure (crash, timeout) "
- "as $(exact_artifact_path). This overrides -artifact_prefix "
- "and will not use checksum in the file name. Do not "
- "use the same path for several parallel processes.")
-FUZZER_FLAG_INT(print_pcs, 0, "If 1, print out newly covered PCs.")
-FUZZER_FLAG_INT(print_final_stats, 0, "If 1, print statistics at exit.")
-FUZZER_FLAG_INT(print_corpus_stats, 0,
- "If 1, print statistics on corpus elements at exit.")
-FUZZER_FLAG_INT(print_coverage, 0, "If 1, print coverage information as text"
- " at exit. To-be-deprecated.")
-FUZZER_FLAG_INT(dump_coverage, 0, "If 1, dump coverage information as a"
- " .sancov file at exit. To-be-deprecated.")
-FUZZER_FLAG_INT(handle_segv, 1, "If 1, try to intercept SIGSEGV.")
-FUZZER_FLAG_INT(handle_bus, 1, "If 1, try to intercept SIGBUS.")
-FUZZER_FLAG_INT(handle_abrt, 1, "If 1, try to intercept SIGABRT.")
-FUZZER_FLAG_INT(handle_ill, 1, "If 1, try to intercept SIGILL.")
-FUZZER_FLAG_INT(handle_fpe, 1, "If 1, try to intercept SIGFPE.")
-FUZZER_FLAG_INT(handle_int, 1, "If 1, try to intercept SIGINT.")
-FUZZER_FLAG_INT(handle_term, 1, "If 1, try to intercept SIGTERM.")
-FUZZER_FLAG_INT(handle_xfsz, 1, "If 1, try to intercept SIGXFSZ.")
-FUZZER_FLAG_INT(close_fd_mask, 0, "If 1, close stdout at startup; "
- "if 2, close stderr; if 3, close both. "
- "Be careful, this will also close e.g. asan's stderr/stdout.")
-FUZZER_FLAG_INT(detect_leaks, 1, "If 1, and if LeakSanitizer is enabled "
- "try to detect memory leaks during fuzzing (i.e. not only at shut down).")
-FUZZER_FLAG_INT(trace_malloc, 0, "If >= 1 will print all mallocs/frees. "
- "If >= 2 will also print stack traces.")
-FUZZER_FLAG_INT(rss_limit_mb, 2048, "If non-zero, the fuzzer will exit upon"
- "reaching this limit of RSS memory usage.")
-FUZZER_FLAG_STRING(exit_on_src_pos, "Exit if a newly found PC originates"
- " from the given source location. Example: -exit_on_src_pos=foo.cc:123. "
- "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(run_equivalence_server, "Experimental")
-FUZZER_FLAG_STRING(use_equivalence_server, "Experimental")
-FUZZER_FLAG_INT(analyze_dict, 0, "Experimental")
-
-FUZZER_DEPRECATED_FLAG(exit_on_first)
-FUZZER_DEPRECATED_FLAG(save_minimized_corpus)
-FUZZER_DEPRECATED_FLAG(sync_command)
-FUZZER_DEPRECATED_FLAG(sync_timeout)
-FUZZER_DEPRECATED_FLAG(test_single_input)
-FUZZER_DEPRECATED_FLAG(drill)
-FUZZER_DEPRECATED_FLAG(truncate_units)
-FUZZER_DEPRECATED_FLAG(output_csv)
Removed: llvm/trunk/lib/Fuzzer/FuzzerIO.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Fuzzer/FuzzerIO.cpp?rev=315936&view=auto
==============================================================================
--- llvm/trunk/lib/Fuzzer/FuzzerIO.cpp (original)
+++ llvm/trunk/lib/Fuzzer/FuzzerIO.cpp (removed)
@@ -1,120 +0,0 @@
-//===- FuzzerIO.cpp - IO utils. -------------------------------------------===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-// IO functions.
-//===----------------------------------------------------------------------===//
-
-#include "FuzzerIO.h"
-#include "FuzzerDefs.h"
-#include "FuzzerExtFunctions.h"
-#include <algorithm>
-#include <cstdarg>
-#include <fstream>
-#include <iterator>
-#include <sys/stat.h>
-#include <sys/types.h>
-
-namespace fuzzer {
-
-static FILE *OutputFile = stderr;
-
-long GetEpoch(const std::string &Path) {
- struct stat St;
- if (stat(Path.c_str(), &St))
- return 0; // Can't stat, be conservative.
- return St.st_mtime;
-}
-
-Unit FileToVector(const std::string &Path, size_t MaxSize, bool ExitOnError) {
- std::ifstream T(Path);
- if (ExitOnError && !T) {
- Printf("No such directory: %s; exiting\n", Path.c_str());
- exit(1);
- }
-
- T.seekg(0, T.end);
- auto EndPos = T.tellg();
- if (EndPos < 0) return {};
- size_t FileLen = EndPos;
- if (MaxSize)
- FileLen = std::min(FileLen, MaxSize);
-
- T.seekg(0, T.beg);
- Unit Res(FileLen);
- T.read(reinterpret_cast<char *>(Res.data()), FileLen);
- return Res;
-}
-
-std::string FileToString(const std::string &Path) {
- std::ifstream T(Path);
- return std::string((std::istreambuf_iterator<char>(T)),
- std::istreambuf_iterator<char>());
-}
-
-void CopyFileToErr(const std::string &Path) {
- Printf("%s", FileToString(Path).c_str());
-}
-
-void WriteToFile(const Unit &U, const std::string &Path) {
- // Use raw C interface because this function may be called from a sig handler.
- FILE *Out = fopen(Path.c_str(), "w");
- if (!Out) return;
- fwrite(U.data(), sizeof(U[0]), U.size(), Out);
- fclose(Out);
-}
-
-void ReadDirToVectorOfUnits(const char *Path, std::vector<Unit> *V,
- long *Epoch, size_t MaxSize, bool ExitOnError) {
- long E = Epoch ? *Epoch : 0;
- std::vector<std::string> Files;
- ListFilesInDirRecursive(Path, Epoch, &Files, /*TopDir*/true);
- size_t NumLoaded = 0;
- for (size_t i = 0; i < Files.size(); i++) {
- auto &X = Files[i];
- if (Epoch && GetEpoch(X) < E) continue;
- NumLoaded++;
- if ((NumLoaded & (NumLoaded - 1)) == 0 && NumLoaded >= 1024)
- Printf("Loaded %zd/%zd files from %s\n", NumLoaded, Files.size(), Path);
- auto S = FileToVector(X, MaxSize, ExitOnError);
- if (!S.empty())
- V->push_back(S);
- }
-}
-
-std::string DirPlusFile(const std::string &DirPath,
- const std::string &FileName) {
- return DirPath + GetSeparator() + FileName;
-}
-
-void DupAndCloseStderr() {
- int OutputFd = DuplicateFile(2);
- if (OutputFd > 0) {
- FILE *NewOutputFile = OpenFile(OutputFd, "w");
- if (NewOutputFile) {
- OutputFile = NewOutputFile;
- if (EF->__sanitizer_set_report_fd)
- EF->__sanitizer_set_report_fd(
- reinterpret_cast<void *>(GetHandleFromFd(OutputFd)));
- DiscardOutput(2);
- }
- }
-}
-
-void CloseStdout() {
- DiscardOutput(1);
-}
-
-void Printf(const char *Fmt, ...) {
- va_list ap;
- va_start(ap, Fmt);
- vfprintf(OutputFile, Fmt, ap);
- va_end(ap);
- fflush(OutputFile);
-}
-
-} // namespace fuzzer
Removed: llvm/trunk/lib/Fuzzer/FuzzerIO.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Fuzzer/FuzzerIO.h?rev=315936&view=auto
==============================================================================
--- llvm/trunk/lib/Fuzzer/FuzzerIO.h (original)
+++ llvm/trunk/lib/Fuzzer/FuzzerIO.h (removed)
@@ -1,76 +0,0 @@
-//===- FuzzerIO.h - Internal header for IO utils ----------------*- C++ -* ===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-// IO interface.
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_FUZZER_IO_H
-#define LLVM_FUZZER_IO_H
-
-#include "FuzzerDefs.h"
-
-namespace fuzzer {
-
-long GetEpoch(const std::string &Path);
-
-Unit FileToVector(const std::string &Path, size_t MaxSize = 0,
- bool ExitOnError = true);
-
-std::string FileToString(const std::string &Path);
-
-void CopyFileToErr(const std::string &Path);
-
-void WriteToFile(const Unit &U, const std::string &Path);
-
-void ReadDirToVectorOfUnits(const char *Path, std::vector<Unit> *V,
- long *Epoch, size_t MaxSize, bool ExitOnError);
-
-// Returns "Dir/FileName" or equivalent for the current OS.
-std::string DirPlusFile(const std::string &DirPath,
- const std::string &FileName);
-
-// Returns the name of the dir, similar to the 'dirname' utility.
-std::string DirName(const std::string &FileName);
-
-// Returns path to a TmpDir.
-std::string TmpDir();
-
-bool IsInterestingCoverageFile(const std::string &FileName);
-
-void DupAndCloseStderr();
-
-void CloseStdout();
-
-void Printf(const char *Fmt, ...);
-
-// Print using raw syscalls, useful when printing at early init stages.
-void RawPrint(const char *Str);
-
-// Platform specific functions:
-bool IsFile(const std::string &Path);
-
-void ListFilesInDirRecursive(const std::string &Dir, long *Epoch,
- std::vector<std::string> *V, bool TopDir);
-
-char GetSeparator();
-
-FILE* OpenFile(int Fd, const char *Mode);
-
-int CloseFile(int Fd);
-
-int DuplicateFile(int Fd);
-
-void RemoveFile(const std::string &Path);
-
-void DiscardOutput(int Fd);
-
-intptr_t GetHandleFromFd(int fd);
-
-} // namespace fuzzer
-
-#endif // LLVM_FUZZER_IO_H
Removed: llvm/trunk/lib/Fuzzer/FuzzerIOPosix.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Fuzzer/FuzzerIOPosix.cpp?rev=315936&view=auto
==============================================================================
--- llvm/trunk/lib/Fuzzer/FuzzerIOPosix.cpp (original)
+++ llvm/trunk/lib/Fuzzer/FuzzerIOPosix.cpp (removed)
@@ -1,123 +0,0 @@
-//===- FuzzerIOPosix.cpp - IO utils for Posix. ----------------------------===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-// IO functions implementation using Posix API.
-//===----------------------------------------------------------------------===//
-#include "FuzzerDefs.h"
-#if LIBFUZZER_POSIX
-
-#include "FuzzerExtFunctions.h"
-#include "FuzzerIO.h"
-#include <cstdarg>
-#include <cstdio>
-#include <dirent.h>
-#include <fstream>
-#include <iterator>
-#include <libgen.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-#include <unistd.h>
-
-namespace fuzzer {
-
-bool IsFile(const std::string &Path) {
- struct stat St;
- if (stat(Path.c_str(), &St))
- return false;
- return S_ISREG(St.st_mode);
-}
-
-void ListFilesInDirRecursive(const std::string &Dir, long *Epoch,
- std::vector<std::string> *V, bool TopDir) {
- auto E = GetEpoch(Dir);
- if (Epoch)
- if (E && *Epoch >= E) return;
-
- DIR *D = opendir(Dir.c_str());
- if (!D) {
- Printf("No such directory: %s; exiting\n", Dir.c_str());
- exit(1);
- }
- while (auto E = readdir(D)) {
- std::string Path = DirPlusFile(Dir, E->d_name);
- if (E->d_type == DT_REG || E->d_type == DT_LNK)
- V->push_back(Path);
- else if (E->d_type == DT_DIR && *E->d_name != '.')
- ListFilesInDirRecursive(Path, Epoch, V, false);
- }
- closedir(D);
- if (Epoch && TopDir)
- *Epoch = E;
-}
-
-char GetSeparator() {
- return '/';
-}
-
-FILE* OpenFile(int Fd, const char* Mode) {
- return fdopen(Fd, Mode);
-}
-
-int CloseFile(int fd) {
- return close(fd);
-}
-
-int DuplicateFile(int Fd) {
- return dup(Fd);
-}
-
-void RemoveFile(const std::string &Path) {
- unlink(Path.c_str());
-}
-
-void DiscardOutput(int Fd) {
- FILE* Temp = fopen("/dev/null", "w");
- if (!Temp)
- return;
- dup2(fileno(Temp), Fd);
- fclose(Temp);
-}
-
-intptr_t GetHandleFromFd(int fd) {
- return static_cast<intptr_t>(fd);
-}
-
-std::string DirName(const std::string &FileName) {
- char *Tmp = new char[FileName.size() + 1];
- memcpy(Tmp, FileName.c_str(), FileName.size() + 1);
- std::string Res = dirname(Tmp);
- delete [] Tmp;
- return Res;
-}
-
-std::string TmpDir() {
- if (auto Env = getenv("TMPDIR"))
- return Env;
- return "/tmp";
-}
-
-bool IsInterestingCoverageFile(const std::string &FileName) {
- if (FileName.find("compiler-rt/lib/") != std::string::npos)
- return false; // sanitizer internal.
- if (FileName.find("/usr/lib/") != std::string::npos)
- return false;
- if (FileName.find("/usr/include/") != std::string::npos)
- return false;
- if (FileName == "<null>")
- return false;
- return true;
-}
-
-
-void RawPrint(const char *Str) {
- write(2, Str, strlen(Str));
-}
-
-} // namespace fuzzer
-
-#endif // LIBFUZZER_POSIX
Removed: llvm/trunk/lib/Fuzzer/FuzzerIOWindows.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Fuzzer/FuzzerIOWindows.cpp?rev=315936&view=auto
==============================================================================
--- llvm/trunk/lib/Fuzzer/FuzzerIOWindows.cpp (original)
+++ llvm/trunk/lib/Fuzzer/FuzzerIOWindows.cpp (removed)
@@ -1,323 +0,0 @@
-//===- FuzzerIOWindows.cpp - IO utils for Windows. ------------------------===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-// IO functions implementation for Windows.
-//===----------------------------------------------------------------------===//
-#include "FuzzerDefs.h"
-#if LIBFUZZER_WINDOWS
-
-#include "FuzzerExtFunctions.h"
-#include "FuzzerIO.h"
-#include <cstdarg>
-#include <cstdio>
-#include <fstream>
-#include <io.h>
-#include <iterator>
-#include <sys/stat.h>
-#include <sys/types.h>
-#include <windows.h>
-
-namespace fuzzer {
-
-static bool IsFile(const std::string &Path, const DWORD &FileAttributes) {
-
- if (FileAttributes & FILE_ATTRIBUTE_NORMAL)
- return true;
-
- if (FileAttributes & FILE_ATTRIBUTE_DIRECTORY)
- return false;
-
- HANDLE FileHandle(
- CreateFileA(Path.c_str(), 0, FILE_SHARE_READ, NULL, OPEN_EXISTING,
- FILE_FLAG_BACKUP_SEMANTICS, 0));
-
- if (FileHandle == INVALID_HANDLE_VALUE) {
- Printf("CreateFileA() failed for \"%s\" (Error code: %lu).\n", Path.c_str(),
- GetLastError());
- return false;
- }
-
- DWORD FileType = GetFileType(FileHandle);
-
- if (FileType == FILE_TYPE_UNKNOWN) {
- Printf("GetFileType() failed for \"%s\" (Error code: %lu).\n", Path.c_str(),
- GetLastError());
- CloseHandle(FileHandle);
- return false;
- }
-
- if (FileType != FILE_TYPE_DISK) {
- CloseHandle(FileHandle);
- return false;
- }
-
- CloseHandle(FileHandle);
- return true;
-}
-
-bool IsFile(const std::string &Path) {
- DWORD Att = GetFileAttributesA(Path.c_str());
-
- if (Att == INVALID_FILE_ATTRIBUTES) {
- Printf("GetFileAttributesA() failed for \"%s\" (Error code: %lu).\n",
- Path.c_str(), GetLastError());
- return false;
- }
-
- return IsFile(Path, Att);
-}
-
-void ListFilesInDirRecursive(const std::string &Dir, long *Epoch,
- std::vector<std::string> *V, bool TopDir) {
- auto E = GetEpoch(Dir);
- if (Epoch)
- if (E && *Epoch >= E) return;
-
- std::string Path(Dir);
- assert(!Path.empty());
- if (Path.back() != '\\')
- Path.push_back('\\');
- Path.push_back('*');
-
- // Get the first directory entry.
- WIN32_FIND_DATAA FindInfo;
- HANDLE FindHandle(FindFirstFileA(Path.c_str(), &FindInfo));
- if (FindHandle == INVALID_HANDLE_VALUE)
- {
- if (GetLastError() == ERROR_FILE_NOT_FOUND)
- return;
- Printf("No such directory: %s; exiting\n", Dir.c_str());
- exit(1);
- }
-
- do {
- std::string FileName = DirPlusFile(Dir, FindInfo.cFileName);
-
- if (FindInfo.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
- size_t FilenameLen = strlen(FindInfo.cFileName);
- if ((FilenameLen == 1 && FindInfo.cFileName[0] == '.') ||
- (FilenameLen == 2 && FindInfo.cFileName[0] == '.' &&
- FindInfo.cFileName[1] == '.'))
- continue;
-
- ListFilesInDirRecursive(FileName, Epoch, V, false);
- }
- else if (IsFile(FileName, FindInfo.dwFileAttributes))
- V->push_back(FileName);
- } while (FindNextFileA(FindHandle, &FindInfo));
-
- DWORD LastError = GetLastError();
- if (LastError != ERROR_NO_MORE_FILES)
- Printf("FindNextFileA failed (Error code: %lu).\n", LastError);
-
- FindClose(FindHandle);
-
- if (Epoch && TopDir)
- *Epoch = E;
-}
-
-char GetSeparator() {
- return '\\';
-}
-
-FILE* OpenFile(int Fd, const char* Mode) {
- return _fdopen(Fd, Mode);
-}
-
-int CloseFile(int Fd) {
- return _close(Fd);
-}
-
-int DuplicateFile(int Fd) {
- return _dup(Fd);
-}
-
-void RemoveFile(const std::string &Path) {
- _unlink(Path.c_str());
-}
-
-void DiscardOutput(int Fd) {
- FILE* Temp = fopen("nul", "w");
- if (!Temp)
- return;
- _dup2(_fileno(Temp), Fd);
- fclose(Temp);
-}
-
-intptr_t GetHandleFromFd(int fd) {
- return _get_osfhandle(fd);
-}
-
-static bool IsSeparator(char C) {
- return C == '\\' || C == '/';
-}
-
-// Parse disk designators, like "C:\". If Relative == true, also accepts: "C:".
-// Returns number of characters considered if successful.
-static size_t ParseDrive(const std::string &FileName, const size_t Offset,
- bool Relative = true) {
- if (Offset + 1 >= FileName.size() || FileName[Offset + 1] != ':')
- return 0;
- if (Offset + 2 >= FileName.size() || !IsSeparator(FileName[Offset + 2])) {
- if (!Relative) // Accept relative path?
- return 0;
- else
- return 2;
- }
- return 3;
-}
-
-// Parse a file name, like: SomeFile.txt
-// Returns number of characters considered if successful.
-static size_t ParseFileName(const std::string &FileName, const size_t Offset) {
- size_t Pos = Offset;
- const size_t End = FileName.size();
- for(; Pos < End && !IsSeparator(FileName[Pos]); ++Pos)
- ;
- return Pos - Offset;
-}
-
-// Parse a directory ending in separator, like: `SomeDir\`
-// Returns number of characters considered if successful.
-static size_t ParseDir(const std::string &FileName, const size_t Offset) {
- size_t Pos = Offset;
- const size_t End = FileName.size();
- if (Pos >= End || IsSeparator(FileName[Pos]))
- return 0;
- for(; Pos < End && !IsSeparator(FileName[Pos]); ++Pos)
- ;
- if (Pos >= End)
- return 0;
- ++Pos; // Include separator.
- return Pos - Offset;
-}
-
-// Parse a servername and share, like: `SomeServer\SomeShare\`
-// Returns number of characters considered if successful.
-static size_t ParseServerAndShare(const std::string &FileName,
- const size_t Offset) {
- size_t Pos = Offset, Res;
- if (!(Res = ParseDir(FileName, Pos)))
- return 0;
- Pos += Res;
- if (!(Res = ParseDir(FileName, Pos)))
- return 0;
- Pos += Res;
- return Pos - Offset;
-}
-
-// Parse the given Ref string from the position Offset, to exactly match the given
-// string Patt.
-// Returns number of characters considered if successful.
-static size_t ParseCustomString(const std::string &Ref, size_t Offset,
- const char *Patt) {
- size_t Len = strlen(Patt);
- if (Offset + Len > Ref.size())
- return 0;
- return Ref.compare(Offset, Len, Patt) == 0 ? Len : 0;
-}
-
-// Parse a location, like:
-// \\?\UNC\Server\Share\ \\?\C:\ \\Server\Share\ \ C:\ C:
-// Returns number of characters considered if successful.
-static size_t ParseLocation(const std::string &FileName) {
- size_t Pos = 0, Res;
-
- if ((Res = ParseCustomString(FileName, Pos, R"(\\?\)"))) {
- Pos += Res;
- if ((Res = ParseCustomString(FileName, Pos, R"(UNC\)"))) {
- Pos += Res;
- if ((Res = ParseServerAndShare(FileName, Pos)))
- return Pos + Res;
- return 0;
- }
- if ((Res = ParseDrive(FileName, Pos, false)))
- return Pos + Res;
- return 0;
- }
-
- if (Pos < FileName.size() && IsSeparator(FileName[Pos])) {
- ++Pos;
- if (Pos < FileName.size() && IsSeparator(FileName[Pos])) {
- ++Pos;
- if ((Res = ParseServerAndShare(FileName, Pos)))
- return Pos + Res;
- return 0;
- }
- return Pos;
- }
-
- if ((Res = ParseDrive(FileName, Pos)))
- return Pos + Res;
-
- return Pos;
-}
-
-std::string DirName(const std::string &FileName) {
- size_t LocationLen = ParseLocation(FileName);
- size_t DirLen = 0, Res;
- while ((Res = ParseDir(FileName, LocationLen + DirLen)))
- DirLen += Res;
- size_t FileLen = ParseFileName(FileName, LocationLen + DirLen);
-
- if (LocationLen + DirLen + FileLen != FileName.size()) {
- Printf("DirName() failed for \"%s\", invalid path.\n", FileName.c_str());
- exit(1);
- }
-
- if (DirLen) {
- --DirLen; // Remove trailing separator.
- if (!FileLen) { // Path ended in separator.
- assert(DirLen);
- // Remove file name from Dir.
- while (DirLen && !IsSeparator(FileName[LocationLen + DirLen - 1]))
- --DirLen;
- if (DirLen) // Remove trailing separator.
- --DirLen;
- }
- }
-
- if (!LocationLen) { // Relative path.
- if (!DirLen)
- return ".";
- return std::string(".\\").append(FileName, 0, DirLen);
- }
-
- return FileName.substr(0, LocationLen + DirLen);
-}
-
-std::string TmpDir() {
- std::string Tmp;
- Tmp.resize(MAX_PATH + 1);
- DWORD Size = GetTempPathA(Tmp.size(), &Tmp[0]);
- if (Size == 0) {
- Printf("Couldn't get Tmp path.\n");
- exit(1);
- }
- Tmp.resize(Size);
- return Tmp;
-}
-
-bool IsInterestingCoverageFile(const std::string &FileName) {
- if (FileName.find("Program Files") != std::string::npos)
- return false;
- if (FileName.find("compiler-rt\\lib\\") != std::string::npos)
- return false; // sanitizer internal.
- if (FileName == "<null>")
- return false;
- return true;
-}
-
-void RawPrint(const char *Str) {
- // Not tested, may or may not work. Fix if needed.
- Printf("%s", Str);
-}
-
-} // namespace fuzzer
-
-#endif // LIBFUZZER_WINDOWS
Removed: llvm/trunk/lib/Fuzzer/FuzzerInterface.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Fuzzer/FuzzerInterface.h?rev=315936&view=auto
==============================================================================
--- llvm/trunk/lib/Fuzzer/FuzzerInterface.h (original)
+++ llvm/trunk/lib/Fuzzer/FuzzerInterface.h (removed)
@@ -1,67 +0,0 @@
-//===- FuzzerInterface.h - Interface 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.
-//
-//===----------------------------------------------------------------------===//
-// Define the interface between libFuzzer and the library being tested.
-//===----------------------------------------------------------------------===//
-
-// NOTE: the libFuzzer interface is thin and in the majority of cases
-// you should not include this file into your target. In 95% of cases
-// all you need is to define the following function in your file:
-// extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size);
-
-// WARNING: keep the interface in C.
-
-#ifndef LLVM_FUZZER_INTERFACE_H
-#define LLVM_FUZZER_INTERFACE_H
-
-#include <stddef.h>
-#include <stdint.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif // __cplusplus
-
-// Mandatory user-provided target function.
-// Executes the code under test with [Data, Data+Size) as the input.
-// libFuzzer will invoke this function *many* times with different inputs.
-// Must return 0.
-int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size);
-
-// Optional user-provided initialization function.
-// If provided, this function will be called by libFuzzer once at startup.
-// It may read and modify argc/argv.
-// Must return 0.
-int LLVMFuzzerInitialize(int *argc, char ***argv);
-
-// Optional user-provided custom mutator.
-// Mutates raw data in [Data, Data+Size) inplace.
-// Returns the new size, which is not greater than MaxSize.
-// Given the same Seed produces the same mutation.
-size_t LLVMFuzzerCustomMutator(uint8_t *Data, size_t Size, size_t MaxSize,
- unsigned int Seed);
-
-// Optional user-provided custom cross-over function.
-// Combines pieces of Data1 & Data2 together into Out.
-// Returns the new size, which is not greater than MaxOutSize.
-// Should produce the same mutation given the same Seed.
-size_t LLVMFuzzerCustomCrossOver(const uint8_t *Data1, size_t Size1,
- const uint8_t *Data2, size_t Size2,
- uint8_t *Out, size_t MaxOutSize,
- unsigned int Seed);
-
-// Experimental, may go away in future.
-// libFuzzer-provided function to be used inside LLVMFuzzerCustomMutator.
-// Mutates raw data in [Data, Data+Size) inplace.
-// Returns the new size, which is not greater than MaxSize.
-size_t LLVMFuzzerMutate(uint8_t *Data, size_t Size, size_t MaxSize);
-
-#ifdef __cplusplus
-} // extern "C"
-#endif // __cplusplus
-
-#endif // LLVM_FUZZER_INTERFACE_H
Removed: llvm/trunk/lib/Fuzzer/FuzzerInternal.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Fuzzer/FuzzerInternal.h?rev=315936&view=auto
==============================================================================
--- llvm/trunk/lib/Fuzzer/FuzzerInternal.h (original)
+++ llvm/trunk/lib/Fuzzer/FuzzerInternal.h (removed)
@@ -1,150 +0,0 @@
-//===- FuzzerInternal.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.
-//
-//===----------------------------------------------------------------------===//
-// Define the main class fuzzer::Fuzzer and most functions.
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_FUZZER_INTERNAL_H
-#define LLVM_FUZZER_INTERNAL_H
-
-#include "FuzzerDefs.h"
-#include "FuzzerExtFunctions.h"
-#include "FuzzerInterface.h"
-#include "FuzzerOptions.h"
-#include "FuzzerSHA1.h"
-#include "FuzzerValueBitMap.h"
-#include <algorithm>
-#include <atomic>
-#include <chrono>
-#include <climits>
-#include <cstdlib>
-#include <string.h>
-
-namespace fuzzer {
-
-using namespace std::chrono;
-
-class Fuzzer {
-public:
-
- Fuzzer(UserCallback CB, InputCorpus &Corpus, MutationDispatcher &MD,
- FuzzingOptions Options);
- ~Fuzzer();
- void Loop();
- void MinimizeCrashLoop(const Unit &U);
- void ShuffleAndMinimize(UnitVector *V);
- void RereadOutputCorpus(size_t MaxSize);
-
- size_t secondsSinceProcessStartUp() {
- return duration_cast<seconds>(system_clock::now() - ProcessStartTime)
- .count();
- }
-
- bool TimedOut() {
- return Options.MaxTotalTimeSec > 0 &&
- secondsSinceProcessStartUp() >
- static_cast<size_t>(Options.MaxTotalTimeSec);
- }
-
- size_t execPerSec() {
- size_t Seconds = secondsSinceProcessStartUp();
- return Seconds ? TotalNumberOfRuns / Seconds : 0;
- }
-
- size_t getTotalNumberOfRuns() { return TotalNumberOfRuns; }
-
- static void StaticAlarmCallback();
- static void StaticCrashSignalCallback();
- static void StaticExitCallback();
- static void StaticInterruptCallback();
- static void StaticFileSizeExceedCallback();
-
- void ExecuteCallback(const uint8_t *Data, size_t Size);
- bool RunOne(const uint8_t *Data, size_t Size, bool MayDeleteFile = false,
- InputInfo *II = nullptr);
-
- // Merge Corpora[1:] into Corpora[0].
- void Merge(const std::vector<std::string> &Corpora);
- void CrashResistantMerge(const std::vector<std::string> &Args,
- const std::vector<std::string> &Corpora,
- const char *CoverageSummaryInputPathOrNull,
- const char *CoverageSummaryOutputPathOrNull);
- void CrashResistantMergeInternalStep(const std::string &ControlFilePath);
- MutationDispatcher &GetMD() { return MD; }
- void PrintFinalStats();
- void SetMaxInputLen(size_t MaxInputLen);
- void SetMaxMutationLen(size_t MaxMutationLen);
- void RssLimitCallback();
-
- bool InFuzzingThread() const { return IsMyThread; }
- size_t GetCurrentUnitInFuzzingThead(const uint8_t **Data) const;
- void TryDetectingAMemoryLeak(const uint8_t *Data, size_t Size,
- bool DuringInitialCorpusExecution);
-
- void HandleMalloc(size_t Size);
- void AnnounceOutput(const uint8_t *Data, size_t Size);
-
-private:
- void AlarmCallback();
- void CrashCallback();
- void ExitCallback();
- void CrashOnOverwrittenData();
- void InterruptCallback();
- void MutateAndTestOne();
- void ReportNewCoverage(InputInfo *II, const Unit &U);
- void PrintPulseAndReportSlowInput(const uint8_t *Data, size_t Size);
- void WriteToOutputCorpus(const Unit &U);
- void WriteUnitToFileWithPrefix(const Unit &U, const char *Prefix);
- void PrintStats(const char *Where, const char *End = "\n", size_t Units = 0);
- void PrintStatusForNewUnit(const Unit &U, const char *Text);
- void ShuffleCorpus(UnitVector *V);
- void CheckExitOnSrcPosOrItem();
-
- static void StaticDeathCallback();
- void DumpCurrentUnit(const char *Prefix);
- void DeathCallback();
-
- void AllocateCurrentUnitData();
- uint8_t *CurrentUnitData = nullptr;
- std::atomic<size_t> CurrentUnitSize;
- uint8_t BaseSha1[kSHA1NumBytes]; // Checksum of the base unit.
- bool RunningCB = false;
-
- size_t TotalNumberOfRuns = 0;
- size_t NumberOfNewUnitsAdded = 0;
-
- size_t LastCorpusUpdateRun = 0;
- system_clock::time_point LastCorpusUpdateTime = system_clock::now();
-
-
- bool HasMoreMallocsThanFrees = false;
- size_t NumberOfLeakDetectionAttempts = 0;
-
- UserCallback CB;
- InputCorpus &Corpus;
- MutationDispatcher &MD;
- FuzzingOptions Options;
-
- system_clock::time_point ProcessStartTime = system_clock::now();
- system_clock::time_point UnitStartTime, UnitStopTime;
- long TimeOfLongestUnitInSeconds = 0;
- long EpochOfLastReadOfOutputCorpus = 0;
-
- size_t MaxInputLen = 0;
- size_t MaxMutationLen = 0;
- size_t TmpMaxMutationLen = 0;
-
- std::vector<uint32_t> UniqFeatureSetTmp;
-
- // Need to know our own thread.
- static thread_local bool IsMyThread;
-};
-
-} // namespace fuzzer
-
-#endif // LLVM_FUZZER_INTERNAL_H
Removed: llvm/trunk/lib/Fuzzer/FuzzerLoop.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Fuzzer/FuzzerLoop.cpp?rev=315936&view=auto
==============================================================================
--- llvm/trunk/lib/Fuzzer/FuzzerLoop.cpp (original)
+++ llvm/trunk/lib/Fuzzer/FuzzerLoop.cpp (removed)
@@ -1,722 +0,0 @@
-//===- FuzzerLoop.cpp - Fuzzer's main loop --------------------------------===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-// Fuzzer's main loop.
-//===----------------------------------------------------------------------===//
-
-#include "FuzzerCorpus.h"
-#include "FuzzerIO.h"
-#include "FuzzerInternal.h"
-#include "FuzzerMutate.h"
-#include "FuzzerRandom.h"
-#include "FuzzerShmem.h"
-#include "FuzzerTracePC.h"
-#include <algorithm>
-#include <cstring>
-#include <memory>
-#include <set>
-
-#if defined(__has_include)
-#if __has_include(<sanitizer / lsan_interface.h>)
-#include <sanitizer/lsan_interface.h>
-#endif
-#endif
-
-#define NO_SANITIZE_MEMORY
-#if defined(__has_feature)
-#if __has_feature(memory_sanitizer)
-#undef NO_SANITIZE_MEMORY
-#define NO_SANITIZE_MEMORY __attribute__((no_sanitize_memory))
-#endif
-#endif
-
-namespace fuzzer {
-static const size_t kMaxUnitSizeToPrint = 256;
-
-thread_local bool Fuzzer::IsMyThread;
-
-SharedMemoryRegion SMR;
-
-// Only one Fuzzer per process.
-static Fuzzer *F;
-
-// Leak detection is expensive, so we first check if there were more mallocs
-// than frees (using the sanitizer malloc hooks) and only then try to call lsan.
-struct MallocFreeTracer {
- void Start(int TraceLevel) {
- this->TraceLevel = TraceLevel;
- if (TraceLevel)
- Printf("MallocFreeTracer: START\n");
- Mallocs = 0;
- Frees = 0;
- }
- // Returns true if there were more mallocs than frees.
- bool Stop() {
- if (TraceLevel)
- Printf("MallocFreeTracer: STOP %zd %zd (%s)\n", Mallocs.load(),
- Frees.load(), Mallocs == Frees ? "same" : "DIFFERENT");
- bool Result = Mallocs > Frees;
- Mallocs = 0;
- Frees = 0;
- TraceLevel = 0;
- return Result;
- }
- std::atomic<size_t> Mallocs;
- std::atomic<size_t> Frees;
- int TraceLevel = 0;
-};
-
-static MallocFreeTracer AllocTracer;
-
-ATTRIBUTE_NO_SANITIZE_MEMORY
-void MallocHook(const volatile void *ptr, size_t size) {
- size_t N = AllocTracer.Mallocs++;
- F->HandleMalloc(size);
- if (int TraceLevel = AllocTracer.TraceLevel) {
- Printf("MALLOC[%zd] %p %zd\n", N, ptr, size);
- if (TraceLevel >= 2 && EF)
- EF->__sanitizer_print_stack_trace();
- }
-}
-
-ATTRIBUTE_NO_SANITIZE_MEMORY
-void FreeHook(const volatile void *ptr) {
- size_t N = AllocTracer.Frees++;
- if (int TraceLevel = AllocTracer.TraceLevel) {
- Printf("FREE[%zd] %p\n", N, ptr);
- if (TraceLevel >= 2 && EF)
- EF->__sanitizer_print_stack_trace();
- }
-}
-
-// Crash on a single malloc that exceeds the rss limit.
-void Fuzzer::HandleMalloc(size_t Size) {
- if (!Options.RssLimitMb || (Size >> 20) < (size_t)Options.RssLimitMb)
- return;
- Printf("==%d== ERROR: libFuzzer: out-of-memory (malloc(%zd))\n", GetPid(),
- Size);
- Printf(" To change the out-of-memory limit use -rss_limit_mb=<N>\n\n");
- if (EF->__sanitizer_print_stack_trace)
- EF->__sanitizer_print_stack_trace();
- DumpCurrentUnit("oom-");
- Printf("SUMMARY: libFuzzer: out-of-memory\n");
- PrintFinalStats();
- _Exit(Options.ErrorExitCode); // Stop right now.
-}
-
-Fuzzer::Fuzzer(UserCallback CB, InputCorpus &Corpus, MutationDispatcher &MD,
- FuzzingOptions Options)
- : CB(CB), Corpus(Corpus), MD(MD), Options(Options) {
- if (EF->__sanitizer_set_death_callback)
- EF->__sanitizer_set_death_callback(StaticDeathCallback);
- assert(!F);
- F = this;
- TPC.ResetMaps();
- IsMyThread = true;
- if (Options.DetectLeaks && EF->__sanitizer_install_malloc_and_free_hooks)
- EF->__sanitizer_install_malloc_and_free_hooks(MallocHook, FreeHook);
- TPC.SetUseCounters(Options.UseCounters);
- TPC.SetUseValueProfile(Options.UseValueProfile);
-
- if (Options.Verbosity)
- TPC.PrintModuleInfo();
- if (!Options.OutputCorpus.empty() && Options.ReloadIntervalSec)
- EpochOfLastReadOfOutputCorpus = GetEpoch(Options.OutputCorpus);
- MaxInputLen = MaxMutationLen = Options.MaxLen;
- TmpMaxMutationLen = Max(size_t(4), Corpus.MaxInputSize());
- AllocateCurrentUnitData();
- CurrentUnitSize = 0;
- memset(BaseSha1, 0, sizeof(BaseSha1));
-}
-
-Fuzzer::~Fuzzer() { }
-
-void Fuzzer::AllocateCurrentUnitData() {
- if (CurrentUnitData || MaxInputLen == 0) return;
- CurrentUnitData = new uint8_t[MaxInputLen];
-}
-
-void Fuzzer::StaticDeathCallback() {
- assert(F);
- F->DeathCallback();
-}
-
-void Fuzzer::DumpCurrentUnit(const char *Prefix) {
- if (!CurrentUnitData) return; // Happens when running individual inputs.
- MD.PrintMutationSequence();
- Printf("; base unit: %s\n", Sha1ToString(BaseSha1).c_str());
- size_t UnitSize = CurrentUnitSize;
- if (UnitSize <= kMaxUnitSizeToPrint) {
- PrintHexArray(CurrentUnitData, UnitSize, "\n");
- PrintASCII(CurrentUnitData, UnitSize, "\n");
- }
- WriteUnitToFileWithPrefix({CurrentUnitData, CurrentUnitData + UnitSize},
- Prefix);
-}
-
-NO_SANITIZE_MEMORY
-void Fuzzer::DeathCallback() {
- DumpCurrentUnit("crash-");
- PrintFinalStats();
-}
-
-void Fuzzer::StaticAlarmCallback() {
- assert(F);
- F->AlarmCallback();
-}
-
-void Fuzzer::StaticCrashSignalCallback() {
- assert(F);
- F->CrashCallback();
-}
-
-void Fuzzer::StaticExitCallback() {
- assert(F);
- F->ExitCallback();
-}
-
-void Fuzzer::StaticInterruptCallback() {
- assert(F);
- F->InterruptCallback();
-}
-
-void Fuzzer::StaticFileSizeExceedCallback() {
- Printf("==%lu== ERROR: libFuzzer: file size exceeded\n", GetPid());
- exit(1);
-}
-
-void Fuzzer::CrashCallback() {
- Printf("==%lu== ERROR: libFuzzer: deadly signal\n", GetPid());
- if (EF->__sanitizer_print_stack_trace)
- EF->__sanitizer_print_stack_trace();
- Printf("NOTE: libFuzzer has rudimentary signal handlers.\n"
- " Combine libFuzzer with AddressSanitizer or similar for better "
- "crash reports.\n");
- Printf("SUMMARY: libFuzzer: deadly signal\n");
- DumpCurrentUnit("crash-");
- PrintFinalStats();
- _Exit(Options.ErrorExitCode); // Stop right now.
-}
-
-void Fuzzer::ExitCallback() {
- if (!RunningCB)
- return; // This exit did not come from the user callback
- Printf("==%lu== ERROR: libFuzzer: fuzz target exited\n", GetPid());
- if (EF->__sanitizer_print_stack_trace)
- EF->__sanitizer_print_stack_trace();
- Printf("SUMMARY: libFuzzer: fuzz target exited\n");
- DumpCurrentUnit("crash-");
- PrintFinalStats();
- _Exit(Options.ErrorExitCode);
-}
-
-
-void Fuzzer::InterruptCallback() {
- Printf("==%lu== libFuzzer: run interrupted; exiting\n", GetPid());
- PrintFinalStats();
- _Exit(0); // Stop right now, don't perform any at-exit actions.
-}
-
-NO_SANITIZE_MEMORY
-void Fuzzer::AlarmCallback() {
- assert(Options.UnitTimeoutSec > 0);
- // In Windows Alarm callback is executed by a different thread.
-#if !LIBFUZZER_WINDOWS
- if (!InFuzzingThread()) return;
-#endif
- if (!RunningCB)
- return; // We have not started running units yet.
- size_t Seconds =
- duration_cast<seconds>(system_clock::now() - UnitStartTime).count();
- if (Seconds == 0)
- return;
- if (Options.Verbosity >= 2)
- Printf("AlarmCallback %zd\n", Seconds);
- if (Seconds >= (size_t)Options.UnitTimeoutSec) {
- Printf("ALARM: working on the last Unit for %zd seconds\n", Seconds);
- Printf(" and the timeout value is %d (use -timeout=N to change)\n",
- Options.UnitTimeoutSec);
- DumpCurrentUnit("timeout-");
- Printf("==%lu== ERROR: libFuzzer: timeout after %d seconds\n", GetPid(),
- Seconds);
- if (EF->__sanitizer_print_stack_trace)
- EF->__sanitizer_print_stack_trace();
- Printf("SUMMARY: libFuzzer: timeout\n");
- PrintFinalStats();
- _Exit(Options.TimeoutExitCode); // Stop right now.
- }
-}
-
-void Fuzzer::RssLimitCallback() {
- Printf(
- "==%lu== ERROR: libFuzzer: out-of-memory (used: %zdMb; limit: %zdMb)\n",
- GetPid(), GetPeakRSSMb(), Options.RssLimitMb);
- Printf(" To change the out-of-memory limit use -rss_limit_mb=<N>\n\n");
- if (EF->__sanitizer_print_memory_profile)
- EF->__sanitizer_print_memory_profile(95, 8);
- DumpCurrentUnit("oom-");
- Printf("SUMMARY: libFuzzer: out-of-memory\n");
- PrintFinalStats();
- _Exit(Options.ErrorExitCode); // Stop right now.
-}
-
-void Fuzzer::PrintStats(const char *Where, const char *End, size_t Units) {
- size_t ExecPerSec = execPerSec();
- if (!Options.Verbosity)
- return;
- Printf("#%zd\t%s", TotalNumberOfRuns, Where);
- if (size_t N = TPC.GetTotalPCCoverage())
- Printf(" cov: %zd", N);
- if (size_t N = Corpus.NumFeatures())
- Printf( " ft: %zd", N);
- if (!Corpus.empty()) {
- Printf(" corp: %zd", Corpus.NumActiveUnits());
- if (size_t N = Corpus.SizeInBytes()) {
- if (N < (1<<14))
- Printf("/%zdb", N);
- else if (N < (1 << 24))
- Printf("/%zdKb", N >> 10);
- else
- Printf("/%zdMb", N >> 20);
- }
- }
- if (Units)
- Printf(" units: %zd", Units);
-
- Printf(" exec/s: %zd", ExecPerSec);
- Printf(" rss: %zdMb", GetPeakRSSMb());
- Printf("%s", End);
-}
-
-void Fuzzer::PrintFinalStats() {
- if (Options.PrintCoverage)
- TPC.PrintCoverage();
- if (Options.DumpCoverage)
- TPC.DumpCoverage();
- if (Options.PrintCorpusStats)
- Corpus.PrintStats();
- if (!Options.PrintFinalStats) return;
- size_t ExecPerSec = execPerSec();
- Printf("stat::number_of_executed_units: %zd\n", TotalNumberOfRuns);
- Printf("stat::average_exec_per_sec: %zd\n", ExecPerSec);
- Printf("stat::new_units_added: %zd\n", NumberOfNewUnitsAdded);
- Printf("stat::slowest_unit_time_sec: %zd\n", TimeOfLongestUnitInSeconds);
- Printf("stat::peak_rss_mb: %zd\n", GetPeakRSSMb());
-}
-
-void Fuzzer::SetMaxInputLen(size_t MaxInputLen) {
- assert(this->MaxInputLen == 0); // Can only reset MaxInputLen from 0 to non-0.
- assert(MaxInputLen);
- this->MaxInputLen = MaxInputLen;
- this->MaxMutationLen = MaxInputLen;
- AllocateCurrentUnitData();
- Printf("INFO: -max_len is not provided; "
- "libFuzzer will not generate inputs larger than %zd bytes\n",
- MaxInputLen);
-}
-
-void Fuzzer::SetMaxMutationLen(size_t MaxMutationLen) {
- assert(MaxMutationLen && MaxMutationLen <= MaxInputLen);
- this->MaxMutationLen = MaxMutationLen;
-}
-
-void Fuzzer::CheckExitOnSrcPosOrItem() {
- if (!Options.ExitOnSrcPos.empty()) {
- static auto *PCsSet = new std::set<uintptr_t>;
- auto HandlePC = [&](uintptr_t PC) {
- if (!PCsSet->insert(PC).second) return;
- std::string Descr = DescribePC("%F %L", PC + 1);
- if (Descr.find(Options.ExitOnSrcPos) != std::string::npos) {
- Printf("INFO: found line matching '%s', exiting.\n",
- Options.ExitOnSrcPos.c_str());
- _Exit(0);
- }
- };
- TPC.ForEachObservedPC(HandlePC);
- }
- if (!Options.ExitOnItem.empty()) {
- if (Corpus.HasUnit(Options.ExitOnItem)) {
- Printf("INFO: found item with checksum '%s', exiting.\n",
- Options.ExitOnItem.c_str());
- _Exit(0);
- }
- }
-}
-
-void Fuzzer::RereadOutputCorpus(size_t MaxSize) {
- if (Options.OutputCorpus.empty() || !Options.ReloadIntervalSec) return;
- std::vector<Unit> AdditionalCorpus;
- ReadDirToVectorOfUnits(Options.OutputCorpus.c_str(), &AdditionalCorpus,
- &EpochOfLastReadOfOutputCorpus, MaxSize,
- /*ExitOnError*/ false);
- if (Options.Verbosity >= 2)
- Printf("Reload: read %zd new units.\n", AdditionalCorpus.size());
- bool Reloaded = false;
- for (auto &U : AdditionalCorpus) {
- if (U.size() > MaxSize)
- U.resize(MaxSize);
- if (!Corpus.HasUnit(U)) {
- if (RunOne(U.data(), U.size())) {
- CheckExitOnSrcPosOrItem();
- Reloaded = true;
- }
- }
- }
- if (Reloaded)
- PrintStats("RELOAD");
-}
-
-void Fuzzer::ShuffleCorpus(UnitVector *V) {
- std::shuffle(V->begin(), V->end(), MD.GetRand());
- if (Options.PreferSmall)
- std::stable_sort(V->begin(), V->end(), [](const Unit &A, const Unit &B) {
- return A.size() < B.size();
- });
-}
-
-void Fuzzer::ShuffleAndMinimize(UnitVector *InitialCorpus) {
- Printf("#0\tREAD units: %zd\n", InitialCorpus->size());
- if (Options.ShuffleAtStartUp)
- ShuffleCorpus(InitialCorpus);
-
- // Test the callback with empty input and never try it again.
- uint8_t dummy;
- ExecuteCallback(&dummy, 0);
-
- for (auto &U : *InitialCorpus) {
- RunOne(U.data(), U.size());
- CheckExitOnSrcPosOrItem();
- TryDetectingAMemoryLeak(U.data(), U.size(),
- /*DuringInitialCorpusExecution*/ true);
- U.clear();
- }
- PrintStats("INITED");
- if (Corpus.empty()) {
- Printf("ERROR: no interesting inputs were found. "
- "Is the code instrumented for coverage? Exiting.\n");
- exit(1);
- }
-}
-
-void Fuzzer::PrintPulseAndReportSlowInput(const uint8_t *Data, size_t Size) {
- auto TimeOfUnit =
- duration_cast<seconds>(UnitStopTime - UnitStartTime).count();
- if (!(TotalNumberOfRuns & (TotalNumberOfRuns - 1)) &&
- secondsSinceProcessStartUp() >= 2)
- PrintStats("pulse ");
- if (TimeOfUnit > TimeOfLongestUnitInSeconds * 1.1 &&
- TimeOfUnit >= Options.ReportSlowUnits) {
- TimeOfLongestUnitInSeconds = TimeOfUnit;
- Printf("Slowest unit: %zd s:\n", TimeOfLongestUnitInSeconds);
- WriteUnitToFileWithPrefix({Data, Data + Size}, "slow-unit-");
- }
-}
-
-bool Fuzzer::RunOne(const uint8_t *Data, size_t Size, bool MayDeleteFile,
- InputInfo *II) {
- if (!Size) return false;
-
- ExecuteCallback(Data, Size);
-
- UniqFeatureSetTmp.clear();
- size_t FoundUniqFeaturesOfII = 0;
- size_t NumUpdatesBefore = Corpus.NumFeatureUpdates();
- TPC.CollectFeatures([&](size_t 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++;
- });
- PrintPulseAndReportSlowInput(Data, Size);
- size_t NumNewFeatures = Corpus.NumFeatureUpdates() - NumUpdatesBefore;
- if (NumNewFeatures) {
- TPC.UpdateObservedPCs();
- Corpus.AddToCorpus({Data, Data + Size}, NumNewFeatures, MayDeleteFile,
- UniqFeatureSetTmp);
- return true;
- }
- if (II && FoundUniqFeaturesOfII &&
- FoundUniqFeaturesOfII == II->UniqFeatureSet.size() &&
- II->U.size() > Size) {
- Corpus.Replace(II, {Data, Data + Size});
- return true;
- }
- return false;
-}
-
-size_t Fuzzer::GetCurrentUnitInFuzzingThead(const uint8_t **Data) const {
- assert(InFuzzingThread());
- *Data = CurrentUnitData;
- return CurrentUnitSize;
-}
-
-void Fuzzer::CrashOnOverwrittenData() {
- Printf("==%d== ERROR: libFuzzer: fuzz target overwrites it's const input\n",
- GetPid());
- DumpCurrentUnit("crash-");
- Printf("SUMMARY: libFuzzer: out-of-memory\n");
- _Exit(Options.ErrorExitCode); // Stop right now.
-}
-
-// Compare two arrays, but not all bytes if the arrays are large.
-static bool LooseMemeq(const uint8_t *A, const uint8_t *B, size_t Size) {
- const size_t Limit = 64;
- if (Size <= 64)
- return !memcmp(A, B, Size);
- // Compare first and last Limit/2 bytes.
- return !memcmp(A, B, Limit / 2) &&
- !memcmp(A + Size - Limit / 2, B + Size - Limit / 2, Limit / 2);
-}
-
-void Fuzzer::ExecuteCallback(const uint8_t *Data, size_t Size) {
- TPC.RecordInitialStack();
- TotalNumberOfRuns++;
- assert(InFuzzingThread());
- if (SMR.IsClient())
- SMR.WriteByteArray(Data, Size);
- // We copy the contents of Unit into a separate heap buffer
- // so that we reliably find buffer overflows in it.
- uint8_t *DataCopy = new uint8_t[Size];
- memcpy(DataCopy, Data, Size);
- if (CurrentUnitData && CurrentUnitData != Data)
- memcpy(CurrentUnitData, Data, Size);
- CurrentUnitSize = Size;
- AllocTracer.Start(Options.TraceMalloc);
- UnitStartTime = system_clock::now();
- TPC.ResetMaps();
- RunningCB = true;
- int Res = CB(DataCopy, Size);
- RunningCB = false;
- UnitStopTime = system_clock::now();
- (void)Res;
- assert(Res == 0);
- HasMoreMallocsThanFrees = AllocTracer.Stop();
- if (!LooseMemeq(DataCopy, Data, Size))
- CrashOnOverwrittenData();
- CurrentUnitSize = 0;
- delete[] DataCopy;
-}
-
-void Fuzzer::WriteToOutputCorpus(const Unit &U) {
- if (Options.OnlyASCII)
- assert(IsASCII(U));
- if (Options.OutputCorpus.empty())
- return;
- std::string Path = DirPlusFile(Options.OutputCorpus, Hash(U));
- WriteToFile(U, Path);
- if (Options.Verbosity >= 2)
- Printf("Written %zd bytes to %s\n", U.size(), Path.c_str());
-}
-
-void Fuzzer::WriteUnitToFileWithPrefix(const Unit &U, const char *Prefix) {
- if (!Options.SaveArtifacts)
- return;
- std::string Path = Options.ArtifactPrefix + Prefix + Hash(U);
- if (!Options.ExactArtifactPath.empty())
- Path = Options.ExactArtifactPath; // Overrides ArtifactPrefix.
- WriteToFile(U, Path);
- Printf("artifact_prefix='%s'; Test unit written to %s\n",
- Options.ArtifactPrefix.c_str(), Path.c_str());
- if (U.size() <= kMaxUnitSizeToPrint)
- Printf("Base64: %s\n", Base64(U).c_str());
-}
-
-void Fuzzer::PrintStatusForNewUnit(const Unit &U, const char *Text) {
- if (!Options.PrintNEW)
- return;
- PrintStats(Text, "");
- if (Options.Verbosity) {
- Printf(" L: %zd/%zd ", U.size(), Corpus.MaxInputSize());
- MD.PrintMutationSequence();
- Printf("\n");
- }
-}
-
-void Fuzzer::ReportNewCoverage(InputInfo *II, const Unit &U) {
- II->NumSuccessfullMutations++;
- MD.RecordSuccessfulMutationSequence();
- PrintStatusForNewUnit(U, II->Reduced ? "REDUCE" :
- "NEW ");
- WriteToOutputCorpus(U);
- NumberOfNewUnitsAdded++;
- CheckExitOnSrcPosOrItem(); // Check only after the unit is saved to corpus.
- LastCorpusUpdateRun = TotalNumberOfRuns;
- LastCorpusUpdateTime = system_clock::now();
-}
-
-// Tries detecting a memory leak on the particular input that we have just
-// executed before calling this function.
-void Fuzzer::TryDetectingAMemoryLeak(const uint8_t *Data, size_t Size,
- bool DuringInitialCorpusExecution) {
- if (!HasMoreMallocsThanFrees) return; // mallocs==frees, a leak is unlikely.
- if (!Options.DetectLeaks) return;
- if (!&(EF->__lsan_enable) || !&(EF->__lsan_disable) ||
- !(EF->__lsan_do_recoverable_leak_check))
- return; // No lsan.
- // Run the target once again, but with lsan disabled so that if there is
- // a real leak we do not report it twice.
- EF->__lsan_disable();
- ExecuteCallback(Data, Size);
- EF->__lsan_enable();
- if (!HasMoreMallocsThanFrees) return; // a leak is unlikely.
- if (NumberOfLeakDetectionAttempts++ > 1000) {
- Options.DetectLeaks = false;
- Printf("INFO: libFuzzer disabled leak detection after every mutation.\n"
- " Most likely the target function accumulates allocated\n"
- " memory in a global state w/o actually leaking it.\n"
- " You may try running this binary with -trace_malloc=[12]"
- " to get a trace of mallocs and frees.\n"
- " If LeakSanitizer is enabled in this process it will still\n"
- " run on the process shutdown.\n");
- return;
- }
- // Now perform the actual lsan pass. This is expensive and we must ensure
- // we don't call it too often.
- if (EF->__lsan_do_recoverable_leak_check()) { // Leak is found, report it.
- if (DuringInitialCorpusExecution)
- Printf("\nINFO: a leak has been found in the initial corpus.\n\n");
- Printf("INFO: to ignore leaks on libFuzzer side use -detect_leaks=0.\n\n");
- CurrentUnitSize = Size;
- DumpCurrentUnit("leak-");
- PrintFinalStats();
- _Exit(Options.ErrorExitCode); // not exit() to disable lsan further on.
- }
-}
-
-void Fuzzer::MutateAndTestOne() {
- MD.StartMutationSequence();
-
- auto &II = Corpus.ChooseUnitToMutate(MD.GetRand());
- const auto &U = II.U;
- memcpy(BaseSha1, II.Sha1, sizeof(BaseSha1));
- assert(CurrentUnitData);
- size_t Size = U.size();
- assert(Size <= MaxInputLen && "Oversized Unit");
- memcpy(CurrentUnitData, U.data(), Size);
-
- assert(MaxMutationLen > 0);
-
- size_t CurrentMaxMutationLen =
- Min(MaxMutationLen, Max(U.size(), TmpMaxMutationLen));
- assert(CurrentMaxMutationLen > 0);
-
- for (int i = 0; i < Options.MutateDepth; i++) {
- if (TotalNumberOfRuns >= Options.MaxNumberOfRuns)
- break;
- size_t NewSize = 0;
- NewSize = MD.Mutate(CurrentUnitData, Size, CurrentMaxMutationLen);
- assert(NewSize > 0 && "Mutator returned empty unit");
- assert(NewSize <= CurrentMaxMutationLen && "Mutator return overisized unit");
- Size = NewSize;
- II.NumExecutedMutations++;
- if (RunOne(CurrentUnitData, Size, /*MayDeleteFile=*/true, &II))
- ReportNewCoverage(&II, {CurrentUnitData, CurrentUnitData + Size});
-
- TryDetectingAMemoryLeak(CurrentUnitData, Size,
- /*DuringInitialCorpusExecution*/ false);
- }
-}
-
-void Fuzzer::Loop() {
- TPC.SetPrintNewPCs(Options.PrintNewCovPcs);
- system_clock::time_point LastCorpusReload = system_clock::now();
- 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)
- break;
- if (TimedOut()) break;
-
- // Update TmpMaxMutationLen
- if (Options.ExperimentalLenControl) {
- if (TmpMaxMutationLen < MaxMutationLen &&
- (TotalNumberOfRuns - LastCorpusUpdateRun > 1000 &&
- duration_cast<seconds>(Now - LastCorpusUpdateTime).count() >= 1)) {
- LastCorpusUpdateRun = TotalNumberOfRuns;
- LastCorpusUpdateTime = Now;
- TmpMaxMutationLen =
- Min(MaxMutationLen,
- TmpMaxMutationLen + Max(size_t(4), TmpMaxMutationLen / 8));
- if (TmpMaxMutationLen <= MaxMutationLen)
- Printf("#%zd\tTEMP_MAX_LEN: %zd\n", TotalNumberOfRuns,
- TmpMaxMutationLen);
- }
- } else {
- TmpMaxMutationLen = MaxMutationLen;
- }
-
- // Perform several mutations and runs.
- MutateAndTestOne();
- }
-
- PrintStats("DONE ", "\n");
- MD.PrintRecommendedDictionary();
-}
-
-void Fuzzer::MinimizeCrashLoop(const Unit &U) {
- if (U.size() <= 1) return;
- while (!TimedOut() && TotalNumberOfRuns < Options.MaxNumberOfRuns) {
- MD.StartMutationSequence();
- memcpy(CurrentUnitData, U.data(), U.size());
- for (int i = 0; i < Options.MutateDepth; i++) {
- size_t NewSize = MD.Mutate(CurrentUnitData, U.size(), MaxMutationLen);
- assert(NewSize > 0 && NewSize <= MaxMutationLen);
- ExecuteCallback(CurrentUnitData, NewSize);
- PrintPulseAndReportSlowInput(CurrentUnitData, NewSize);
- TryDetectingAMemoryLeak(CurrentUnitData, NewSize,
- /*DuringInitialCorpusExecution*/ false);
- }
- }
-}
-
-void Fuzzer::AnnounceOutput(const uint8_t *Data, size_t Size) {
- if (SMR.IsServer()) {
- SMR.WriteByteArray(Data, Size);
- } else if (SMR.IsClient()) {
- SMR.PostClient();
- SMR.WaitServer();
- size_t OtherSize = SMR.ReadByteArraySize();
- uint8_t *OtherData = SMR.GetByteArray();
- if (Size != OtherSize || memcmp(Data, OtherData, Size) != 0) {
- size_t i = 0;
- for (i = 0; i < Min(Size, OtherSize); i++)
- if (Data[i] != OtherData[i])
- break;
- Printf("==%lu== ERROR: libFuzzer: equivalence-mismatch. Sizes: %zd %zd; "
- "offset %zd\n", GetPid(), Size, OtherSize, i);
- DumpCurrentUnit("mismatch-");
- Printf("SUMMARY: libFuzzer: equivalence-mismatch\n");
- PrintFinalStats();
- _Exit(Options.ErrorExitCode);
- }
- }
-}
-
-} // namespace fuzzer
-
-extern "C" {
-
-size_t LLVMFuzzerMutate(uint8_t *Data, size_t Size, size_t MaxSize) {
- assert(fuzzer::F);
- return fuzzer::F->GetMD().DefaultMutate(Data, Size, MaxSize);
-}
-
-// Experimental
-void LLVMFuzzerAnnounceOutput(const uint8_t *Data, size_t Size) {
- assert(fuzzer::F);
- fuzzer::F->AnnounceOutput(Data, Size);
-}
-} // extern "C"
Removed: llvm/trunk/lib/Fuzzer/FuzzerMain.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Fuzzer/FuzzerMain.cpp?rev=315936&view=auto
==============================================================================
--- llvm/trunk/lib/Fuzzer/FuzzerMain.cpp (original)
+++ llvm/trunk/lib/Fuzzer/FuzzerMain.cpp (removed)
@@ -1,21 +0,0 @@
-//===- FuzzerMain.cpp - main() function and flags -------------------------===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-// main() and flags.
-//===----------------------------------------------------------------------===//
-
-#include "FuzzerDefs.h"
-
-extern "C" {
-// This function should be defined by the user.
-int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size);
-} // extern "C"
-
-int main(int argc, char **argv) {
- return fuzzer::FuzzerDriver(&argc, &argv, LLVMFuzzerTestOneInput);
-}
Removed: llvm/trunk/lib/Fuzzer/FuzzerMerge.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Fuzzer/FuzzerMerge.cpp?rev=315936&view=auto
==============================================================================
--- llvm/trunk/lib/Fuzzer/FuzzerMerge.cpp (original)
+++ llvm/trunk/lib/Fuzzer/FuzzerMerge.cpp (removed)
@@ -1,338 +0,0 @@
-//===- FuzzerMerge.cpp - merging corpora ----------------------------------===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-// Merging corpora.
-//===----------------------------------------------------------------------===//
-
-#include "FuzzerMerge.h"
-#include "FuzzerIO.h"
-#include "FuzzerInternal.h"
-#include "FuzzerTracePC.h"
-#include "FuzzerUtil.h"
-
-#include <fstream>
-#include <iterator>
-#include <set>
-#include <sstream>
-
-namespace fuzzer {
-
-bool Merger::Parse(const std::string &Str, bool ParseCoverage) {
- std::istringstream SS(Str);
- return Parse(SS, ParseCoverage);
-}
-
-void Merger::ParseOrExit(std::istream &IS, bool ParseCoverage) {
- if (!Parse(IS, ParseCoverage)) {
- Printf("MERGE: failed to parse the control file (unexpected error)\n");
- exit(1);
- }
-}
-
-// The control file example:
-//
-// 3 # The number of inputs
-// 1 # The number of inputs in the first corpus, <= the previous number
-// file0
-// file1
-// file2 # One file name per line.
-// STARTED 0 123 # FileID, file size
-// DONE 0 1 4 6 8 # FileID COV1 COV2 ...
-// STARTED 1 456 # If DONE is missing, the input crashed while processing.
-// STARTED 2 567
-// DONE 2 8 9
-bool Merger::Parse(std::istream &IS, bool ParseCoverage) {
- LastFailure.clear();
- std::string Line;
-
- // Parse NumFiles.
- if (!std::getline(IS, Line, '\n')) return false;
- std::istringstream L1(Line);
- size_t NumFiles = 0;
- L1 >> NumFiles;
- if (NumFiles == 0 || NumFiles > 10000000) return false;
-
- // Parse NumFilesInFirstCorpus.
- if (!std::getline(IS, Line, '\n')) return false;
- std::istringstream L2(Line);
- NumFilesInFirstCorpus = NumFiles + 1;
- L2 >> NumFilesInFirstCorpus;
- if (NumFilesInFirstCorpus > NumFiles) return false;
-
- // Parse file names.
- Files.resize(NumFiles);
- for (size_t i = 0; i < NumFiles; i++)
- if (!std::getline(IS, Files[i].Name, '\n'))
- return false;
-
- // Parse STARTED and DONE lines.
- size_t ExpectedStartMarker = 0;
- const size_t kInvalidStartMarker = -1;
- size_t LastSeenStartMarker = kInvalidStartMarker;
- std::vector<uint32_t> TmpFeatures;
- while (std::getline(IS, Line, '\n')) {
- std::istringstream ISS1(Line);
- std::string Marker;
- size_t N;
- ISS1 >> Marker;
- ISS1 >> N;
- if (Marker == "STARTED") {
- // STARTED FILE_ID FILE_SIZE
- if (ExpectedStartMarker != N)
- return false;
- ISS1 >> Files[ExpectedStartMarker].Size;
- LastSeenStartMarker = ExpectedStartMarker;
- assert(ExpectedStartMarker < Files.size());
- ExpectedStartMarker++;
- } else if (Marker == "DONE") {
- // DONE FILE_ID COV1 COV2 COV3 ...
- size_t CurrentFileIdx = N;
- if (CurrentFileIdx != LastSeenStartMarker)
- return false;
- LastSeenStartMarker = kInvalidStartMarker;
- if (ParseCoverage) {
- TmpFeatures.clear(); // use a vector from outer scope to avoid resizes.
- while (ISS1 >> std::hex >> N)
- TmpFeatures.push_back(N);
- std::sort(TmpFeatures.begin(), TmpFeatures.end());
- Files[CurrentFileIdx].Features = TmpFeatures;
- }
- } else {
- return false;
- }
- }
- if (LastSeenStartMarker != kInvalidStartMarker)
- LastFailure = Files[LastSeenStartMarker].Name;
-
- FirstNotProcessedFile = ExpectedStartMarker;
- return true;
-}
-
-size_t Merger::ApproximateMemoryConsumption() const {
- size_t Res = 0;
- for (const auto &F: Files)
- Res += sizeof(F) + F.Features.size() * sizeof(F.Features[0]);
- return Res;
-}
-
-// Decides which files need to be merged (add thost to NewFiles).
-// Returns the number of new features added.
-size_t Merger::Merge(const std::set<uint32_t> &InitialFeatures,
- std::vector<std::string> *NewFiles) {
- NewFiles->clear();
- assert(NumFilesInFirstCorpus <= Files.size());
- std::set<uint32_t> AllFeatures(InitialFeatures);
-
- // What features are in the initial corpus?
- for (size_t i = 0; i < NumFilesInFirstCorpus; i++) {
- auto &Cur = Files[i].Features;
- AllFeatures.insert(Cur.begin(), Cur.end());
- }
- size_t InitialNumFeatures = AllFeatures.size();
-
- // Remove all features that we already know from all other inputs.
- for (size_t i = NumFilesInFirstCorpus; i < Files.size(); i++) {
- auto &Cur = Files[i].Features;
- std::vector<uint32_t> Tmp;
- std::set_difference(Cur.begin(), Cur.end(), AllFeatures.begin(),
- AllFeatures.end(), std::inserter(Tmp, Tmp.begin()));
- Cur.swap(Tmp);
- }
-
- // Sort. Give preference to
- // * smaller files
- // * files with more features.
- std::sort(Files.begin() + NumFilesInFirstCorpus, Files.end(),
- [&](const MergeFileInfo &a, const MergeFileInfo &b) -> bool {
- if (a.Size != b.Size)
- return a.Size < b.Size;
- return a.Features.size() > b.Features.size();
- });
-
- // One greedy pass: add the file's features to AllFeatures.
- // If new features were added, add this file to NewFiles.
- for (size_t i = NumFilesInFirstCorpus; i < Files.size(); i++) {
- auto &Cur = Files[i].Features;
- // Printf("%s -> sz %zd ft %zd\n", Files[i].Name.c_str(),
- // Files[i].Size, Cur.size());
- size_t OldSize = AllFeatures.size();
- AllFeatures.insert(Cur.begin(), Cur.end());
- if (AllFeatures.size() > OldSize)
- NewFiles->push_back(Files[i].Name);
- }
- return AllFeatures.size() - InitialNumFeatures;
-}
-
-void Merger::PrintSummary(std::ostream &OS) {
- for (auto &File : Files) {
- OS << std::hex;
- OS << File.Name << " size: " << File.Size << " features: ";
- for (auto Feature : File.Features)
- OS << " " << Feature;
- OS << "\n";
- }
-}
-
-std::set<uint32_t> Merger::AllFeatures() const {
- std::set<uint32_t> S;
- for (auto &File : Files)
- S.insert(File.Features.begin(), File.Features.end());
- return S;
-}
-
-std::set<uint32_t> Merger::ParseSummary(std::istream &IS) {
- std::string Line, Tmp;
- std::set<uint32_t> Res;
- while (std::getline(IS, Line, '\n')) {
- size_t N;
- std::istringstream ISS1(Line);
- ISS1 >> Tmp; // Name
- ISS1 >> Tmp; // size:
- assert(Tmp == "size:" && "Corrupt summary file");
- ISS1 >> std::hex;
- ISS1 >> N; // File Size
- ISS1 >> Tmp; // features:
- assert(Tmp == "features:" && "Corrupt summary file");
- while (ISS1 >> std::hex >> N)
- Res.insert(N);
- }
- return Res;
-}
-
-// Inner process. May crash if the target crashes.
-void Fuzzer::CrashResistantMergeInternalStep(const std::string &CFPath) {
- Printf("MERGE-INNER: using the control file '%s'\n", CFPath.c_str());
- Merger M;
- std::ifstream IF(CFPath);
- M.ParseOrExit(IF, false);
- IF.close();
- if (!M.LastFailure.empty())
- Printf("MERGE-INNER: '%s' caused a failure at the previous merge step\n",
- M.LastFailure.c_str());
-
- Printf("MERGE-INNER: %zd total files;"
- " %zd processed earlier; will process %zd files now\n",
- M.Files.size(), M.FirstNotProcessedFile,
- M.Files.size() - M.FirstNotProcessedFile);
-
- std::ofstream OF(CFPath, std::ofstream::out | std::ofstream::app);
- for (size_t i = M.FirstNotProcessedFile; i < M.Files.size(); i++) {
- auto U = FileToVector(M.Files[i].Name);
- if (U.size() > MaxInputLen) {
- U.resize(MaxInputLen);
- U.shrink_to_fit();
- }
- std::ostringstream StartedLine;
- // Write the pre-run marker.
- OF << "STARTED " << std::dec << i << " " << U.size() << "\n";
- OF.flush(); // Flush is important since ExecuteCommand may crash.
- // Run.
- TPC.ResetMaps();
- ExecuteCallback(U.data(), U.size());
- // Collect coverage.
- std::set<size_t> Features;
- TPC.CollectFeatures([&](size_t Feature) -> bool {
- Features.insert(Feature);
- return true;
- });
- // Show stats.
- if (!(TotalNumberOfRuns & (TotalNumberOfRuns - 1)))
- PrintStats("pulse ");
- // Write the post-run marker and the coverage.
- OF << "DONE " << i;
- for (size_t F : Features)
- OF << " " << std::hex << F;
- OF << "\n";
- }
-}
-
-// Outer process. Does not call the target code and thus sohuld not fail.
-void Fuzzer::CrashResistantMerge(const std::vector<std::string> &Args,
- const std::vector<std::string> &Corpora,
- const char *CoverageSummaryInputPathOrNull,
- const char *CoverageSummaryOutputPathOrNull) {
- if (Corpora.size() <= 1) {
- Printf("Merge requires two or more corpus dirs\n");
- return;
- }
- std::vector<std::string> AllFiles;
- ListFilesInDirRecursive(Corpora[0], nullptr, &AllFiles, /*TopDir*/true);
- size_t NumFilesInFirstCorpus = AllFiles.size();
- for (size_t i = 1; i < Corpora.size(); i++)
- ListFilesInDirRecursive(Corpora[i], nullptr, &AllFiles, /*TopDir*/true);
- Printf("MERGE-OUTER: %zd files, %zd in the initial corpus\n",
- AllFiles.size(), NumFilesInFirstCorpus);
- auto CFPath = DirPlusFile(TmpDir(),
- "libFuzzerTemp." + std::to_string(GetPid()) + ".txt");
- // Write the control file.
- RemoveFile(CFPath);
- std::ofstream ControlFile(CFPath);
- ControlFile << AllFiles.size() << "\n";
- ControlFile << NumFilesInFirstCorpus << "\n";
- for (auto &Path: AllFiles)
- ControlFile << Path << "\n";
- if (!ControlFile) {
- Printf("MERGE-OUTER: failed to write to the control file: %s\n",
- CFPath.c_str());
- exit(1);
- }
- ControlFile.close();
-
- // Execute the inner process untill it passes.
- // Every inner process should execute at least one input.
- auto BaseCmd = SplitBefore("-ignore_remaining_args=1",
- CloneArgsWithoutX(Args, "keep-all-flags"));
- bool Success = false;
- for (size_t i = 1; i <= AllFiles.size(); i++) {
- Printf("MERGE-OUTER: attempt %zd\n", i);
- auto ExitCode = ExecuteCommand(BaseCmd.first + " -merge_control_file=" +
- CFPath + " " + BaseCmd.second);
- if (!ExitCode) {
- Printf("MERGE-OUTER: succesfull in %zd attempt(s)\n", i);
- Success = true;
- break;
- }
- }
- if (!Success) {
- Printf("MERGE-OUTER: zero succesfull attempts, exiting\n");
- exit(1);
- }
- // Read the control file and do the merge.
- Merger M;
- std::ifstream IF(CFPath);
- IF.seekg(0, IF.end);
- Printf("MERGE-OUTER: the control file has %zd bytes\n", (size_t)IF.tellg());
- IF.seekg(0, IF.beg);
- M.ParseOrExit(IF, true);
- IF.close();
- Printf("MERGE-OUTER: consumed %zdMb (%zdMb rss) to parse the control file\n",
- M.ApproximateMemoryConsumption() >> 20, GetPeakRSSMb());
- if (CoverageSummaryOutputPathOrNull) {
- Printf("MERGE-OUTER: writing coverage summary for %zd files to %s\n",
- M.Files.size(), CoverageSummaryOutputPathOrNull);
- std::ofstream SummaryOut(CoverageSummaryOutputPathOrNull);
- M.PrintSummary(SummaryOut);
- }
- std::vector<std::string> NewFiles;
- std::set<uint32_t> InitialFeatures;
- if (CoverageSummaryInputPathOrNull) {
- std::ifstream SummaryIn(CoverageSummaryInputPathOrNull);
- InitialFeatures = M.ParseSummary(SummaryIn);
- Printf("MERGE-OUTER: coverage summary loaded from %s, %zd features found\n",
- CoverageSummaryInputPathOrNull, InitialFeatures.size());
- }
- size_t NumNewFeatures = M.Merge(InitialFeatures, &NewFiles);
- Printf("MERGE-OUTER: %zd new files with %zd new features added\n",
- NewFiles.size(), NumNewFeatures);
- for (auto &F: NewFiles)
- WriteToOutputCorpus(FileToVector(F));
- // We are done, delete the control file.
- RemoveFile(CFPath);
-}
-
-} // namespace fuzzer
Removed: llvm/trunk/lib/Fuzzer/FuzzerMerge.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Fuzzer/FuzzerMerge.h?rev=315936&view=auto
==============================================================================
--- llvm/trunk/lib/Fuzzer/FuzzerMerge.h (original)
+++ llvm/trunk/lib/Fuzzer/FuzzerMerge.h (removed)
@@ -1,80 +0,0 @@
-//===- FuzzerMerge.h - merging corpa ----------------------------*- C++ -* ===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-// Merging Corpora.
-//
-// The task:
-// Take the existing corpus (possibly empty) and merge new inputs into
-// it so that only inputs with new coverage ('features') are added.
-// The process should tolerate the crashes, OOMs, leaks, etc.
-//
-// Algorithm:
-// The outter process collects the set of files and writes their names
-// into a temporary "control" file, then repeatedly launches the inner
-// process until all inputs are processed.
-// The outer process does not actually execute the target code.
-//
-// The inner process reads the control file and sees a) list of all the inputs
-// and b) the last processed input. Then it starts processing the inputs one
-// by one. Before processing every input it writes one line to control file:
-// STARTED INPUT_ID INPUT_SIZE
-// After processing an input it write another line:
-// DONE INPUT_ID Feature1 Feature2 Feature3 ...
-// If a crash happens while processing an input the last line in the control
-// file will be "STARTED INPUT_ID" and so the next process will know
-// where to resume.
-//
-// Once all inputs are processed by the innner process(es) the outer process
-// reads the control files and does the merge based entirely on the contents
-// of control file.
-// It uses a single pass greedy algorithm choosing first the smallest inputs
-// within the same size the inputs that have more new features.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_FUZZER_MERGE_H
-#define LLVM_FUZZER_MERGE_H
-
-#include "FuzzerDefs.h"
-
-#include <istream>
-#include <ostream>
-#include <set>
-#include <vector>
-
-namespace fuzzer {
-
-struct MergeFileInfo {
- std::string Name;
- size_t Size = 0;
- std::vector<uint32_t> Features;
-};
-
-struct Merger {
- std::vector<MergeFileInfo> Files;
- size_t NumFilesInFirstCorpus = 0;
- size_t FirstNotProcessedFile = 0;
- std::string LastFailure;
-
- bool Parse(std::istream &IS, bool ParseCoverage);
- bool Parse(const std::string &Str, bool ParseCoverage);
- void ParseOrExit(std::istream &IS, bool ParseCoverage);
- void PrintSummary(std::ostream &OS);
- std::set<uint32_t> ParseSummary(std::istream &IS);
- size_t Merge(const std::set<uint32_t> &InitialFeatures,
- std::vector<std::string> *NewFiles);
- size_t Merge(std::vector<std::string> *NewFiles) {
- return Merge(std::set<uint32_t>{}, NewFiles);
- }
- size_t ApproximateMemoryConsumption() const;
- std::set<uint32_t> AllFeatures() const;
-};
-
-} // namespace fuzzer
-
-#endif // LLVM_FUZZER_MERGE_H
Removed: llvm/trunk/lib/Fuzzer/FuzzerMutate.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Fuzzer/FuzzerMutate.cpp?rev=315936&view=auto
==============================================================================
--- llvm/trunk/lib/Fuzzer/FuzzerMutate.cpp (original)
+++ llvm/trunk/lib/Fuzzer/FuzzerMutate.cpp (removed)
@@ -1,533 +0,0 @@
-//===- FuzzerMutate.cpp - Mutate a test input -----------------------------===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-// Mutate a test input.
-//===----------------------------------------------------------------------===//
-
-#include "FuzzerMutate.h"
-#include "FuzzerCorpus.h"
-#include "FuzzerDefs.h"
-#include "FuzzerExtFunctions.h"
-#include "FuzzerIO.h"
-#include "FuzzerOptions.h"
-
-namespace fuzzer {
-
-const size_t Dictionary::kMaxDictSize;
-
-static void PrintASCII(const Word &W, const char *PrintAfter) {
- PrintASCII(W.data(), W.size(), PrintAfter);
-}
-
-MutationDispatcher::MutationDispatcher(Random &Rand,
- const FuzzingOptions &Options)
- : Rand(Rand), Options(Options) {
- DefaultMutators.insert(
- DefaultMutators.begin(),
- {
- {&MutationDispatcher::Mutate_EraseBytes, "EraseBytes"},
- {&MutationDispatcher::Mutate_InsertByte, "InsertByte"},
- {&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_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, "Custom"});
- else
- Mutators = DefaultMutators;
-
- if (EF->LLVMFuzzerCustomCrossOver)
- Mutators.push_back(
- {&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_Custom(uint8_t *Data, size_t Size,
- size_t MaxSize) {
- return EF->LLVMFuzzerCustomMutator(Data, Size, MaxSize, Rand.Rand());
-}
-
-size_t MutationDispatcher::Mutate_CustomCrossOver(uint8_t *Data, size_t Size,
- size_t MaxSize) {
- if (!Corpus || Corpus->size() < 2 || Size == 0)
- return 0;
- size_t Idx = Rand(Corpus->size());
- const Unit &Other = (*Corpus)[Idx];
- if (Other.empty())
- return 0;
- 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);
- 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 ShuffleStart = Rand(Size - ShuffleAmount);
- assert(ShuffleStart + ShuffleAmount <= Size);
- std::shuffle(Data + ShuffleStart, Data + ShuffleStart + ShuffleAmount, Rand);
- return Size;
-}
-
-size_t MutationDispatcher::Mutate_EraseBytes(uint8_t *Data, size_t Size,
- size_t MaxSize) {
- if (Size <= 1) return 0;
- size_t N = Rand(Size / 2) + 1;
- assert(N < Size);
- size_t Idx = Rand(Size - N + 1);
- // Erase Data[Idx:Idx+N].
- memmove(Data + Idx, Data + Idx + N, Size - Idx - N);
- // Printf("Erase: %zd %zd => %zd; Idx %zd\n", N, Size, Size - N, Idx);
- return Size - N;
-}
-
-size_t MutationDispatcher::Mutate_InsertByte(uint8_t *Data, size_t Size,
- size_t MaxSize) {
- if (Size >= MaxSize) return 0;
- size_t Idx = Rand(Size + 1);
- // Insert new value at Data[Idx].
- memmove(Data + Idx + 1, Data + Idx, Size - Idx);
- Data[Idx] = RandCh(Rand);
- return Size + 1;
-}
-
-size_t MutationDispatcher::Mutate_InsertRepeatedBytes(uint8_t *Data,
- size_t Size,
- size_t MaxSize) {
- const size_t kMinBytesToInsert = 3;
- if (Size + kMinBytesToInsert >= MaxSize) return 0;
- size_t MaxBytesToInsert = std::min(MaxSize - Size, (size_t)128);
- size_t N = Rand(MaxBytesToInsert - kMinBytesToInsert + 1) + kMinBytesToInsert;
- assert(Size + N <= MaxSize && N);
- size_t Idx = Rand(Size + 1);
- // Insert new values at Data[Idx].
- memmove(Data + Idx + N, Data + Idx, Size - Idx);
- // Give preference to 0x00 and 0xff.
- uint8_t Byte = Rand.RandBool() ? Rand(256) : (Rand.RandBool() ? 0 : 255);
- for (size_t i = 0; i < N; i++)
- Data[Idx + i] = Byte;
- return Size + N;
-}
-
-size_t MutationDispatcher::Mutate_ChangeByte(uint8_t *Data, size_t Size,
- size_t MaxSize) {
- if (Size > MaxSize) return 0;
- size_t Idx = Rand(Size);
- Data[Idx] = RandCh(Rand);
- return Size;
-}
-
-size_t MutationDispatcher::Mutate_ChangeBit(uint8_t *Data, size_t Size,
- size_t MaxSize) {
- if (Size > MaxSize) return 0;
- size_t Idx = Rand(Size);
- Data[Idx] ^= 1 << Rand(8);
- return Size;
-}
-
-size_t MutationDispatcher::Mutate_AddWordFromManualDictionary(uint8_t *Data,
- size_t Size,
- size_t MaxSize) {
- return AddWordFromDictionary(ManualDictionary, Data, Size, MaxSize);
-}
-
-size_t MutationDispatcher::ApplyDictionaryEntry(uint8_t *Data, size_t Size,
- size_t MaxSize,
- DictionaryEntry &DE) {
- const Word &W = DE.GetW();
- bool UsePositionHint = DE.HasPositionHint() &&
- DE.GetPositionHint() + W.size() < Size &&
- Rand.RandBool();
- if (Rand.RandBool()) { // Insert W.
- if (Size + W.size() > MaxSize) return 0;
- size_t Idx = UsePositionHint ? DE.GetPositionHint() : Rand(Size + 1);
- memmove(Data + Idx + W.size(), Data + Idx, Size - Idx);
- memcpy(Data + Idx, W.data(), W.size());
- Size += W.size();
- } else { // Overwrite some bytes with W.
- if (W.size() > Size) return 0;
- size_t Idx = UsePositionHint ? DE.GetPositionHint() : Rand(Size - W.size());
- memcpy(Data + Idx, W.data(), W.size());
- }
- return Size;
-}
-
-// Somewhere in the past we have observed a comparison instructions
-// with arguments Arg1 Arg2. This function tries to guess a dictionary
-// entry that will satisfy that comparison.
-// It first tries to find one of the arguments (possibly swapped) in the
-// input and if it succeeds it creates a DE with a position hint.
-// Otherwise it creates a DE with one of the arguments w/o a position hint.
-DictionaryEntry MutationDispatcher::MakeDictionaryEntryFromCMP(
- const void *Arg1, const void *Arg2,
- const void *Arg1Mutation, const void *Arg2Mutation,
- size_t ArgSize, const uint8_t *Data,
- size_t Size) {
- ScopedDoingMyOwnMemOrStr scoped_doing_my_own_mem_os_str;
- bool HandleFirst = Rand.RandBool();
- const void *ExistingBytes, *DesiredBytes;
- Word W;
- const uint8_t *End = Data + Size;
- for (int Arg = 0; Arg < 2; Arg++) {
- ExistingBytes = HandleFirst ? Arg1 : Arg2;
- DesiredBytes = HandleFirst ? Arg2Mutation : Arg1Mutation;
- HandleFirst = !HandleFirst;
- W.Set(reinterpret_cast<const uint8_t*>(DesiredBytes), ArgSize);
- const size_t kMaxNumPositions = 8;
- size_t Positions[kMaxNumPositions];
- size_t NumPositions = 0;
- for (const uint8_t *Cur = Data;
- Cur < End && NumPositions < kMaxNumPositions; Cur++) {
- Cur =
- (const uint8_t *)SearchMemory(Cur, End - Cur, ExistingBytes, ArgSize);
- if (!Cur) break;
- Positions[NumPositions++] = Cur - Data;
- }
- if (!NumPositions) continue;
- return DictionaryEntry(W, Positions[Rand(NumPositions)]);
- }
- DictionaryEntry DE(W);
- return DE;
-}
-
-
-template <class T>
-DictionaryEntry MutationDispatcher::MakeDictionaryEntryFromCMP(
- T Arg1, T Arg2, const uint8_t *Data, size_t Size) {
- if (Rand.RandBool()) Arg1 = Bswap(Arg1);
- if (Rand.RandBool()) Arg2 = Bswap(Arg2);
- T Arg1Mutation = Arg1 + Rand(-1, 1);
- T Arg2Mutation = Arg2 + Rand(-1, 1);
- return MakeDictionaryEntryFromCMP(&Arg1, &Arg2, &Arg1Mutation, &Arg2Mutation,
- sizeof(Arg1), Data, Size);
-}
-
-DictionaryEntry MutationDispatcher::MakeDictionaryEntryFromCMP(
- const Word &Arg1, const Word &Arg2, const uint8_t *Data, size_t Size) {
- return MakeDictionaryEntryFromCMP(Arg1.data(), Arg2.data(), Arg1.data(),
- Arg2.data(), Arg1.size(), Data, Size);
-}
-
-size_t MutationDispatcher::Mutate_AddWordFromTORC(
- uint8_t *Data, size_t Size, size_t MaxSize) {
- Word W;
- DictionaryEntry DE;
- switch (Rand(4)) {
- case 0: {
- auto X = TPC.TORC8.Get(Rand.Rand());
- DE = MakeDictionaryEntryFromCMP(X.A, X.B, Data, Size);
- } break;
- case 1: {
- auto X = TPC.TORC4.Get(Rand.Rand());
- if ((X.A >> 16) == 0 && (X.B >> 16) == 0 && Rand.RandBool())
- DE = MakeDictionaryEntryFromCMP((uint16_t)X.A, (uint16_t)X.B, Data, Size);
- else
- DE = MakeDictionaryEntryFromCMP(X.A, X.B, Data, Size);
- } break;
- case 2: {
- auto X = TPC.TORCW.Get(Rand.Rand());
- DE = MakeDictionaryEntryFromCMP(X.A, X.B, Data, Size);
- } break;
- case 3: if (Options.UseMemmem) {
- auto X = TPC.MMT.Get(Rand.Rand());
- DE = DictionaryEntry(X);
- } break;
- default:
- assert(0);
- }
- if (!DE.GetW().size()) return 0;
- Size = ApplyDictionaryEntry(Data, Size, MaxSize, DE);
- if (!Size) return 0;
- DictionaryEntry &DERef =
- CmpDictionaryEntriesDeque[CmpDictionaryEntriesDequeIdx++ %
- kCmpDictionaryEntriesDequeSize];
- DERef = DE;
- CurrentDictionaryEntrySequence.push_back(&DERef);
- return Size;
-}
-
-size_t MutationDispatcher::Mutate_AddWordFromPersistentAutoDictionary(
- uint8_t *Data, size_t Size, size_t MaxSize) {
- return AddWordFromDictionary(PersistentAutoDictionary, Data, Size, MaxSize);
-}
-
-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).
- size_t ToBeg = Rand(ToSize);
- size_t CopySize = Rand(ToSize - ToBeg) + 1;
- assert(ToBeg + CopySize <= ToSize);
- CopySize = std::min(CopySize, FromSize);
- size_t FromBeg = Rand(FromSize - CopySize + 1);
- assert(FromBeg + CopySize <= FromSize);
- memmove(To + ToBeg, From + FromBeg, CopySize);
- return ToSize;
-}
-
-// Inserts part of From[0,ToSize) into To.
-// Returns new size of To on success or 0 on failure.
-size_t MutationDispatcher::InsertPartOf(const uint8_t *From, size_t FromSize,
- uint8_t *To, size_t ToSize,
- size_t MaxToSize) {
- if (ToSize >= MaxToSize) return 0;
- size_t AvailableSpace = MaxToSize - ToSize;
- size_t MaxCopySize = std::min(AvailableSpace, FromSize);
- size_t CopySize = Rand(MaxCopySize) + 1;
- size_t FromBeg = Rand(FromSize - CopySize + 1);
- assert(FromBeg + CopySize <= FromSize);
- size_t ToInsertPos = Rand(ToSize + 1);
- assert(ToInsertPos + CopySize <= MaxToSize);
- size_t TailSize = ToSize - ToInsertPos;
- if (To == From) {
- MutateInPlaceHere.resize(MaxToSize);
- memcpy(MutateInPlaceHere.data(), From + FromBeg, CopySize);
- memmove(To + ToInsertPos + CopySize, To + ToInsertPos, TailSize);
- memmove(To + ToInsertPos, MutateInPlaceHere.data(), CopySize);
- } else {
- memmove(To + ToInsertPos + CopySize, To + ToInsertPos, TailSize);
- memmove(To + ToInsertPos, From + FromBeg, CopySize);
- }
- return ToSize + CopySize;
-}
-
-size_t MutationDispatcher::Mutate_CopyPart(uint8_t *Data, size_t Size,
- size_t MaxSize) {
- if (Size > MaxSize || Size == 0) return 0;
- if (Rand.RandBool())
- return CopyPartOf(Data, Size, Data, Size);
- else
- return InsertPartOf(Data, Size, Data, Size, MaxSize);
-}
-
-size_t MutationDispatcher::Mutate_ChangeASCIIInteger(uint8_t *Data, size_t Size,
- size_t MaxSize) {
- if (Size > MaxSize) return 0;
- size_t B = Rand(Size);
- while (B < Size && !isdigit(Data[B])) B++;
- if (B == Size) return 0;
- size_t E = B;
- while (E < Size && isdigit(Data[E])) E++;
- assert(B < E);
- // now we have digits in [B, E).
- // strtol and friends don't accept non-zero-teminated data, parse it manually.
- uint64_t Val = Data[B] - '0';
- for (size_t i = B + 1; i < E; i++)
- Val = Val * 10 + Data[i] - '0';
-
- // Mutate the integer value.
- switch(Rand(5)) {
- case 0: Val++; break;
- case 1: Val--; break;
- case 2: Val /= 2; break;
- case 3: Val *= 2; break;
- case 4: Val = Rand(Val * Val); break;
- default: assert(0);
- }
- // Just replace the bytes with the new ones, don't bother moving bytes.
- for (size_t i = B; i < E; i++) {
- size_t Idx = E + B - i - 1;
- assert(Idx >= B && Idx < E);
- Data[Idx] = (Val % 10) + '0';
- Val /= 10;
- }
- return Size;
-}
-
-template<class T>
-size_t ChangeBinaryInteger(uint8_t *Data, size_t Size, Random &Rand) {
- if (Size < sizeof(T)) return 0;
- size_t Off = Rand(Size - sizeof(T) + 1);
- assert(Off + sizeof(T) <= Size);
- T Val;
- if (Off < 64 && !Rand(4)) {
- Val = Size;
- if (Rand.RandBool())
- Val = Bswap(Val);
- } else {
- memcpy(&Val, Data + Off, sizeof(Val));
- T Add = Rand(21);
- Add -= 10;
- if (Rand.RandBool())
- Val = Bswap(T(Bswap(Val) + Add)); // Add assuming different endiannes.
- else
- Val = Val + Add; // Add assuming current endiannes.
- if (Add == 0 || Rand.RandBool()) // Maybe negate.
- Val = -Val;
- }
- memcpy(Data + Off, &Val, sizeof(Val));
- return Size;
-}
-
-size_t MutationDispatcher::Mutate_ChangeBinaryInteger(uint8_t *Data,
- size_t Size,
- size_t MaxSize) {
- if (Size > MaxSize) return 0;
- switch (Rand(4)) {
- case 3: return ChangeBinaryInteger<uint64_t>(Data, Size, Rand);
- case 2: return ChangeBinaryInteger<uint32_t>(Data, Size, Rand);
- case 1: return ChangeBinaryInteger<uint16_t>(Data, Size, Rand);
- case 0: return ChangeBinaryInteger<uint8_t>(Data, Size, Rand);
- default: assert(0);
- }
- return 0;
-}
-
-size_t MutationDispatcher::Mutate_CrossOver(uint8_t *Data, size_t Size,
- size_t MaxSize) {
- if (Size > MaxSize) return 0;
- if (!Corpus || Corpus->size() < 2 || Size == 0) return 0;
- size_t Idx = Rand(Corpus->size());
- const Unit &O = (*Corpus)[Idx];
- if (O.empty()) return 0;
- MutateInPlaceHere.resize(MaxSize);
- auto &U = MutateInPlaceHere;
- size_t NewSize = 0;
- switch(Rand(3)) {
- case 0:
- NewSize = CrossOver(Data, Size, O.data(), O.size(), U.data(), U.size());
- break;
- case 1:
- NewSize = InsertPartOf(O.data(), O.size(), U.data(), U.size(), MaxSize);
- if (!NewSize)
- NewSize = CopyPartOf(O.data(), O.size(), U.data(), U.size());
- break;
- 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);
- return NewSize;
-}
-
-void MutationDispatcher::StartMutationSequence() {
- CurrentMutatorSequence.clear();
- CurrentDictionaryEntrySequence.clear();
-}
-
-// Copy successful dictionary entries to PersistentAutoDictionary.
-void MutationDispatcher::RecordSuccessfulMutationSequence() {
- for (auto DE : CurrentDictionaryEntrySequence) {
- // PersistentAutoDictionary.AddWithSuccessCountOne(DE);
- DE->IncSuccessCount();
- assert(DE->GetW().size());
- // Linear search is fine here as this happens seldom.
- if (!PersistentAutoDictionary.ContainsWord(DE->GetW()))
- PersistentAutoDictionary.push_back({DE->GetW(), 1});
- }
-}
-
-void MutationDispatcher::PrintRecommendedDictionary() {
- std::vector<DictionaryEntry> V;
- for (auto &DE : PersistentAutoDictionary)
- if (!ManualDictionary.ContainsWord(DE.GetW()))
- V.push_back(DE);
- if (V.empty()) return;
- Printf("###### Recommended dictionary. ######\n");
- for (auto &DE: V) {
- assert(DE.GetW().size());
- Printf("\"");
- PrintASCII(DE.GetW(), "\"");
- Printf(" # Uses: %zd\n", DE.GetUseCount());
- }
- Printf("###### End of recommended dictionary. ######\n");
-}
-
-void MutationDispatcher::PrintMutationSequence() {
- Printf("MS: %zd ", CurrentMutatorSequence.size());
- for (auto M : CurrentMutatorSequence)
- Printf("%s-", M.Name);
- if (!CurrentDictionaryEntrySequence.empty()) {
- Printf(" DE: ");
- for (auto DE : CurrentDictionaryEntrySequence) {
- Printf("\"");
- PrintASCII(DE->GetW(), "\"-");
- }
- }
-}
-
-size_t MutationDispatcher::Mutate(uint8_t *Data, size_t Size, size_t MaxSize) {
- return MutateImpl(Data, Size, MaxSize, Mutators);
-}
-
-size_t MutationDispatcher::DefaultMutate(uint8_t *Data, size_t Size,
- size_t MaxSize) {
- return MutateImpl(Data, Size, MaxSize, DefaultMutators);
-}
-
-// Mutates Data in place, returns new size.
-size_t MutationDispatcher::MutateImpl(uint8_t *Data, size_t Size,
- size_t MaxSize,
- const std::vector<Mutator> &Mutators) {
- assert(MaxSize > 0);
- // Some mutations may fail (e.g. can't insert more bytes if Size == MaxSize),
- // in which case they will return 0.
- // Try several times before returning un-mutated data.
- for (int Iter = 0; Iter < 100; Iter++) {
- auto M = Mutators[Rand(Mutators.size())];
- size_t NewSize = (this->*(M.Fn))(Data, Size, MaxSize);
- if (NewSize && NewSize <= MaxSize) {
- if (Options.OnlyASCII)
- ToASCII(Data, NewSize);
- CurrentMutatorSequence.push_back(M);
- return NewSize;
- }
- }
- *Data = ' ';
- return 1; // Fallback, should not happen frequently.
-}
-
-void MutationDispatcher::AddWordToManualDictionary(const Word &W) {
- ManualDictionary.push_back(
- {W, std::numeric_limits<size_t>::max()});
-}
-
-} // namespace fuzzer
Removed: llvm/trunk/lib/Fuzzer/FuzzerMutate.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Fuzzer/FuzzerMutate.h?rev=315936&view=auto
==============================================================================
--- llvm/trunk/lib/Fuzzer/FuzzerMutate.h (original)
+++ llvm/trunk/lib/Fuzzer/FuzzerMutate.h (removed)
@@ -1,150 +0,0 @@
-//===- FuzzerMutate.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.
-//
-//===----------------------------------------------------------------------===//
-// fuzzer::MutationDispatcher
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_FUZZER_MUTATE_H
-#define LLVM_FUZZER_MUTATE_H
-
-#include "FuzzerDefs.h"
-#include "FuzzerDictionary.h"
-#include "FuzzerOptions.h"
-#include "FuzzerRandom.h"
-
-namespace fuzzer {
-
-class MutationDispatcher {
-public:
- MutationDispatcher(Random &Rand, const FuzzingOptions &Options);
- ~MutationDispatcher() {}
- /// Indicate that we are about to start a new sequence of mutations.
- void StartMutationSequence();
- /// Print the current sequence of mutations.
- void PrintMutationSequence();
- /// Indicate that the current sequence of mutations was successfull.
- void RecordSuccessfulMutationSequence();
- /// Mutates data by invoking user-provided mutator.
- size_t Mutate_Custom(uint8_t *Data, size_t Size, size_t MaxSize);
- /// Mutates data by invoking user-provided crossover.
- size_t Mutate_CustomCrossOver(uint8_t *Data, size_t Size, size_t MaxSize);
- /// Mutates data by shuffling bytes.
- size_t Mutate_ShuffleBytes(uint8_t *Data, size_t Size, size_t MaxSize);
- /// Mutates data by erasing bytes.
- size_t Mutate_EraseBytes(uint8_t *Data, size_t Size, size_t MaxSize);
- /// Mutates data by inserting a byte.
- size_t Mutate_InsertByte(uint8_t *Data, size_t Size, size_t MaxSize);
- /// Mutates data by inserting several repeated bytes.
- size_t Mutate_InsertRepeatedBytes(uint8_t *Data, size_t Size, size_t MaxSize);
- /// Mutates data by chanding one byte.
- size_t Mutate_ChangeByte(uint8_t *Data, size_t Size, size_t MaxSize);
- /// Mutates data by chanding one bit.
- size_t Mutate_ChangeBit(uint8_t *Data, size_t Size, size_t MaxSize);
- /// Mutates data by copying/inserting a part of data into a different place.
- size_t Mutate_CopyPart(uint8_t *Data, size_t Size, size_t MaxSize);
-
- /// Mutates data by adding a word from the manual dictionary.
- size_t Mutate_AddWordFromManualDictionary(uint8_t *Data, size_t Size,
- size_t MaxSize);
-
- /// Mutates data by adding a word from the TORC.
- size_t Mutate_AddWordFromTORC(uint8_t *Data, size_t Size, size_t MaxSize);
-
- /// Mutates data by adding a word from the persistent automatic dictionary.
- size_t Mutate_AddWordFromPersistentAutoDictionary(uint8_t *Data, size_t Size,
- size_t MaxSize);
-
- /// Tries to find an ASCII integer in Data, changes it to another ASCII int.
- size_t Mutate_ChangeASCIIInteger(uint8_t *Data, size_t Size, size_t MaxSize);
- /// Change a 1-, 2-, 4-, or 8-byte integer in interesting ways.
- size_t Mutate_ChangeBinaryInteger(uint8_t *Data, size_t Size, size_t MaxSize);
-
- /// CrossOver Data with some other element of the corpus.
- size_t Mutate_CrossOver(uint8_t *Data, size_t Size, size_t MaxSize);
-
- /// Applies one of the configured mutations.
- /// Returns the new size of data which could be up to MaxSize.
- size_t Mutate(uint8_t *Data, size_t Size, size_t MaxSize);
- /// Applies one of the default mutations. Provided as a service
- /// to mutation authors.
- size_t DefaultMutate(uint8_t *Data, size_t Size, size_t MaxSize);
-
- /// Creates a cross-over of two pieces of Data, returns its size.
- size_t CrossOver(const uint8_t *Data1, size_t Size1, const uint8_t *Data2,
- size_t Size2, uint8_t *Out, size_t MaxOutSize);
-
- void AddWordToManualDictionary(const Word &W);
-
- void PrintRecommendedDictionary();
-
- void SetCorpus(const InputCorpus *Corpus) { this->Corpus = Corpus; }
-
- Random &GetRand() { return Rand; }
-
-private:
-
- struct Mutator {
- size_t (MutationDispatcher::*Fn)(uint8_t *Data, size_t Size, size_t Max);
- const char *Name;
- };
-
- 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,
- const std::vector<Mutator> &Mutators);
-
- size_t InsertPartOf(const uint8_t *From, size_t FromSize, uint8_t *To,
- size_t ToSize, size_t MaxToSize);
- size_t CopyPartOf(const uint8_t *From, size_t FromSize, uint8_t *To,
- size_t ToSize);
- size_t ApplyDictionaryEntry(uint8_t *Data, size_t Size, size_t MaxSize,
- DictionaryEntry &DE);
-
- template <class T>
- DictionaryEntry MakeDictionaryEntryFromCMP(T Arg1, T Arg2,
- const uint8_t *Data, size_t Size);
- DictionaryEntry MakeDictionaryEntryFromCMP(const Word &Arg1, const Word &Arg2,
- const uint8_t *Data, size_t Size);
- DictionaryEntry MakeDictionaryEntryFromCMP(const void *Arg1, const void *Arg2,
- const void *Arg1Mutation,
- const void *Arg2Mutation,
- size_t ArgSize,
- const uint8_t *Data, size_t Size);
-
- Random &Rand;
- const FuzzingOptions Options;
-
- // Dictionary provided by the user via -dict=DICT_FILE.
- Dictionary ManualDictionary;
- // Temporary dictionary modified by the fuzzer itself,
- // recreated periodically.
- Dictionary TempAutoDictionary;
- // Persistent dictionary modified by the fuzzer, consists of
- // entries that led to successfull discoveries in the past mutations.
- Dictionary PersistentAutoDictionary;
-
- std::vector<Mutator> CurrentMutatorSequence;
- std::vector<DictionaryEntry *> CurrentDictionaryEntrySequence;
-
- static const size_t kCmpDictionaryEntriesDequeSize = 16;
- DictionaryEntry CmpDictionaryEntriesDeque[kCmpDictionaryEntriesDequeSize];
- size_t CmpDictionaryEntriesDequeIdx = 0;
-
- const InputCorpus *Corpus = nullptr;
- std::vector<uint8_t> MutateInPlaceHere;
- // CustomCrossOver needs its own buffer as a custom implementation may call
- // LLVMFuzzerMutate, which in turn may resize MutateInPlaceHere.
- std::vector<uint8_t> CustomCrossOverInPlaceHere;
-
- std::vector<Mutator> Mutators;
- std::vector<Mutator> DefaultMutators;
-};
-
-} // namespace fuzzer
-
-#endif // LLVM_FUZZER_MUTATE_H
Removed: llvm/trunk/lib/Fuzzer/FuzzerOptions.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Fuzzer/FuzzerOptions.h?rev=315936&view=auto
==============================================================================
--- llvm/trunk/lib/Fuzzer/FuzzerOptions.h (original)
+++ llvm/trunk/lib/Fuzzer/FuzzerOptions.h (removed)
@@ -1,68 +0,0 @@
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-// fuzzer::FuzzingOptions
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_FUZZER_OPTIONS_H
-#define LLVM_FUZZER_OPTIONS_H
-
-#include "FuzzerDefs.h"
-
-namespace fuzzer {
-
-struct FuzzingOptions {
- int Verbosity = 1;
- size_t MaxLen = 0;
- bool ExperimentalLenControl = false;
- int UnitTimeoutSec = 300;
- int TimeoutExitCode = 77;
- int ErrorExitCode = 77;
- int MaxTotalTimeSec = 0;
- int RssLimitMb = 0;
- bool DoCrossOver = true;
- int MutateDepth = 5;
- bool UseCounters = false;
- bool UseIndirCalls = true;
- bool UseMemmem = true;
- bool UseCmp = false;
- bool UseValueProfile = false;
- bool Shrink = false;
- bool ReduceInputs = false;
- int ReloadIntervalSec = 1;
- bool ShuffleAtStartUp = true;
- bool PreferSmall = true;
- size_t MaxNumberOfRuns = -1L;
- int ReportSlowUnits = 10;
- bool OnlyASCII = false;
- std::string OutputCorpus;
- std::string ArtifactPrefix = "./";
- std::string ExactArtifactPath;
- std::string ExitOnSrcPos;
- std::string ExitOnItem;
- bool SaveArtifacts = true;
- bool PrintNEW = true; // Print a status line when new units are found;
- bool PrintNewCovPcs = false;
- bool PrintFinalStats = false;
- bool PrintCorpusStats = false;
- bool PrintCoverage = false;
- bool DumpCoverage = false;
- bool DetectLeaks = true;
- int TraceMalloc = 0;
- bool HandleAbrt = false;
- bool HandleBus = false;
- bool HandleFpe = false;
- bool HandleIll = false;
- bool HandleInt = false;
- bool HandleSegv = false;
- bool HandleTerm = false;
- bool HandleXfsz = false;
-};
-
-} // namespace fuzzer
-
-#endif // LLVM_FUZZER_OPTIONS_H
Removed: llvm/trunk/lib/Fuzzer/FuzzerRandom.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Fuzzer/FuzzerRandom.h?rev=315936&view=auto
==============================================================================
--- llvm/trunk/lib/Fuzzer/FuzzerRandom.h (original)
+++ llvm/trunk/lib/Fuzzer/FuzzerRandom.h (removed)
@@ -1,34 +0,0 @@
-//===- FuzzerRandom.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.
-//
-//===----------------------------------------------------------------------===//
-// fuzzer::Random
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_FUZZER_RANDOM_H
-#define LLVM_FUZZER_RANDOM_H
-
-#include <random>
-
-namespace fuzzer {
-class Random : public std::mt19937 {
- public:
- Random(unsigned int seed) : std::mt19937(seed) {}
- result_type operator()() { return this->std::mt19937::operator()(); }
- size_t Rand() { return this->operator()(); }
- size_t RandBool() { return Rand() % 2; }
- size_t operator()(size_t n) { return n ? Rand() % n : 0; }
- intptr_t operator()(intptr_t From, intptr_t To) {
- assert(From < To);
- intptr_t RangeSize = To - From + 1;
- return operator()(RangeSize) + From;
- }
-};
-
-} // namespace fuzzer
-
-#endif // LLVM_FUZZER_RANDOM_H
Removed: llvm/trunk/lib/Fuzzer/FuzzerSHA1.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Fuzzer/FuzzerSHA1.cpp?rev=315936&view=auto
==============================================================================
--- llvm/trunk/lib/Fuzzer/FuzzerSHA1.cpp (original)
+++ llvm/trunk/lib/Fuzzer/FuzzerSHA1.cpp (removed)
@@ -1,222 +0,0 @@
-//===- FuzzerSHA1.h - Private copy of the SHA1 implementation ---*- C++ -* ===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-// This code is taken from public domain
-// (http://oauth.googlecode.com/svn/code/c/liboauth/src/sha1.c)
-// and modified by adding anonymous namespace, adding an interface
-// function fuzzer::ComputeSHA1() and removing unnecessary code.
-//
-// lib/Fuzzer can not use SHA1 implementation from openssl because
-// openssl may not be available and because we may be fuzzing openssl itself.
-// For the same reason we do not want to depend on SHA1 from LLVM tree.
-//===----------------------------------------------------------------------===//
-
-#include "FuzzerSHA1.h"
-#include "FuzzerDefs.h"
-
-/* This code is public-domain - it is based on libcrypt
- * placed in the public domain by Wei Dai and other contributors.
- */
-
-#include <iomanip>
-#include <sstream>
-#include <stdint.h>
-#include <string.h>
-
-namespace { // Added for LibFuzzer
-
-#ifdef __BIG_ENDIAN__
-# define SHA_BIG_ENDIAN
-#elif defined __LITTLE_ENDIAN__
-/* override */
-#elif defined __BYTE_ORDER
-# if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
-# define SHA_BIG_ENDIAN
-# endif
-#else // ! defined __LITTLE_ENDIAN__
-# include <endian.h> // machine/endian.h
-# if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
-# define SHA_BIG_ENDIAN
-# endif
-#endif
-
-
-/* header */
-
-#define HASH_LENGTH 20
-#define BLOCK_LENGTH 64
-
-typedef struct sha1nfo {
- uint32_t buffer[BLOCK_LENGTH/4];
- uint32_t state[HASH_LENGTH/4];
- uint32_t byteCount;
- uint8_t bufferOffset;
- uint8_t keyBuffer[BLOCK_LENGTH];
- uint8_t innerHash[HASH_LENGTH];
-} sha1nfo;
-
-/* public API - prototypes - TODO: doxygen*/
-
-/**
- */
-void sha1_init(sha1nfo *s);
-/**
- */
-void sha1_writebyte(sha1nfo *s, uint8_t data);
-/**
- */
-void sha1_write(sha1nfo *s, const char *data, size_t len);
-/**
- */
-uint8_t* sha1_result(sha1nfo *s);
-
-
-/* code */
-#define SHA1_K0 0x5a827999
-#define SHA1_K20 0x6ed9eba1
-#define SHA1_K40 0x8f1bbcdc
-#define SHA1_K60 0xca62c1d6
-
-void sha1_init(sha1nfo *s) {
- s->state[0] = 0x67452301;
- s->state[1] = 0xefcdab89;
- s->state[2] = 0x98badcfe;
- s->state[3] = 0x10325476;
- s->state[4] = 0xc3d2e1f0;
- s->byteCount = 0;
- s->bufferOffset = 0;
-}
-
-uint32_t sha1_rol32(uint32_t number, uint8_t bits) {
- return ((number << bits) | (number >> (32-bits)));
-}
-
-void sha1_hashBlock(sha1nfo *s) {
- uint8_t i;
- uint32_t a,b,c,d,e,t;
-
- a=s->state[0];
- b=s->state[1];
- c=s->state[2];
- d=s->state[3];
- e=s->state[4];
- for (i=0; i<80; i++) {
- if (i>=16) {
- t = s->buffer[(i+13)&15] ^ s->buffer[(i+8)&15] ^ s->buffer[(i+2)&15] ^ s->buffer[i&15];
- s->buffer[i&15] = sha1_rol32(t,1);
- }
- if (i<20) {
- t = (d ^ (b & (c ^ d))) + SHA1_K0;
- } else if (i<40) {
- t = (b ^ c ^ d) + SHA1_K20;
- } else if (i<60) {
- t = ((b & c) | (d & (b | c))) + SHA1_K40;
- } else {
- t = (b ^ c ^ d) + SHA1_K60;
- }
- t+=sha1_rol32(a,5) + e + s->buffer[i&15];
- e=d;
- d=c;
- c=sha1_rol32(b,30);
- b=a;
- a=t;
- }
- s->state[0] += a;
- s->state[1] += b;
- s->state[2] += c;
- s->state[3] += d;
- s->state[4] += e;
-}
-
-void sha1_addUncounted(sha1nfo *s, uint8_t data) {
- uint8_t * const b = (uint8_t*) s->buffer;
-#ifdef SHA_BIG_ENDIAN
- b[s->bufferOffset] = data;
-#else
- b[s->bufferOffset ^ 3] = data;
-#endif
- s->bufferOffset++;
- if (s->bufferOffset == BLOCK_LENGTH) {
- sha1_hashBlock(s);
- s->bufferOffset = 0;
- }
-}
-
-void sha1_writebyte(sha1nfo *s, uint8_t data) {
- ++s->byteCount;
- sha1_addUncounted(s, data);
-}
-
-void sha1_write(sha1nfo *s, const char *data, size_t len) {
- for (;len--;) sha1_writebyte(s, (uint8_t) *data++);
-}
-
-void sha1_pad(sha1nfo *s) {
- // Implement SHA-1 padding (fips180-2 §5.1.1)
-
- // Pad with 0x80 followed by 0x00 until the end of the block
- sha1_addUncounted(s, 0x80);
- while (s->bufferOffset != 56) sha1_addUncounted(s, 0x00);
-
- // Append length in the last 8 bytes
- sha1_addUncounted(s, 0); // We're only using 32 bit lengths
- sha1_addUncounted(s, 0); // But SHA-1 supports 64 bit lengths
- sha1_addUncounted(s, 0); // So zero pad the top bits
- sha1_addUncounted(s, s->byteCount >> 29); // Shifting to multiply by 8
- sha1_addUncounted(s, s->byteCount >> 21); // as SHA-1 supports bitstreams as well as
- sha1_addUncounted(s, s->byteCount >> 13); // byte.
- sha1_addUncounted(s, s->byteCount >> 5);
- sha1_addUncounted(s, s->byteCount << 3);
-}
-
-uint8_t* sha1_result(sha1nfo *s) {
- // Pad to complete the last block
- sha1_pad(s);
-
-#ifndef SHA_BIG_ENDIAN
- // Swap byte order back
- int i;
- for (i=0; i<5; i++) {
- s->state[i]=
- (((s->state[i])<<24)& 0xff000000)
- | (((s->state[i])<<8) & 0x00ff0000)
- | (((s->state[i])>>8) & 0x0000ff00)
- | (((s->state[i])>>24)& 0x000000ff);
- }
-#endif
-
- // Return pointer to hash (20 characters)
- return (uint8_t*) s->state;
-}
-
-} // namespace; Added for LibFuzzer
-
-namespace fuzzer {
-
-// The rest is added for LibFuzzer
-void ComputeSHA1(const uint8_t *Data, size_t Len, uint8_t *Out) {
- sha1nfo s;
- sha1_init(&s);
- sha1_write(&s, (const char*)Data, Len);
- memcpy(Out, sha1_result(&s), HASH_LENGTH);
-}
-
-std::string Sha1ToString(const uint8_t Sha1[kSHA1NumBytes]) {
- std::stringstream SS;
- for (int i = 0; i < kSHA1NumBytes; i++)
- SS << std::hex << std::setfill('0') << std::setw(2) << (unsigned)Sha1[i];
- return SS.str();
-}
-
-std::string Hash(const Unit &U) {
- uint8_t Hash[kSHA1NumBytes];
- ComputeSHA1(U.data(), U.size(), Hash);
- return Sha1ToString(Hash);
-}
-
-}
Removed: llvm/trunk/lib/Fuzzer/FuzzerSHA1.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Fuzzer/FuzzerSHA1.h?rev=315936&view=auto
==============================================================================
--- llvm/trunk/lib/Fuzzer/FuzzerSHA1.h (original)
+++ llvm/trunk/lib/Fuzzer/FuzzerSHA1.h (removed)
@@ -1,33 +0,0 @@
-//===- FuzzerSHA1.h - Internal header for the SHA1 utils --------*- C++ -* ===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-// SHA1 utils.
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_FUZZER_SHA1_H
-#define LLVM_FUZZER_SHA1_H
-
-#include "FuzzerDefs.h"
-#include <cstddef>
-#include <stdint.h>
-
-namespace fuzzer {
-
-// Private copy of SHA1 implementation.
-static const int kSHA1NumBytes = 20;
-
-// Computes SHA1 hash of 'Len' bytes in 'Data', writes kSHA1NumBytes to 'Out'.
-void ComputeSHA1(const uint8_t *Data, size_t Len, uint8_t *Out);
-
-std::string Sha1ToString(const uint8_t Sha1[kSHA1NumBytes]);
-
-std::string Hash(const Unit &U);
-
-} // namespace fuzzer
-
-#endif // LLVM_FUZZER_SHA1_H
Removed: llvm/trunk/lib/Fuzzer/FuzzerShmem.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Fuzzer/FuzzerShmem.h?rev=315936&view=auto
==============================================================================
--- llvm/trunk/lib/Fuzzer/FuzzerShmem.h (original)
+++ llvm/trunk/lib/Fuzzer/FuzzerShmem.h (removed)
@@ -1,69 +0,0 @@
-//===- FuzzerShmem.h - shared memory interface ------------------*- C++ -* ===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-// SharedMemoryRegion
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_FUZZER_SHMEM_H
-#define LLVM_FUZZER_SHMEM_H
-
-#include <algorithm>
-#include <cstring>
-#include <string>
-
-#include "FuzzerDefs.h"
-
-namespace fuzzer {
-
-class SharedMemoryRegion {
- public:
- bool Create(const char *Name);
- bool Open(const char *Name);
- bool Destroy(const char *Name);
- uint8_t *GetData() { return Data; }
- void PostServer() {Post(0);}
- void WaitServer() {Wait(0);}
- void PostClient() {Post(1);}
- void WaitClient() {Wait(1);}
-
- size_t WriteByteArray(const uint8_t *Bytes, size_t N) {
- assert(N <= kShmemSize - sizeof(N));
- memcpy(GetData(), &N, sizeof(N));
- memcpy(GetData() + sizeof(N), Bytes, N);
- assert(N == ReadByteArraySize());
- return N;
- }
- size_t ReadByteArraySize() {
- size_t Res;
- memcpy(&Res, GetData(), sizeof(Res));
- return Res;
- }
- uint8_t *GetByteArray() { return GetData() + sizeof(size_t); }
-
- bool IsServer() const { return Data && IAmServer; }
- bool IsClient() const { return Data && !IAmServer; }
-
-private:
-
- static const size_t kShmemSize = 1 << 22;
- bool IAmServer;
- std::string Path(const char *Name);
- std::string SemName(const char *Name, int Idx);
- void Post(int Idx);
- void Wait(int Idx);
-
- bool Map(int fd);
- uint8_t *Data = nullptr;
- void *Semaphore[2];
-};
-
-extern SharedMemoryRegion SMR;
-
-} // namespace fuzzer
-
-#endif // LLVM_FUZZER_SHMEM_H
Removed: llvm/trunk/lib/Fuzzer/FuzzerShmemPosix.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Fuzzer/FuzzerShmemPosix.cpp?rev=315936&view=auto
==============================================================================
--- llvm/trunk/lib/Fuzzer/FuzzerShmemPosix.cpp (original)
+++ llvm/trunk/lib/Fuzzer/FuzzerShmemPosix.cpp (removed)
@@ -1,103 +0,0 @@
-//===- FuzzerShmemPosix.cpp - Posix shared memory ---------------*- C++ -* ===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-// SharedMemoryRegion
-//===----------------------------------------------------------------------===//
-#include "FuzzerDefs.h"
-#if LIBFUZZER_POSIX
-
-#include "FuzzerIO.h"
-#include "FuzzerShmem.h"
-
-#include <errno.h>
-#include <fcntl.h>
-#include <semaphore.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <sys/mman.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-#include <unistd.h>
-
-namespace fuzzer {
-
-std::string SharedMemoryRegion::Path(const char *Name) {
- return DirPlusFile(TmpDir(), Name);
-}
-
-std::string SharedMemoryRegion::SemName(const char *Name, int Idx) {
- std::string Res(Name);
- return Res + (char)('0' + Idx);
-}
-
-bool SharedMemoryRegion::Map(int fd) {
- Data =
- (uint8_t *)mmap(0, kShmemSize, PROT_WRITE | PROT_READ, MAP_SHARED, fd, 0);
- if (Data == (uint8_t*)-1)
- return false;
- return true;
-}
-
-bool SharedMemoryRegion::Create(const char *Name) {
- int fd = open(Path(Name).c_str(), O_CREAT | O_RDWR, 0777);
- if (fd < 0) return false;
- if (ftruncate(fd, kShmemSize) < 0) return false;
- if (!Map(fd))
- return false;
- for (int i = 0; i < 2; i++) {
- sem_unlink(SemName(Name, i).c_str());
- Semaphore[i] = sem_open(SemName(Name, i).c_str(), O_CREAT, 0644, 0);
- if (Semaphore[i] == (void *)-1)
- return false;
- }
- IAmServer = true;
- return true;
-}
-
-bool SharedMemoryRegion::Open(const char *Name) {
- int fd = open(Path(Name).c_str(), O_RDWR);
- if (fd < 0) return false;
- struct stat stat_res;
- if (0 != fstat(fd, &stat_res))
- return false;
- assert(stat_res.st_size == kShmemSize);
- if (!Map(fd))
- return false;
- for (int i = 0; i < 2; i++) {
- Semaphore[i] = sem_open(SemName(Name, i).c_str(), 0);
- if (Semaphore[i] == (void *)-1)
- return false;
- }
- IAmServer = false;
- return true;
-}
-
-bool SharedMemoryRegion::Destroy(const char *Name) {
- return 0 == unlink(Path(Name).c_str());
-}
-
-void SharedMemoryRegion::Post(int Idx) {
- assert(Idx == 0 || Idx == 1);
- sem_post((sem_t*)Semaphore[Idx]);
-}
-
-void SharedMemoryRegion::Wait(int Idx) {
- assert(Idx == 0 || Idx == 1);
- for (int i = 0; i < 10 && sem_wait((sem_t*)Semaphore[Idx]); i++) {
- // sem_wait may fail if interrupted by a signal.
- sleep(i);
- if (i)
- Printf("%s: sem_wait[%d] failed %s\n", i < 9 ? "WARNING" : "ERROR", i,
- strerror(errno));
- if (i == 9) abort();
- }
-}
-
-} // namespace fuzzer
-
-#endif // LIBFUZZER_POSIX
Removed: llvm/trunk/lib/Fuzzer/FuzzerShmemWindows.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Fuzzer/FuzzerShmemWindows.cpp?rev=315936&view=auto
==============================================================================
--- llvm/trunk/lib/Fuzzer/FuzzerShmemWindows.cpp (original)
+++ llvm/trunk/lib/Fuzzer/FuzzerShmemWindows.cpp (removed)
@@ -1,64 +0,0 @@
-//===- FuzzerShmemWindows.cpp - Posix shared memory -------------*- C++ -* ===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-// SharedMemoryRegion
-//===----------------------------------------------------------------------===//
-#include "FuzzerDefs.h"
-#if LIBFUZZER_WINDOWS
-
-#include "FuzzerIO.h"
-#include "FuzzerShmem.h"
-
-#include <fcntl.h>
-#include <stdio.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-
-namespace fuzzer {
-
-std::string SharedMemoryRegion::Path(const char *Name) {
- return DirPlusFile(TmpDir(), Name);
-}
-
-std::string SharedMemoryRegion::SemName(const char *Name, int Idx) {
- std::string Res(Name);
- return Res + (char)('0' + Idx);
-}
-
-bool SharedMemoryRegion::Map(int fd) {
- assert(0 && "UNIMPLEMENTED");
- return false;
-}
-
-bool SharedMemoryRegion::Create(const char *Name) {
- assert(0 && "UNIMPLEMENTED");
- return false;
-}
-
-bool SharedMemoryRegion::Open(const char *Name) {
- assert(0 && "UNIMPLEMENTED");
- return false;
-}
-
-bool SharedMemoryRegion::Destroy(const char *Name) {
- assert(0 && "UNIMPLEMENTED");
- return false;
-}
-
-void SharedMemoryRegion::Post(int Idx) {
- assert(0 && "UNIMPLEMENTED");
-}
-
-void SharedMemoryRegion::Wait(int Idx) {
- Semaphore[1] = nullptr;
- assert(0 && "UNIMPLEMENTED");
-}
-
-} // namespace fuzzer
-
-#endif // LIBFUZZER_WINDOWS
Removed: llvm/trunk/lib/Fuzzer/FuzzerTracePC.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Fuzzer/FuzzerTracePC.cpp?rev=315936&view=auto
==============================================================================
--- llvm/trunk/lib/Fuzzer/FuzzerTracePC.cpp (original)
+++ llvm/trunk/lib/Fuzzer/FuzzerTracePC.cpp (removed)
@@ -1,583 +0,0 @@
-//===- FuzzerTracePC.cpp - PC tracing--------------------------------------===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-// Trace PCs.
-// This module implements __sanitizer_cov_trace_pc_guard[_init],
-// the callback required for -fsanitize-coverage=trace-pc-guard instrumentation.
-//
-//===----------------------------------------------------------------------===//
-
-#include "FuzzerTracePC.h"
-#include "FuzzerCorpus.h"
-#include "FuzzerDefs.h"
-#include "FuzzerDictionary.h"
-#include "FuzzerExtFunctions.h"
-#include "FuzzerIO.h"
-#include "FuzzerUtil.h"
-#include "FuzzerValueBitMap.h"
-#include <set>
-
-// The coverage counters and PCs.
-// These are declared as global variables named "__sancov_*" to simplify
-// experiments with inlined instrumentation.
-alignas(64) ATTRIBUTE_INTERFACE
-uint8_t __sancov_trace_pc_guard_8bit_counters[fuzzer::TracePC::kNumPCs];
-
-ATTRIBUTE_INTERFACE
-uintptr_t __sancov_trace_pc_pcs[fuzzer::TracePC::kNumPCs];
-
-// Used by -fsanitize-coverage=stack-depth to track stack depth
-ATTRIBUTE_INTERFACE thread_local uintptr_t __sancov_lowest_stack;
-
-namespace fuzzer {
-
-TracePC TPC;
-
-int ScopedDoingMyOwnMemOrStr::DoingMyOwnMemOrStr;
-
-uint8_t *TracePC::Counters() const {
- return __sancov_trace_pc_guard_8bit_counters;
-}
-
-uintptr_t *TracePC::PCs() const {
- return __sancov_trace_pc_pcs;
-}
-
-size_t TracePC::GetTotalPCCoverage() {
- if (ObservedPCs.size())
- return ObservedPCs.size();
- size_t Res = 0;
- for (size_t i = 1, N = GetNumPCs(); i < N; i++)
- if (PCs()[i])
- Res++;
- return Res;
-}
-
-
-void TracePC::HandleInline8bitCountersInit(uint8_t *Start, uint8_t *Stop) {
- if (Start == Stop) return;
- if (NumModulesWithInline8bitCounters &&
- ModuleCounters[NumModulesWithInline8bitCounters-1].Start == Start) return;
- assert(NumModulesWithInline8bitCounters <
- sizeof(ModuleCounters) / sizeof(ModuleCounters[0]));
- ModuleCounters[NumModulesWithInline8bitCounters++] = {Start, Stop};
- NumInline8bitCounters += Stop - Start;
-}
-
-void TracePC::HandlePCsInit(const uint8_t *Start, const uint8_t *Stop) {
- const uintptr_t *B = reinterpret_cast<const uintptr_t *>(Start);
- const uintptr_t *E = reinterpret_cast<const uintptr_t *>(Stop);
- if (NumPCTables && ModulePCTable[NumPCTables - 1].Start == B) return;
- assert(NumPCTables < sizeof(ModulePCTable) / sizeof(ModulePCTable[0]));
- ModulePCTable[NumPCTables++] = {B, E};
- NumPCsInPCTables += E - B;
-}
-
-void TracePC::HandleInit(uint32_t *Start, uint32_t *Stop) {
- if (Start == Stop || *Start) return;
- assert(NumModules < sizeof(Modules) / sizeof(Modules[0]));
- for (uint32_t *P = Start; P < Stop; P++) {
- NumGuards++;
- if (NumGuards == kNumPCs) {
- RawPrint(
- "WARNING: The binary has too many instrumented PCs.\n"
- " You may want to reduce the size of the binary\n"
- " for more efficient fuzzing and precise coverage data\n");
- }
- *P = NumGuards % kNumPCs;
- }
- Modules[NumModules].Start = Start;
- Modules[NumModules].Stop = Stop;
- NumModules++;
-}
-
-void TracePC::PrintModuleInfo() {
- if (NumGuards) {
- Printf("INFO: Loaded %zd modules (%zd guards): ", NumModules, NumGuards);
- for (size_t i = 0; i < NumModules; i++)
- Printf("%zd [%p, %p), ", Modules[i].Stop - Modules[i].Start,
- Modules[i].Start, Modules[i].Stop);
- Printf("\n");
- }
- if (NumModulesWithInline8bitCounters) {
- Printf("INFO: Loaded %zd modules (%zd inline 8-bit counters): ",
- NumModulesWithInline8bitCounters, NumInline8bitCounters);
- for (size_t i = 0; i < NumModulesWithInline8bitCounters; i++)
- Printf("%zd [%p, %p), ", ModuleCounters[i].Stop - ModuleCounters[i].Start,
- ModuleCounters[i].Start, ModuleCounters[i].Stop);
- Printf("\n");
- }
- if (NumPCTables) {
- Printf("INFO: Loaded %zd PC tables (%zd PCs): ", NumPCTables,
- NumPCsInPCTables);
- for (size_t i = 0; i < NumPCTables; i++) {
- Printf("%zd [%p,%p), ", ModulePCTable[i].Stop - ModulePCTable[i].Start,
- ModulePCTable[i].Start, ModulePCTable[i].Stop);
- }
- Printf("\n");
-
- if ((NumGuards && NumGuards != NumPCsInPCTables) ||
- (NumInline8bitCounters && NumInline8bitCounters != NumPCsInPCTables)) {
- Printf("ERROR: The size of coverage PC tables does not match the"
- " number of instrumented PCs. This might be a bug in the compiler,"
- " please contact the libFuzzer developers.\n");
- _Exit(1);
- }
- }
- if (size_t NumClangCounters = ClangCountersEnd() - ClangCountersBegin())
- Printf("INFO: %zd Clang Coverage Counters\n", NumClangCounters);
-}
-
-ATTRIBUTE_NO_SANITIZE_ALL
-void TracePC::HandleCallerCallee(uintptr_t Caller, uintptr_t Callee) {
- const uintptr_t kBits = 12;
- const uintptr_t kMask = (1 << kBits) - 1;
- uintptr_t Idx = (Caller & kMask) | ((Callee & kMask) << kBits);
- ValueProfileMap.AddValueModPrime(Idx);
-}
-
-void TracePC::UpdateObservedPCs() {
- auto Observe = [&](uintptr_t PC) {
- bool Inserted = ObservedPCs.insert(PC).second;
- if (Inserted && DoPrintNewPCs)
- PrintPC("\tNEW_PC: %p %F %L\n", "\tNEW_PC: %p\n", PC + 1);
- };
- if (NumPCsInPCTables) {
- if (NumInline8bitCounters == NumPCsInPCTables) {
- for (size_t i = 0; i < NumModulesWithInline8bitCounters; i++) {
- uint8_t *Beg = ModuleCounters[i].Start;
- size_t Size = ModuleCounters[i].Stop - Beg;
- assert(Size ==
- (size_t)(ModulePCTable[i].Stop - ModulePCTable[i].Start));
- for (size_t j = 0; j < Size; j++)
- if (Beg[j])
- Observe(ModulePCTable[i].Start[j]);
- }
- } else if (NumGuards == NumPCsInPCTables) {
- size_t GuardIdx = 1;
- for (size_t i = 0; i < NumModules; i++) {
- uint32_t *Beg = Modules[i].Start;
- size_t Size = Modules[i].Stop - Beg;
- assert(Size ==
- (size_t)(ModulePCTable[i].Stop - ModulePCTable[i].Start));
- for (size_t j = 0; j < Size; j++, GuardIdx++)
- if (Counters()[GuardIdx])
- Observe(ModulePCTable[i].Start[j]);
- }
- }
- }
- if (size_t NumClangCounters =
- ClangCountersEnd() - ClangCountersBegin()) {
- auto P = ClangCountersBegin();
- for (size_t Idx = 0; Idx < NumClangCounters; Idx++)
- if (P[Idx])
- Observe((uintptr_t)Idx);
- }
-}
-
-inline ALWAYS_INLINE uintptr_t GetPreviousInstructionPc(uintptr_t PC) {
- // TODO: this implementation is x86 only.
- // see sanitizer_common GetPreviousInstructionPc for full implementation.
- return PC - 1;
-}
-
-inline ALWAYS_INLINE uintptr_t GetNextInstructionPc(uintptr_t PC) {
- // TODO: this implementation is x86 only.
- // see sanitizer_common GetPreviousInstructionPc for full implementation.
- return PC + 1;
-}
-
-static std::string GetModuleName(uintptr_t PC) {
- char ModulePathRaw[4096] = ""; // What's PATH_MAX in portable C++?
- void *OffsetRaw = nullptr;
- if (!EF->__sanitizer_get_module_and_offset_for_pc(
- reinterpret_cast<void *>(PC), ModulePathRaw,
- sizeof(ModulePathRaw), &OffsetRaw))
- return "";
- return ModulePathRaw;
-}
-
-void TracePC::PrintCoverage() {
- if (!EF->__sanitizer_symbolize_pc ||
- !EF->__sanitizer_get_module_and_offset_for_pc) {
- Printf("INFO: __sanitizer_symbolize_pc or "
- "__sanitizer_get_module_and_offset_for_pc is not available,"
- " not printing coverage\n");
- return;
- }
- Printf("COVERAGE:\n");
- std::string LastFunctionName = "";
- std::string LastFileStr = "";
- std::set<size_t> UncoveredLines;
- std::set<size_t> CoveredLines;
-
- auto FunctionEndCallback = [&](const std::string &CurrentFunc,
- const std::string &CurrentFile) {
- if (LastFunctionName != CurrentFunc) {
- if (CoveredLines.empty() && !UncoveredLines.empty()) {
- Printf("UNCOVERED_FUNC: %s\n", LastFunctionName.c_str());
- } else {
- for (auto Line : UncoveredLines) {
- if (!CoveredLines.count(Line))
- Printf("UNCOVERED_LINE: %s %s:%zd\n", LastFunctionName.c_str(),
- LastFileStr.c_str(), Line);
- }
- }
-
- UncoveredLines.clear();
- CoveredLines.clear();
- LastFunctionName = CurrentFunc;
- LastFileStr = CurrentFile;
- }
- };
-
- for (size_t i = 0; i < NumPCTables; i++) {
- auto &M = ModulePCTable[i];
- assert(M.Start < M.Stop);
- auto ModuleName = GetModuleName(*M.Start);
- for (auto Ptr = M.Start; Ptr < M.Stop; Ptr++) {
- auto PC = *Ptr;
- auto VisualizePC = GetNextInstructionPc(PC);
- bool IsObserved = ObservedPCs.count(PC);
- std::string FileStr = DescribePC("%s", VisualizePC);
- if (!IsInterestingCoverageFile(FileStr)) continue;
- std::string FunctionStr = DescribePC("%F", VisualizePC);
- FunctionEndCallback(FunctionStr, FileStr);
- std::string LineStr = DescribePC("%l", VisualizePC);
- size_t Line = std::stoul(LineStr);
- if (IsObserved && CoveredLines.insert(Line).second)
- Printf("COVERED: %s %s:%zd\n", FunctionStr.c_str(), FileStr.c_str(),
- Line);
- else
- UncoveredLines.insert(Line);
- }
- }
- FunctionEndCallback("", "");
-}
-
-void TracePC::DumpCoverage() {
- if (EF->__sanitizer_dump_coverage) {
- std::vector<uintptr_t> PCsCopy(GetNumPCs());
- for (size_t i = 0; i < GetNumPCs(); i++)
- PCsCopy[i] = PCs()[i] ? GetPreviousInstructionPc(PCs()[i]) : 0;
- EF->__sanitizer_dump_coverage(PCsCopy.data(), PCsCopy.size());
- }
-}
-
-// Value profile.
-// We keep track of various values that affect control flow.
-// These values are inserted into a bit-set-based hash map.
-// Every new bit in the map is treated as a new coverage.
-//
-// For memcmp/strcmp/etc the interesting value is the length of the common
-// prefix of the parameters.
-// For cmp instructions the interesting value is a XOR of the parameters.
-// The interesting value is mixed up with the PC and is then added to the map.
-
-ATTRIBUTE_NO_SANITIZE_ALL
-void TracePC::AddValueForMemcmp(void *caller_pc, const void *s1, const void *s2,
- size_t n, bool StopAtZero) {
- if (!n) return;
- size_t Len = std::min(n, Word::GetMaxSize());
- const uint8_t *A1 = reinterpret_cast<const uint8_t *>(s1);
- const uint8_t *A2 = reinterpret_cast<const uint8_t *>(s2);
- uint8_t B1[Word::kMaxSize];
- uint8_t B2[Word::kMaxSize];
- // Copy the data into locals in this non-msan-instrumented function
- // to avoid msan complaining further.
- size_t Hash = 0; // Compute some simple hash of both strings.
- for (size_t i = 0; i < Len; i++) {
- B1[i] = A1[i];
- B2[i] = A2[i];
- size_t T = B1[i];
- Hash ^= (T << 8) | B2[i];
- }
- size_t I = 0;
- for (; I < Len; I++)
- if (B1[I] != B2[I] || (StopAtZero && B1[I] == 0))
- break;
- size_t PC = reinterpret_cast<size_t>(caller_pc);
- size_t Idx = (PC & 4095) | (I << 12);
- ValueProfileMap.AddValue(Idx);
- TORCW.Insert(Idx ^ Hash, Word(B1, Len), Word(B2, Len));
-}
-
-template <class T>
-ATTRIBUTE_TARGET_POPCNT ALWAYS_INLINE
-ATTRIBUTE_NO_SANITIZE_ALL
-void TracePC::HandleCmp(uintptr_t PC, T Arg1, T Arg2) {
- uint64_t ArgXor = Arg1 ^ Arg2;
- uint64_t ArgDistance = __builtin_popcountll(ArgXor) + 1; // [1,65]
- uintptr_t Idx = ((PC & 4095) + 1) * ArgDistance;
- if (sizeof(T) == 4)
- TORC4.Insert(ArgXor, Arg1, Arg2);
- else if (sizeof(T) == 8)
- TORC8.Insert(ArgXor, Arg1, Arg2);
- ValueProfileMap.AddValue(Idx);
-}
-
-static size_t InternalStrnlen(const char *S, size_t MaxLen) {
- size_t Len = 0;
- for (; Len < MaxLen && S[Len]; Len++) {}
- return Len;
-}
-
-// Finds min of (strlen(S1), strlen(S2)).
-// Needed bacause one of these strings may actually be non-zero terminated.
-static size_t InternalStrnlen2(const char *S1, const char *S2) {
- size_t Len = 0;
- for (; S1[Len] && S2[Len]; Len++) {}
- return Len;
-}
-
-void TracePC::ClearInlineCounters() {
- for (size_t i = 0; i < NumModulesWithInline8bitCounters; i++) {
- uint8_t *Beg = ModuleCounters[i].Start;
- size_t Size = ModuleCounters[i].Stop - Beg;
- memset(Beg, 0, Size);
- }
-}
-
-void TracePC::RecordInitialStack() {
- InitialStack = __sancov_lowest_stack;
-}
-
-uintptr_t TracePC::GetMaxStackOffset() const {
- return InitialStack - __sancov_lowest_stack; // Stack grows down
-}
-
-} // namespace fuzzer
-
-extern "C" {
-ATTRIBUTE_INTERFACE
-ATTRIBUTE_NO_SANITIZE_ALL
-void __sanitizer_cov_trace_pc_guard(uint32_t *Guard) {
- uintptr_t PC = reinterpret_cast<uintptr_t>(__builtin_return_address(0));
- uint32_t Idx = *Guard;
- __sancov_trace_pc_pcs[Idx] = PC;
- __sancov_trace_pc_guard_8bit_counters[Idx]++;
-}
-
-// Best-effort support for -fsanitize-coverage=trace-pc, which is available
-// in both Clang and GCC.
-ATTRIBUTE_INTERFACE
-ATTRIBUTE_NO_SANITIZE_ALL
-void __sanitizer_cov_trace_pc() {
- uintptr_t PC = reinterpret_cast<uintptr_t>(__builtin_return_address(0));
- uintptr_t Idx = PC & (((uintptr_t)1 << fuzzer::TracePC::kTracePcBits) - 1);
- __sancov_trace_pc_pcs[Idx] = PC;
- __sancov_trace_pc_guard_8bit_counters[Idx]++;
-}
-
-ATTRIBUTE_INTERFACE
-void __sanitizer_cov_trace_pc_guard_init(uint32_t *Start, uint32_t *Stop) {
- fuzzer::TPC.HandleInit(Start, Stop);
-}
-
-ATTRIBUTE_INTERFACE
-void __sanitizer_cov_8bit_counters_init(uint8_t *Start, uint8_t *Stop) {
- fuzzer::TPC.HandleInline8bitCountersInit(Start, Stop);
-}
-
-ATTRIBUTE_INTERFACE
-void __sanitizer_cov_pcs_init(const uint8_t *pcs_beg, const uint8_t *pcs_end) {
- fuzzer::TPC.HandlePCsInit(pcs_beg, pcs_end);
-}
-
-ATTRIBUTE_INTERFACE
-ATTRIBUTE_NO_SANITIZE_ALL
-void __sanitizer_cov_trace_pc_indir(uintptr_t Callee) {
- uintptr_t PC = reinterpret_cast<uintptr_t>(__builtin_return_address(0));
- fuzzer::TPC.HandleCallerCallee(PC, Callee);
-}
-
-ATTRIBUTE_INTERFACE
-ATTRIBUTE_NO_SANITIZE_ALL
-ATTRIBUTE_TARGET_POPCNT
-void __sanitizer_cov_trace_cmp8(uint64_t Arg1, uint64_t Arg2) {
- uintptr_t PC = reinterpret_cast<uintptr_t>(__builtin_return_address(0));
- fuzzer::TPC.HandleCmp(PC, Arg1, Arg2);
-}
-
-ATTRIBUTE_INTERFACE
-ATTRIBUTE_NO_SANITIZE_ALL
-ATTRIBUTE_TARGET_POPCNT
-// Now the __sanitizer_cov_trace_const_cmp[1248] callbacks just mimic
-// the behaviour of __sanitizer_cov_trace_cmp[1248] ones. This, however,
-// should be changed later to make full use of instrumentation.
-void __sanitizer_cov_trace_const_cmp8(uint64_t Arg1, uint64_t Arg2) {
- uintptr_t PC = reinterpret_cast<uintptr_t>(__builtin_return_address(0));
- fuzzer::TPC.HandleCmp(PC, Arg1, Arg2);
-}
-
-ATTRIBUTE_INTERFACE
-ATTRIBUTE_NO_SANITIZE_ALL
-ATTRIBUTE_TARGET_POPCNT
-void __sanitizer_cov_trace_cmp4(uint32_t Arg1, uint32_t Arg2) {
- uintptr_t PC = reinterpret_cast<uintptr_t>(__builtin_return_address(0));
- fuzzer::TPC.HandleCmp(PC, Arg1, Arg2);
-}
-
-ATTRIBUTE_INTERFACE
-ATTRIBUTE_NO_SANITIZE_ALL
-ATTRIBUTE_TARGET_POPCNT
-void __sanitizer_cov_trace_const_cmp4(uint32_t Arg1, uint32_t Arg2) {
- uintptr_t PC = reinterpret_cast<uintptr_t>(__builtin_return_address(0));
- fuzzer::TPC.HandleCmp(PC, Arg1, Arg2);
-}
-
-ATTRIBUTE_INTERFACE
-ATTRIBUTE_NO_SANITIZE_ALL
-ATTRIBUTE_TARGET_POPCNT
-void __sanitizer_cov_trace_cmp2(uint16_t Arg1, uint16_t Arg2) {
- uintptr_t PC = reinterpret_cast<uintptr_t>(__builtin_return_address(0));
- fuzzer::TPC.HandleCmp(PC, Arg1, Arg2);
-}
-
-ATTRIBUTE_INTERFACE
-ATTRIBUTE_NO_SANITIZE_ALL
-ATTRIBUTE_TARGET_POPCNT
-void __sanitizer_cov_trace_const_cmp2(uint16_t Arg1, uint16_t Arg2) {
- uintptr_t PC = reinterpret_cast<uintptr_t>(__builtin_return_address(0));
- fuzzer::TPC.HandleCmp(PC, Arg1, Arg2);
-}
-
-ATTRIBUTE_INTERFACE
-ATTRIBUTE_NO_SANITIZE_ALL
-ATTRIBUTE_TARGET_POPCNT
-void __sanitizer_cov_trace_cmp1(uint8_t Arg1, uint8_t Arg2) {
- uintptr_t PC = reinterpret_cast<uintptr_t>(__builtin_return_address(0));
- fuzzer::TPC.HandleCmp(PC, Arg1, Arg2);
-}
-
-ATTRIBUTE_INTERFACE
-ATTRIBUTE_NO_SANITIZE_ALL
-ATTRIBUTE_TARGET_POPCNT
-void __sanitizer_cov_trace_const_cmp1(uint8_t Arg1, uint8_t Arg2) {
- uintptr_t PC = reinterpret_cast<uintptr_t>(__builtin_return_address(0));
- fuzzer::TPC.HandleCmp(PC, Arg1, Arg2);
-}
-
-ATTRIBUTE_INTERFACE
-ATTRIBUTE_NO_SANITIZE_ALL
-ATTRIBUTE_TARGET_POPCNT
-void __sanitizer_cov_trace_switch(uint64_t Val, uint64_t *Cases) {
- uint64_t N = Cases[0];
- uint64_t ValSizeInBits = Cases[1];
- uint64_t *Vals = Cases + 2;
- // Skip the most common and the most boring case.
- if (Vals[N - 1] < 256 && Val < 256)
- return;
- uintptr_t PC = reinterpret_cast<uintptr_t>(__builtin_return_address(0));
- size_t i;
- uint64_t Token = 0;
- for (i = 0; i < N; i++) {
- Token = Val ^ Vals[i];
- if (Val < Vals[i])
- break;
- }
-
- if (ValSizeInBits == 16)
- fuzzer::TPC.HandleCmp(PC + i, static_cast<uint16_t>(Token), (uint16_t)(0));
- else if (ValSizeInBits == 32)
- fuzzer::TPC.HandleCmp(PC + i, static_cast<uint32_t>(Token), (uint32_t)(0));
- else
- fuzzer::TPC.HandleCmp(PC + i, Token, (uint64_t)(0));
-}
-
-ATTRIBUTE_INTERFACE
-ATTRIBUTE_NO_SANITIZE_ALL
-ATTRIBUTE_TARGET_POPCNT
-void __sanitizer_cov_trace_div4(uint32_t Val) {
- uintptr_t PC = reinterpret_cast<uintptr_t>(__builtin_return_address(0));
- fuzzer::TPC.HandleCmp(PC, Val, (uint32_t)0);
-}
-
-ATTRIBUTE_INTERFACE
-ATTRIBUTE_NO_SANITIZE_ALL
-ATTRIBUTE_TARGET_POPCNT
-void __sanitizer_cov_trace_div8(uint64_t Val) {
- uintptr_t PC = reinterpret_cast<uintptr_t>(__builtin_return_address(0));
- fuzzer::TPC.HandleCmp(PC, Val, (uint64_t)0);
-}
-
-ATTRIBUTE_INTERFACE
-ATTRIBUTE_NO_SANITIZE_ALL
-ATTRIBUTE_TARGET_POPCNT
-void __sanitizer_cov_trace_gep(uintptr_t Idx) {
- uintptr_t PC = reinterpret_cast<uintptr_t>(__builtin_return_address(0));
- fuzzer::TPC.HandleCmp(PC, Idx, (uintptr_t)0);
-}
-
-ATTRIBUTE_INTERFACE ATTRIBUTE_NO_SANITIZE_MEMORY
-void __sanitizer_weak_hook_memcmp(void *caller_pc, const void *s1,
- const void *s2, size_t n, int result) {
- if (fuzzer::ScopedDoingMyOwnMemOrStr::DoingMyOwnMemOrStr) return;
- if (result == 0) return; // No reason to mutate.
- if (n <= 1) return; // Not interesting.
- fuzzer::TPC.AddValueForMemcmp(caller_pc, s1, s2, n, /*StopAtZero*/false);
-}
-
-ATTRIBUTE_INTERFACE ATTRIBUTE_NO_SANITIZE_MEMORY
-void __sanitizer_weak_hook_strncmp(void *caller_pc, const char *s1,
- const char *s2, size_t n, int result) {
- if (fuzzer::ScopedDoingMyOwnMemOrStr::DoingMyOwnMemOrStr) return;
- if (result == 0) return; // No reason to mutate.
- size_t Len1 = fuzzer::InternalStrnlen(s1, n);
- size_t Len2 = fuzzer::InternalStrnlen(s2, n);
- n = std::min(n, Len1);
- n = std::min(n, Len2);
- if (n <= 1) return; // Not interesting.
- fuzzer::TPC.AddValueForMemcmp(caller_pc, s1, s2, n, /*StopAtZero*/true);
-}
-
-ATTRIBUTE_INTERFACE ATTRIBUTE_NO_SANITIZE_MEMORY
-void __sanitizer_weak_hook_strcmp(void *caller_pc, const char *s1,
- const char *s2, int result) {
- if (fuzzer::ScopedDoingMyOwnMemOrStr::DoingMyOwnMemOrStr) return;
- if (result == 0) return; // No reason to mutate.
- size_t N = fuzzer::InternalStrnlen2(s1, s2);
- if (N <= 1) return; // Not interesting.
- fuzzer::TPC.AddValueForMemcmp(caller_pc, s1, s2, N, /*StopAtZero*/true);
-}
-
-ATTRIBUTE_INTERFACE ATTRIBUTE_NO_SANITIZE_MEMORY
-void __sanitizer_weak_hook_strncasecmp(void *called_pc, const char *s1,
- const char *s2, size_t n, int result) {
- if (fuzzer::ScopedDoingMyOwnMemOrStr::DoingMyOwnMemOrStr) return;
- return __sanitizer_weak_hook_strncmp(called_pc, s1, s2, n, result);
-}
-
-ATTRIBUTE_INTERFACE ATTRIBUTE_NO_SANITIZE_MEMORY
-void __sanitizer_weak_hook_strcasecmp(void *called_pc, const char *s1,
- const char *s2, int result) {
- if (fuzzer::ScopedDoingMyOwnMemOrStr::DoingMyOwnMemOrStr) return;
- return __sanitizer_weak_hook_strcmp(called_pc, s1, s2, result);
-}
-
-ATTRIBUTE_INTERFACE ATTRIBUTE_NO_SANITIZE_MEMORY
-void __sanitizer_weak_hook_strstr(void *called_pc, const char *s1,
- const char *s2, char *result) {
- if (fuzzer::ScopedDoingMyOwnMemOrStr::DoingMyOwnMemOrStr) return;
- fuzzer::TPC.MMT.Add(reinterpret_cast<const uint8_t *>(s2), strlen(s2));
-}
-
-ATTRIBUTE_INTERFACE ATTRIBUTE_NO_SANITIZE_MEMORY
-void __sanitizer_weak_hook_strcasestr(void *called_pc, const char *s1,
- const char *s2, char *result) {
- if (fuzzer::ScopedDoingMyOwnMemOrStr::DoingMyOwnMemOrStr) return;
- fuzzer::TPC.MMT.Add(reinterpret_cast<const uint8_t *>(s2), strlen(s2));
-}
-
-ATTRIBUTE_INTERFACE ATTRIBUTE_NO_SANITIZE_MEMORY
-void __sanitizer_weak_hook_memmem(void *called_pc, const void *s1, size_t len1,
- const void *s2, size_t len2, void *result) {
- if (fuzzer::ScopedDoingMyOwnMemOrStr::DoingMyOwnMemOrStr) return;
- fuzzer::TPC.MMT.Add(reinterpret_cast<const uint8_t *>(s2), len2);
-}
-} // extern "C"
Removed: llvm/trunk/lib/Fuzzer/FuzzerTracePC.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Fuzzer/FuzzerTracePC.h?rev=315936&view=auto
==============================================================================
--- llvm/trunk/lib/Fuzzer/FuzzerTracePC.h (original)
+++ llvm/trunk/lib/Fuzzer/FuzzerTracePC.h (removed)
@@ -1,257 +0,0 @@
-//===- FuzzerTracePC.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.
-//
-//===----------------------------------------------------------------------===//
-// fuzzer::TracePC
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_FUZZER_TRACE_PC
-#define LLVM_FUZZER_TRACE_PC
-
-#include "FuzzerDefs.h"
-#include "FuzzerDictionary.h"
-#include "FuzzerValueBitMap.h"
-
-#include <set>
-
-namespace fuzzer {
-
-// TableOfRecentCompares (TORC) remembers the most recently performed
-// comparisons of type T.
-// We record the arguments of CMP instructions in this table unconditionally
-// because it seems cheaper this way than to compute some expensive
-// conditions inside __sanitizer_cov_trace_cmp*.
-// After the unit has been executed we may decide to use the contents of
-// this table to populate a Dictionary.
-template<class T, size_t kSizeT>
-struct TableOfRecentCompares {
- static const size_t kSize = kSizeT;
- struct Pair {
- T A, B;
- };
- ATTRIBUTE_NO_SANITIZE_ALL
- void Insert(size_t Idx, const T &Arg1, const T &Arg2) {
- Idx = Idx % kSize;
- Table[Idx].A = Arg1;
- Table[Idx].B = Arg2;
- }
-
- Pair Get(size_t I) { return Table[I % kSize]; }
-
- Pair Table[kSize];
-};
-
-template <size_t kSizeT>
-struct MemMemTable {
- static const size_t kSize = kSizeT;
- Word MemMemWords[kSize];
- Word EmptyWord;
-
- void Add(const uint8_t *Data, size_t Size) {
- if (Size <= 2) return;
- Size = std::min(Size, Word::GetMaxSize());
- size_t Idx = SimpleFastHash(Data, Size) % kSize;
- MemMemWords[Idx].Set(Data, Size);
- }
- const Word &Get(size_t Idx) {
- for (size_t i = 0; i < kSize; i++) {
- const Word &W = MemMemWords[(Idx + i) % kSize];
- if (W.size()) return W;
- }
- EmptyWord.Set(nullptr, 0);
- return EmptyWord;
- }
-};
-
-class TracePC {
- public:
- static const size_t kNumPCs = 1 << 21;
- // How many bits of PC are used from __sanitizer_cov_trace_pc.
- static const size_t kTracePcBits = 18;
-
- void HandleInit(uint32_t *Start, uint32_t *Stop);
- void HandleInline8bitCountersInit(uint8_t *Start, uint8_t *Stop);
- void HandlePCsInit(const uint8_t *Start, const uint8_t *Stop);
- void HandleCallerCallee(uintptr_t Caller, uintptr_t Callee);
- template <class T> void HandleCmp(uintptr_t PC, T Arg1, T Arg2);
- size_t GetTotalPCCoverage();
- void SetUseCounters(bool UC) { UseCounters = UC; }
- void SetUseValueProfile(bool VP) { UseValueProfile = VP; }
- void SetPrintNewPCs(bool P) { DoPrintNewPCs = P; }
- void UpdateObservedPCs();
- template <class Callback> void CollectFeatures(Callback CB) const;
-
- void ResetMaps() {
- ValueProfileMap.Reset();
- if (NumModules)
- memset(Counters(), 0, GetNumPCs());
- ClearExtraCounters();
- ClearInlineCounters();
- ClearClangCounters();
- }
-
- void ClearInlineCounters();
-
- void UpdateFeatureSet(size_t CurrentElementIdx, size_t CurrentElementSize);
- void PrintFeatureSet();
-
- void PrintModuleInfo();
-
- void PrintCoverage();
- void DumpCoverage();
-
- void AddValueForMemcmp(void *caller_pc, const void *s1, const void *s2,
- size_t n, bool StopAtZero);
-
- TableOfRecentCompares<uint32_t, 32> TORC4;
- TableOfRecentCompares<uint64_t, 32> TORC8;
- TableOfRecentCompares<Word, 32> TORCW;
- MemMemTable<1024> MMT;
-
- size_t GetNumPCs() const {
- return NumGuards == 0 ? (1 << kTracePcBits) : Min(kNumPCs, NumGuards + 1);
- }
- uintptr_t GetPC(size_t Idx) {
- assert(Idx < GetNumPCs());
- return PCs()[Idx];
- }
-
- void RecordInitialStack();
- uintptr_t GetMaxStackOffset() const;
-
- template<class CallBack>
- void ForEachObservedPC(CallBack CB) {
- for (auto PC : ObservedPCs)
- CB(PC);
- }
-
-private:
- bool UseCounters = false;
- bool UseValueProfile = false;
- bool DoPrintNewPCs = false;
-
- struct Module {
- uint32_t *Start, *Stop;
- };
-
- Module Modules[4096];
- size_t NumModules; // linker-initialized.
- size_t NumGuards; // linker-initialized.
-
- struct { uint8_t *Start, *Stop; } ModuleCounters[4096];
- size_t NumModulesWithInline8bitCounters; // linker-initialized.
- size_t NumInline8bitCounters;
-
- struct { const uintptr_t *Start, *Stop; } ModulePCTable[4096];
- size_t NumPCTables;
- size_t NumPCsInPCTables;
-
- uint8_t *Counters() const;
- uintptr_t *PCs() const;
-
- std::set<uintptr_t> ObservedPCs;
-
- ValueBitMap ValueProfileMap;
- uintptr_t InitialStack;
-};
-
-template <class Callback>
-// void Callback(size_t FirstFeature, size_t Idx, uint8_t Value);
-ATTRIBUTE_NO_SANITIZE_ALL
-void ForEachNonZeroByte(const uint8_t *Begin, const uint8_t *End,
- size_t FirstFeature, Callback Handle8bitCounter) {
- typedef uintptr_t LargeType;
- const size_t Step = sizeof(LargeType) / sizeof(uint8_t);
- const size_t StepMask = Step - 1;
- auto P = Begin;
- // Iterate by 1 byte until either the alignment boundary or the end.
- for (; reinterpret_cast<uintptr_t>(P) & StepMask && P < End; P++)
- if (uint8_t V = *P)
- Handle8bitCounter(FirstFeature, P - Begin, V);
-
- // Iterate by Step bytes at a time.
- for (; P < End; P += Step)
- if (LargeType Bundle = *reinterpret_cast<const LargeType *>(P))
- for (size_t I = 0; I < Step; I++, Bundle >>= 8)
- if (uint8_t V = Bundle & 0xff)
- Handle8bitCounter(FirstFeature, P - Begin + I, V);
-
- // Iterate by 1 byte until the end.
- for (; P < End; P++)
- if (uint8_t V = *P)
- Handle8bitCounter(FirstFeature, P - Begin, V);
-}
-
-// Given a non-zero Counters returns a number in [0,7].
-template<class T>
-unsigned CounterToFeature(T Counter) {
- assert(Counter);
- unsigned Bit = 0;
- /**/ if (Counter >= 128) Bit = 7;
- else if (Counter >= 32) Bit = 6;
- else if (Counter >= 16) Bit = 5;
- else if (Counter >= 8) Bit = 4;
- else if (Counter >= 4) Bit = 3;
- else if (Counter >= 3) Bit = 2;
- else if (Counter >= 2) Bit = 1;
- return Bit;
-}
-
-template <class Callback> // bool Callback(size_t Feature)
-ATTRIBUTE_NO_SANITIZE_ADDRESS
-__attribute__((noinline))
-void TracePC::CollectFeatures(Callback HandleFeature) const {
- uint8_t *Counters = this->Counters();
- size_t N = GetNumPCs();
- auto Handle8bitCounter = [&](size_t FirstFeature,
- size_t Idx, uint8_t Counter) {
- HandleFeature(FirstFeature + Idx * 8 + CounterToFeature(Counter));
- };
-
- size_t FirstFeature = 0;
-
- if (!NumInline8bitCounters) {
- ForEachNonZeroByte(Counters, Counters + N, FirstFeature, Handle8bitCounter);
- FirstFeature += N * 8;
- }
-
- if (NumInline8bitCounters) {
- for (size_t i = 0; i < NumModulesWithInline8bitCounters; i++) {
- ForEachNonZeroByte(ModuleCounters[i].Start, ModuleCounters[i].Stop,
- FirstFeature, Handle8bitCounter);
- FirstFeature += 8 * (ModuleCounters[i].Stop - ModuleCounters[i].Start);
- }
- }
-
- if (size_t NumClangCounters = ClangCountersEnd() - ClangCountersBegin()) {
- auto P = ClangCountersBegin();
- for (size_t Idx = 0; Idx < NumClangCounters; Idx++)
- if (auto Cnt = P[Idx])
- HandleFeature(FirstFeature + Idx * 8 + CounterToFeature(Cnt));
- FirstFeature += NumClangCounters;
- }
-
- ForEachNonZeroByte(ExtraCountersBegin(), ExtraCountersEnd(), FirstFeature,
- Handle8bitCounter);
- FirstFeature += (ExtraCountersEnd() - ExtraCountersBegin()) * 8;
-
- if (UseValueProfile) {
- ValueProfileMap.ForEach([&](size_t Idx) {
- HandleFeature(FirstFeature + Idx);
- });
- FirstFeature += ValueProfileMap.SizeInBits();
- }
-
- if (auto MaxStackOffset = GetMaxStackOffset())
- HandleFeature(FirstFeature + MaxStackOffset);
-}
-
-extern TracePC TPC;
-
-} // namespace fuzzer
-
-#endif // LLVM_FUZZER_TRACE_PC
Removed: llvm/trunk/lib/Fuzzer/FuzzerUtil.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Fuzzer/FuzzerUtil.cpp?rev=315936&view=auto
==============================================================================
--- llvm/trunk/lib/Fuzzer/FuzzerUtil.cpp (original)
+++ llvm/trunk/lib/Fuzzer/FuzzerUtil.cpp (removed)
@@ -1,215 +0,0 @@
-//===- FuzzerUtil.cpp - Misc utils ----------------------------------------===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-// Misc utils.
-//===----------------------------------------------------------------------===//
-
-#include "FuzzerUtil.h"
-#include "FuzzerIO.h"
-#include "FuzzerInternal.h"
-#include <cassert>
-#include <chrono>
-#include <cstring>
-#include <errno.h>
-#include <signal.h>
-#include <sstream>
-#include <stdio.h>
-#include <sys/types.h>
-#include <thread>
-
-namespace fuzzer {
-
-void PrintHexArray(const uint8_t *Data, size_t Size,
- const char *PrintAfter) {
- for (size_t i = 0; i < Size; i++)
- Printf("0x%x,", (unsigned)Data[i]);
- Printf("%s", PrintAfter);
-}
-
-void Print(const Unit &v, const char *PrintAfter) {
- PrintHexArray(v.data(), v.size(), PrintAfter);
-}
-
-void PrintASCIIByte(uint8_t Byte) {
- if (Byte == '\\')
- Printf("\\\\");
- else if (Byte == '"')
- Printf("\\\"");
- else if (Byte >= 32 && Byte < 127)
- Printf("%c", Byte);
- else
- Printf("\\x%02x", Byte);
-}
-
-void PrintASCII(const uint8_t *Data, size_t Size, const char *PrintAfter) {
- for (size_t i = 0; i < Size; i++)
- PrintASCIIByte(Data[i]);
- Printf("%s", PrintAfter);
-}
-
-void PrintASCII(const Unit &U, const char *PrintAfter) {
- PrintASCII(U.data(), U.size(), PrintAfter);
-}
-
-bool ToASCII(uint8_t *Data, size_t Size) {
- bool Changed = false;
- for (size_t i = 0; i < Size; i++) {
- uint8_t &X = Data[i];
- auto NewX = X;
- NewX &= 127;
- if (!isspace(NewX) && !isprint(NewX))
- NewX = ' ';
- Changed |= NewX != X;
- X = NewX;
- }
- return Changed;
-}
-
-bool IsASCII(const Unit &U) { return IsASCII(U.data(), U.size()); }
-
-bool IsASCII(const uint8_t *Data, size_t Size) {
- for (size_t i = 0; i < Size; i++)
- if (!(isprint(Data[i]) || isspace(Data[i]))) return false;
- return true;
-}
-
-bool ParseOneDictionaryEntry(const std::string &Str, Unit *U) {
- U->clear();
- if (Str.empty()) return false;
- size_t L = 0, R = Str.size() - 1; // We are parsing the range [L,R].
- // Skip spaces from both sides.
- while (L < R && isspace(Str[L])) L++;
- while (R > L && isspace(Str[R])) R--;
- if (R - L < 2) return false;
- // Check the closing "
- if (Str[R] != '"') return false;
- R--;
- // Find the opening "
- while (L < R && Str[L] != '"') L++;
- if (L >= R) return false;
- assert(Str[L] == '\"');
- L++;
- assert(L <= R);
- for (size_t Pos = L; Pos <= R; Pos++) {
- uint8_t V = (uint8_t)Str[Pos];
- if (!isprint(V) && !isspace(V)) return false;
- if (V =='\\') {
- // Handle '\\'
- if (Pos + 1 <= R && (Str[Pos + 1] == '\\' || Str[Pos + 1] == '"')) {
- U->push_back(Str[Pos + 1]);
- Pos++;
- continue;
- }
- // Handle '\xAB'
- if (Pos + 3 <= R && Str[Pos + 1] == 'x'
- && isxdigit(Str[Pos + 2]) && isxdigit(Str[Pos + 3])) {
- char Hex[] = "0xAA";
- Hex[2] = Str[Pos + 2];
- Hex[3] = Str[Pos + 3];
- U->push_back(strtol(Hex, nullptr, 16));
- Pos += 3;
- continue;
- }
- return false; // Invalid escape.
- } else {
- // Any other character.
- U->push_back(V);
- }
- }
- return true;
-}
-
-bool ParseDictionaryFile(const std::string &Text, std::vector<Unit> *Units) {
- if (Text.empty()) {
- Printf("ParseDictionaryFile: file does not exist or is empty\n");
- return false;
- }
- std::istringstream ISS(Text);
- Units->clear();
- Unit U;
- int LineNo = 0;
- std::string S;
- while (std::getline(ISS, S, '\n')) {
- LineNo++;
- size_t Pos = 0;
- while (Pos < S.size() && isspace(S[Pos])) Pos++; // Skip spaces.
- if (Pos == S.size()) continue; // Empty line.
- if (S[Pos] == '#') continue; // Comment line.
- if (ParseOneDictionaryEntry(S, &U)) {
- Units->push_back(U);
- } else {
- Printf("ParseDictionaryFile: error in line %d\n\t\t%s\n", LineNo,
- S.c_str());
- return false;
- }
- }
- return true;
-}
-
-std::string Base64(const Unit &U) {
- static const char Table[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
- "abcdefghijklmnopqrstuvwxyz"
- "0123456789+/";
- std::string Res;
- size_t i;
- for (i = 0; i + 2 < U.size(); i += 3) {
- uint32_t x = (U[i] << 16) + (U[i + 1] << 8) + U[i + 2];
- Res += Table[(x >> 18) & 63];
- Res += Table[(x >> 12) & 63];
- Res += Table[(x >> 6) & 63];
- Res += Table[x & 63];
- }
- if (i + 1 == U.size()) {
- uint32_t x = (U[i] << 16);
- Res += Table[(x >> 18) & 63];
- Res += Table[(x >> 12) & 63];
- Res += "==";
- } else if (i + 2 == U.size()) {
- uint32_t x = (U[i] << 16) + (U[i + 1] << 8);
- Res += Table[(x >> 18) & 63];
- Res += Table[(x >> 12) & 63];
- Res += Table[(x >> 6) & 63];
- Res += "=";
- }
- return Res;
-}
-
-std::string DescribePC(const char *SymbolizedFMT, uintptr_t PC) {
- if (!EF->__sanitizer_symbolize_pc) return "<can not symbolize>";
- char PcDescr[1024];
- EF->__sanitizer_symbolize_pc(reinterpret_cast<void*>(PC),
- SymbolizedFMT, PcDescr, sizeof(PcDescr));
- PcDescr[sizeof(PcDescr) - 1] = 0; // Just in case.
- return PcDescr;
-}
-
-void PrintPC(const char *SymbolizedFMT, const char *FallbackFMT, uintptr_t PC) {
- if (EF->__sanitizer_symbolize_pc)
- Printf("%s", DescribePC(SymbolizedFMT, PC).c_str());
- else
- Printf(FallbackFMT, PC);
-}
-
-unsigned NumberOfCpuCores() {
- unsigned N = std::thread::hardware_concurrency();
- if (!N) {
- Printf("WARNING: std::thread::hardware_concurrency not well defined for "
- "your platform. Assuming CPU count of 1.\n");
- N = 1;
- }
- return N;
-}
-
-size_t SimpleFastHash(const uint8_t *Data, size_t Size) {
- size_t Res = 0;
- for (size_t i = 0; i < Size; i++)
- Res = Res * 11 + Data[i];
- return Res;
-}
-
-} // namespace fuzzer
Removed: llvm/trunk/lib/Fuzzer/FuzzerUtil.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Fuzzer/FuzzerUtil.h?rev=315936&view=auto
==============================================================================
--- llvm/trunk/lib/Fuzzer/FuzzerUtil.h (original)
+++ llvm/trunk/lib/Fuzzer/FuzzerUtil.h (removed)
@@ -1,84 +0,0 @@
-//===- FuzzerUtil.h - Internal header for the Fuzzer Utils ------*- C++ -* ===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-// Util functions.
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_FUZZER_UTIL_H
-#define LLVM_FUZZER_UTIL_H
-
-#include "FuzzerDefs.h"
-
-namespace fuzzer {
-
-void PrintHexArray(const Unit &U, const char *PrintAfter = "");
-
-void PrintHexArray(const uint8_t *Data, size_t Size,
- const char *PrintAfter = "");
-
-void PrintASCII(const uint8_t *Data, size_t Size, const char *PrintAfter = "");
-
-void PrintASCII(const Unit &U, const char *PrintAfter = "");
-
-// Changes U to contain only ASCII (isprint+isspace) characters.
-// Returns true iff U has been changed.
-bool ToASCII(uint8_t *Data, size_t Size);
-
-bool IsASCII(const Unit &U);
-
-bool IsASCII(const uint8_t *Data, size_t Size);
-
-std::string Base64(const Unit &U);
-
-void PrintPC(const char *SymbolizedFMT, const char *FallbackFMT, uintptr_t PC);
-
-std::string DescribePC(const char *SymbolizedFMT, uintptr_t PC);
-
-unsigned NumberOfCpuCores();
-
-// Platform specific functions.
-void SetSignalHandler(const FuzzingOptions& Options);
-
-void SleepSeconds(int Seconds);
-
-unsigned long GetPid();
-
-size_t GetPeakRSSMb();
-
-int ExecuteCommand(const std::string &Command);
-
-FILE *OpenProcessPipe(const char *Command, const char *Mode);
-
-const void *SearchMemory(const void *haystack, size_t haystacklen,
- const void *needle, size_t needlelen);
-
-std::string CloneArgsWithoutX(const std::vector<std::string> &Args,
- const char *X1, const char *X2);
-
-inline std::string CloneArgsWithoutX(const std::vector<std::string> &Args,
- const char *X) {
- return CloneArgsWithoutX(Args, X, X);
-}
-
-inline std::pair<std::string, std::string> SplitBefore(std::string X,
- std::string S) {
- auto Pos = S.find(X);
- if (Pos == std::string::npos)
- return std::make_pair(S, "");
- return std::make_pair(S.substr(0, Pos), S.substr(Pos));
-}
-
-std::string DisassembleCmd(const std::string &FileName);
-
-std::string SearchRegexCmd(const std::string &Regex);
-
-size_t SimpleFastHash(const uint8_t *Data, size_t Size);
-
-} // namespace fuzzer
-
-#endif // LLVM_FUZZER_UTIL_H
Removed: llvm/trunk/lib/Fuzzer/FuzzerUtilDarwin.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Fuzzer/FuzzerUtilDarwin.cpp?rev=315936&view=auto
==============================================================================
--- llvm/trunk/lib/Fuzzer/FuzzerUtilDarwin.cpp (original)
+++ llvm/trunk/lib/Fuzzer/FuzzerUtilDarwin.cpp (removed)
@@ -1,161 +0,0 @@
-//===- FuzzerUtilDarwin.cpp - Misc utils ----------------------------------===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-// Misc utils for Darwin.
-//===----------------------------------------------------------------------===//
-#include "FuzzerDefs.h"
-#if LIBFUZZER_APPLE
-
-#include "FuzzerIO.h"
-#include <mutex>
-#include <signal.h>
-#include <spawn.h>
-#include <stdlib.h>
-#include <string.h>
-#include <sys/wait.h>
-
-// There is no header for this on macOS so declare here
-extern "C" char **environ;
-
-namespace fuzzer {
-
-static std::mutex SignalMutex;
-// Global variables used to keep track of how signal handling should be
-// restored. They should **not** be accessed without holding `SignalMutex`.
-static int ActiveThreadCount = 0;
-static struct sigaction OldSigIntAction;
-static struct sigaction OldSigQuitAction;
-static sigset_t OldBlockedSignalsSet;
-
-// This is a reimplementation of Libc's `system()`. On Darwin the Libc
-// implementation contains a mutex which prevents it from being used
-// concurrently. This implementation **can** be used concurrently. It sets the
-// signal handlers when the first thread enters and restores them when the last
-// thread finishes execution of the function and ensures this is not racey by
-// using a mutex.
-int ExecuteCommand(const std::string &Command) {
- posix_spawnattr_t SpawnAttributes;
- if (posix_spawnattr_init(&SpawnAttributes))
- return -1;
- // Block and ignore signals of the current process when the first thread
- // enters.
- {
- std::lock_guard<std::mutex> Lock(SignalMutex);
- if (ActiveThreadCount == 0) {
- static struct sigaction IgnoreSignalAction;
- sigset_t BlockedSignalsSet;
- memset(&IgnoreSignalAction, 0, sizeof(IgnoreSignalAction));
- IgnoreSignalAction.sa_handler = SIG_IGN;
-
- if (sigaction(SIGINT, &IgnoreSignalAction, &OldSigIntAction) == -1) {
- Printf("Failed to ignore SIGINT\n");
- (void)posix_spawnattr_destroy(&SpawnAttributes);
- return -1;
- }
- if (sigaction(SIGQUIT, &IgnoreSignalAction, &OldSigQuitAction) == -1) {
- Printf("Failed to ignore SIGQUIT\n");
- // Try our best to restore the signal handlers.
- (void)sigaction(SIGINT, &OldSigIntAction, NULL);
- (void)posix_spawnattr_destroy(&SpawnAttributes);
- return -1;
- }
-
- (void)sigemptyset(&BlockedSignalsSet);
- (void)sigaddset(&BlockedSignalsSet, SIGCHLD);
- if (sigprocmask(SIG_BLOCK, &BlockedSignalsSet, &OldBlockedSignalsSet) ==
- -1) {
- Printf("Failed to block SIGCHLD\n");
- // Try our best to restore the signal handlers.
- (void)sigaction(SIGQUIT, &OldSigQuitAction, NULL);
- (void)sigaction(SIGINT, &OldSigIntAction, NULL);
- (void)posix_spawnattr_destroy(&SpawnAttributes);
- return -1;
- }
- }
- ++ActiveThreadCount;
- }
-
- // NOTE: Do not introduce any new `return` statements past this
- // point. It is important that `ActiveThreadCount` always be decremented
- // when leaving this function.
-
- // Make sure the child process uses the default handlers for the
- // following signals rather than inheriting what the parent has.
- sigset_t DefaultSigSet;
- (void)sigemptyset(&DefaultSigSet);
- (void)sigaddset(&DefaultSigSet, SIGQUIT);
- (void)sigaddset(&DefaultSigSet, SIGINT);
- (void)posix_spawnattr_setsigdefault(&SpawnAttributes, &DefaultSigSet);
- // Make sure the child process doesn't block SIGCHLD
- (void)posix_spawnattr_setsigmask(&SpawnAttributes, &OldBlockedSignalsSet);
- short SpawnFlags = POSIX_SPAWN_SETSIGDEF | POSIX_SPAWN_SETSIGMASK;
- (void)posix_spawnattr_setflags(&SpawnAttributes, SpawnFlags);
-
- pid_t Pid;
- char **Environ = environ; // Read from global
- const char *CommandCStr = Command.c_str();
- char *const Argv[] = {
- strdup("sh"),
- strdup("-c"),
- strdup(CommandCStr),
- NULL
- };
- int ErrorCode = 0, ProcessStatus = 0;
- // FIXME: We probably shouldn't hardcode the shell path.
- ErrorCode = posix_spawn(&Pid, "/bin/sh", NULL, &SpawnAttributes,
- Argv, Environ);
- (void)posix_spawnattr_destroy(&SpawnAttributes);
- if (!ErrorCode) {
- pid_t SavedPid = Pid;
- do {
- // Repeat until call completes uninterrupted.
- Pid = waitpid(SavedPid, &ProcessStatus, /*options=*/0);
- } while (Pid == -1 && errno == EINTR);
- if (Pid == -1) {
- // Fail for some other reason.
- ProcessStatus = -1;
- }
- } else if (ErrorCode == ENOMEM || ErrorCode == EAGAIN) {
- // Fork failure.
- ProcessStatus = -1;
- } else {
- // Shell execution failure.
- ProcessStatus = W_EXITCODE(127, 0);
- }
- for (unsigned i = 0, n = sizeof(Argv) / sizeof(Argv[0]); i < n; ++i)
- free(Argv[i]);
-
- // Restore the signal handlers of the current process when the last thread
- // using this function finishes.
- {
- std::lock_guard<std::mutex> Lock(SignalMutex);
- --ActiveThreadCount;
- if (ActiveThreadCount == 0) {
- bool FailedRestore = false;
- if (sigaction(SIGINT, &OldSigIntAction, NULL) == -1) {
- Printf("Failed to restore SIGINT handling\n");
- FailedRestore = true;
- }
- if (sigaction(SIGQUIT, &OldSigQuitAction, NULL) == -1) {
- Printf("Failed to restore SIGQUIT handling\n");
- FailedRestore = true;
- }
- if (sigprocmask(SIG_BLOCK, &OldBlockedSignalsSet, NULL) == -1) {
- Printf("Failed to unblock SIGCHLD\n");
- FailedRestore = true;
- }
- if (FailedRestore)
- ProcessStatus = -1;
- }
- }
- return ProcessStatus;
-}
-
-} // namespace fuzzer
-
-#endif // LIBFUZZER_APPLE
Removed: llvm/trunk/lib/Fuzzer/FuzzerUtilLinux.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Fuzzer/FuzzerUtilLinux.cpp?rev=315936&view=auto
==============================================================================
--- llvm/trunk/lib/Fuzzer/FuzzerUtilLinux.cpp (original)
+++ llvm/trunk/lib/Fuzzer/FuzzerUtilLinux.cpp (removed)
@@ -1,24 +0,0 @@
-//===- FuzzerUtilLinux.cpp - Misc utils for Linux. ------------------------===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-// Misc utils for Linux.
-//===----------------------------------------------------------------------===//
-#include "FuzzerDefs.h"
-#if LIBFUZZER_LINUX
-
-#include <stdlib.h>
-
-namespace fuzzer {
-
-int ExecuteCommand(const std::string &Command) {
- return system(Command.c_str());
-}
-
-} // namespace fuzzer
-
-#endif // LIBFUZZER_LINUX
Removed: llvm/trunk/lib/Fuzzer/FuzzerUtilPosix.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Fuzzer/FuzzerUtilPosix.cpp?rev=315936&view=auto
==============================================================================
--- llvm/trunk/lib/Fuzzer/FuzzerUtilPosix.cpp (original)
+++ llvm/trunk/lib/Fuzzer/FuzzerUtilPosix.cpp (removed)
@@ -1,144 +0,0 @@
-//===- FuzzerUtilPosix.cpp - Misc utils for Posix. ------------------------===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-// Misc utils implementation using Posix API.
-//===----------------------------------------------------------------------===//
-#include "FuzzerDefs.h"
-#if LIBFUZZER_POSIX
-#include "FuzzerIO.h"
-#include "FuzzerInternal.h"
-#include <cassert>
-#include <chrono>
-#include <cstring>
-#include <errno.h>
-#include <iomanip>
-#include <signal.h>
-#include <sstream>
-#include <stdio.h>
-#include <sys/resource.h>
-#include <sys/syscall.h>
-#include <sys/time.h>
-#include <sys/types.h>
-#include <thread>
-#include <unistd.h>
-
-namespace fuzzer {
-
-static void AlarmHandler(int, siginfo_t *, void *) {
- Fuzzer::StaticAlarmCallback();
-}
-
-static void CrashHandler(int, siginfo_t *, void *) {
- Fuzzer::StaticCrashSignalCallback();
-}
-
-static void InterruptHandler(int, siginfo_t *, void *) {
- Fuzzer::StaticInterruptCallback();
-}
-
-static void FileSizeExceedHandler(int, siginfo_t *, void *) {
- Fuzzer::StaticFileSizeExceedCallback();
-}
-
-static void SetSigaction(int signum,
- void (*callback)(int, siginfo_t *, void *)) {
- struct sigaction sigact = {};
- if (sigaction(signum, nullptr, &sigact)) {
- Printf("libFuzzer: sigaction failed with %d\n", errno);
- exit(1);
- }
- if (sigact.sa_flags & SA_SIGINFO) {
- if (sigact.sa_sigaction)
- return;
- } else {
- if (sigact.sa_handler != SIG_DFL && sigact.sa_handler != SIG_IGN &&
- sigact.sa_handler != SIG_ERR)
- return;
- }
-
- sigact = {};
- sigact.sa_sigaction = callback;
- if (sigaction(signum, &sigact, 0)) {
- Printf("libFuzzer: sigaction failed with %d\n", errno);
- exit(1);
- }
-}
-
-void SetTimer(int Seconds) {
- struct itimerval T {
- {Seconds, 0}, { Seconds, 0 }
- };
- if (setitimer(ITIMER_REAL, &T, nullptr)) {
- Printf("libFuzzer: setitimer failed with %d\n", errno);
- exit(1);
- }
- SetSigaction(SIGALRM, AlarmHandler);
-}
-
-void SetSignalHandler(const FuzzingOptions& Options) {
- if (Options.UnitTimeoutSec > 0)
- SetTimer(Options.UnitTimeoutSec / 2 + 1);
- if (Options.HandleInt)
- SetSigaction(SIGINT, InterruptHandler);
- if (Options.HandleTerm)
- SetSigaction(SIGTERM, InterruptHandler);
- if (Options.HandleSegv)
- SetSigaction(SIGSEGV, CrashHandler);
- if (Options.HandleBus)
- SetSigaction(SIGBUS, CrashHandler);
- if (Options.HandleAbrt)
- SetSigaction(SIGABRT, CrashHandler);
- if (Options.HandleIll)
- SetSigaction(SIGILL, CrashHandler);
- if (Options.HandleFpe)
- SetSigaction(SIGFPE, CrashHandler);
- if (Options.HandleXfsz)
- SetSigaction(SIGXFSZ, FileSizeExceedHandler);
-}
-
-void SleepSeconds(int Seconds) {
- sleep(Seconds); // Use C API to avoid coverage from instrumented libc++.
-}
-
-unsigned long GetPid() { return (unsigned long)getpid(); }
-
-size_t GetPeakRSSMb() {
- struct rusage usage;
- if (getrusage(RUSAGE_SELF, &usage))
- return 0;
- if (LIBFUZZER_LINUX) {
- // ru_maxrss is in KiB
- return usage.ru_maxrss >> 10;
- } else if (LIBFUZZER_APPLE) {
- // ru_maxrss is in bytes
- return usage.ru_maxrss >> 20;
- }
- assert(0 && "GetPeakRSSMb() is not implemented for your platform");
- return 0;
-}
-
-FILE *OpenProcessPipe(const char *Command, const char *Mode) {
- return popen(Command, Mode);
-}
-
-const void *SearchMemory(const void *Data, size_t DataLen, const void *Patt,
- size_t PattLen) {
- return memmem(Data, DataLen, Patt, PattLen);
-}
-
-std::string DisassembleCmd(const std::string &FileName) {
- return "objdump -d " + FileName;
-}
-
-std::string SearchRegexCmd(const std::string &Regex) {
- return "grep '" + Regex + "'";
-}
-
-} // namespace fuzzer
-
-#endif // LIBFUZZER_POSIX
Removed: llvm/trunk/lib/Fuzzer/FuzzerUtilWindows.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Fuzzer/FuzzerUtilWindows.cpp?rev=315936&view=auto
==============================================================================
--- llvm/trunk/lib/Fuzzer/FuzzerUtilWindows.cpp (original)
+++ llvm/trunk/lib/Fuzzer/FuzzerUtilWindows.cpp (removed)
@@ -1,193 +0,0 @@
-//===- FuzzerUtilWindows.cpp - Misc utils for Windows. --------------------===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-// Misc utils implementation for Windows.
-//===----------------------------------------------------------------------===//
-#include "FuzzerDefs.h"
-#if LIBFUZZER_WINDOWS
-#include "FuzzerIO.h"
-#include "FuzzerInternal.h"
-#include <cassert>
-#include <chrono>
-#include <cstring>
-#include <errno.h>
-#include <iomanip>
-#include <signal.h>
-#include <sstream>
-#include <stdio.h>
-#include <sys/types.h>
-#include <windows.h>
-
-// This must be included after windows.h.
-#include <Psapi.h>
-
-namespace fuzzer {
-
-static const FuzzingOptions* HandlerOpt = nullptr;
-
-static LONG CALLBACK ExceptionHandler(PEXCEPTION_POINTERS ExceptionInfo) {
- switch (ExceptionInfo->ExceptionRecord->ExceptionCode) {
- case EXCEPTION_ACCESS_VIOLATION:
- case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
- case EXCEPTION_STACK_OVERFLOW:
- if (HandlerOpt->HandleSegv)
- Fuzzer::StaticCrashSignalCallback();
- break;
- case EXCEPTION_DATATYPE_MISALIGNMENT:
- case EXCEPTION_IN_PAGE_ERROR:
- if (HandlerOpt->HandleBus)
- Fuzzer::StaticCrashSignalCallback();
- break;
- case EXCEPTION_ILLEGAL_INSTRUCTION:
- case EXCEPTION_PRIV_INSTRUCTION:
- if (HandlerOpt->HandleIll)
- Fuzzer::StaticCrashSignalCallback();
- break;
- case EXCEPTION_FLT_DENORMAL_OPERAND:
- case EXCEPTION_FLT_DIVIDE_BY_ZERO:
- case EXCEPTION_FLT_INEXACT_RESULT:
- case EXCEPTION_FLT_INVALID_OPERATION:
- case EXCEPTION_FLT_OVERFLOW:
- case EXCEPTION_FLT_STACK_CHECK:
- case EXCEPTION_FLT_UNDERFLOW:
- case EXCEPTION_INT_DIVIDE_BY_ZERO:
- case EXCEPTION_INT_OVERFLOW:
- if (HandlerOpt->HandleFpe)
- Fuzzer::StaticCrashSignalCallback();
- break;
- // TODO: handle (Options.HandleXfsz)
- }
- return EXCEPTION_CONTINUE_SEARCH;
-}
-
-BOOL WINAPI CtrlHandler(DWORD dwCtrlType) {
- switch (dwCtrlType) {
- case CTRL_C_EVENT:
- if (HandlerOpt->HandleInt)
- Fuzzer::StaticInterruptCallback();
- return TRUE;
- case CTRL_BREAK_EVENT:
- if (HandlerOpt->HandleTerm)
- Fuzzer::StaticInterruptCallback();
- return TRUE;
- }
- return FALSE;
-}
-
-void CALLBACK AlarmHandler(PVOID, BOOLEAN) {
- Fuzzer::StaticAlarmCallback();
-}
-
-class TimerQ {
- HANDLE TimerQueue;
- public:
- TimerQ() : TimerQueue(NULL) {};
- ~TimerQ() {
- if (TimerQueue)
- DeleteTimerQueueEx(TimerQueue, NULL);
- };
- void SetTimer(int Seconds) {
- if (!TimerQueue) {
- TimerQueue = CreateTimerQueue();
- if (!TimerQueue) {
- Printf("libFuzzer: CreateTimerQueue failed.\n");
- exit(1);
- }
- }
- HANDLE Timer;
- if (!CreateTimerQueueTimer(&Timer, TimerQueue, AlarmHandler, NULL,
- Seconds*1000, Seconds*1000, 0)) {
- Printf("libFuzzer: CreateTimerQueueTimer failed.\n");
- exit(1);
- }
- };
-};
-
-static TimerQ Timer;
-
-static void CrashHandler(int) { Fuzzer::StaticCrashSignalCallback(); }
-
-void SetSignalHandler(const FuzzingOptions& Options) {
- HandlerOpt = &Options;
-
- if (Options.UnitTimeoutSec > 0)
- Timer.SetTimer(Options.UnitTimeoutSec / 2 + 1);
-
- if (Options.HandleInt || Options.HandleTerm)
- if (!SetConsoleCtrlHandler(CtrlHandler, TRUE)) {
- DWORD LastError = GetLastError();
- Printf("libFuzzer: SetConsoleCtrlHandler failed (Error code: %lu).\n",
- LastError);
- exit(1);
- }
-
- if (Options.HandleSegv || Options.HandleBus || Options.HandleIll ||
- Options.HandleFpe)
- SetUnhandledExceptionFilter(ExceptionHandler);
-
- if (Options.HandleAbrt)
- if (SIG_ERR == signal(SIGABRT, CrashHandler)) {
- Printf("libFuzzer: signal failed with %d\n", errno);
- exit(1);
- }
-}
-
-void SleepSeconds(int Seconds) { Sleep(Seconds * 1000); }
-
-unsigned long GetPid() { return GetCurrentProcessId(); }
-
-size_t GetPeakRSSMb() {
- PROCESS_MEMORY_COUNTERS info;
- if (!GetProcessMemoryInfo(GetCurrentProcess(), &info, sizeof(info)))
- return 0;
- return info.PeakWorkingSetSize >> 20;
-}
-
-FILE *OpenProcessPipe(const char *Command, const char *Mode) {
- return _popen(Command, Mode);
-}
-
-int ExecuteCommand(const std::string &Command) {
- return system(Command.c_str());
-}
-
-const void *SearchMemory(const void *Data, size_t DataLen, const void *Patt,
- size_t PattLen) {
- // TODO: make this implementation more efficient.
- const char *Cdata = (const char *)Data;
- const char *Cpatt = (const char *)Patt;
-
- if (!Data || !Patt || DataLen == 0 || PattLen == 0 || DataLen < PattLen)
- return NULL;
-
- if (PattLen == 1)
- return memchr(Data, *Cpatt, DataLen);
-
- const char *End = Cdata + DataLen - PattLen + 1;
-
- for (const char *It = Cdata; It < End; ++It)
- if (It[0] == Cpatt[0] && memcmp(It, Cpatt, PattLen) == 0)
- return It;
-
- return NULL;
-}
-
-std::string DisassembleCmd(const std::string &FileName) {
- if (ExecuteCommand("dumpbin /summary > nul") == 0)
- return "dumpbin /disasm " + FileName;
- Printf("libFuzzer: couldn't find tool to disassemble (dumpbin)\n");
- exit(1);
-}
-
-std::string SearchRegexCmd(const std::string &Regex) {
- return "findstr /r \"" + Regex + "\"";
-}
-
-} // namespace fuzzer
-
-#endif // LIBFUZZER_WINDOWS
Removed: llvm/trunk/lib/Fuzzer/FuzzerValueBitMap.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Fuzzer/FuzzerValueBitMap.h?rev=315936&view=auto
==============================================================================
--- llvm/trunk/lib/Fuzzer/FuzzerValueBitMap.h (original)
+++ llvm/trunk/lib/Fuzzer/FuzzerValueBitMap.h (removed)
@@ -1,73 +0,0 @@
-//===- FuzzerValueBitMap.h - INTERNAL - Bit map -----------------*- C++ -* ===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-// ValueBitMap.
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_FUZZER_VALUE_BIT_MAP_H
-#define LLVM_FUZZER_VALUE_BIT_MAP_H
-
-#include "FuzzerDefs.h"
-
-namespace fuzzer {
-
-// A bit map containing kMapSizeInWords bits.
-struct ValueBitMap {
- static const size_t kMapSizeInBits = 1 << 16;
- static const size_t kMapPrimeMod = 65371; // Largest Prime < kMapSizeInBits;
- static const size_t kBitsInWord = (sizeof(uintptr_t) * 8);
- static const size_t kMapSizeInWords = kMapSizeInBits / kBitsInWord;
- public:
-
- // Clears all bits.
- void Reset() { memset(Map, 0, sizeof(Map)); }
-
- // Computes a hash function of Value and sets the corresponding bit.
- // Returns true if the bit was changed from 0 to 1.
- ATTRIBUTE_NO_SANITIZE_ALL
- inline bool AddValue(uintptr_t Value) {
- uintptr_t Idx = Value % kMapSizeInBits;
- uintptr_t WordIdx = Idx / kBitsInWord;
- uintptr_t BitIdx = Idx % kBitsInWord;
- uintptr_t Old = Map[WordIdx];
- uintptr_t New = Old | (1UL << BitIdx);
- Map[WordIdx] = New;
- return New != Old;
- }
-
- ATTRIBUTE_NO_SANITIZE_ALL
- inline bool AddValueModPrime(uintptr_t Value) {
- return AddValue(Value % kMapPrimeMod);
- }
-
- inline bool Get(uintptr_t Idx) {
- assert(Idx < kMapSizeInBits);
- uintptr_t WordIdx = Idx / kBitsInWord;
- uintptr_t BitIdx = Idx % kBitsInWord;
- return Map[WordIdx] & (1UL << BitIdx);
- }
-
- size_t SizeInBits() const { return kMapSizeInBits; }
-
- template <class Callback>
- ATTRIBUTE_NO_SANITIZE_ALL
- void ForEach(Callback CB) const {
- for (size_t i = 0; i < kMapSizeInWords; i++)
- if (uintptr_t M = Map[i])
- for (size_t j = 0; j < sizeof(M) * 8; j++)
- if (M & ((uintptr_t)1 << j))
- CB(i * sizeof(M) * 8 + j);
- }
-
- private:
- uintptr_t Map[kMapSizeInWords] __attribute__((aligned(512)));
-};
-
-} // namespace fuzzer
-
-#endif // LLVM_FUZZER_VALUE_BIT_MAP_H
Modified: llvm/trunk/lib/Fuzzer/README.txt
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Fuzzer/README.txt?rev=315937&r1=315936&r2=315937&view=diff
==============================================================================
--- llvm/trunk/lib/Fuzzer/README.txt (original)
+++ llvm/trunk/lib/Fuzzer/README.txt Mon Oct 16 13:48:19 2017
@@ -1,5 +1 @@
libFuzzer was moved to compiler-rt in https://reviews.llvm.org/D36908.
-All future changes should be directed there.
-
-The copy of sources is temporarily left in this folder for the duration of a
-move.
Removed: llvm/trunk/lib/Fuzzer/build.sh
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Fuzzer/build.sh?rev=315936&view=auto
==============================================================================
--- llvm/trunk/lib/Fuzzer/build.sh (original)
+++ llvm/trunk/lib/Fuzzer/build.sh (removed)
@@ -1,11 +0,0 @@
-#!/bin/bash
-LIBFUZZER_SRC_DIR=$(dirname $0)
-CXX="${CXX:-clang}"
-for f in $LIBFUZZER_SRC_DIR/*.cpp; do
- $CXX -g -O2 -fno-omit-frame-pointer -std=c++11 $f -c &
-done
-wait
-rm -f libFuzzer.a
-ar ru libFuzzer.a Fuzzer*.o
-rm -f Fuzzer*.o
-
Removed: llvm/trunk/lib/Fuzzer/cxx.dict
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Fuzzer/cxx.dict?rev=315936&view=auto
==============================================================================
--- llvm/trunk/lib/Fuzzer/cxx.dict (original)
+++ llvm/trunk/lib/Fuzzer/cxx.dict (removed)
@@ -1,122 +0,0 @@
-"++"
-"--"
-"<<"
-">>"
-"+="
-"-="
-"*="
-"/="
-">>="
-"<<="
-"&="
-"|="
-"^="
-"%="
-"!="
-"&&"
-"||"
-"=="
-">="
-"<="
-"->"
-"alignas"
-"alignof"
-"and"
-"and_eq"
-"asm"
-"auto"
-"bitand"
-"bitor"
-"bool"
-"break"
-"case"
-"catch"
-"char"
-"char16_t"
-"char32_t"
-"class"
-"compl"
-"concept"
-"const"
-"constexpr"
-"const_cast"
-"continue"
-"decltype"
-"default"
-"delete"
-"do"
-"double"
-"dynamic_cast"
-"else"
-"enum"
-"explicit"
-"export"
-"extern"
-"false"
-"float"
-"for"
-"friend"
-"goto"
-"if"
-"inline"
-"int"
-"long"
-"mutable"
-"namespace"
-"new"
-"noexcept"
-"not"
-"not_eq"
-"nullptr"
-"operator"
-"or"
-"or_eq"
-"private"
-"protected"
-"public"
-"register"
-"reinterpret_cast"
-"requires"
-"return"
-"short"
-"signed"
-"sizeof"
-"static"
-"static_assert"
-"static_cast"
-"struct"
-"switch"
-"template"
-"this"
-"thread_local"
-"throw"
-"true"
-"try"
-"typedef"
-"typeid"
-"typename"
-"union"
-"unsigned"
-"using"
-"virtual"
-"void"
-"volatile"
-"wchar_t"
-"while"
-"xor"
-"xor_eq"
-"if"
-"elif"
-"else"
-"endif"
-"defined"
-"ifdef"
-"ifndef"
-"define"
-"undef"
-"include"
-"line"
-"error"
-"pragma"
-"override"
-"final"
More information about the llvm-commits
mailing list