Add abilities to generate bitcode buffers from munged bitcode.

This CL adds capabilities to read/write a munged list of bitcode
records.

BUG=None
[email protected]

Review URL: https://codereview.chromium.org/1113023005

Author: KarlSchimpf

include/llvm/Bitcode/NaCl/NaClBitcodeMunge.h

@@ -13,7 +13,7 @@
 // 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
@@ -47,7 +47,6 @@
 
 namespace llvm {
 
-class NaClBitstreamWriter;
 class NaClBitCodeAbbrev;
 
 /// Base class to run tests on munged bitcode files.
@@ -57,10 +56,21 @@ class NaClBitcodeMunger {
   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.
@@ -88,52 +98,43 @@ class NaClBitcodeMunger {
     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
@@ -142,14 +143,12 @@ class NaClBitcodeMunger {
   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.
@@ -159,8 +158,7 @@ class NaClObjDumpMunger : public NaClBitcodeMunger {
   /// 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
@@ -178,18 +176,6 @@ class NaClObjDumpMunger : public NaClBitcodeMunger {
                             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) {
@@ -235,11 +221,6 @@ class NaClObjDumpMunger : public NaClBitcodeMunger {
                         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.

include/llvm/Bitcode/NaCl/NaClBitcodeMungeUtils.h

@@ -81,6 +81,7 @@
 
 namespace llvm {
 
+class MemoryBuffer;            // Buffer to read bitcode from
 class NaClBitcodeAbbrevRecord; // bitcode record.
 class NaClMungedBitcodeIter;   // iterator over edited bitcode records.
 
@@ -99,6 +100,10 @@ void readNaClBitcodeRecordList(NaClBitcodeRecordList &RecordList,
                                size_t RecordsSize,
                                uint64_t RecordTerminator);
 
+/// \brief Read in the list of records from bitcode in a memory buffer.
+void readNaClBitcodeRecordList(NaClBitcodeRecordList &RecordList,
+                               std::unique_ptr<MemoryBuffer> InputBuffer);
+
 /// \brief An edited (i.e. munged) list of bitcode records. Edits are
 /// always relative to the initial list of records.
 class NaClMungedBitcode {
@@ -111,6 +116,9 @@ class NaClMungedBitcode {
   /// \brief Iterator over edited records.
   typedef NaClMungedBitcodeIter iterator;
 
+  /// \brief Read in initial list of records from bitcode in a memory buffer.
+  explicit NaClMungedBitcode(std::unique_ptr<MemoryBuffer> InputBuffer);
+
   /// \brief Initialize the list of records to be edited.
   explicit NaClMungedBitcode(std::unique_ptr<NaClBitcodeRecordList> BaseRecords)
       : BaseRecords(std::move(BaseRecords)) {}
@@ -160,6 +168,84 @@ class NaClMungedBitcode {
   /// \brief Print out the resulting edited list of records.
   void print(raw_ostream &Out) const;
 
+  /// Defines set of possible write flags.
+  struct WriteFlags {
+    /// True if error recovery should be applied.
+    bool getTryToRecover() const { return TryToRecover; }
+
+    /// Define that error recovery should be applied when writing.
+    void setTryToRecover(bool NewValue) {
+      TryToRecover = NewValue;
+      assert(!(TryToRecover && WriteBadAbbrevIndex));
+    }
+
+    /// True if a bad abbreviation index should be written (rather than
+    /// trying error recovery) so that bitcode readers can be tested for
+    /// this condition.
+    bool getWriteBadAbbrevIndex() const { return WriteBadAbbrevIndex; }
+
+    /// Define that the first bad abbreviation index should be written,
+    /// and corresponding minimal context added so that the bitcode can
+    /// be used to test reading the erroneous written bitcode.
+    void setWriteBadAbbrevIndex(bool NewValue) {
+      WriteBadAbbrevIndex = NewValue;
+      assert(!(TryToRecover && WriteBadAbbrevIndex));
+    }
+
+    /// Get the stream to print errors while writing bitcode.
+    raw_ostream &getErrStream() const {
+      return ErrStream ? *ErrStream : errs();
+    }
+
+    /// Set the stream to print errors to.
+    void setErrStream(raw_ostream &NewValue) {
+      ErrStream = &NewValue;
+    }
+
+    void reset() {
+      TryToRecover = false;
+      WriteBadAbbrevIndex = false;
+      ErrStream = nullptr;
+    }
+
+  private:
+    bool TryToRecover = false;
+    bool WriteBadAbbrevIndex = false;
+    raw_ostream *ErrStream = nullptr;
+  };
+
+  /// Defines the results associated with writing bitcode.
+  struct WriteResults {
+    /// Number of errors generated.
+    size_t NumErrors = 0;
+    /// Number of repairs (via error recovery) that were applied.
+    size_t NumRepairs = 0;
+    /// True if a bad abbreviation index were written.
+    bool WroteBadAbbrevIndex = false;
+  };
+
+  /// \brief Write out the edited list of bitcode records using
+  /// the given buffer.
+  ///
+  /// \param Buffer The buffer to write into.
+  /// \param AddHeader Add header block when true.
+  /// \param Flags Write flags to use.
+  ///
+  /// \return Returns the results of the write.
+  WriteResults writeMaybeRepair(
+      SmallVectorImpl<char> &Buffer, bool AddHeader,
+      const WriteFlags &Flags) const;
+
+  bool write(SmallVectorImpl<char> &Buffer, bool AddHeader,
+             const WriteFlags &Flags) const {
+    return writeMaybeRepair(Buffer, AddHeader, Flags).NumErrors == 0;
+  }
+
+  bool write(SmallVectorImpl<char> &Buffer, bool AddHeader) const {
+    WriteFlags Flags;
+    return write(Buffer, AddHeader, Flags);
+  }
+
   /// \brief The types of editing actions that can be applied.
   enum EditAction {
     AddBefore, // Insert new record before base record at index.
@@ -190,6 +276,11 @@ class NaClMungedBitcode {
   /// set of base records.
   void removeEdits();
 
+  /// Returns the unedited list of bitcode records.
+  const NaClBitcodeRecordList &getBaseRecords() const {
+    return *BaseRecords;
+  }
+
 private:
   typedef std::list<NaClBitcodeAbbrevRecord *> RecordListType;
   typedef std::map<size_t, RecordListType *> InsertionsMapType;
@@ -241,7 +332,7 @@ class NaClBitcodeAbbrevRecord : public NaClBitcodeRecordData {
   /// \param Code The selector code of the record.
   /// \param Values The values associated with the selector code.
   NaClBitcodeAbbrevRecord(unsigned Abbrev, unsigned Code,
-                          NaClRecordVector &Values)
+                          const NaClRecordVector &Values)
       : NaClBitcodeRecordData(Code, Values), Abbrev(Abbrev) {}
 
   /// \brief Creates a copy of the given abbreviated bitcode record.

include/llvm/Bitcode/NaCl/NaClBitstreamWriter.h

@@ -123,7 +123,7 @@ class NaClBitstreamWriter {
       : Out(O), CurBit(0), CurValue(0), CurCodeSize() {}
 
   ~NaClBitstreamWriter() {
-    assert(CurBit == 0 && "Unflused data remaining");
+    assert(CurBit == 0 && "Unflushed data remaining");
     assert(BlockScope.empty() && CurAbbrevs.empty() && "Block imbalance");
 
     // Free the BlockInfoRecords.

lib/Bitcode/NaCl/TestUtils/CMakeLists.txt

@@ -1,5 +1,7 @@
 add_llvm_library(LLVMNaClBitTestUtils
   NaClBitcodeMunge.cpp
+  NaClBitcodeMungeReader.cpp
   NaClBitcodeMungeUtils.cpp
+  NaClBitcodeMungeWriter.cpp
   )
 add_dependencies(LLVMNaClBitTestUtils intrinsics_gen)