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 70 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
   //===--------------------------------------------------------------------===//
 
   /// 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(); }
 
   /// If there is block info for the specified ID, return it, otherwise return
@@ skipping 93 matching lines @@
   uint64_t StartBit;
 };
 
 /// 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;
 
   // The size of the bitcode. 0 if we don't know it yet.
   size_t Size;
 
   /// 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 size_t word_t;
@@ skipping 18 matching lines @@
         : PrevCodeSize(PCS) {}
   };
 
   /// 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() { init(nullptr); }
+  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();
     Size = 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 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() {
     if (BitsInCurWord != 0)
       return false;
     if (Size != 0)
@@ skipping 10 matching lines @@
     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 {
     /// 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,
 
     /// If this flag is used, abbrev entries are returned just like normal
     /// records.
     AF_DontAutoprocessAbbrevs = 2
   };
@@ skipping 37 matching lines @@
       // If we found a sub-block, just skip over it and check the next entry.
       if (SkipBlock())
         return NaClBitstreamEntry::getError();
     }
   }
 
   /// 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;
 
     // Skip over any bits that are already consumed.
     if (WordBitNo)
       Read(WordBitNo);
   }
 
@@ skipping 172 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:
 
   /// 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];
   }
 
   /// 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