lib/Fuzzer/FuzzerMain.cpp

   1 //===- FuzzerMain.cpp - main() 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 // main() and flags.
  10 //===----------------------------------------------------------------------===//
  11
  12 #include "FuzzerInternal.h"
  13
  14 #include <climits>
  15 #include <cstring>
  16 #include <unistd.h>
  17 #include <iostream>
  18
  19 // ASAN options:
  20 //   * don't dump the coverage to disk.
  21 extern "C" const char* __asan_default_options() { return "coverage_pcs=0"; }
  22
  23 // Program arguments.
  24 struct FlagDescription {
  25   const char *Name;
  26   const char *Description;
  27   int   Default;
  28   int   *Flag;
  29 };
  30
  31 struct {
  32 #define FUZZER_FLAG(Type, Name, Default, Description) Type Name;
  33 #include "FuzzerFlags.def"
  34 #undef FUZZER_FLAG
  35 } Flags;
  36
  37 static FlagDescription FlagDescriptions [] {
  38 #define FUZZER_FLAG(Type, Name, Default, Description) {#Name, Description, Default, &Flags.Name},
  39 #include "FuzzerFlags.def"
  40 #undef FUZZER_FLAG
  41 };
  42
  43 static const size_t kNumFlags =
  44     sizeof(FlagDescriptions) / sizeof(FlagDescriptions[0]);
  45
  46 static std::vector<std::string> inputs;
  47 static const char *ProgName;
  48
  49 static void PrintHelp() {
  50   std::cerr << "Usage: " << ProgName
  51             << " [-flag1=val1 [-flag2=val2 ...] ] [dir1 [dir2 ...] ]\n";
  52   std::cerr << "\nFlags: (strictly in form -flag=value)\n";
  53   size_t MaxFlagLen = 0;
  54   for (size_t F = 0; F < kNumFlags; F++)
  55     MaxFlagLen = std::max(strlen(FlagDescriptions[F].Name), MaxFlagLen);
  56
  57   for (size_t F = 0; F < kNumFlags; F++) {
  58     const auto &D = FlagDescriptions[F];
  59     std::cerr << "  " << D.Name;
  60     for (size_t i = 0, n = MaxFlagLen - strlen(D.Name); i < n; i++)
  61       std::cerr << " ";
  62     std::cerr << "\t";
  63     std::cerr << D.Default << "\t" << D.Description << "\n";
  64   }
  65 }
  66
  67 static const char *FlagValue(const char *Param, const char *Name) {
  68   size_t Len = strlen(Name);
  69   if (Param[0] == '-' && strstr(Param + 1, Name) == Param + 1 &&
  70       Param[Len + 1] == '=')
  71       return &Param[Len + 2];
  72   return nullptr;
  73 }
  74
  75 static bool ParseOneFlag(const char *Param) {
  76   if (Param[0] != '-') return false;
  77   for (size_t F = 0; F < kNumFlags; F++) {
  78     const char *Name = FlagDescriptions[F].Name;
  79     const char *Str = FlagValue(Param, Name);
  80     if (Str)  {
  81       int Val = std::stol(Str);
  82       *FlagDescriptions[F].Flag = Val;
  83       if (Flags.verbosity >= 2)
  84         std::cerr << "Flag: " << Name << " " << Val << "\n";
  85       return true;
  86     }
  87   }
  88   PrintHelp();
  89   exit(1);
  90 }
  91
  92 // We don't use any library to minimize dependencies.
  93 static void ParseFlags(int argc, char **argv) {
  94   for (size_t F = 0; F < kNumFlags; F++)
  95     *FlagDescriptions[F].Flag = FlagDescriptions[F].Default;
  96   for (int A = 1; A < argc; A++) {
  97     if (ParseOneFlag(argv[A])) continue;
  98     inputs.push_back(argv[A]);
  99   }
 100 }
 101
 102 int main(int argc, char **argv) {
 103   using namespace fuzzer;
 104
 105   ProgName = argv[0];
 106   ParseFlags(argc, argv);
 107   if (Flags.help) {
 108     PrintHelp();
 109     return 0;
 110   }
 111   Fuzzer::FuzzingOptions Options;
 112   Options.Verbosity = Flags.verbosity;
 113   Options.MaxLen = Flags.max_len;
 114   Options.DoCrossOver = Flags.cross_over;
 115   Options.MutateDepth = Flags.mutate_depth;
 116   Options.ExitOnFirst = Flags.exit_on_first;
 117   if (!inputs.empty())
 118     Options.OutputCorpus = inputs[0];
 119   Fuzzer F(Options);
 120
 121   unsigned seed = Flags.seed;
 122   // Initialize seed.
 123   if (seed == 0)
 124     seed = time(0) * 10000 + getpid();
 125   if (Flags.verbosity)
 126     std::cerr << "Seed: " << seed << "\n";
 127   srand(seed);
 128
 129   // Timer
 130   if (Flags.timeout > 0)
 131     SetTimer(Flags.timeout);
 132
 133   for (auto &inp : inputs)
 134     F.ReadDir(inp);
 135
 136   if (F.CorpusSize() == 0)
 137     F.AddToCorpus(Unit());  // Can't fuzz empty corpus, so add an empty input.
 138   F.ShuffleAndMinimize();
 139   F.Loop(Flags.iterations < 0 ? INT_MAX : Flags.iterations);
 140   if (Flags.verbosity)
 141     std::cerr << "Done\n";
 142   return 1;
 143 }