Fix the NaCl bitstream reader to report fatal errors.

include/llvm/Bitcode/NaCl/NaClBitstreamReader.h

 //===- NaClBitstreamReader.h -----------------------------------*- C++ -*-===//
 //     Low-level bitstream reader interface
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
@@ skipping 72 matching lines @@
         Info.Abbrevs[i]->dropRef();
       BlockInfoRecords.pop_back();
     }
   }
 
   /// \brief Returns the initial address (after the header) of the input stream.
   size_t getInitialAddress() const {
     return InitialAddress;
   }
 
+  /// Returns the Bit as a Byte:BitInByte string. MinByteWidth is the
+  /// minimum number of characters to print out the Byte value (blank
+  /// fills).
+  static std::string getBitAddress(uint64_t Bit, unsigned MinByteWidth=1);
+
   //===--------------------------------------------------------------------===//
   // Block Manipulation
   //===--------------------------------------------------------------------===//
 
   /// hasBlockInfoRecords - Return true if we've already read and processed the
   /// block info block for this Bitstream.  We only process it for the first
   /// cursor that walks over it.
   bool hasBlockInfoRecords() const { return !BlockInfoRecords.empty(); }
 
   /// getBlockInfo - If there is block info for the specified ID, return it,
@@ skipping 99 matching lines @@
   uint64_t StartBit;
 };
 
 /// NaClBitstreamCursor - This represents a position within a bitcode
 /// file.  There may be multiple independent cursors reading within
 /// one bitstream, each maintaining their own local state.
 ///
 /// Unlike iterators, NaClBitstreamCursors are heavy-weight objects
 /// that should not be passed by value.
 class NaClBitstreamCursor {
+public:
+  /// This class handles errors in the bitstream reader. Redirects
+  /// fatal error messages to virtual method Fatal.
+  class ErrorHandler {
+    ErrorHandler(const ErrorHandler &) = delete;
+    ErrorHandler &operator=(const ErrorHandler &) = delete;
+  public:
+    explicit ErrorHandler(NaClBitstreamCursor &Cursor) : Cursor(Cursor) {}
+    LLVM_ATTRIBUTE_NORETURN
+    virtual void Fatal(const std::string &ErrorMessage) const;
+    virtual ~ErrorHandler() {}
+    uint64_t getCurrentBitNo() const {
+      return Cursor.GetCurrentBitNo();
+    }
+  private:
+    NaClBitstreamCursor &Cursor;
+  };
+
+private:
   friend class Deserializer;
   NaClBitstreamReader *BitStream;
   size_t NextChar;
+  // The current error handler for the bitstream reader.
+  std::unique_ptr<ErrorHandler> ErrHandler;
 
   /// CurWord/word_t - This is the current data we have pulled from the stream
   /// but have not returned to the client.  This is specifically and
   /// intentionally defined to follow the word size of the host machine for
   /// efficiency.  We use word_t in places that are aware of this to make it
   /// perfectly explicit what is going on.
   typedef uint32_t word_t;
   word_t CurWord;
 
   /// BitsInCurWord - This is the number of bits in CurWord that are valid. This
@@ skipping 16 matching lines @@
   };
 
   /// BlockScope - This tracks the codesize of parent blocks.
   SmallVector<Block, 8> BlockScope;
 
   NaClBitstreamCursor(const NaClBitstreamCursor &) LLVM_DELETED_FUNCTION;
   NaClBitstreamCursor &operator=(const NaClBitstreamCursor &) LLVM_DELETED_FUNCTION;
 
 public:
 
