Add abilities to generate bitcode buffers from munged bitcode.

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
 // an array, and parse/objdump/compress the resulting contents.
 //
 // Generates a bitcode memory buffer from an array containing 1 or
 // more PNaCl records. Used to test errors in PNaCl bitcode.
 //
-// Bitcode records are modeleled using arrays using the format
+// Bitcode records are modeled using arrays using the format
 // specified in NaClBitcodeMungeUtils.h.
 //
 // Note: Since the header record doesn't have any abbreviation indices
 // associated with it, one can use any value. The value will simply be
 // ignored.
 //
 // In addition to specifying the sequence of records, one can also
 // define a sequence of edits to be applied to the original sequence
 // of records. This allows the same record sequence to be used in
 // multiple tests. Again, see NaClBitcodeMungeUtils.h for the
@@ skipping 13 matching lines @@
 
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Bitcode/NaCl/NaClBitcodeMungeUtils.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/raw_ostream.h"
 
 #include <string>
 
 namespace llvm {
 
-class NaClBitstreamWriter;
 class NaClBitCodeAbbrev;
 
 /// Base class to run tests on munged bitcode files.
 class NaClBitcodeMunger {
 public:
   /// Creates a bitcode munger, based on the given array of values.
   NaClBitcodeMunger(const uint64_t Records[], size_t RecordsSize,
                     uint64_t RecordTerminator)
       : MungedBitcode(Records, RecordsSize, RecordTerminator),
-        RecordTerminator(RecordTerminator), WriteBlockID(-1), SetBID(-1),
+        RecordTerminator(RecordTerminator),
         DumpResults("Error: No previous dump results!\n"),
-        DumpStream(nullptr), Writer(nullptr), FoundErrors(false),
-        FatalBuffer(), FatalStream(FatalBuffer) {}
+        DumpStream(nullptr), FoundErrors(false), RunAsDeathTest(false) {}
+
+  /// Returns true if running as death test.
+  bool getRunAsDeathTest() const {
+    return RunAsDeathTest;
+  }
+
+  /// 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(
       const char *TestName, const uint64_t Munges[], size_t MungesSize,
       bool AddHeader);
 
   /// Cleans up state after a test.
   void 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);
   }
 
   /// Returns the lines starting with the given Prefix, from the string
   /// getTestResults().
   std::string getLinesWithPrefix(const std::string &Prefix) const {
     return getLinesWithTextMatch(Prefix, true);
   }
 
+  /// When NewValue, use error recovery when writing bitcode during
+  /// next test.
+  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);
+  }
+
 protected:
   // The bitcode records being munged.
   NaClMungedBitcode MungedBitcode;
   // The value used as record terminator.
   uint64_t RecordTerminator;
-  // The block ID associated with the block being written.
-  int WriteBlockID;
-  // The SetBID for the blockinfo block.
-  int SetBID;
   // 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.
   raw_ostream *DumpStream;
-  // The bitstream writer to use to generate the bitcode file.
-  NaClBitstreamWriter *Writer;
   // True if any errors were reported.
   bool FoundErrors;
-  // The buffer to hold the generated fatal message.
-  std::string FatalBuffer;
-  // The stream to write the fatal message to.
-  raw_string_ostream FatalStream;
-  // The stack of maximum abbreviation indices allowed by block enter record.
-  SmallVector<uint64_t, 3> AbbrevIndexLimitStack;
   // The buffer for the contents of the munged input.
   SmallVector<char, 1024> MungedInputBuffer;
+  /// The write flags to use when writing bitcode.
+  NaClMungedBitcode::WriteFlags WriteFlags;
+  // Flag to redirect dump stream if running death test.
+  bool RunAsDeathTest;
 
   // Records that an error occurred, and returns stream to print error
   // message to.
   raw_ostream &Error() {
     FoundErrors = true;
-    return *DumpStream << "Error: ";
-  }
-
-  // Returns stream to print fatal error message to.
-  // Note: Once the fatal error message has been dumped to the stream,
-  // one must call ReportFatalError to display the error and terminate
-  // execution.
-  raw_ostream &Fatal() {
-    return FatalStream << "Fatal: ";
-  }
-
-  // Displays the fatal error message and exits the program.
-  void ReportFatalError() {
-    report_fatal_error(FatalStream.str());
+    return getDumpStream() << "Error: ";
   }
 
   // Returns the lines containing the given Substring, from the string
   // getTestResults(). If MustBePrefix, then Substring must match at
   // the beginning of the line.
   std::string getLinesWithTextMatch(const std::string &Substring,
                                     bool MustBePrefix = false) const;
 
-  // Writes out munged bitcode records.
-  void writeMungedBitcode(const NaClMungedBitcode &Bitcode, bool AddHeader);
-
-  // Emits the given record to the bitcode file.
-  void emitRecord(const NaClBitcodeAbbrevRecord &Record);
-
-  // Converts the abbreviation record to the corresponding abbreviation.
-  NaClBitCodeAbbrev *buildAbbrev(const NaClBitcodeAbbrevRecord &Record);
+  // 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 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),
-        RunAsDeathTest(false) {}
+      : NaClBitcodeMunger(Records, RecordsSize, RecordTerminator) {}
 
   /// Runs function NaClObjDump on the sequence of records associated
   /// with the instance. The memory buffer containing the bitsequence
   /// associated with the record is automatically generated, and
   /// passed to NaClObjDump.  TestName is the name associated with the
   /// memory buffer.  If AddHeader is true, test assumes that the
   /// sequence of records doesn't contain a header record, and the
   /// test should add one. Arguments NoRecords and NoAssembly are
   /// passed to NaClObjDump. Returns true if test succeeds without
   /// errors.
   bool runTestWithFlags(const char *TestName, bool AddHeader,
                         bool NoRecords, bool NoAssembly) {
     uint64_t NoMunges[] = {0};
     return runTestWithFlags(TestName, NoMunges, 0, AddHeader, NoRecords,
                             NoAssembly);
   }
 
-  /// Returns true if running as death test.
-  bool getRunAsDeathTest() const {
-    return RunAsDeathTest;
-  }
-
-  /// 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;
-  }
-
   /// 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.
   bool runTestForAssembly(const char *TestName) {
     return runTestWithFlags(TestName, true, true, false);
   }
@@ skipping 25 matching lines @@
 
   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);
   }
-
-private:
-  // Flag to redirect dump stream if running death test.
-  bool RunAsDeathTest;
-
 };
 
 // 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
@@ skipping 20 matching lines @@
 
   bool runTest(const char* TestName) {
     uint64_t NoMunges[] = {0};
     return runTest(TestName, NoMunges, 0);
   }
 };
 
 } // end namespace llvm.
 
 #endif // LLVM_BITCODE_NACL_NACLBITCODEMUNGE_H