Harden writer of munged bitcode for fuzzing

include/llvm/Bitcode/NaCl/NaClBitcodeMunge.h

 //===- NaClBitcodeMunge.h - Bitcode Munger ----------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // Test harness for generating a PNaCl bitcode memory buffer from
@@ skipping 55 matching lines @@
   }
 
   /// Sets death test flag. When true, output will be redirected to
   /// the errs() (rather than buffered) so that the test can be
   /// debugged.
   void setRunAsDeathTest(bool NewValue) {
     RunAsDeathTest = NewValue;
   }
 
   /// Creates MungedInput and DumpStream for running tests, based on
-  /// given Munges.
-  void setupTest(
+  /// given Munges. Returns true if able to set up test.
+  bool setupTest(
       const char *TestName, const uint64_t Munges[], size_t MungesSize,
       bool AddHeader);
 
-  /// Cleans up state after a test.
-  void cleanupTest();
+  /// Cleans up state after a test. Returns true if no errors found.
+  bool cleanupTest();
 
   /// Returns the resulting string generated by the corresponding test.
   const std::string &getTestResults() const {
     return DumpResults;
   }
 
   /// Returns the lines containing the given Substring, from the
   /// string getTestResults().
   std::string getLinesWithSubstring(const std::string &Substring) const {
     return getLinesWithTextMatch(Substring, false);
@@ skipping 10 matching lines @@
   void setTryToRecoverOnWrite(bool NewValue) {
     WriteFlags.setTryToRecover(NewValue);
   }
 
   /// When NewValue, write bad abbreviation index into bitcode when
   /// writing during next test.
   void setWriteBadAbbrevIndex(bool NewValue) {
     WriteFlags.setWriteBadAbbrevIndex(NewValue);
   }
 
+  /// Get access to munged bitcodes.
+  NaClMungedBitcode &getMungedBitcode() {
+    return MungedBitcode;
+  }
+
+  /// Apply given munges to the munged bitcode.
+  void munge(const uint64_t Munges[], size_t MungesSize) {
+    MungedBitcode.munge(Munges, MungesSize, RecordTerminator);
+  }
+
 protected:
   // The bitcode records being munged.
   NaClMungedBitcode MungedBitcode;
   // The value used as record terminator.
   uint64_t RecordTerminator;
   // The results buffer of the last dump.
   std::string DumpResults;
   // The memory buffer containing the munged input.
   std::unique_ptr<MemoryBuffer> MungedInput;
   // The stream containing errors and the objdump of the generated bitcode file.
@@ skipping 21 matching lines @@
                                     bool MustBePrefix = false) const;
 
   // Returns the log stream to use. When running death tests, redirect output
   // to the error stream (rather than buffering in DumpStream), so that
   // the output can be seen in gtest death tests.
   raw_ostream &getDumpStream() const {
     return RunAsDeathTest ? errs() : *DumpStream;
   }
 };
 
+/// Class to run tests writing munged bitcode.
+class NaClWriteMunger : public NaClBitcodeMunger {
+public:
+  NaClWriteMunger(const uint64_t Records[], size_t RecordsSize,
+                  uint64_t RecordTerminator)
+      : NaClBitcodeMunger(Records, RecordsSize, RecordTerminator) {}
+
+  /// Writes munged bitcode and puts error messages into DumpResults.
+  /// Returns true if successful.
+  bool runTest(const char* TestName, const uint64_t Munges[],
+               size_t MungesSize);
+
+  /// Same as above, but without test name.
+  bool runTest(const uint64_t Munges[], size_t MungesSize) {
+    return runTest("Test", Munges, MungesSize);
+  }
+
+  /// Same as above, but without any edits.
+  bool runTest(const char* TestName) {
+    uint64_t NoMunges[] = {0};
+    return runTest(TestName, NoMunges, 0);
+  }
+
+  /// Same as above, but without test name.
+  bool runTest() {
+    return runTest("Test");
+  }
+};
+
 /// Class to run tests for function llvm::NaClObjDump.
 class NaClObjDumpMunger : public NaClBitcodeMunger {
 public:
 
   /// Creates a bitcode munger, based on the given array of values.
   NaClObjDumpMunger(const uint64_t Records[], size_t RecordsSize,
                     uint64_t RecordTerminator)
       : NaClBitcodeMunger(Records, RecordsSize, RecordTerminator) {}
 
   /// Runs function NaClObjDump on the sequence of records associated
@@ skipping 11 matching lines @@
     return runTestWithFlags(TestName, NoMunges, 0, AddHeader, NoRecords,
                             NoAssembly);
   }
 
   /// Same as above except it runs function NaClObjDump with flags
   /// NoRecords and NoAssembly set to false, and AddHeader set to true.
   bool runTest(const char *TestName) {
     return runTestWithFlags(TestName, true, false, false);
   }
 
