Kostya Serebryany | 016852c | 2015-02-19 18:45:37 +0000 | [diff] [blame] | 1 | //===- FuzzerDriver.cpp - FuzzerDriver function and flags -----------------===// |
| 2 | // |
| 3 | // The LLVM Compiler Infrastructure |
| 4 | // |
| 5 | // This file is distributed under the University of Illinois Open Source |
| 6 | // License. See LICENSE.TXT for details. |
| 7 | // |
| 8 | //===----------------------------------------------------------------------===// |
| 9 | // FuzzerDriver and flag parsing. |
| 10 | //===----------------------------------------------------------------------===// |
| 11 | |
| 12 | #include "FuzzerInterface.h" |
| 13 | #include "FuzzerInternal.h" |
Kostya Serebryany | 6f5a804 | 2016-09-21 01:50:50 +0000 | [diff] [blame^] | 14 | #include "FuzzerMutate.h" |
| 15 | #include "FuzzerRandom.h" |
Kostya Serebryany | 016852c | 2015-02-19 18:45:37 +0000 | [diff] [blame] | 16 | |
Mehdi Amini | b550cb1 | 2016-04-18 09:17:29 +0000 | [diff] [blame] | 17 | #include <algorithm> |
Kostya Serebryany | 016852c | 2015-02-19 18:45:37 +0000 | [diff] [blame] | 18 | #include <atomic> |
Mehdi Amini | b550cb1 | 2016-04-18 09:17:29 +0000 | [diff] [blame] | 19 | #include <chrono> |
| 20 | #include <cstring> |
Kostya Serebryany | 016852c | 2015-02-19 18:45:37 +0000 | [diff] [blame] | 21 | #include <mutex> |
Kostya Serebryany | 52a788e | 2015-03-31 20:13:20 +0000 | [diff] [blame] | 22 | #include <string> |
Mehdi Amini | b550cb1 | 2016-04-18 09:17:29 +0000 | [diff] [blame] | 23 | #include <thread> |
| 24 | #include <unistd.h> |
Kostya Serebryany | 016852c | 2015-02-19 18:45:37 +0000 | [diff] [blame] | 25 | |
Kostya Serebryany | 4282d30 | 2016-01-15 00:17:37 +0000 | [diff] [blame] | 26 | // This function should be present in the libFuzzer so that the client |
| 27 | // binary can test for its existence. |
| 28 | extern "C" __attribute__((used)) void __libfuzzer_is_present() {} |
| 29 | |
Kostya Serebryany | 016852c | 2015-02-19 18:45:37 +0000 | [diff] [blame] | 30 | namespace fuzzer { |
| 31 | |
| 32 | // Program arguments. |
| 33 | struct FlagDescription { |
| 34 | const char *Name; |
| 35 | const char *Description; |
| 36 | int Default; |
Kostya Serebryany | 52a788e | 2015-03-31 20:13:20 +0000 | [diff] [blame] | 37 | int *IntFlag; |
| 38 | const char **StrFlag; |
Mike Aizatsky | a1a5c69 | 2015-12-10 20:41:53 +0000 | [diff] [blame] | 39 | unsigned int *UIntFlag; |
Kostya Serebryany | 016852c | 2015-02-19 18:45:37 +0000 | [diff] [blame] | 40 | }; |
| 41 | |
| 42 | struct { |
Kostya Serebryany | 3d95dd9 | 2016-03-01 22:33:14 +0000 | [diff] [blame] | 43 | #define FUZZER_DEPRECATED_FLAG(Name) |
Kostya Serebryany | 52a788e | 2015-03-31 20:13:20 +0000 | [diff] [blame] | 44 | #define FUZZER_FLAG_INT(Name, Default, Description) int Name; |
Mike Aizatsky | a1a5c69 | 2015-12-10 20:41:53 +0000 | [diff] [blame] | 45 | #define FUZZER_FLAG_UNSIGNED(Name, Default, Description) unsigned int Name; |
Kostya Serebryany | 52a788e | 2015-03-31 20:13:20 +0000 | [diff] [blame] | 46 | #define FUZZER_FLAG_STRING(Name, Description) const char *Name; |
Kostya Serebryany | 016852c | 2015-02-19 18:45:37 +0000 | [diff] [blame] | 47 | #include "FuzzerFlags.def" |
Kostya Serebryany | 3d95dd9 | 2016-03-01 22:33:14 +0000 | [diff] [blame] | 48 | #undef FUZZER_DEPRECATED_FLAG |
Kostya Serebryany | 52a788e | 2015-03-31 20:13:20 +0000 | [diff] [blame] | 49 | #undef FUZZER_FLAG_INT |
Mike Aizatsky | a1a5c69 | 2015-12-10 20:41:53 +0000 | [diff] [blame] | 50 | #undef FUZZER_FLAG_UNSIGNED |
Kostya Serebryany | 52a788e | 2015-03-31 20:13:20 +0000 | [diff] [blame] | 51 | #undef FUZZER_FLAG_STRING |
Kostya Serebryany | 016852c | 2015-02-19 18:45:37 +0000 | [diff] [blame] | 52 | } Flags; |
| 53 | |
Craig Topper | 2626094 | 2015-10-18 05:15:34 +0000 | [diff] [blame] | 54 | static const FlagDescription FlagDescriptions [] { |
Kostya Serebryany | 3d95dd9 | 2016-03-01 22:33:14 +0000 | [diff] [blame] | 55 | #define FUZZER_DEPRECATED_FLAG(Name) \ |
| 56 | {#Name, "Deprecated; don't use", 0, nullptr, nullptr, nullptr}, |
Kostya Serebryany | 52a788e | 2015-03-31 20:13:20 +0000 | [diff] [blame] | 57 | #define FUZZER_FLAG_INT(Name, Default, Description) \ |
Mike Aizatsky | a1a5c69 | 2015-12-10 20:41:53 +0000 | [diff] [blame] | 58 | {#Name, Description, Default, &Flags.Name, nullptr, nullptr}, |
| 59 | #define FUZZER_FLAG_UNSIGNED(Name, Default, Description) \ |
| 60 | {#Name, Description, static_cast<int>(Default), \ |
| 61 | nullptr, nullptr, &Flags.Name}, |
Kostya Serebryany | 52a788e | 2015-03-31 20:13:20 +0000 | [diff] [blame] | 62 | #define FUZZER_FLAG_STRING(Name, Description) \ |
Mike Aizatsky | a1a5c69 | 2015-12-10 20:41:53 +0000 | [diff] [blame] | 63 | {#Name, Description, 0, nullptr, &Flags.Name, nullptr}, |
Kostya Serebryany | 016852c | 2015-02-19 18:45:37 +0000 | [diff] [blame] | 64 | #include "FuzzerFlags.def" |
Kostya Serebryany | 3d95dd9 | 2016-03-01 22:33:14 +0000 | [diff] [blame] | 65 | #undef FUZZER_DEPRECATED_FLAG |
Kostya Serebryany | 52a788e | 2015-03-31 20:13:20 +0000 | [diff] [blame] | 66 | #undef FUZZER_FLAG_INT |
Mike Aizatsky | a1a5c69 | 2015-12-10 20:41:53 +0000 | [diff] [blame] | 67 | #undef FUZZER_FLAG_UNSIGNED |
Kostya Serebryany | 52a788e | 2015-03-31 20:13:20 +0000 | [diff] [blame] | 68 | #undef FUZZER_FLAG_STRING |
Kostya Serebryany | 016852c | 2015-02-19 18:45:37 +0000 | [diff] [blame] | 69 | }; |
| 70 | |
| 71 | static const size_t kNumFlags = |
| 72 | sizeof(FlagDescriptions) / sizeof(FlagDescriptions[0]); |
| 73 | |
Kostya Serebryany | a938bcb | 2015-09-10 16:57:57 +0000 | [diff] [blame] | 74 | static std::vector<std::string> *Inputs; |
| 75 | static std::string *ProgName; |
Kostya Serebryany | 016852c | 2015-02-19 18:45:37 +0000 | [diff] [blame] | 76 | |
| 77 | static void PrintHelp() { |
Kostya Serebryany | bfbe7fc | 2016-02-02 03:03:47 +0000 | [diff] [blame] | 78 | Printf("Usage:\n"); |
| 79 | auto Prog = ProgName->c_str(); |
| 80 | Printf("\nTo run fuzzing pass 0 or more directories.\n"); |
| 81 | Printf("%s [-flag1=val1 [-flag2=val2 ...] ] [dir1 [dir2 ...] ]\n", Prog); |
| 82 | |
| 83 | Printf("\nTo run individual tests without fuzzing pass 1 or more files:\n"); |
| 84 | Printf("%s [-flag1=val1 [-flag2=val2 ...] ] file1 [file2 ...]\n", Prog); |
| 85 | |
Kostya Serebryany | 20e9bcb | 2015-05-23 01:07:46 +0000 | [diff] [blame] | 86 | Printf("\nFlags: (strictly in form -flag=value)\n"); |
Kostya Serebryany | 016852c | 2015-02-19 18:45:37 +0000 | [diff] [blame] | 87 | size_t MaxFlagLen = 0; |
| 88 | for (size_t F = 0; F < kNumFlags; F++) |
| 89 | MaxFlagLen = std::max(strlen(FlagDescriptions[F].Name), MaxFlagLen); |
| 90 | |
| 91 | for (size_t F = 0; F < kNumFlags; F++) { |
| 92 | const auto &D = FlagDescriptions[F]; |
Kostya Serebryany | 4529960 | 2016-09-10 00:35:30 +0000 | [diff] [blame] | 93 | if (strstr(D.Description, "internal flag") == D.Description) continue; |
Kostya Serebryany | 20e9bcb | 2015-05-23 01:07:46 +0000 | [diff] [blame] | 94 | Printf(" %s", D.Name); |
Kostya Serebryany | 016852c | 2015-02-19 18:45:37 +0000 | [diff] [blame] | 95 | for (size_t i = 0, n = MaxFlagLen - strlen(D.Name); i < n; i++) |
Kostya Serebryany | 20e9bcb | 2015-05-23 01:07:46 +0000 | [diff] [blame] | 96 | Printf(" "); |
| 97 | Printf("\t"); |
| 98 | Printf("%d\t%s\n", D.Default, D.Description); |
Kostya Serebryany | 016852c | 2015-02-19 18:45:37 +0000 | [diff] [blame] | 99 | } |
Kostya Serebryany | 20e9bcb | 2015-05-23 01:07:46 +0000 | [diff] [blame] | 100 | Printf("\nFlags starting with '--' will be ignored and " |
| 101 | "will be passed verbatim to subprocesses.\n"); |
Kostya Serebryany | 016852c | 2015-02-19 18:45:37 +0000 | [diff] [blame] | 102 | } |
| 103 | |
| 104 | static const char *FlagValue(const char *Param, const char *Name) { |
| 105 | size_t Len = strlen(Name); |
| 106 | if (Param[0] == '-' && strstr(Param + 1, Name) == Param + 1 && |
| 107 | Param[Len + 1] == '=') |
| 108 | return &Param[Len + 2]; |
| 109 | return nullptr; |
| 110 | } |
| 111 | |
Kostya Serebryany | 4282d30 | 2016-01-15 00:17:37 +0000 | [diff] [blame] | 112 | // Avoid calling stol as it triggers a bug in clang/glibc build. |
| 113 | static long MyStol(const char *Str) { |
| 114 | long Res = 0; |
Kostya Serebryany | 311f27c | 2016-01-19 20:33:57 +0000 | [diff] [blame] | 115 | long Sign = 1; |
| 116 | if (*Str == '-') { |
| 117 | Str++; |
| 118 | Sign = -1; |
| 119 | } |
Kostya Serebryany | 4282d30 | 2016-01-15 00:17:37 +0000 | [diff] [blame] | 120 | for (size_t i = 0; Str[i]; i++) { |
| 121 | char Ch = Str[i]; |
| 122 | if (Ch < '0' || Ch > '9') |
| 123 | return Res; |
| 124 | Res = Res * 10 + (Ch - '0'); |
| 125 | } |
Kostya Serebryany | 311f27c | 2016-01-19 20:33:57 +0000 | [diff] [blame] | 126 | return Res * Sign; |
Kostya Serebryany | 4282d30 | 2016-01-15 00:17:37 +0000 | [diff] [blame] | 127 | } |
| 128 | |
Kostya Serebryany | 016852c | 2015-02-19 18:45:37 +0000 | [diff] [blame] | 129 | static bool ParseOneFlag(const char *Param) { |
| 130 | if (Param[0] != '-') return false; |
Kostya Serebryany | 71e0feb | 2015-05-21 20:39:13 +0000 | [diff] [blame] | 131 | if (Param[1] == '-') { |
| 132 | static bool PrintedWarning = false; |
| 133 | if (!PrintedWarning) { |
| 134 | PrintedWarning = true; |
Kostya Serebryany | 64d2457 | 2016-03-12 01:57:04 +0000 | [diff] [blame] | 135 | Printf("INFO: libFuzzer ignores flags that start with '--'\n"); |
Kostya Serebryany | 71e0feb | 2015-05-21 20:39:13 +0000 | [diff] [blame] | 136 | } |
Kostya Serebryany | b60397f | 2016-04-15 21:56:29 +0000 | [diff] [blame] | 137 | for (size_t F = 0; F < kNumFlags; F++) |
| 138 | if (FlagValue(Param + 1, FlagDescriptions[F].Name)) |
| 139 | Printf("WARNING: did you mean '%s' (single dash)?\n", Param + 1); |
Kostya Serebryany | 71e0feb | 2015-05-21 20:39:13 +0000 | [diff] [blame] | 140 | return true; |
| 141 | } |
Kostya Serebryany | 016852c | 2015-02-19 18:45:37 +0000 | [diff] [blame] | 142 | for (size_t F = 0; F < kNumFlags; F++) { |
| 143 | const char *Name = FlagDescriptions[F].Name; |
| 144 | const char *Str = FlagValue(Param, Name); |
| 145 | if (Str) { |
Kostya Serebryany | 52a788e | 2015-03-31 20:13:20 +0000 | [diff] [blame] | 146 | if (FlagDescriptions[F].IntFlag) { |
Kostya Serebryany | 4282d30 | 2016-01-15 00:17:37 +0000 | [diff] [blame] | 147 | int Val = MyStol(Str); |
Kostya Serebryany | 52a788e | 2015-03-31 20:13:20 +0000 | [diff] [blame] | 148 | *FlagDescriptions[F].IntFlag = Val; |
| 149 | if (Flags.verbosity >= 2) |
Kostya Serebryany | 20e9bcb | 2015-05-23 01:07:46 +0000 | [diff] [blame] | 150 | Printf("Flag: %s %d\n", Name, Val);; |
Kostya Serebryany | 52a788e | 2015-03-31 20:13:20 +0000 | [diff] [blame] | 151 | return true; |
Mike Aizatsky | a1a5c69 | 2015-12-10 20:41:53 +0000 | [diff] [blame] | 152 | } else if (FlagDescriptions[F].UIntFlag) { |
| 153 | unsigned int Val = std::stoul(Str); |
| 154 | *FlagDescriptions[F].UIntFlag = Val; |
| 155 | if (Flags.verbosity >= 2) |
| 156 | Printf("Flag: %s %u\n", Name, Val); |
| 157 | return true; |
Kostya Serebryany | 52a788e | 2015-03-31 20:13:20 +0000 | [diff] [blame] | 158 | } else if (FlagDescriptions[F].StrFlag) { |
| 159 | *FlagDescriptions[F].StrFlag = Str; |
| 160 | if (Flags.verbosity >= 2) |
Kostya Serebryany | 20e9bcb | 2015-05-23 01:07:46 +0000 | [diff] [blame] | 161 | Printf("Flag: %s %s\n", Name, Str); |
Kostya Serebryany | 52a788e | 2015-03-31 20:13:20 +0000 | [diff] [blame] | 162 | return true; |
Kostya Serebryany | 3d95dd9 | 2016-03-01 22:33:14 +0000 | [diff] [blame] | 163 | } else { // Deprecated flag. |
| 164 | Printf("Flag: %s: deprecated, don't use\n", Name); |
| 165 | return true; |
Kostya Serebryany | 52a788e | 2015-03-31 20:13:20 +0000 | [diff] [blame] | 166 | } |
Kostya Serebryany | 016852c | 2015-02-19 18:45:37 +0000 | [diff] [blame] | 167 | } |
| 168 | } |
Kostya Serebryany | f817731 | 2016-06-01 16:41:12 +0000 | [diff] [blame] | 169 | Printf("\n\nWARNING: unrecognized flag '%s'; " |
| 170 | "use -help=1 to list all flags\n\n", Param); |
| 171 | return true; |
Kostya Serebryany | 016852c | 2015-02-19 18:45:37 +0000 | [diff] [blame] | 172 | } |
| 173 | |
| 174 | // We don't use any library to minimize dependencies. |
Kostya Serebryany | a938bcb | 2015-09-10 16:57:57 +0000 | [diff] [blame] | 175 | static void ParseFlags(const std::vector<std::string> &Args) { |
Kostya Serebryany | 52a788e | 2015-03-31 20:13:20 +0000 | [diff] [blame] | 176 | for (size_t F = 0; F < kNumFlags; F++) { |
| 177 | if (FlagDescriptions[F].IntFlag) |
| 178 | *FlagDescriptions[F].IntFlag = FlagDescriptions[F].Default; |
Mike Aizatsky | a1a5c69 | 2015-12-10 20:41:53 +0000 | [diff] [blame] | 179 | if (FlagDescriptions[F].UIntFlag) |
| 180 | *FlagDescriptions[F].UIntFlag = |
| 181 | static_cast<unsigned int>(FlagDescriptions[F].Default); |
Kostya Serebryany | 52a788e | 2015-03-31 20:13:20 +0000 | [diff] [blame] | 182 | if (FlagDescriptions[F].StrFlag) |
| 183 | *FlagDescriptions[F].StrFlag = nullptr; |
| 184 | } |
Kostya Serebryany | a938bcb | 2015-09-10 16:57:57 +0000 | [diff] [blame] | 185 | Inputs = new std::vector<std::string>; |
| 186 | for (size_t A = 1; A < Args.size(); A++) { |
| 187 | if (ParseOneFlag(Args[A].c_str())) continue; |
| 188 | Inputs->push_back(Args[A]); |
Kostya Serebryany | 016852c | 2015-02-19 18:45:37 +0000 | [diff] [blame] | 189 | } |
| 190 | } |
| 191 | |
Kostya Serebryany | 83fd486 | 2015-05-11 21:31:51 +0000 | [diff] [blame] | 192 | static std::mutex Mu; |
| 193 | |
| 194 | static void PulseThread() { |
| 195 | while (true) { |
Kostya Serebryany | 8b8f7a3 | 2016-05-06 23:38:07 +0000 | [diff] [blame] | 196 | SleepSeconds(600); |
Kostya Serebryany | 83fd486 | 2015-05-11 21:31:51 +0000 | [diff] [blame] | 197 | std::lock_guard<std::mutex> Lock(Mu); |
Kostya Serebryany | 20e9bcb | 2015-05-23 01:07:46 +0000 | [diff] [blame] | 198 | Printf("pulse...\n"); |
Kostya Serebryany | 83fd486 | 2015-05-11 21:31:51 +0000 | [diff] [blame] | 199 | } |
| 200 | } |
| 201 | |
Kostya Serebryany | 016852c | 2015-02-19 18:45:37 +0000 | [diff] [blame] | 202 | static void WorkerThread(const std::string &Cmd, std::atomic<int> *Counter, |
| 203 | int NumJobs, std::atomic<bool> *HasErrors) { |
Kostya Serebryany | 016852c | 2015-02-19 18:45:37 +0000 | [diff] [blame] | 204 | while (true) { |
| 205 | int C = (*Counter)++; |
| 206 | if (C >= NumJobs) break; |
| 207 | std::string Log = "fuzz-" + std::to_string(C) + ".log"; |
| 208 | std::string ToRun = Cmd + " > " + Log + " 2>&1\n"; |
| 209 | if (Flags.verbosity) |
Kostya Serebryany | 20e9bcb | 2015-05-23 01:07:46 +0000 | [diff] [blame] | 210 | Printf("%s", ToRun.c_str()); |
Hans Wennborg | e631996 | 2016-04-11 20:35:17 +0000 | [diff] [blame] | 211 | int ExitCode = ExecuteCommand(ToRun); |
Kostya Serebryany | 016852c | 2015-02-19 18:45:37 +0000 | [diff] [blame] | 212 | if (ExitCode != 0) |
| 213 | *HasErrors = true; |
Kostya Serebryany | 83fd486 | 2015-05-11 21:31:51 +0000 | [diff] [blame] | 214 | std::lock_guard<std::mutex> Lock(Mu); |
Kostya Serebryany | 20e9bcb | 2015-05-23 01:07:46 +0000 | [diff] [blame] | 215 | Printf("================== Job %d exited with exit code %d ============\n", |
| 216 | C, ExitCode); |
Kostya Serebryany | 016852c | 2015-02-19 18:45:37 +0000 | [diff] [blame] | 217 | fuzzer::CopyFileToErr(Log); |
| 218 | } |
| 219 | } |
| 220 | |
Kostya Serebryany | e2d0f63 | 2016-09-01 01:22:27 +0000 | [diff] [blame] | 221 | static std::string CloneArgsWithoutX(const std::vector<std::string> &Args, |
| 222 | const char *X1, const char *X2) { |
| 223 | std::string Cmd; |
| 224 | for (auto &S : Args) { |
| 225 | if (FlagValue(S.c_str(), X1) || FlagValue(S.c_str(), X2)) |
| 226 | continue; |
| 227 | Cmd += S + " "; |
| 228 | } |
| 229 | return Cmd; |
| 230 | } |
| 231 | |
| 232 | static std::string CloneArgsWithoutX(const std::vector<std::string> &Args, |
| 233 | const char *X) { |
| 234 | return CloneArgsWithoutX(Args, X, X); |
| 235 | } |
| 236 | |
Kostya Serebryany | a938bcb | 2015-09-10 16:57:57 +0000 | [diff] [blame] | 237 | static int RunInMultipleProcesses(const std::vector<std::string> &Args, |
| 238 | int NumWorkers, int NumJobs) { |
Kostya Serebryany | 016852c | 2015-02-19 18:45:37 +0000 | [diff] [blame] | 239 | std::atomic<int> Counter(0); |
| 240 | std::atomic<bool> HasErrors(false); |
Kostya Serebryany | e2d0f63 | 2016-09-01 01:22:27 +0000 | [diff] [blame] | 241 | std::string Cmd = CloneArgsWithoutX(Args, "jobs", "workers"); |
Kostya Serebryany | 016852c | 2015-02-19 18:45:37 +0000 | [diff] [blame] | 242 | std::vector<std::thread> V; |
Kostya Serebryany | 83fd486 | 2015-05-11 21:31:51 +0000 | [diff] [blame] | 243 | std::thread Pulse(PulseThread); |
Kostya Serebryany | cd7629c | 2015-05-12 01:43:20 +0000 | [diff] [blame] | 244 | Pulse.detach(); |
Kostya Serebryany | 016852c | 2015-02-19 18:45:37 +0000 | [diff] [blame] | 245 | for (int i = 0; i < NumWorkers; i++) |
| 246 | V.push_back(std::thread(WorkerThread, Cmd, &Counter, NumJobs, &HasErrors)); |
| 247 | for (auto &T : V) |
| 248 | T.join(); |
| 249 | return HasErrors ? 1 : 0; |
| 250 | } |
| 251 | |
Kostya Serebryany | 52b394e | 2016-05-06 21:58:35 +0000 | [diff] [blame] | 252 | static void RssThread(Fuzzer *F, size_t RssLimitMb) { |
| 253 | while (true) { |
Kostya Serebryany | 8b8f7a3 | 2016-05-06 23:38:07 +0000 | [diff] [blame] | 254 | SleepSeconds(1); |
Kostya Serebryany | 52b394e | 2016-05-06 21:58:35 +0000 | [diff] [blame] | 255 | size_t Peak = GetPeakRSSMb(); |
| 256 | if (Peak > RssLimitMb) |
Kostya Serebryany | 8b8f7a3 | 2016-05-06 23:38:07 +0000 | [diff] [blame] | 257 | F->RssLimitCallback(); |
Kostya Serebryany | 52b394e | 2016-05-06 21:58:35 +0000 | [diff] [blame] | 258 | } |
| 259 | } |
| 260 | |
| 261 | static void StartRssThread(Fuzzer *F, size_t RssLimitMb) { |
| 262 | if (!RssLimitMb) return; |
| 263 | std::thread T(RssThread, F, RssLimitMb); |
| 264 | T.detach(); |
| 265 | } |
| 266 | |
Kostya Serebryany | a016a45 | 2016-08-30 14:52:05 +0000 | [diff] [blame] | 267 | int RunOneTest(Fuzzer *F, const char *InputFilePath, size_t MaxLen) { |
Ivan Krasin | 95e82d5 | 2015-10-01 23:23:06 +0000 | [diff] [blame] | 268 | Unit U = FileToVector(InputFilePath); |
Kostya Serebryany | a016a45 | 2016-08-30 14:52:05 +0000 | [diff] [blame] | 269 | if (MaxLen && MaxLen < U.size()) |
| 270 | U.resize(MaxLen); |
| 271 | F->RunOne(U.data(), U.size()); |
Ivan Krasin | 95e82d5 | 2015-10-01 23:23:06 +0000 | [diff] [blame] | 272 | return 0; |
| 273 | } |
| 274 | |
Kostya Serebryany | bfbe7fc | 2016-02-02 03:03:47 +0000 | [diff] [blame] | 275 | static bool AllInputsAreFiles() { |
| 276 | if (Inputs->empty()) return false; |
| 277 | for (auto &Path : *Inputs) |
| 278 | if (!IsFile(Path)) |
| 279 | return false; |
| 280 | return true; |
| 281 | } |
| 282 | |
Kostya Serebryany | e2d0f63 | 2016-09-01 01:22:27 +0000 | [diff] [blame] | 283 | int MinimizeCrashInput(const std::vector<std::string> &Args) { |
| 284 | if (Inputs->size() != 1) { |
| 285 | Printf("ERROR: -minimize_crash should be given one input file\n"); |
| 286 | exit(1); |
| 287 | } |
| 288 | if (Flags.runs <= 0 && Flags.max_total_time == 0) { |
| 289 | Printf("ERROR: you need to use -runs=N or " |
| 290 | "-max_total_time=N with -minimize_crash=1\n" ); |
| 291 | exit(1); |
| 292 | } |
| 293 | std::string InputFilePath = Inputs->at(0); |
| 294 | std::string BaseCmd = CloneArgsWithoutX(Args, "minimize_crash"); |
| 295 | auto InputPos = BaseCmd.find(" " + InputFilePath + " "); |
| 296 | assert(InputPos != std::string::npos); |
| 297 | BaseCmd.erase(InputPos, InputFilePath.size() + 1); |
| 298 | // BaseCmd += " > /dev/null 2>&1 "; |
| 299 | |
| 300 | std::string CurrentFilePath = InputFilePath; |
| 301 | while (true) { |
| 302 | Unit U = FileToVector(CurrentFilePath); |
| 303 | if (U.size() < 2) { |
| 304 | Printf("CRASH_MIN: '%s' is small enough\n", CurrentFilePath.c_str()); |
| 305 | return 0; |
| 306 | } |
| 307 | Printf("CRASH_MIN: minimizing crash input: '%s' (%zd bytes)\n", |
| 308 | CurrentFilePath.c_str(), U.size()); |
| 309 | |
| 310 | auto Cmd = BaseCmd + " " + CurrentFilePath; |
| 311 | |
| 312 | Printf("CRASH_MIN: executing: %s\n", Cmd.c_str()); |
| 313 | int ExitCode = ExecuteCommand(Cmd); |
| 314 | if (ExitCode == 0) { |
| 315 | Printf("ERROR: the input %s did not crash\n", CurrentFilePath.c_str()); |
| 316 | exit(1); |
| 317 | } |
| 318 | Printf("CRASH_MIN: '%s' (%zd bytes) caused a crash. Will try to minimize " |
| 319 | "it further\n", |
| 320 | CurrentFilePath.c_str(), U.size()); |
| 321 | |
| 322 | std::string ArtifactPath = "minimized-from-" + Hash(U); |
| 323 | Cmd += " -minimize_crash_internal_step=1 -exact_artifact_path=" + |
| 324 | ArtifactPath; |
| 325 | Printf("CRASH_MIN: executing: %s\n", Cmd.c_str()); |
| 326 | ExitCode = ExecuteCommand(Cmd); |
| 327 | if (ExitCode == 0) { |
| 328 | Printf("CRASH_MIN: failed to minimize beyond %s (%d bytes), exiting\n", |
| 329 | CurrentFilePath.c_str(), U.size()); |
| 330 | return 0; |
| 331 | } |
| 332 | CurrentFilePath = ArtifactPath; |
| 333 | Printf("\n\n\n\n\n\n*********************************\n"); |
| 334 | } |
| 335 | return 0; |
| 336 | } |
| 337 | |
| 338 | int MinimizeCrashInputInternalStep(Fuzzer *F) { |
| 339 | assert(Inputs->size() == 1); |
| 340 | std::string InputFilePath = Inputs->at(0); |
| 341 | Unit U = FileToVector(InputFilePath); |
| 342 | assert(U.size() > 2); |
| 343 | Printf("INFO: Starting MinimizeCrashInputInternalStep: %zd\n", U.size()); |
| 344 | Unit X(U.size() - 1); |
| 345 | for (size_t I = 0; I < U.size(); I++) { |
| 346 | std::copy(U.begin(), U.begin() + I, X.begin()); |
| 347 | std::copy(U.begin() + I + 1, U.end(), X.begin() + I); |
| 348 | F->AddToCorpus(X); |
| 349 | } |
| 350 | F->SetMaxLen(U.size() - 1); |
| 351 | F->Loop(); |
| 352 | Printf("INFO: Done MinimizeCrashInputInternalStep, no crashes found\n"); |
| 353 | exit(0); |
| 354 | return 0; |
| 355 | } |
| 356 | |
Dan Liew | d3c3311 | 2016-06-02 05:48:02 +0000 | [diff] [blame] | 357 | int FuzzerDriver(int *argc, char ***argv, UserCallback Callback) { |
Kostya Serebryany | a938bcb | 2015-09-10 16:57:57 +0000 | [diff] [blame] | 358 | using namespace fuzzer; |
Dan Liew | d3c3311 | 2016-06-02 05:48:02 +0000 | [diff] [blame] | 359 | assert(argc && argv && "Argument pointers cannot be nullptr"); |
Dan Liew | 1873a49 | 2016-06-07 23:32:50 +0000 | [diff] [blame] | 360 | EF = new ExternalFunctions(); |
| 361 | if (EF->LLVMFuzzerInitialize) |
| 362 | EF->LLVMFuzzerInitialize(argc, argv); |
Dan Liew | d3c3311 | 2016-06-02 05:48:02 +0000 | [diff] [blame] | 363 | const std::vector<std::string> Args(*argv, *argv + *argc); |
Kostya Serebryany | a938bcb | 2015-09-10 16:57:57 +0000 | [diff] [blame] | 364 | assert(!Args.empty()); |
| 365 | ProgName = new std::string(Args[0]); |
| 366 | ParseFlags(Args); |
Kostya Serebryany | 016852c | 2015-02-19 18:45:37 +0000 | [diff] [blame] | 367 | if (Flags.help) { |
| 368 | PrintHelp(); |
| 369 | return 0; |
| 370 | } |
| 371 | |
Kostya Serebryany | e2d0f63 | 2016-09-01 01:22:27 +0000 | [diff] [blame] | 372 | if (Flags.minimize_crash) |
| 373 | return MinimizeCrashInput(Args); |
| 374 | |
Kostya Serebryany | 49e4090 | 2016-03-18 20:58:29 +0000 | [diff] [blame] | 375 | if (Flags.close_fd_mask & 2) |
| 376 | DupAndCloseStderr(); |
| 377 | if (Flags.close_fd_mask & 1) |
| 378 | CloseStdout(); |
| 379 | |
Kostya Serebryany | 9690fcf | 2015-05-12 18:51:57 +0000 | [diff] [blame] | 380 | if (Flags.jobs > 0 && Flags.workers == 0) { |
| 381 | Flags.workers = std::min(NumberOfCpuCores() / 2, Flags.jobs); |
| 382 | if (Flags.workers > 1) |
Kostya Serebryany | 20e9bcb | 2015-05-23 01:07:46 +0000 | [diff] [blame] | 383 | Printf("Running %d workers\n", Flags.workers); |
Kostya Serebryany | 9690fcf | 2015-05-12 18:51:57 +0000 | [diff] [blame] | 384 | } |
| 385 | |
Kostya Serebryany | 016852c | 2015-02-19 18:45:37 +0000 | [diff] [blame] | 386 | if (Flags.workers > 0 && Flags.jobs > 0) |
Kostya Serebryany | a938bcb | 2015-09-10 16:57:57 +0000 | [diff] [blame] | 387 | return RunInMultipleProcesses(Args, Flags.workers, Flags.jobs); |
Kostya Serebryany | 016852c | 2015-02-19 18:45:37 +0000 | [diff] [blame] | 388 | |
Kostya Serebryany | 64d2457 | 2016-03-12 01:57:04 +0000 | [diff] [blame] | 389 | const size_t kMaxSaneLen = 1 << 20; |
Kostya Serebryany | 0c5e3af | 2016-03-15 01:28:00 +0000 | [diff] [blame] | 390 | const size_t kMinDefaultLen = 64; |
Mike Aizatsky | f0b3e85 | 2016-06-23 20:44:48 +0000 | [diff] [blame] | 391 | FuzzingOptions Options; |
Kostya Serebryany | 016852c | 2015-02-19 18:45:37 +0000 | [diff] [blame] | 392 | Options.Verbosity = Flags.verbosity; |
| 393 | Options.MaxLen = Flags.max_len; |
Kostya Serebryany | 490bbd6 | 2015-05-19 22:12:57 +0000 | [diff] [blame] | 394 | Options.UnitTimeoutSec = Flags.timeout; |
Kostya Serebryany | 54a6363 | 2016-01-29 23:30:07 +0000 | [diff] [blame] | 395 | Options.TimeoutExitCode = Flags.timeout_exitcode; |
Kostya Serebryany | b85db17 | 2015-10-02 20:47:55 +0000 | [diff] [blame] | 396 | Options.MaxTotalTimeSec = Flags.max_total_time; |
Kostya Serebryany | 016852c | 2015-02-19 18:45:37 +0000 | [diff] [blame] | 397 | Options.DoCrossOver = Flags.cross_over; |
| 398 | Options.MutateDepth = Flags.mutate_depth; |
Kostya Serebryany | be5e0ed | 2015-03-03 23:27:02 +0000 | [diff] [blame] | 399 | Options.UseCounters = Flags.use_counters; |
Kostya Serebryany | 2e9fca9 | 2015-10-22 23:55:39 +0000 | [diff] [blame] | 400 | Options.UseIndirCalls = Flags.use_indir_calls; |
Kostya Serebryany | ae5b956 | 2016-01-15 06:24:05 +0000 | [diff] [blame] | 401 | Options.UseMemcmp = Flags.use_memcmp; |
Kostya Serebryany | c135b55 | 2016-07-15 23:27:19 +0000 | [diff] [blame] | 402 | Options.UseMemmem = Flags.use_memmem; |
Kostya Serebryany | fed509e | 2015-10-17 04:38:26 +0000 | [diff] [blame] | 403 | Options.ShuffleAtStartUp = Flags.shuffle; |
Kostya Serebryany | 945761b | 2016-03-18 00:23:29 +0000 | [diff] [blame] | 404 | Options.PreferSmall = Flags.prefer_small; |
Kostya Serebryany | 1ac8055 | 2015-05-08 21:30:55 +0000 | [diff] [blame] | 405 | Options.Reload = Flags.reload; |
Kostya Serebryany | bc7c0ad | 2015-08-11 01:44:42 +0000 | [diff] [blame] | 406 | Options.OnlyASCII = Flags.only_ascii; |
Mike Aizatsky | a9c2387 | 2015-11-12 04:38:40 +0000 | [diff] [blame] | 407 | Options.OutputCSV = Flags.output_csv; |
Kostya Serebryany | 1bfd583 | 2016-04-20 00:24:21 +0000 | [diff] [blame] | 408 | Options.DetectLeaks = Flags.detect_leaks; |
Kostya Serebryany | 8b8f7a3 | 2016-05-06 23:38:07 +0000 | [diff] [blame] | 409 | Options.RssLimitMb = Flags.rss_limit_mb; |
Kostya Serebryany | 016852c | 2015-02-19 18:45:37 +0000 | [diff] [blame] | 410 | if (Flags.runs >= 0) |
| 411 | Options.MaxNumberOfRuns = Flags.runs; |
Kostya Serebryany | e2d0f63 | 2016-09-01 01:22:27 +0000 | [diff] [blame] | 412 | if (!Inputs->empty() && !Flags.minimize_crash_internal_step) |
Kostya Serebryany | a938bcb | 2015-09-10 16:57:57 +0000 | [diff] [blame] | 413 | Options.OutputCorpus = (*Inputs)[0]; |
Kostya Serebryany | 70926ae | 2015-08-05 21:43:48 +0000 | [diff] [blame] | 414 | Options.ReportSlowUnits = Flags.report_slow_units; |
Kostya Serebryany | bd5d1cd | 2015-10-09 03:57:59 +0000 | [diff] [blame] | 415 | if (Flags.artifact_prefix) |
| 416 | Options.ArtifactPrefix = Flags.artifact_prefix; |
Kostya Serebryany | 2d0ef14 | 2015-11-25 21:40:46 +0000 | [diff] [blame] | 417 | if (Flags.exact_artifact_path) |
| 418 | Options.ExactArtifactPath = Flags.exact_artifact_path; |
Kostya Serebryany | dc3135d | 2015-11-12 01:02:01 +0000 | [diff] [blame] | 419 | std::vector<Unit> Dictionary; |
Kostya Serebryany | 7d21166 | 2015-09-04 00:12:11 +0000 | [diff] [blame] | 420 | if (Flags.dict) |
Kostya Serebryany | dc3135d | 2015-11-12 01:02:01 +0000 | [diff] [blame] | 421 | if (!ParseDictionaryFile(FileToString(Flags.dict), &Dictionary)) |
Kostya Serebryany | 7d21166 | 2015-09-04 00:12:11 +0000 | [diff] [blame] | 422 | return 1; |
Kostya Serebryany | dc3135d | 2015-11-12 01:02:01 +0000 | [diff] [blame] | 423 | if (Flags.verbosity > 0 && !Dictionary.empty()) |
| 424 | Printf("Dictionary: %zd entries\n", Dictionary.size()); |
Kostya Serebryany | c5575aa | 2016-03-17 19:59:39 +0000 | [diff] [blame] | 425 | bool DoPlainRun = AllInputsAreFiles(); |
Kostya Serebryany | e2d0f63 | 2016-09-01 01:22:27 +0000 | [diff] [blame] | 426 | Options.SaveArtifacts = |
| 427 | !DoPlainRun || Flags.minimize_crash_internal_step; |
Kostya Serebryany | 0f0fa4f | 2016-08-25 22:35:08 +0000 | [diff] [blame] | 428 | Options.PrintNewCovPcs = Flags.print_pcs; |
Kostya Serebryany | 66ff075 | 2016-02-26 22:42:23 +0000 | [diff] [blame] | 429 | Options.PrintFinalStats = Flags.print_final_stats; |
Kostya Serebryany | b706b48 | 2016-09-18 21:47:08 +0000 | [diff] [blame] | 430 | Options.PrintCoverage = Flags.print_coverage; |
Mike Aizatsky | 1f88b12 | 2016-06-07 18:16:32 +0000 | [diff] [blame] | 431 | Options.PruneCorpus = Flags.prune_corpus; |
Kostya Serebryany | 7d21166 | 2015-09-04 00:12:11 +0000 | [diff] [blame] | 432 | |
Kostya Serebryany | d46a59f | 2016-08-16 19:33:51 +0000 | [diff] [blame] | 433 | if (Flags.use_value_profile) |
| 434 | EnableValueProfile(); |
| 435 | |
Kostya Serebryany | a399221 | 2016-02-13 03:00:53 +0000 | [diff] [blame] | 436 | unsigned Seed = Flags.seed; |
| 437 | // Initialize Seed. |
| 438 | if (Seed == 0) |
| 439 | Seed = (std::chrono::system_clock::now().time_since_epoch().count() << 10) + |
| 440 | getpid(); |
| 441 | if (Flags.verbosity) |
Kostya Serebryany | 64d2457 | 2016-03-12 01:57:04 +0000 | [diff] [blame] | 442 | Printf("INFO: Seed: %u\n", Seed); |
Kostya Serebryany | a399221 | 2016-02-13 03:00:53 +0000 | [diff] [blame] | 443 | |
| 444 | Random Rand(Seed); |
Mike Aizatsky | f0b3e85 | 2016-06-23 20:44:48 +0000 | [diff] [blame] | 445 | MutationDispatcher MD(Rand, Options); |
Kostya Serebryany | 7ec0c56 | 2016-02-13 03:25:16 +0000 | [diff] [blame] | 446 | Fuzzer F(Callback, MD, Options); |
Kostya Serebryany | 016852c | 2015-02-19 18:45:37 +0000 | [diff] [blame] | 447 | |
Kostya Serebryany | dc3135d | 2015-11-12 01:02:01 +0000 | [diff] [blame] | 448 | for (auto &U: Dictionary) |
Kostya Serebryany | 476f0ce | 2016-01-16 03:53:32 +0000 | [diff] [blame] | 449 | if (U.size() <= Word::GetMaxSize()) |
Kostya Serebryany | 7ec0c56 | 2016-02-13 03:25:16 +0000 | [diff] [blame] | 450 | MD.AddWordToManualDictionary(Word(U.data(), U.size())); |
Kostya Serebryany | dc3135d | 2015-11-12 01:02:01 +0000 | [diff] [blame] | 451 | |
Kostya Serebryany | 52b394e | 2016-05-06 21:58:35 +0000 | [diff] [blame] | 452 | StartRssThread(&F, Flags.rss_limit_mb); |
| 453 | |
Kostya Serebryany | b91c62b | 2015-10-16 22:41:47 +0000 | [diff] [blame] | 454 | // Timer |
| 455 | if (Flags.timeout > 0) |
| 456 | SetTimer(Flags.timeout / 2 + 1); |
Kostya Serebryany | 228d5b1 | 2016-03-01 22:19:21 +0000 | [diff] [blame] | 457 | if (Flags.handle_segv) SetSigSegvHandler(); |
| 458 | if (Flags.handle_bus) SetSigBusHandler(); |
| 459 | if (Flags.handle_abrt) SetSigAbrtHandler(); |
| 460 | if (Flags.handle_ill) SetSigIllHandler(); |
| 461 | if (Flags.handle_fpe) SetSigFpeHandler(); |
| 462 | if (Flags.handle_int) SetSigIntHandler(); |
Kostya Serebryany | f389ae1 | 2016-03-24 21:03:58 +0000 | [diff] [blame] | 463 | if (Flags.handle_term) SetSigTermHandler(); |
Kostya Serebryany | b91c62b | 2015-10-16 22:41:47 +0000 | [diff] [blame] | 464 | |
Kostya Serebryany | e2d0f63 | 2016-09-01 01:22:27 +0000 | [diff] [blame] | 465 | if (Flags.minimize_crash_internal_step) |
| 466 | return MinimizeCrashInputInternalStep(&F); |
| 467 | |
Kostya Serebryany | c5575aa | 2016-03-17 19:59:39 +0000 | [diff] [blame] | 468 | if (DoPlainRun) { |
| 469 | Options.SaveArtifacts = false; |
Kostya Serebryany | 9d14e4b | 2016-02-12 02:32:03 +0000 | [diff] [blame] | 470 | int Runs = std::max(1, Flags.runs); |
| 471 | Printf("%s: Running %zd inputs %d time(s) each.\n", ProgName->c_str(), |
| 472 | Inputs->size(), Runs); |
Kostya Serebryany | bfbe7fc | 2016-02-02 03:03:47 +0000 | [diff] [blame] | 473 | for (auto &Path : *Inputs) { |
| 474 | auto StartTime = system_clock::now(); |
Kostya Serebryany | 042d1a7 | 2016-06-17 13:07:06 +0000 | [diff] [blame] | 475 | Printf("Running: %s\n", Path.c_str()); |
Kostya Serebryany | 5c3701c | 2016-03-04 22:35:40 +0000 | [diff] [blame] | 476 | for (int Iter = 0; Iter < Runs; Iter++) |
Kostya Serebryany | a016a45 | 2016-08-30 14:52:05 +0000 | [diff] [blame] | 477 | RunOneTest(&F, Path.c_str(), Options.MaxLen); |
Kostya Serebryany | bfbe7fc | 2016-02-02 03:03:47 +0000 | [diff] [blame] | 478 | auto StopTime = system_clock::now(); |
| 479 | auto MS = duration_cast<milliseconds>(StopTime - StartTime).count(); |
Kostya Serebryany | 042d1a7 | 2016-06-17 13:07:06 +0000 | [diff] [blame] | 480 | Printf("Executed %s in %zd ms\n", Path.c_str(), (long)MS); |
Kostya Serebryany | bfbe7fc | 2016-02-02 03:03:47 +0000 | [diff] [blame] | 481 | } |
Kostya Serebryany | bdb220c | 2016-08-15 19:44:04 +0000 | [diff] [blame] | 482 | Printf("***\n" |
| 483 | "*** NOTE: fuzzing was not performed, you have only\n" |
| 484 | "*** executed the target code on a fixed set of inputs.\n" |
| 485 | "***\n"); |
Kostya Serebryany | baf7fd0 | 2016-05-04 20:44:50 +0000 | [diff] [blame] | 486 | F.PrintFinalStats(); |
Kostya Serebryany | bfbe7fc | 2016-02-02 03:03:47 +0000 | [diff] [blame] | 487 | exit(0); |
| 488 | } |
| 489 | |
Kostya Serebryany | 9cc3b0d | 2015-10-24 01:16:40 +0000 | [diff] [blame] | 490 | if (Flags.merge) { |
Kostya Serebryany | 64d2457 | 2016-03-12 01:57:04 +0000 | [diff] [blame] | 491 | if (Options.MaxLen == 0) |
| 492 | F.SetMaxLen(kMaxSaneLen); |
Kostya Serebryany | 9cc3b0d | 2015-10-24 01:16:40 +0000 | [diff] [blame] | 493 | F.Merge(*Inputs); |
| 494 | exit(0); |
| 495 | } |
| 496 | |
Kostya Serebryany | 64d2457 | 2016-03-12 01:57:04 +0000 | [diff] [blame] | 497 | size_t TemporaryMaxLen = Options.MaxLen ? Options.MaxLen : kMaxSaneLen; |
Kostya Serebryany | 016852c | 2015-02-19 18:45:37 +0000 | [diff] [blame] | 498 | |
Kostya Serebryany | 09aa01a | 2016-09-21 01:04:43 +0000 | [diff] [blame] | 499 | UnitVector InitialCorpus; |
| 500 | for (auto &Inp : *Inputs) { |
| 501 | Printf("Loading corpus dir: %s\n", Inp.c_str()); |
| 502 | ReadDirToVectorOfUnits(Inp.c_str(), &InitialCorpus, nullptr, TemporaryMaxLen); |
| 503 | } |
Kostya Serebryany | 64d2457 | 2016-03-12 01:57:04 +0000 | [diff] [blame] | 504 | |
Kostya Serebryany | 09aa01a | 2016-09-21 01:04:43 +0000 | [diff] [blame] | 505 | if (Options.MaxLen == 0) { |
| 506 | size_t MaxLen = 0; |
| 507 | for (auto &U : InitialCorpus) |
| 508 | MaxLen = std::max(U.size(), MaxLen); |
| 509 | F.SetMaxLen(std::min(std::max(kMinDefaultLen, MaxLen), kMaxSaneLen)); |
| 510 | } |
Kostya Serebryany | 016852c | 2015-02-19 18:45:37 +0000 | [diff] [blame] | 511 | |
Kostya Serebryany | 09aa01a | 2016-09-21 01:04:43 +0000 | [diff] [blame] | 512 | if (InitialCorpus.empty()) { |
| 513 | InitialCorpus.push_back(Unit()); |
Kostya Serebryany | 09087bb | 2016-04-18 21:14:11 +0000 | [diff] [blame] | 514 | if (Options.Verbosity) |
| 515 | Printf("INFO: A corpus is not provided, starting from an empty corpus\n"); |
| 516 | } |
Kostya Serebryany | 09aa01a | 2016-09-21 01:04:43 +0000 | [diff] [blame] | 517 | F.ShuffleAndMinimize(&InitialCorpus); |
| 518 | F.Loop(); |
Kostya Serebryany | dc3135d | 2015-11-12 01:02:01 +0000 | [diff] [blame] | 519 | |
Kostya Serebryany | 016852c | 2015-02-19 18:45:37 +0000 | [diff] [blame] | 520 | if (Flags.verbosity) |
Kostya Serebryany | 20e9bcb | 2015-05-23 01:07:46 +0000 | [diff] [blame] | 521 | Printf("Done %d runs in %zd second(s)\n", F.getTotalNumberOfRuns(), |
| 522 | F.secondsSinceProcessStartUp()); |
Kostya Serebryany | 66ff075 | 2016-02-26 22:42:23 +0000 | [diff] [blame] | 523 | F.PrintFinalStats(); |
Kostya Serebryany | 20e9bcb | 2015-05-23 01:07:46 +0000 | [diff] [blame] | 524 | |
Kostya Serebryany | c8cd29f | 2015-10-03 07:02:05 +0000 | [diff] [blame] | 525 | exit(0); // Don't let F destroy itself. |
Kostya Serebryany | 016852c | 2015-02-19 18:45:37 +0000 | [diff] [blame] | 526 | } |
Dan Liew | 1873a49 | 2016-06-07 23:32:50 +0000 | [diff] [blame] | 527 | |
| 528 | // Storage for global ExternalFunctions object. |
| 529 | ExternalFunctions *EF = nullptr; |
| 530 | |
Kostya Serebryany | 016852c | 2015-02-19 18:45:37 +0000 | [diff] [blame] | 531 | } // namespace fuzzer |