Fix index while building following bitstream reader API update

Upstream change in rL364464 broke downstream index while building.

apple-llvm-split-commit: 994094aa63b43bc0bc2d900ce27c0f376ac10f5c
apple-llvm-split-dir: clang/

Author: jfbastien

clang/lib/Index/BitstreamVisitor.h

@@ -26,7 +26,9 @@ struct SavedStreamPosition {
     : Cursor(Cursor), Offset(Cursor.GetCurrentBitNo()) { }
 
   ~SavedStreamPosition() {
-    Cursor.JumpToBit(Offset);
+    if (llvm::Error Err = Cursor.JumpToBit(Offset))
+      llvm::report_fatal_error("SavedStreamPosition failed jumping: " +
+                               toString(std::move(Err)));
   }
 
 private:
@@ -62,7 +64,12 @@ class BitstreamVisitor {
 
     ASTReader::RecordData Record;
     while (1) {
-      llvm::BitstreamEntry Entry = Stream.advance(llvm::BitstreamCursor::AF_DontPopBlockAtEnd);
+      Expected<llvm::BitstreamEntry> MaybeEntry = Stream.advance(llvm::BitstreamCursor::AF_DontPopBlockAtEnd);
+      if (!MaybeEntry) {
+        Error = toString(MaybeEntry.takeError());
+        return false;
+      }
+      llvm::BitstreamEntry Entry = MaybeEntry.get();
 
       switch (Entry.Kind) {
       case llvm::BitstreamEntry::Error:
@@ -83,7 +90,12 @@ class BitstreamVisitor {
 
       case llvm::BitstreamEntry::SubBlock: {
         if (Entry.ID == llvm::bitc::BLOCKINFO_BLOCK_ID) {
-          BlockInfo = Stream.ReadBlockInfoBlock();
+          Expected<Optional<llvm::BitstreamBlockInfo>> MaybeBlockInfo = Stream.ReadBlockInfoBlock();
+          if (!MaybeBlockInfo) {
+            Error = toString(MaybeBlockInfo.takeError());
+            return false;
+          }
+          BlockInfo = MaybeBlockInfo.get();
           if (!BlockInfo) {
             Error = "malformed BlockInfoBlock";
             return false;
@@ -99,7 +111,10 @@ class BitstreamVisitor {
             Error = "malformed block record";
             return false;
           }
-          readBlockAbbrevs(Stream);
+          if (llvm::Error Err = readBlockAbbrevs(Stream)) {
+            Error = toString(std::move(Err));
+            return false;
+          }
           BlockStack.push_back(Entry.ID);
           break;
 
@@ -121,15 +136,23 @@ class BitstreamVisitor {
       case llvm::BitstreamEntry::Record: {
         Record.clear();
         StringRef Blob;
-        unsigned RecID = Stream.readRecord(Entry.ID, Record, &Blob);
+        Expected<unsigned> MaybeRecID = Stream.readRecord(Entry.ID, Record, &Blob);
+        if (!MaybeRecID) {
+          Error = toString(MaybeRecID.takeError());
+          return false;
+        }
+        unsigned RecID = MaybeRecID.get();
         unsigned BlockID = BlockStack.empty() ? 0 : BlockStack.back();
         StreamVisit Ret = static_cast<ImplClass*>(this)->visitRecord(BlockID, RecID, Record, Blob);
         switch (Ret) {
         case StreamVisit::Continue:
           break;
 
         case StreamVisit::Skip: 
-          Stream.skipRecord(Entry.ID);
+          if (Expected<unsigned> Skipped = Stream.skipRecord(Entry.ID)) {
+            Error = toString(Skipped.takeError());
+            return false;
+          }
           break;
 
         case StreamVisit::Abort:
@@ -141,17 +164,22 @@ class BitstreamVisitor {
     }
   }
 
-  static void readBlockAbbrevs(llvm::BitstreamCursor &Cursor) {
+  static llvm::Error readBlockAbbrevs(llvm::BitstreamCursor &Cursor) {
     while (true) {
       uint64_t Offset = Cursor.GetCurrentBitNo();
-      unsigned Code = Cursor.ReadCode();
+      Expected<unsigned> MaybeCode = Cursor.ReadCode();
+      if (!MaybeCode)
+        return MaybeCode.takeError();
+      unsigned Code = MaybeCode.get();
 
       // We expect all abbrevs to be at the start of the block.
       if (Code != llvm::bitc::DEFINE_ABBREV) {
-        Cursor.JumpToBit(Offset);
-        return;
+        if (llvm::Error Err = Cursor.JumpToBit(Offset))
+          return Err;
+        return llvm::Error::success();
       }
-      Cursor.ReadAbbrevRecord();
+      if (llvm::Error Err = Cursor.ReadAbbrevRecord())
+        return Err;
     }
   }
 };

clang/lib/Index/IndexRecordReader.cpp

@@ -91,9 +91,22 @@ struct IndexRecordReader::Implementation {
   void readDecl(unsigned Index, IndexRecordDecl &RecD) {
     RecordData Record;
     StringRef Blob;
-    DeclCursor.JumpToBit(DeclOffsets[Index]);
-    unsigned Code = DeclCursor.ReadCode();
-    unsigned RecID = DeclCursor.readRecord(Code, Record, &Blob);
+    if (llvm::Error Err = DeclCursor.JumpToBit(DeclOffsets[Index])) {
+      // FIXME this drops the error on the floor.
+      consumeError(std::move(Err));
+    }
+    Expected<unsigned> MaybeCode = DeclCursor.ReadCode();
+    if (!MaybeCode) {
+      // FIXME this drops the error on the floor.
+      consumeError(MaybeCode.takeError());
+    }
+    unsigned Code = MaybeCode.get();
+    Expected<unsigned> MaybeRecID = DeclCursor.readRecord(Code, Record, &Blob);
+    if (!MaybeRecID) {
+      // FIXME this drops the error on the floor.
+      consumeError(MaybeRecID.takeError());
+    }
+    unsigned RecID = MaybeRecID.get();
     assert(RecID == REC_DECLINFO);
     (void)RecID;
 
@@ -273,7 +286,10 @@ class IndexBitstreamVisitor : public BitstreamVisitor<IndexBitstreamVisitor> {
         *Error = "malformed block record";
         return StreamVisit::Abort;
       }
-      readBlockAbbrevs(Reader.DeclCursor);
+      if (llvm::Error Err = readBlockAbbrevs(Reader.DeclCursor)) {
+        *Error = toString(std::move(Err));
+        return StreamVisit::Abort;
+      }
       return StreamVisit::Skip;
 
     case REC_DECLOCCURRENCES_BLOCK_ID:
@@ -282,7 +298,10 @@ class IndexBitstreamVisitor : public BitstreamVisitor<IndexBitstreamVisitor> {
         *Error = "malformed block record";
         return StreamVisit::Abort;
       }
-      readBlockAbbrevs(Reader.OccurCursor);
+      if (llvm::Error Err = readBlockAbbrevs(Reader.OccurCursor)) {
+        *Error = toString(std::move(Err));
+        return StreamVisit::Abort;
+      }
       return StreamVisit::Skip;
     }
 
@@ -358,10 +377,14 @@ IndexRecordReader::createWithBuffer(std::unique_ptr<llvm::MemoryBuffer> Buffer,
   }
 
   // Sniff for the signature.
-  if (Stream.Read(8) != 'I' ||
-      Stream.Read(8) != 'D' ||
-      Stream.Read(8) != 'X' ||
-      Stream.Read(8) != 'R') {
+  for (unsigned char C : {'I', 'D', 'X', 'R'}) {
+    if (Expected<llvm::SimpleBitstreamCursor::word_t> Res = Stream.Read(8)) {
+      if (Res.get() == C)
+        continue;
+    } else {
+      Error = toString(Res.takeError());
+      return nullptr;
+    }
     Error = "not a serialized index record file";
     return nullptr;
   }

clang/lib/Index/IndexUnitReader.cpp

@@ -123,15 +123,21 @@ class IndexUnitBitstreamVisitor : public BitstreamVisitor<IndexUnitBitstreamVisi
         *Error = "malformed unit dependencies block record";
         return StreamVisit::Abort;
       }
-      readBlockAbbrevs(Reader.DependCursor);
+      if (llvm::Error Err = readBlockAbbrevs(Reader.DependCursor)) {
+        *Error = toString(std::move(Err));
+        return StreamVisit::Abort;
+      }
       return StreamVisit::Skip;
     case UNIT_INCLUDES_BLOCK_ID:
       Reader.IncludeCursor = Stream;
       if (Reader.IncludeCursor.EnterSubBlock(ID)) {
         *Error = "malformed unit includes block record";
         return StreamVisit::Abort;
       }
-      readBlockAbbrevs(Reader.IncludeCursor);
+      if (llvm::Error Err = readBlockAbbrevs(Reader.IncludeCursor)) {
+        *Error = toString(std::move(Err));
+        return StreamVisit::Abort;
+      }
       return StreamVisit::Skip;
     }
 
@@ -276,10 +282,14 @@ bool IndexUnitReaderImpl::init(std::unique_ptr<MemoryBuffer> Buf,
   }
 
   // Sniff for the signature.
-  if (Stream.Read(8) != 'I' ||
-      Stream.Read(8) != 'D' ||
-      Stream.Read(8) != 'X' ||
-      Stream.Read(8) != 'U') {
+  for (unsigned char C : {'I', 'D', 'X', 'U'}) {
+    if (Expected<llvm::SimpleBitstreamCursor::word_t> Res = Stream.Read(8)) {
+      if (Res.get() == C)
+        continue;
+    } else {
+      Error = toString(Res.takeError());
+      return true;
+    }
     Error = "not a serialized index unit file";
     return true;
   }