-  /// Same as runTest, but only print out assembly and errors.
+  /// Same as above but without test name.
+  bool runTest() {
+    return runTest("Test");
+  }
+
+  /// Same as above, but only print out assembly and errors.
   bool runTestForAssembly(const char *TestName) {
     return runTestWithFlags(TestName, true, true, false);
   }
 
-  /// Same as runTest, but only generate error messages.
+  /// Same as above, but only generate error messages.
   bool runTestForErrors(const char *TestName) {
     return runTestWithFlags(TestName, true, true, true);
   }
 
   /// Runs function llvm::NaClObjDump on the sequence of records
   /// associated with the instance. Array Munges contains the sequence
   /// of edits to apply to the sequence of records when generating the
   /// bitsequence in a memory buffer. This generated bitsequence is
   /// then passed to NaClObjDump.  TestName is the name associated
   /// with the memory buffer.  Arguments NoRecords and NoAssembly are
   /// passed to NaClObjDump. Returns true if test succeeds without
   /// errors.
   bool runTestWithFlags(const char* TestName, const uint64_t Munges[],
                         size_t MungesSize, bool AddHeader,
                         bool NoRecords, bool NoAssembly);
 
   /// Same as above except it runs function NaClObjDump with flags
   /// NoRecords and NoAssembly set to false, and AddHeader set to
   /// true.
   bool runTest(const char* TestName, const uint64_t Munges[],
                       size_t MungesSize) {
     return runTestWithFlags(TestName, Munges, MungesSize, true, false, false);
   }
 
+  bool runTest(const uint64_t Munges[], size_t MungesSize) {
+    return runTest("Test", Munges, MungesSize);
+  }
+
   bool runTestForAssembly(const char* TestName, const uint64_t Munges[],
                           size_t MungesSize) {
     return runTestWithFlags(TestName, Munges, MungesSize, true, true, false);
   }
 
   bool runTestForErrors(const char* TestName, const uint64_t Munges[],
                         size_t MungesSize) {
     return runTestWithFlags(TestName, Munges, MungesSize, true, true, true);
   }
 };
 
 // Class to run tests for function NaClParseBitcodeFile.
 class NaClParseBitcodeMunger : public NaClBitcodeMunger {
 public:
   NaClParseBitcodeMunger(const uint64_t Records[], size_t RecordsSize,
                          uint64_t RecordTerminator)
       : NaClBitcodeMunger(Records, RecordsSize, RecordTerminator) {}
 
   /// Runs function llvm::NaClParseBitcodeFile, and puts error messages
   /// into DumpResults. Returns true if parse is successful.
   bool runTest(const char* TestName, const uint64_t Munges[],
                size_t MungesSize, bool VerboseErrors);
 
+  /// Same as above, but without test name.
+  bool runTest(const uint64_t Munges[], size_t MungesSize, bool VerboseErrors) {
+    return runTest("Test", Munges, MungesSize, VerboseErrors);
+  }
+
   // Same as above, but without any edits.
   bool runTest(const char* TestName, bool VerboseErrors) {
     uint64_t NoMunges[] = {0};
     return runTest(TestName, NoMunges, 0, VerboseErrors);
   }
 };
 
 // Class to run tests for NaClBitcodeCompressor.compress().
 class NaClCompressMunger : public NaClBitcodeMunger {
 public:
   NaClCompressMunger(const uint64_t Records[], size_t RecordsSize,
                      uint64_t RecordTerminator)
       : NaClBitcodeMunger(Records, RecordsSize, RecordTerminator) {}
 
   bool runTest(const char* TestName, const uint64_t Munges[],
                size_t MungesSize);
 
   bool runTest(const char* TestName) {
     uint64_t NoMunges[] = {0};
     return runTest(TestName, NoMunges, 0);
   }
 };
 
 } // end namespace llvm.
 
 #endif // LLVM_BITCODE_NACL_NACLBITCODEMUNGE_H