Fix the NaCl bitstream reader to report fatal errors.

lib/Bitcode/NaCl/TestUtils/NaClBitcodeMunge.cpp

 //===--- Bitcode/NaCl/TestUtils/NaClBitcodeMunge.cpp - Bitcode Munger -----===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // Bitcode writer/munger implementation for testing.
@@ skipping 205 matching lines @@
       if (NumBits < 2) {
         Fatal() << "Error: Bit size " << NumBits
                 << " for record should be >= 2\n";
         ReportFatalError();
       }
     } else {
       Fatal() << "Error: Values for enter record should be of size 2. Found: "
               << Values.size();
       ReportFatalError();
     }
+    uint64_t MaxAbbrev = (static_cast<uint64_t>(1) << NumBits) - 1;
+    AbbrevIndexLimitStack.push_back(MaxAbbrev);
     if (WriteBlockID == naclbitc::BLOCKINFO_BLOCK_ID) {
       if (NumBits != naclbitc::DEFAULT_MAX_ABBREV) {
         Fatal()
             << "Error: Numbits entry for abbreviations record not 2. Found: "
             << NumBits << "\n";
         ReportFatalError();
       }
       Writer->EnterBlockInfoBlock();
     } else {
-      unsigned NumPossibleAbbrevs = (1 << NumBits) - 1;
-      Writer->EnterSubblock(WriteBlockID, NumPossibleAbbrevs);
+      NaClBitcodeSelectorAbbrev CurCodeLen(MaxAbbrev);
+      Writer->EnterSubblock(WriteBlockID, CurCodeLen);
     }
     return;
   }
   case naclbitc::BLK_CODE_EXIT:
     if (AbbrevIndex != naclbitc::END_BLOCK) {
       Fatal() << "Error: Exit block record code " << RecordCode
               << " uses illegal abbreviation index " << AbbrevIndex << "\n";
       ReportFatalError();
     }
     if (!Values.empty()) {
       Fatal() << "Error: Exit block should not have values. Found: "
               << Values.size() << "\n";
       ReportFatalError();
     }
+    if (!AbbrevIndexLimitStack.empty())
+      AbbrevIndexLimitStack.pop_back();
     Writer->ExitBlock();
     return;
   case naclbitc::BLK_CODE_DEFINE_ABBREV: {
     if (AbbrevIndex != naclbitc::DEFINE_ABBREV) {
       Fatal() << "Error: Define abbreviation record code " << RecordCode
                << " uses illegal abbreviation index " << AbbrevIndex << "\n";
       ReportFatalError();
     }
     NaClBitCodeAbbrev *Abbrev = buildAbbrev(RecordCode, Values);
     if (Abbrev == NULL) return;
     if (WriteBlockID == naclbitc::BLOCKINFO_BLOCK_ID) {
       Writer->EmitBlockInfoAbbrev(SetBID, Abbrev);
     } else {
       Writer->EmitAbbrev(Abbrev);
     }
     return;
   }
   case naclbitc::BLK_CODE_HEADER:
     // Note: There is no abbreviation index here. Ignore.
     for (SmallVectorImpl<uint64_t>::const_iterator
              Iter = Values.begin(), IterEnd = Values.end();
          Iter != IterEnd; ++Iter) {
       Writer->Emit(*Iter, 8);
     }
     return;
   default:
     if ((AbbrevIndex != naclbitc::UNABBREV_RECORD
          && !Writer->isUserRecordAbbreviation(AbbrevIndex))) {
-      Fatal() << "Error: Record code " << RecordCode
-              << " uses illegal abbreviation index " << AbbrevIndex << "\n";
-      ReportFatalError();
+      uint64_t BlockAbbrevIndexLimit = 0;
+      if (!AbbrevIndexLimitStack.empty())
+        BlockAbbrevIndexLimit = AbbrevIndexLimitStack.back();
+      if (AbbrevIndex > BlockAbbrevIndexLimit) {
+        Fatal() << "Error: Record code " << RecordCode
+                << " uses illegal abbreviation index " << AbbrevIndex
+                << ". Must not exceed " << BlockAbbrevIndexLimit << "\n";
+        ReportFatalError();
+      }
+      // Note: If this point is reached, the abbreviation is
+      // bad. However, that may be the point of munge being
+      // applied. Hence, emit the bad abbreviation and the data so
+      // that the reader can be tested on this bad input.  For
+      // simplicity, we output the record data using the default
+      // abbreviation pattern.
+      errs() << "Warning: Record code " << RecordCode
+             << " uses illegal abbreviation index " << AbbrevIndex << "\n";
+      Writer->EmitCode(AbbrevIndex);
+      Writer->EmitVBR(RecordCode, 6);
+      uint32_t NumValues = static_cast<uint32_t>(Values.size());
+      Writer->EmitVBR(NumValues, 6);
+      for (uint32_t i = 0; i < NumValues; ++i) {
+        Writer->EmitVBR64(Values[i], 6);
+      }
+      return;
     }
     if (AbbrevIndex == naclbitc::UNABBREV_RECORD)
       Writer->EmitRecord(RecordCode, Values);
     else
       Writer->EmitRecord(RecordCode, Values, AbbrevIndex);
     return;
   }
   Fatal() << "emitRecord on unimplemented code" << "\n";
   ReportFatalError();
 }
@@ skipping 71 matching lines @@
       ReportFatalError();
     }
   }
   return Abbrev;
 }
 
 bool NaClObjDumpMunger::runTestWithFlags(
     const char *Name, const uint64_t Munges[], size_t MungesSize,
     bool AddHeader, bool NoRecords, bool NoAssembly) {
   setupTest(Name, Munges, MungesSize, AddHeader);
+
+  /// If running in death mode, redirect output directly to the
+  /// error stream (rather than buffering in DumpStream), so that
+  /// output can be seen in gtest death test.
+  raw_ostream &Output = RunAsDeathTest ? errs() : *DumpStream;
   // TODO(jvoung,kschimpf): Should NaClObjDump take a MemoryBufferRef
   // like the parser?
-  if (NaClObjDump(MungedInput.get(), *DumpStream, NoRecords, NoAssembly))
+  if (NaClObjDump(MungedInput.get(), Output, NoRecords, NoAssembly))
     FoundErrors = true;
   cleanupTest();
   return !FoundErrors;
 }
 
 bool NaClParseBitcodeMunger::runTest(
     const char *Name, const uint64_t Munges[], size_t MungesSize,
     bool VerboseErrors) {
   bool AddHeader = true;
   setupTest(Name, Munges, MungesSize, AddHeader);
@@ skipping 15 matching lines @@
 
 bool NaClCompressMunger::runTest(const char* Name, const uint64_t Munges[],
                                  size_t MungesSize) {
   bool AddHeader = true;
   setupTest(Name, Munges, MungesSize, AddHeader);
   NaClBitcodeCompressor Compressor;
   bool Result = Compressor.compress(MungedInput.get(), *DumpStream);
   cleanupTest();
   return Result;
 }