[LibFuzzer] Introducing FUZZER_FLAG_UNSIGNED and using it for seeding.

[aizatsky]

Summary

Reported: https://llvm.org/bugs/show_bug.cgi?id=25767

[aizatsky]

nits

[danielaustin]

Verified, seed values are accepted as unsigned values and sessions can be easily replayed as well. Thanks for the quick fix!

[kcc]

code LGTM.
Please add a test to test/fuzzer.test, then good to go.

[aizatsky]

Was submitted as http://reviews.llvm.org/rL255296

lib/Fuzzer/FuzzerDriver.cpp

 
 // Program arguments.
 struct FlagDescription {
   const char *Name;
   const char *Description;
   int   Default;
   int   *IntFlag;
   const char **StrFlag;
+  unsigned int *UIntFlag;
 };
 
 struct {
 #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_FLAG_INT
+#undef FUZZER_FLAG_UNSIGNED
 #undef FUZZER_FLAG_STRING
 } Flags;
 
 static const FlagDescription FlagDescriptions [] {
 #define FUZZER_FLAG_INT(Name, Default, Description)                            \
-  { #Name, Description, Default, &Flags.Name, nullptr},
+  {#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 },
+  {#Name, Description, 0, nullptr, &Flags.Name, nullptr},
 #include "FuzzerFlags.def"
 #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;
for (size_t F = 0; F < kNumFlags; F++) {
     const char *Str = FlagValue(Param, Name);
     if (Str)  {
       if (FlagDescriptions[F].IntFlag) {
         int Val = std::stol(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;
       }
     }
   }
   PrintHelp();
   exit(1);
 }
 
 // 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())) continue;
     Inputs->push_back(Args[A]);
   }

lib/Fuzzer/FuzzerFlags.def

 //===- 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_INT(seed, 0, "Random seed. If 0, seed is generated.")
+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, 64, "Maximum length of the test input.")
 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(

lib/Fuzzer/FuzzerInterface.h

 #\endcode
 */
 int FuzzerDriver(int argc, char **argv, UserCallback Callback);
 
 class FuzzerRandomBase {
  public:
   FuzzerRandomBase(){}
   virtual ~FuzzerRandomBase(){};
-  virtual void ResetSeed(int seed) = 0;
+  virtual void ResetSeed(unsigned int seed) = 0;
   // Return a random number.
   virtual size_t Rand() = 0;
   // Return a random number in range [0,n).
   size_t operator()(size_t n) { return n ? Rand() % n : 0; }
   bool RandBool() { return Rand() % 2; }
 };
 
 class FuzzerRandomLibc : public FuzzerRandomBase {
  public:
-  FuzzerRandomLibc(int seed) { ResetSeed(seed); }
-  void ResetSeed(int seed) override;
+  FuzzerRandomLibc(unsigned int seed) { ResetSeed(seed); }
+  void ResetSeed(unsigned int seed) override;
   ~FuzzerRandomLibc() override {}
   size_t Rand() override;
 };
 
 class MutationDispatcher {
  public:
   MutationDispatcher(FuzzerRandomBase &Rand);
   ~MutationDispatcher();

lib/Fuzzer/FuzzerInterface.cpp

 //===----------------------------------------------------------------------===//
 
 
 #include "FuzzerInterface.h"
 #include "FuzzerInternal.h"
 
 namespace fuzzer {
 
-void FuzzerRandomLibc::ResetSeed(int seed) { srand(seed); }
+void FuzzerRandomLibc::ResetSeed(unsigned int seed) { srand(seed); }
 
 size_t FuzzerRandomLibc::Rand() { return rand(); }
 
 UserSuppliedFuzzer::UserSuppliedFuzzer(FuzzerRandomBase *Rand)
     : Rand(Rand), MD(*Rand) {}
 
 UserSuppliedFuzzer::~UserSuppliedFuzzer() {
   if (OwnRand)
     delete Rand;
 }
 
 }  // namespace fuzzer.