Fix the NaCl bitstream reader to report fatal errors.

lib/Bitcode/NaCl/Reader/NaClBitstreamReader.cpp

 //===- NaClBitstreamReader.cpp --------------------------------------------===//
 //     NaClBitstreamReader implementation
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Bitcode/NaCl/NaClBitstreamReader.h"
+#include "llvm/Support/Format.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
 
+std::string NaClBitstreamReader::getBitAddress(uint64_t Bit,
+                                               unsigned MinByteWidth) {
+  std::string Buffer;
+  raw_string_ostream Stream(Buffer);
+  Stream << '%' << MinByteWidth << PRIu64 << ":%u";
+  Stream.flush();
+  std::string FormatString(Buffer);
+  Buffer.clear();
+  Stream << format(FormatString.c_str(),
+                   (Bit / 8),
+                   static_cast<unsigned>(Bit % 8));
+  return Stream.str();
+}
+
 //===----------------------------------------------------------------------===//
 //  NaClBitstreamCursor implementation
 //===----------------------------------------------------------------------===//
 
+void NaClBitstreamCursor::ErrorHandler::
+Fatal(const std::string &ErrorMessage) const {
+  // Default implementation is simply print message, and the bit where
+  // the error occurred.
+  std::string Buffer;
+  raw_string_ostream StrBuf(Buffer);
+  StrBuf << "Error(" << Cursor.getBitAddress(Cursor.GetCurrentBitNo()) << "): "
+         << ErrorMessage;
+  report_fatal_error(StrBuf.str());
+}
+
 void NaClBitstreamCursor::freeState() {
   // Free all the Abbrevs.
   for (size_t i = 0, e = CurAbbrevs.size(); i != e; ++i)
     CurAbbrevs[i]->dropRef();
   CurAbbrevs.clear();
 
   // Free all the Abbrevs in the block scope.
   for (size_t S = 0, e = BlockScope.size(); S != e; ++S) {
     std::vector<NaClBitCodeAbbrev*> &Abbrevs = BlockScope[S].PrevAbbrevs;
     for (size_t i = 0, e = Abbrevs.size(); i != e; ++i)
       Abbrevs[i]->dropRef();
   }
   BlockScope.clear();
 }
 