-  NaClBitstreamCursor() {
+  NaClBitstreamCursor() : ErrHandler(new ErrorHandler(*this)) {
     init(nullptr);
   }
 
-  explicit NaClBitstreamCursor(NaClBitstreamReader &R) { init(&R); }
+  explicit NaClBitstreamCursor(NaClBitstreamReader &R)
+      : ErrHandler(new ErrorHandler(*this)) { init(&R); }
 
   void init(NaClBitstreamReader *R) {
     freeState();
     BitStream = R;
     NextChar = (BitStream == nullptr) ? 0 : BitStream->getInitialAddress();
     CurWord = 0;
     BitsInCurWord = 0;
   }
 
   ~NaClBitstreamCursor() {
     freeState();
   }
 
   void freeState();
 
+  // Replaces the current bitstream error handler with the new
+  // handler. Takes ownership of the new handler and deletes it when
+  // it is no longer needed.
+  void setErrorHandler(std::unique_ptr<ErrorHandler> &NewHandler) {
+    ErrHandler = std::move(NewHandler);
+  }
+
   bool isEndPos(size_t pos) {
     return BitStream->getBitcodeBytes().isObjectEnd(static_cast<uint64_t>(pos));
   }
 
   bool canSkipToPos(size_t pos) const {
     // pos can be skipped to if it is a valid address or one byte past the end.
     return pos == 0 || BitStream->getBitcodeBytes().isValidAddress(
         static_cast<uint64_t>(pos - 1));
   }
 
   bool AtEndOfStream() {
     return BitsInCurWord == 0 && isEndPos(NextChar);
   }
 
   /// getAbbrevIDWidth - Return the number of bits used to encode an abbrev #.
   unsigned getAbbrevIDWidth() const { return CurCodeSize.NumBits; }
 
   /// GetCurrentBitNo - Return the bit # of the bit we are reading.
   uint64_t GetCurrentBitNo() const {
     return NextChar*CHAR_BIT - BitsInCurWord;
   }
 
   NaClBitstreamReader *getBitStreamReader() {
     return BitStream;
   }
   const NaClBitstreamReader *getBitStreamReader() const {
     return BitStream;
   }
 
+  /// Returns the current bit address (string) of the bit cursor.
+  /// MinByteWidth is the minimum number of characters to print out
+  /// the Byte value (blank fills).
+  std::string getCurrentBitAddress(unsigned MinByteWidth=1) const {
+    return BitStream->getBitAddress(GetCurrentBitNo(), MinByteWidth);
+  }
+
   /// Flags that modify the behavior of advance().
   enum {
     /// AF_DontPopBlockAtEnd - If this flag is used, the advance() method does
     /// not automatically pop the block scope when the end of a block is
     /// reached.
     AF_DontPopBlockAtEnd = 1,
 
     /// AF_DontAutoprocessAbbrevs - If this flag is used, abbrev entries are
     /// returned just like normal records.
     AF_DontAutoprocessAbbrevs = 2
@@ skipping 38 matching lines @@
       // If we found a sub-block, just skip over it and check the next entry.
       if (SkipBlock())
         return NaClBitstreamEntry::getError();
     }
   }
 
   /// JumpToBit - Reset the stream to the specified bit number.
   void JumpToBit(uint64_t BitNo) {
     uintptr_t ByteNo = uintptr_t(BitNo/8) & ~(sizeof(word_t)-1);
     unsigned WordBitNo = unsigned(BitNo & (sizeof(word_t)*8-1));
-    assert(canSkipToPos(ByteNo) && "Invalid location");
+    if (!canSkipToPos(ByteNo))
+      reportInvalidJumpToBit(BitNo);
 
     // Move the cursor to the right word.
     NextChar = ByteNo;
     BitsInCurWord = 0;
     CurWord = 0;
 
     // Skip over any bits that are already consumed.
     if (WordBitNo) {
       if (sizeof(word_t) > 4)
         Read64(WordBitNo);
@@ skipping 177 matching lines @@
 
     BlockScope.back().PrevAbbrevs.swap(CurAbbrevs);
     BlockScope.pop_back();
   }
 
   //===--------------------------------------------------------------------===//
   // Record Processing
   //===--------------------------------------------------------------------===//
 
 private:
+  // Returns abbreviation encoding associated with Value.
+  NaClBitCodeAbbrevOp::Encoding getEncoding(uint64_t Value);
+
   void skipAbbreviatedField(const NaClBitCodeAbbrevOp &Op);
 
   // Reads the next Value using the abbreviation Op. Returns true only
   // if Op is an array (and sets Value to the number of elements in the
   // array).
   inline bool readRecordAbbrevField(const NaClBitCodeAbbrevOp &Op,
                                     uint64_t &Value);
 
   // Reads and returns the next value using the abbreviation Op,
   // assuming Op appears after an array abbreviation.
   inline uint64_t readArrayAbbreviatedField(const NaClBitCodeAbbrevOp &Op);
 
   // Reads the array abbreviation Op, NumArrayElements times, putting
   // the read values in Vals.
   inline void readArrayAbbrev(const NaClBitCodeAbbrevOp &Op,
                               unsigned NumArrayElements,
                               SmallVectorImpl<uint64_t> &Vals);
 
+  // Reports that that abbreviation Index is not valid.
+  void reportInvalidAbbrevNumber(unsigned Index) const;
+
+  // Reports that jumping to Bit is not valid.
+  void reportInvalidJumpToBit(uint64_t Bit) const;
+
 public:
 
   /// getAbbrev - Return the abbreviation for the specified AbbrevId.
   const NaClBitCodeAbbrev *getAbbrev(unsigned AbbrevID) const {
     unsigned AbbrevNo = AbbrevID-naclbitc::FIRST_APPLICATION_ABBREV;
-    assert(AbbrevNo < CurAbbrevs.size() && "Invalid abbrev #!");
+    if (AbbrevNo >= CurAbbrevs.size())
+      reportInvalidAbbrevNumber(AbbrevID);
     return CurAbbrevs[AbbrevNo];
   }
 
   /// skipRecord - Read the current record and discard it.
   void skipRecord(unsigned AbbrevID);
   
   unsigned readRecord(unsigned AbbrevID, SmallVectorImpl<uint64_t> &Vals);
 
   //===--------------------------------------------------------------------===//
   // Abbrev Processing
   //===--------------------------------------------------------------------===//
   // IsLocal indicates where the abbreviation occurs. If it is in the
   // BlockInfo block, IsLocal is false. In all other cases, IsLocal is
   // true.
   void ReadAbbrevRecord(bool IsLocal,
                         NaClAbbrevListener *Listener);
 
   // Skips over an abbreviation record. Duplicates code of ReadAbbrevRecord,
   // except that no abbreviation is built.
   void SkipAbbrevRecord();
   
   bool ReadBlockInfoBlock(NaClAbbrevListener *Listener);
 };
 
 } // End llvm namespace
 
 #endif