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 200 matching lines @@
       if (NumBits > 32) {
         Fatal() << "Error: Bit size " << NumBits
                 << " for record should be <= 32\n";
         ReportFatalError();
       }
     } else {
       Fatal() << "Error: Values for enter record should be of size 2. Found: "
               << Values.size();
       ReportFatalError();
     }
+    uint64_t MaxAbbrev = (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 {
-      Writer->EnterSubblock(WriteBlockID, NumBits);
+      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();
+      }
+      errs() << "Warning: Record code " << RecordCode
+             << " uses illegal abbreviation index " << AbbrevIndex << "\n";
+      // Fake writing out record using default abbreviation pattern.

[jvoung (off chromium), 2015/02/20 00:12:42]

When is this sort of error recovery needed?

Can you just abort either way?

[Karl, 2015/02/20 21:41:17]

The purpose of the munger is to be able to introduce "errors" in bitcode files.
One of them is abbreviations. This code allows illegal abbreviations to be put
in the bitcode file, so that the reader can be tested and report the error.

Updated the comment to reflect this.

+      Writer->EmitCode(AbbrevIndex);
+      Writer->EmitVBR(RecordCode, 6);
+      uint32_t NumValues = uint32_t(Values.size());

[jvoung (off chromium), 2015/02/20 00:12:42]

static_cast<uint32_t>()?

[Karl, 2015/02/20 21:41:17]

Done.

+      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 55 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 (NaClObjDump(MungedInput.get(), *DumpStream, NoRecords, NoAssembly))
+
+  /// 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;
+  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);
   LLVMContext &Context = getGlobalContext();
   raw_ostream *VerboseStrm = VerboseErrors ? DumpStream : nullptr;
   ErrorOr<Module *> ModuleOrError =
       NaClParseBitcodeFile(MungedInput.get(), Context, VerboseStrm);
   if (ModuleOrError) {
     if (VerboseErrors)
       *DumpStream << "Successful parse!\n";
     delete ModuleOrError.get();
   } else {
     Error() << ModuleOrError.getError().message() << "\n";
   }
   cleanupTest();
   return !FoundErrors;
 }