Fix the NaCl bitstream reader to report fatal errors.

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 121 matching lines @@
   // 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.
+  std::vector<uint64_t> AbbrevIndexLimitStack;
 
   // 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,
@@ skipping 38 matching lines @@
                     size_t &Index);
 };
 
 /// 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) {}
+      : NaClBitcodeMunger(Records, RecordsSize, RecordTerminator),
+        RunAsDeathTest(false) {}
 
   /// 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
+  /// errstream so that they can be tested.
+  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
   /// 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 any edits.
   bool runTest(const char* TestName, bool VerboseErrors) {
     uint64_t NoMunges[] = {0};
     return runTest(TestName, NoMunges, 0, VerboseErrors);
   }
 };
 
 } // end namespace llvm.
 
 #endif // LLVM_BITCODE_NACL_NACLBITCODEMUNGE_H