+void NaClBitstreamCursor::reportInvalidAbbrevNumber(unsigned AbbrevNo) const {
+  std::string Buffer;
+  raw_string_ostream StrBuf(Buffer);
+  StrBuf << "Invalid abbreviation # " << AbbrevNo << " defined for record";
+  ErrHandler->Fatal(StrBuf.str());
+}
+
+void NaClBitstreamCursor::reportInvalidJumpToBit(uint64_t BitNo) const {
+  std::string Buffer;
+  raw_string_ostream StrBuf(Buffer);
+  StrBuf << "Invalid jump to bit " << BitNo;
+  ErrHandler->Fatal(StrBuf.str());
+}
+
 /// EnterSubBlock - Having read the ENTER_SUBBLOCK abbrevid, enter
 /// the block, and return true if the block has an error.
 bool NaClBitstreamCursor::EnterSubBlock(unsigned BlockID, unsigned *NumWordsP) {
   // Save the current block's state on BlockScope.
   BlockScope.push_back(Block(CurCodeSize));
   BlockScope.back().PrevAbbrevs.swap(CurAbbrevs);
 
   // Add the abbrevs specific to this block to the CurAbbrevs list.
   if (const NaClBitstreamReader::BlockInfo *Info =
       BitStream->getBlockInfo(BlockID)) {
@@ skipping 14 matching lines @@
   if (CurCodeSize.NumBits == 0 || AtEndOfStream())
     return true;
 
   return false;
 }
 
 void NaClBitstreamCursor::skipAbbreviatedField(const NaClBitCodeAbbrevOp &Op) {
   // Decode the value as we are commanded.
   switch (Op.getEncoding()) {
   case NaClBitCodeAbbrevOp::Literal:
-    report_fatal_error("Not to be used with literals!");
+    llvm_unreachable("Not to be used with literals!");
+    break;
   case NaClBitCodeAbbrevOp::Fixed:
     (void)Read((unsigned)Op.getValue());
     break;
   case NaClBitCodeAbbrevOp::VBR:
     (void)ReadVBR64((unsigned)Op.getValue());
     break;
   case NaClBitCodeAbbrevOp::Array:
-    report_fatal_error("Bad array abbreviation encoding!");
+    llvm_unreachable("Bad array abbreviation encoding!");
+    break;
   case NaClBitCodeAbbrevOp::Char6:
     (void)Read(6);
     break;
   }
 }
 
 /// skipRecord - Read the current record and discard it.
 void NaClBitstreamCursor::skipRecord(unsigned AbbrevID) {
   // Skip unabbreviated records by reading past their entries.
   if (AbbrevID == naclbitc::UNABBREV_RECORD) {
@@ skipping 52 matching lines @@
     break;
   }
   return false;
 }
 
 uint64_t NaClBitstreamCursor::readArrayAbbreviatedField(
     const NaClBitCodeAbbrevOp &Op) {
   // Decode the value as we are commanded.
   switch (Op.getEncoding()) {
   case NaClBitCodeAbbrevOp::Literal:
-    report_fatal_error("Not to be used with literals!");
+    llvm_unreachable("Not to be used with literals!");
+    break;
   case NaClBitCodeAbbrevOp::Fixed:
     return Read((unsigned)Op.getValue());
   case NaClBitCodeAbbrevOp::VBR:
     return ReadVBR64((unsigned)Op.getValue());
   case NaClBitCodeAbbrevOp::Array:
-    report_fatal_error("Bad array abbreviation encoding!");
+    llvm_unreachable("Bad array abbreviation encoding!");
+    break;
   case NaClBitCodeAbbrevOp::Char6:
     return NaClBitCodeAbbrevOp::DecodeChar6(Read(6));
   }
   llvm_unreachable("unhandled NaClBitCodeAbbrevOp encoding");
 }
 
 void NaClBitstreamCursor::readArrayAbbrev(
     const NaClBitCodeAbbrevOp &Op, unsigned NumArrayElements,
     SmallVectorImpl<uint64_t> &Vals) {
   for (; NumArrayElements; --NumArrayElements) {
     Vals.push_back(readArrayAbbreviatedField(Op));
   }
 }
 
 unsigned NaClBitstreamCursor::readRecord(unsigned AbbrevID,
                                          SmallVectorImpl<uint64_t> &Vals) {
   if (AbbrevID == naclbitc::UNABBREV_RECORD) {
     unsigned Code = ReadVBR(6);
     unsigned NumElts = ReadVBR(6);
     for (unsigned i = 0; i != NumElts; ++i)
       Vals.push_back(ReadVBR64(6));
     return Code;
   }
 
+  // Read code.
   const NaClBitCodeAbbrev *Abbv = getAbbrev(AbbrevID);
-  unsigned NumOperands = Abbv->getNumOperandInfos();
-  assert(NumOperands > 0 && "Too few operands for abbreviation!");
-
   uint64_t Value;
-
-  // Read code.
   unsigned Code;
   if (readRecordAbbrevField(Abbv->getOperandInfo(0), Value)) {
     // Array found, use to read all elements.
-    assert(Value > 0 && "No code found for record!");
+    if (Value == 0)
+      ErrHandler->Fatal("No code found for record!");
     const NaClBitCodeAbbrevOp &Op = Abbv->getOperandInfo(1);
     Code = readArrayAbbreviatedField(Op);
     readArrayAbbrev(Op, Value - 1, Vals);
     return Code;
   }
   Code = Value;
 
   // Read arguments.
+  unsigned NumOperands = Abbv->getNumOperandInfos();
   for (unsigned i = 1; i != NumOperands; ++i) {
     if (readRecordAbbrevField(Abbv->getOperandInfo(i), Value)) {
       ++i;
       readArrayAbbrev(Abbv->getOperandInfo(i), Value, Vals);
       return Code;
     }
     Vals.push_back(Value);
   }
   return Code;
 }
 
 
-namespace {
-
-static NaClBitCodeAbbrevOp::Encoding getEncoding(uint64_t Encoding) {
-  if (!NaClBitCodeAbbrevOp::isValidEncoding(Encoding)) {
+NaClBitCodeAbbrevOp::Encoding NaClBitstreamCursor::
+getEncoding(uint64_t Value) {
+  if (!NaClBitCodeAbbrevOp::isValidEncoding(Value)) {
     std::string Buffer;
     raw_string_ostream StrBuf(Buffer);
-    StrBuf << "Invalid abbreviation encoding " << Encoding
-           << "specified in bitcode file";
-    report_fatal_error(StrBuf.str());
+    StrBuf << "Invalid abbreviation encoding specified in bitcode file: "
+           << Value;
+    ErrHandler->Fatal(StrBuf.str());
   }
-  return NaClBitCodeAbbrevOp::Encoding(Encoding);
+  return NaClBitCodeAbbrevOp::Encoding(Value);
 }
 
-} // end of anonymous space.
-
 void NaClBitstreamCursor::ReadAbbrevRecord(bool IsLocal,
                                            NaClAbbrevListener *Listener) {
   NaClBitCodeAbbrev *Abbv = new NaClBitCodeAbbrev();
   unsigned NumOpInfo = ReadVBR(5);
   if (Listener) Listener->Values.push_back(NumOpInfo);
   for (unsigned i = 0; i != NumOpInfo; ++i) {
     bool IsLiteral = Read(1) ? true : false;
     if (Listener) Listener->Values.push_back(IsLiteral);
     if (IsLiteral) {
       uint64_t Value = ReadVBR64(8);
@@ skipping 115 matching lines @@
         if (Record.size() < 1) return true;
         CurBlockInfo = &BitStream->getOrCreateBlockInfo((unsigned)Record[0]);
         if (Listener) {
           Listener->Values = Record;
           Listener->SetBID();
         }
         break;
     }
   }
 }