Bitcode: Change reader interface to take memory buffers.

[pcc]

Summary

As proposed on llvm-dev:
http://lists.llvm.org/pipermail/llvm-dev/2016-October/106595.html

This change also fixes an API oddity where BitstreamCursor::Read() would
return zero for the first read past the end of the bitstream, but would
report_fatal_error for subsequent reads. Now we always report_fatal_error
for all reads past the end. Updated clients to check for the end of the
bitstream before reading from it.

I also needed to add padding to the invalid bitcode tests in
test/Bitcode/. This is because the streaming interface was not checking that
the file size is a multiple of 4.

[jordan_rose]

Sounds great to me, but it would be kind of nice to do it in two commits: one to add the new API and one to remove the old one.

[pcc]

Split out API removal to D26222

[mehdi_amini]

llvm/include/llvm/Bitcode/BitstreamReader.h

63 ↗

(On Diff #76645)

= default; ?

69 ↗

(On Diff #76645)

You can forward to the next ctor:

BitstreamReader(MemoryBufferRef BitcodeBytes)
      : BitstreamReader(BitcodeBytes.getBuffer()) {}

llvm/lib/Bitcode/Reader/BitcodeReader.cpp

235 ↗

(On Diff #76645)

Is this related to this commit?

402 ↗

(On Diff #76645)

Is this related to this change or can you remove this as a pre-commit?

[mehdi_amini]

llvm/include/llvm/Bitcode/BitstreamReader.h

63 ↗

(On Diff #76651)

The = default() was supposed to be here (commented while you updated the diff)

[pcc]

• Use = default and delegating ctor

llvm/lib/Bitcode/Reader/BitcodeReader.cpp

235 ↗

(On Diff #76645)

Yes, this ctor is currently needed elsewhere (marked below).

402 ↗

(On Diff #76645)

Same here.

6691 ↗

(On Diff #76651)

This is where we currently use the ctor.

[mehdi_amini]

Alright, LGTM!

[mehdi_amini]

Alright, LGTM!

llvm/trunk/include/llvm/Bitcode/BitstreamReader.h

435

There is a semantic change here.

Previously, when at the end of the stream after calling Stream.advance(BitstreamCursor::AF_DontPopBlockAtEnd); we would call ReadCode() which would return 0 which is also bitc::END_BLOCK, and we would enter the condition below and return BitstreamEntry::getEndBlock();.
Now we return an error instead.

This is breaking the loop pattern in BitcodeReader::parseIdentificationBlock, which is conceptually the following:

// We expect a number of well-defined blocks, though we don't necessarily
// need to understand them all.
while (1) {
  BitstreamEntry Entry =
      Stream.advance(BitstreamCursor::AF_DontPopBlockAtEnd);
  // Ignore other sub-blocks.
  if (Stream.SkipBlock())
    return error("Malformed block");
}

[pcc]

llvm/trunk/include/llvm/Bitcode/BitstreamReader.h

435

As discussed on IRC, let's add a BitstreamEntry::EOF enum and change the clients to handle it.

cfe/trunk/lib/CodeGen/ObjectFilePCHContainerOperations.cpp

if (OFOrErr) {
     bool IsCOFF = isa<llvm::object::COFFObjectFile>(*OF);
     // Find the clang AST section in the container.
     for (auto &Section : OF->sections()) {
       StringRef Name;
       Section.getName(Name);
       if ((!IsCOFF && Name == "__clangast") || (IsCOFF && Name == "clangast")) {
         StringRef Buf;
         Section.getContents(Buf);
-        return StreamFile.init((const unsigned char *)Buf.begin(),
-                               (const unsigned char *)Buf.end());
+        StreamFile = llvm::BitstreamReader(Buf);
+        return;
       }
     }
   }
   handleAllErrors(OFOrErr.takeError(), [&](const llvm::ErrorInfoBase &EIB) {
     if (EIB.convertToErrorCode() ==
         llvm::object::object_error::invalid_file_type)
       // As a fallback, treat the buffer as a raw AST.
-      StreamFile.init((const unsigned char *)Buffer.getBufferStart(),
-                      (const unsigned char *)Buffer.getBufferEnd());
+      StreamFile = llvm::BitstreamReader(Buffer);
     else
       EIB.log(llvm::errs());
   });
 }

cfe/trunk/lib/Frontend/PCHContainerOperations.cpp

std::unique_ptr<ASTConsumer> RawPCHContainerWriter::CreatePCHContainerGenerator(
     CompilerInstance &CI, const std::string &MainFileName,
     const std::string &OutputFileName, std::unique_ptr<llvm::raw_pwrite_stream> OS,
     std::shared_ptr<PCHBuffer> Buffer) const {
   return llvm::make_unique<RawPCHContainerGenerator>(std::move(OS), Buffer);
 }
 
 void RawPCHContainerReader::ExtractPCH(
     llvm::MemoryBufferRef Buffer, llvm::BitstreamReader &StreamFile) const {
-  StreamFile.init((const unsigned char *)Buffer.getBufferStart(),
-                  (const unsigned char *)Buffer.getBufferEnd());
+  StreamFile = llvm::BitstreamReader(Buffer);
 }
 
 PCHContainerOperations::PCHContainerOperations() {
   registerWriter(llvm::make_unique<RawPCHContainerWriter>());
   registerReader(llvm::make_unique<RawPCHContainerReader>());
 }

cfe/trunk/lib/Frontend/SerializedDiagnosticReader.cpp

std::error_code SerializedDiagnosticReader::readDiagnostics(StringRef File) {
   // Open the diagnostics file.
   FileSystemOptions FO;
   FileManager FileMgr(FO);
 
   auto Buffer = FileMgr.getBufferForFile(File);
   if (!Buffer)
     return SDError::CouldNotLoad;
 
-  llvm::BitstreamReader StreamFile;
-  StreamFile.init((const unsigned char *)(*Buffer)->getBufferStart(),
-                  (const unsigned char *)(*Buffer)->getBufferEnd());
-
+  llvm::BitstreamReader StreamFile(**Buffer);
   llvm::BitstreamCursor Stream(StreamFile);
 
   // Sniff for the signature.
   if (Stream.Read(8) != 'D' ||
       Stream.Read(8) != 'I' ||
       Stream.Read(8) != 'A' ||
       Stream.Read(8) != 'G')
     return SDError::InvalidSignature;

cfe/trunk/lib/Serialization/ASTReader.cpp

ASTReader::ASTReadResult ASTReader::ReadAST(StringRef FileName,
 
   return Success;
 }
 
 static ASTFileSignature readASTFileSignature(llvm::BitstreamReader &StreamFile);
 
 /// \brief Whether \p Stream starts with the AST/PCH file magic number 'CPCH'.
 static bool startsWithASTFileMagic(BitstreamCursor &Stream) {
-  return Stream.Read(8) == 'C' &&
+  return Stream.canSkipToPos(4) &&
+         Stream.Read(8) == 'C' &&
          Stream.Read(8) == 'P' &&
          Stream.Read(8) == 'C' &&
          Stream.Read(8) == 'H';
 }
 
 static unsigned moduleKindForDiagnostic(ModuleKind Kind) {
   switch (Kind) {
   case MK_PCH:

cfe/trunk/lib/Serialization/GlobalModuleIndex.cpp

GlobalModuleIndex::readIndex(StringRef Path) {
 
   llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> BufferOrErr =
       llvm::MemoryBuffer::getFile(IndexPath.c_str());
   if (!BufferOrErr)
     return std::make_pair(nullptr, EC_NotFound);
   std::unique_ptr<llvm::MemoryBuffer> Buffer = std::move(BufferOrErr.get());
 
   /// \brief The bitstream reader from which we'll read the AST file.
-  llvm::BitstreamReader Reader((const unsigned char *)Buffer->getBufferStart(),
-                               (const unsigned char *)Buffer->getBufferEnd());
+  llvm::BitstreamReader Reader(*Buffer);
 
   /// \brief The main bitstream cursor for the main block.
   llvm::BitstreamCursor Cursor(Reader);
 
   // Sniff for the signature.
   if (Cursor.Read(8) != 'B' ||
       Cursor.Read(8) != 'C' ||
       Cursor.Read(8) != 'G' ||

llvm/trunk/include/llvm/Bitcode/BitstreamReader.h

 // This header defines the BitstreamReader class.  This class can be used to
 // read an arbitrary bitstream, regardless of its contents.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_BITCODE_BITSTREAMREADER_H
 #define LLVM_BITCODE_BITSTREAMREADER_H
 
+#include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/IntrusiveRefCntPtr.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Bitcode/BitCodes.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MathExtras.h"
-#include "llvm/Support/StreamingMemoryObject.h"
+#include "llvm/Support/MemoryBuffer.h"
 #include <algorithm>
 #include <cassert>
 #include <climits>
 #include <cstddef>
 #include <cstdint>
 #include <memory>
 #include <string>
 #include <utility>
public:
   struct BlockInfo {
     unsigned BlockID;
     std::vector<IntrusiveRefCntPtr<BitCodeAbbrev>> Abbrevs;
     std::string Name;
     std::vector<std::pair<unsigned, std::string> > RecordNames;
   };
 
 private:
-  std::unique_ptr<MemoryObject> BitcodeBytes;
+  ArrayRef<uint8_t> BitcodeBytes;
 
   std::vector<BlockInfo> BlockInfoRecords;
 
   /// This is set to true if we don't care about the block/record name
   /// information in the BlockInfo block. Only llvm-bcanalyzer uses this.
-  bool IgnoreBlockInfoNames;
+  bool IgnoreBlockInfoNames = true;
 
 public:
-  BitstreamReader() : IgnoreBlockInfoNames(true) {
-  }
-
-  BitstreamReader(const unsigned char *Start, const unsigned char *End)
-      : IgnoreBlockInfoNames(true) {
-    init(Start, End);
-  }
+  BitstreamReader() = default;
+  BitstreamReader(ArrayRef<uint8_t> BitcodeBytes)
+      : BitcodeBytes(BitcodeBytes) {}
+  BitstreamReader(StringRef BitcodeBytes)
+      : BitcodeBytes(reinterpret_cast<const uint8_t *>(BitcodeBytes.data()),
+                     BitcodeBytes.size()) {}
+  BitstreamReader(MemoryBufferRef BitcodeBytes)
+      : BitstreamReader(BitcodeBytes.getBuffer()) {}
 
-  BitstreamReader(std::unique_ptr<MemoryObject> BitcodeBytes)
-      : BitcodeBytes(std::move(BitcodeBytes)), IgnoreBlockInfoNames(true) {}
-
-  void init(const unsigned char *Start, const unsigned char *End) {
-    assert(((End-Start) & 3) == 0 &&"Bitcode stream not a multiple of 4 bytes");
-    BitcodeBytes.reset(getNonStreamedMemoryObject(Start, End));
-  }
-
-  MemoryObject &getBitcodeBytes() { return *BitcodeBytes; }
+  ArrayRef<uint8_t> getBitcodeBytes() { return BitcodeBytes; }
 
   /// This is called by clients that want block/record name information.
   void CollectBlockInfoNames() { IgnoreBlockInfoNames = false; }
   bool isIgnoringBlockInfoNames() { return IgnoreBlockInfoNames; }
 
   //===--------------------------------------------------------------------===//
   // Block Manipulation
   //===--------------------------------------------------------------------===//

 
 /// This represents a position within a bitstream. There may be multiple
 /// independent cursors reading within one bitstream, each maintaining their
 /// own local state.
 class SimpleBitstreamCursor {
   BitstreamReader *R = nullptr;
   size_t NextChar = 0;
 
-  // The size of the bicode. 0 if we don't know it yet.
-  size_t Size = 0;
-
 public:
   /// 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;
 
public:
 
   SimpleBitstreamCursor() = default;
 
   explicit SimpleBitstreamCursor(BitstreamReader &R) : R(&R) {}
   explicit SimpleBitstreamCursor(BitstreamReader *R) : R(R) {}
 
   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 ||
-           R->getBitcodeBytes().isValidAddress(static_cast<uint64_t>(pos - 1));
+    return pos <= R->getBitcodeBytes().size();
   }
 
   bool AtEndOfStream() {
-    if (BitsInCurWord != 0)
-      return false;
-    if (Size != 0)
-      return Size <= NextChar;
-    fillCurWord();
-    return BitsInCurWord == 0;
+    return BitsInCurWord == 0 && R->getBitcodeBytes().size() <= NextChar;
   }
 
   /// Return the bit # of the bit we are reading.
   uint64_t GetCurrentBitNo() const {
     return NextChar*CHAR_BIT - BitsInCurWord;
   }
 
   // Return the byte # of the current bit.
assert((intptr_t)getPointerToByte(getCurrentByteNo(), 1) ==
            "Expected to reach pointer");
   }
   void jumpToPointer(const char *Pointer) {
     jumpToPointer((const uint8_t *)Pointer);
   }
 
   /// Get a pointer into the bitstream at the specified byte offset.
   const uint8_t *getPointerToByte(uint64_t ByteNo, uint64_t NumBytes) {
-    return R->getBitcodeBytes().getPointer(ByteNo, NumBytes);
+    return R->getBitcodeBytes().data() + ByteNo;
   }
 
   /// Get a pointer into the bitstream at the specified bit offset.
   ///
   /// The bit offset must be on a byte boundary.
   const uint8_t *getPointerToBit(uint64_t BitNo, uint64_t NumBytes) {
     assert(!(BitNo % 8) && "Expected bit on byte boundary");
     return getPointerToByte(BitNo / 8, NumBytes);
   }
 
   void fillCurWord() {
-    if (Size != 0 && NextChar >= Size)
+    ArrayRef<uint8_t> Buf = R->getBitcodeBytes();
+    if (NextChar >= Buf.size())
       report_fatal_error("Unexpected end of file");
 
     // Read the next word from the stream.
-    uint8_t Array[sizeof(word_t)] = {0};
-
-    uint64_t BytesRead =
-        R->getBitcodeBytes().readBytes(Array, sizeof(Array), NextChar);
-
-    // If we run out of data, stop at the end of the stream.
-    if (BytesRead == 0) {
-      CurWord = 0;
-      BitsInCurWord = 0;
-      Size = NextChar;
-      return;
-    }
-
+    const uint8_t *NextCharPtr = Buf.data() + NextChar;
+    unsigned BytesRead;
+    if (Buf.size() >= NextChar + sizeof(word_t)) {
+      BytesRead = sizeof(word_t);
       CurWord =
           support::endian::read<word_t, support::little, support::unaligned>(
-            Array);
+              NextCharPtr);
+    } else {
+      // Short read.
+      BytesRead = Buf.size() - NextChar;
+      CurWord = 0;
+      for (unsigned B = 0; B != BytesRead; ++B)
+        CurWord |= NextCharPtr[B] << (B * 8);
+    }
     NextChar += BytesRead;
     BitsInCurWord = BytesRead * 8;
   }
 
   word_t Read(unsigned NumBits) {
     static const unsigned BitsInWord = MaxChunkSize;
 
     assert(NumBits && NumBits <= BitsInWord &&
if (BitsInCurWord >= NumBits) {
       return R;
     }
 
     word_t R = BitsInCurWord ? CurWord : 0;
     unsigned BitsLeft = NumBits - BitsInCurWord;
 
     fillCurWord();
 
-    // If we run out of data, stop at the end of the stream.
+    // If we run out of data, abort.
     if (BitsLeft > BitsInCurWord)
-      return 0;
+      report_fatal_error("Unexpected end of file");
 
     word_t R2 = CurWord & (~word_t(0) >> (BitsInWord - BitsLeft));
 
     // Use a mask to avoid undefined behavior.
     CurWord >>= (BitsLeft & Mask);
 
     BitsInCurWord -= BitsLeft;
 
if (sizeof(word_t) > 4 &&
       BitsInCurWord = 32;
       return;
     }
 
     BitsInCurWord = 0;
   }
 
   /// Skip to the end of the file.
-  void skipToEnd() { NextChar = R->getBitcodeBytes().getExtent(); }
-
-  /// Prevent the cursor from reading past a byte boundary.
-  ///
-  /// Prevent the cursor from requesting byte reads past \c Limit.  This is
-  /// useful when working with a cursor on a StreamingMemoryObject, when it's
-  /// desirable to avoid invalidating the result of getPointerToByte().
-  ///
-  /// If \c Limit is on a word boundary, AtEndOfStream() will return true if
-  /// the cursor position reaches or exceeds \c Limit, regardless of the true
-  /// number of available bytes.  Otherwise, AtEndOfStream() returns true when
-  /// it reaches or exceeds the next word boundary.
-  void setArtificialByteLimit(uint64_t Limit) {
-    assert(getCurrentByteNo() < Limit && "Move cursor before lowering limit");
-
-    // Round to word boundary.
-    Limit = alignTo(Limit, sizeof(word_t));
-
-    // Only change size if the new one is lower.
-    if (!Size || Size > Limit)
-      Size = Limit;
-  }
-
-  /// Return the Size, if known.
-  uint64_t getSizeIfKnown() const { return Size; }
+  void skipToEnd() { NextChar = R->getBitcodeBytes().size(); }
 };
 
 /// When advancing through a bitstream cursor, each advance can discover a few
 /// different kinds of entries:
 struct BitstreamEntry {
   enum {
     Error,    // Malformed bitcode was found.
     EndBlock, // We've reached the end of the current block, (or the end of the
enum {
     /// If this flag is used, abbrev entries are returned just like normal
     /// records.
     AF_DontAutoprocessAbbrevs = 2
   };
 
   /// Advance the current bitstream, returning the next entry in the stream.
   BitstreamEntry advance(unsigned Flags = 0) {
     while (true) {
+      if (AtEndOfStream())
+        return BitstreamEntry::getError();
+
       unsigned Code = ReadCode();
       if (Code == bitc::END_BLOCK) {
         // Pop the end of the block unless Flags tells us not to.
         if (!(Flags & AF_DontPopBlockAtEnd) && ReadBlockEnd())
           return BitstreamEntry::getError();
         return BitstreamEntry::getEndBlock();
       }
 

llvm/trunk/include/llvm/Bitcode/ReaderWriter.h

 #include "llvm/Support/Endian.h"
 #include "llvm/Support/ErrorOr.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include <memory>
 #include <string>
 
 namespace llvm {
   class BitstreamWriter;
-  class DataStreamer;
   class LLVMContext;
   class Module;
   class ModulePass;
   class raw_ostream;
 
   /// Offsets of the 32-bit fields of bitcode wrapper header.
   static const unsigned BWH_MagicField = 0*4;
   static const unsigned BWH_VersionField = 1*4;
   static const unsigned BWH_OffsetField = 2*4;
   static const unsigned BWH_SizeField = 3*4;
   static const unsigned BWH_CPUTypeField = 4*4;
   static const unsigned BWH_HeaderSize = 5*4;
 
   /// Read the header of the specified bitcode buffer and prepare for lazy
   /// deserialization of function bodies. If ShouldLazyLoadMetadata is true,
   /// lazily load metadata as well. If successful, this moves Buffer. On
   /// error, this *does not* move Buffer.
   ErrorOr<std::unique_ptr<Module>>
   getLazyBitcodeModule(std::unique_ptr<MemoryBuffer> &&Buffer,
                        LLVMContext &Context,
                        bool ShouldLazyLoadMetadata = false);
 
-  /// Read the header of the specified stream and prepare for lazy
-  /// deserialization and streaming of function bodies.
-  ErrorOr<std::unique_ptr<Module>>
-  getStreamedBitcodeModule(StringRef Name,
-                           std::unique_ptr<DataStreamer> Streamer,
-                           LLVMContext &Context);
-
   /// Read the header of the specified bitcode buffer and extract just the
   /// triple information. If successful, this returns a string. On error, this
   /// returns "".
   std::string getBitcodeTargetTriple(MemoryBufferRef Buffer,
                                      LLVMContext &Context);
 
   /// Return true if \p Buffer contains a bitcode file with ObjC code (category
   /// or class) in it.

llvm/trunk/lib/Bitcode/Reader/BitcodeReader.cpp

 #include "llvm/IR/Operator.h"
 #include "llvm/IR/TrackingMDRef.h"
 #include "llvm/IR/Type.h"
 #include "llvm/IR/ValueHandle.h"
 #include "llvm/Support/AtomicOrdering.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Compiler.h"
-#include "llvm/Support/DataStream.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/ErrorOr.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/raw_ostream.h"
-#include "llvm/Support/StreamingMemoryObject.h"
 #include <algorithm>
 #include <cassert>
 #include <cstddef>
 #include <cstdint>
 #include <deque>
 #include <limits>
 #include <map>
 #include <memory>
public:
   Metadata *upgradeTypeRefArray(Metadata *MaybeTuple);
 
 private:
   Metadata *resolveTypeRefArray(Metadata *MaybeTuple);
 };
 
 class BitcodeReaderBase {
 protected:
-  BitcodeReaderBase() = default;
   BitcodeReaderBase(MemoryBuffer *Buffer) : Buffer(Buffer) {}
 
   std::unique_ptr<MemoryBuffer> Buffer;
   std::unique_ptr<BitstreamReader> StreamFile;
   BitstreamCursor Stream;
 
-  std::error_code initStream(std::unique_ptr<DataStreamer> Streamer);
-  std::error_code initStreamFromBuffer();
-  std::error_code initLazyStream(std::unique_ptr<DataStreamer> Streamer);
+  std::error_code initStream();
 
   virtual std::error_code error(const Twine &Message) = 0;
   virtual ~BitcodeReaderBase() = default;
 };
 
-std::error_code
-BitcodeReaderBase::initStream(std::unique_ptr<DataStreamer> Streamer) {
-  if (Streamer)
-    return initLazyStream(std::move(Streamer));
-  return initStreamFromBuffer();
-}
-
-std::error_code BitcodeReaderBase::initStreamFromBuffer() {
+std::error_code BitcodeReaderBase::initStream() {
   const unsigned char *BufPtr = (const unsigned char*)Buffer->getBufferStart();
   const unsigned char *BufEnd = BufPtr+Buffer->getBufferSize();
 
   if (Buffer->getBufferSize() & 3)
     return error("Invalid bitcode signature");
 
   // If we have a wrapper header, parse it and ignore the non-bc file contents.
   // The magic number is 0x0B17C0DE stored in little endian.
   if (isBitcodeWrapper(BufPtr, BufEnd))
     if (SkipBitcodeWrapperHeader(BufPtr, BufEnd, true))
       return error("Invalid bitcode wrapper header");
 
-  StreamFile.reset(new BitstreamReader(BufPtr, BufEnd));
+  StreamFile.reset(new BitstreamReader(ArrayRef<uint8_t>(BufPtr, BufEnd)));
   Stream.init(&*StreamFile);
 
   return std::error_code();
 }
 
-std::error_code
-BitcodeReaderBase::initLazyStream(std::unique_ptr<DataStreamer> Streamer) {
-  // Check and strip off the bitcode wrapper; BitstreamReader expects never to
-  // see it.
-  auto OwnedBytes =
-      llvm::make_unique<StreamingMemoryObject>(std::move(Streamer));
-  StreamingMemoryObject &Bytes = *OwnedBytes;
-  StreamFile = llvm::make_unique<BitstreamReader>(std::move(OwnedBytes));
-  Stream.init(&*StreamFile);
-
-  unsigned char buf[16];
-  if (Bytes.readBytes(buf, 16, 0) != 16)
-    return error("Invalid bitcode signature");
-
-  if (!isBitcode(buf, buf + 16))
-    return error("Invalid bitcode signature");
-
-  if (isBitcodeWrapper(buf, buf + 4)) {
-    const unsigned char *bitcodeStart = buf;
-    const unsigned char *bitcodeEnd = buf + 16;
-    SkipBitcodeWrapperHeader(bitcodeStart, bitcodeEnd, false);
-    Bytes.dropLeadingBytes(bitcodeStart - buf);
-    Bytes.setKnownObjectSize(bitcodeEnd - bitcodeStart);
-  }
-  return std::error_code();
-}
-
 class BitcodeReader : public BitcodeReaderBase, public GVMaterializer {
   LLVMContext &Context;
   Module *TheModule = nullptr;
   // Next offset to start scanning for lazy parsing of function bodies.
   uint64_t NextUnreadBit = 0;
   // Last function offset found in the VST.
   uint64_t LastFunctionBlockBit = 0;
   bool SeenValueSymbolTable = false;
class BitcodeReader : public BitcodeReaderBase, public GVMaterializer {
 
   std::vector<std::string> BundleTags;
 
 public:
   std::error_code error(BitcodeError E, const Twine &Message);
   std::error_code error(const Twine &Message) override;
 
   BitcodeReader(MemoryBuffer *Buffer, LLVMContext &Context);
-  BitcodeReader(LLVMContext &Context);
   ~BitcodeReader() override { freeState(); }
 
   std::error_code materializeForwardReferencedFunctions();
 
   void freeState();
 
   void releaseBuffer();
 
   std::error_code materialize(GlobalValue *GV) override;
   std::error_code materializeModule() override;
   std::vector<StructType *> getIdentifiedStructTypes() const override;
 
   /// \brief Main interface to parsing a bitcode buffer.
   /// \returns true if an error occurred.
-  std::error_code parseBitcodeInto(std::unique_ptr<DataStreamer> Streamer,
-                                   Module *M,
+  std::error_code parseBitcodeInto(Module *M,
                                    bool ShouldLazyLoadMetadata = false);
 
   /// \brief Cheap mechanism to just extract module triple
   /// \returns true if an error occurred.
   ErrorOr<std::string> parseTriple();
 
   /// Cheap mechanism to just extract the identification block out of bitcode.
   ErrorOr<std::string> parseIdentificationBlock();
public:
 
   void releaseBuffer();
 
   /// Check if the parser has encountered a summary section.
   bool foundGlobalValSummary() { return SeenGlobalValSummary; }
 
   /// \brief Main interface to parsing a bitcode buffer.
   /// \returns true if an error occurred.
-  std::error_code parseSummaryIndexInto(std::unique_ptr<DataStreamer> Streamer,
-                                        ModuleSummaryIndex *I);
+  std::error_code parseSummaryIndexInto(ModuleSummaryIndex *I);
 
 private:
   std::error_code parseModule();
   std::error_code parseValueSymbolTable(
       uint64_t Offset,
       DenseMap<unsigned, GlobalValue::LinkageTypes> &ValueIdToLinkageMap);
   std::error_code parseEntireSummary();
   std::error_code parseModuleStringTable();
std::error_code BitcodeReader::error(const Twine &Message) {
   return ::error(Context, make_error_code(BitcodeError::CorruptedBitcode),
                  Message);
 }
 
 BitcodeReader::BitcodeReader(MemoryBuffer *Buffer, LLVMContext &Context)
     : BitcodeReaderBase(Buffer), Context(Context), ValueList(Context),
       MetadataList(Context) {}
 
-BitcodeReader::BitcodeReader(LLVMContext &Context)
-    : Context(Context), ValueList(Context), MetadataList(Context) {}
-
 std::error_code BitcodeReader::materializeForwardReferencedFunctions() {
   if (WillMaterializeAllForwardRefs)
     return std::error_code();
 
   // Prevent recursion.
   WillMaterializeAllForwardRefs = true;
 
   while (!BasicBlockFwdRefQueue.empty()) {
if (!NumStrings)
     return error("Invalid record: metadata strings with no strings");
   if (StringsOffset > Blob.size())
     return error("Invalid record: metadata strings corrupt offset");
 
   StringRef Lengths = Blob.slice(0, StringsOffset);
   SimpleBitstreamCursor R(*StreamFile);
   R.jumpToPointer(Lengths.begin());
 
-  // Ensure that Blob doesn't get invalidated, even if this is reading from
-  // a StreamingMemoryObject with corrupt data.
-  R.setArtificialByteLimit(R.getCurrentByteNo() + StringsOffset);
-
   StringRef Strings = Blob.drop_front(StringsOffset);
   do {
     if (R.AtEndOfStream())
       return error("Invalid record: metadata strings bad length");
 
     unsigned Size = R.ReadVBR(6);
     if (Strings.size() < Size)
       return error("Invalid record: metadata strings truncated chars");
if (Stream.Read(8) != 'B' ||
       Stream.Read(4) != 0x0 ||
       Stream.Read(4) != 0xC ||
       Stream.Read(4) != 0xE ||
       Stream.Read(4) != 0xD)
     return false;
   return true;
 }
 
-std::error_code
-BitcodeReader::parseBitcodeInto(std::unique_ptr<DataStreamer> Streamer,
-                                Module *M, bool ShouldLazyLoadMetadata) {
+std::error_code BitcodeReader::parseBitcodeInto(Module *M,
+                                                bool ShouldLazyLoadMetadata) {
   TheModule = M;
 
-  if (std::error_code EC = initStream(std::move(Streamer)))
+  if (std::error_code EC = initStream())
     return EC;
 
   // Sniff for the signature.
   if (!hasValidBitcodeHeader(Stream))
     return error("Invalid bitcode signature");
 
   // We expect a number of well-defined blocks, though we don't necessarily
   // need to understand them all.
while (true) {
     }
     }
     Record.clear();
   }
   llvm_unreachable("Exit infinite loop");
 }
 
 ErrorOr<std::string> BitcodeReader::parseTriple() {
-  if (std::error_code EC = initStream(nullptr))
+  if (std::error_code EC = initStream())
     return EC;
 
   // Sniff for the signature.
   if (!hasValidBitcodeHeader(Stream))
     return error("Invalid bitcode signature");
 
   // We expect a number of well-defined blocks, though we don't necessarily
   // need to understand them all.
while (true) {
     case BitstreamEntry::Record:
       Stream.skipRecord(Entry.ID);
       continue;
     }
   }
 }
 
 ErrorOr<std::string> BitcodeReader::parseIdentificationBlock() {
-  if (std::error_code EC = initStream(nullptr))
+  if (std::error_code EC = initStream())
     return EC;
 
   // Sniff for the signature.
   if (!hasValidBitcodeHeader(Stream))
     return error("Invalid bitcode signature");
 
   // We expect a number of well-defined blocks, though we don't necessarily
   // need to understand them all.
for (unsigned I = 0, E = Record.size(); I != E; I += 2) {
     if (!MD)
       return error("Invalid metadata attachment");
     GO.addMetadata(K->second, *MD);
   }
   return std::error_code();
 }
 
 ErrorOr<bool> BitcodeReader::hasObjCCategory() {
-  if (std::error_code EC = initStream(nullptr))
+  if (std::error_code EC = initStream())
     return EC;
 
   // Sniff for the signature.
   if (!hasValidBitcodeHeader(Stream))
     return error("Invalid bitcode signature");
 
   // We expect a number of well-defined blocks, though we don't necessarily
   // need to understand them all.

 std::error_code ModuleSummaryIndexBitcodeReader::error(const Twine &Message) {
   return ::error(DiagnosticHandler,
                  make_error_code(BitcodeError::CorruptedBitcode), Message);
 }
 
 ModuleSummaryIndexBitcodeReader::ModuleSummaryIndexBitcodeReader(
     MemoryBuffer *Buffer, DiagnosticHandlerFunction DiagnosticHandler,
     bool CheckGlobalValSummaryPresenceOnly)
-    : BitcodeReaderBase(Buffer), DiagnosticHandler(std::move(DiagnosticHandler)),
+    : BitcodeReaderBase(Buffer),
+      DiagnosticHandler(std::move(DiagnosticHandler)),
       CheckGlobalValSummaryPresenceOnly(CheckGlobalValSummaryPresenceOnly) {}
 
 void ModuleSummaryIndexBitcodeReader::freeState() { Buffer = nullptr; }
 
 void ModuleSummaryIndexBitcodeReader::releaseBuffer() { Buffer.release(); }
 
 std::pair<GlobalValue::GUID, GlobalValue::GUID>
 ModuleSummaryIndexBitcodeReader::getGUIDFromValueId(unsigned ValueId) {
case bitc::MST_CODE_HASH: {
       break;
     }
     }
   }
   llvm_unreachable("Exit infinite loop");
 }
 
 // Parse the function info index from the bitcode streamer into the given index.
-std::error_code ModuleSummaryIndexBitcodeReader::parseSummaryIndexInto(
-    std::unique_ptr<DataStreamer> Streamer, ModuleSummaryIndex *I) {
+std::error_code
+ModuleSummaryIndexBitcodeReader::parseSummaryIndexInto(ModuleSummaryIndex *I) {
   TheIndex = I;
 
-  if (std::error_code EC = initStream(std::move(Streamer)))
+  if (std::error_code EC = initStream())
     return EC;
 
   // Sniff for the signature.
   if (!hasValidBitcodeHeader(Stream))
     return error("Invalid bitcode signature");
 
   // We expect a number of well-defined blocks, though we don't necessarily
   // need to understand them all.
const std::error_category &llvm::BitcodeErrorCategory() {
   return *ErrorCategory;
 }
 
 //===----------------------------------------------------------------------===//
 // External interface
 //===----------------------------------------------------------------------===//
 
 static ErrorOr<std::unique_ptr<Module>>
-getBitcodeModuleImpl(std::unique_ptr<DataStreamer> Streamer, StringRef Name,
-                     BitcodeReader *R, LLVMContext &Context,
+getBitcodeModuleImpl(StringRef Name, BitcodeReader *R, LLVMContext &Context,
                      bool MaterializeAll, bool ShouldLazyLoadMetadata) {
   std::unique_ptr<Module> M = llvm::make_unique<Module>(Name, Context);
   M->setMaterializer(R);
 
   auto cleanupOnError = [&](std::error_code EC) {
     R->releaseBuffer(); // Never take ownership on error.
     return EC;
   };
 
   // Delay parsing Metadata if ShouldLazyLoadMetadata is true.
-  if (std::error_code EC = R->parseBitcodeInto(std::move(Streamer), M.get(),
-                                               ShouldLazyLoadMetadata))
+  if (std::error_code EC = R->parseBitcodeInto(M.get(), ShouldLazyLoadMetadata))
     return cleanupOnError(EC);
 
   if (MaterializeAll) {
     // Read in the entire module, and destroy the BitcodeReader.
     if (std::error_code EC = M->materializeAll())
       return cleanupOnError(EC);
   } else {
     // Resolve forward references from blockaddresses.

 /// everything.
 static ErrorOr<std::unique_ptr<Module>>
 getLazyBitcodeModuleImpl(std::unique_ptr<MemoryBuffer> &&Buffer,
                          LLVMContext &Context, bool MaterializeAll,
                          bool ShouldLazyLoadMetadata = false) {
   BitcodeReader *R = new BitcodeReader(Buffer.get(), Context);
 
   ErrorOr<std::unique_ptr<Module>> Ret =
-      getBitcodeModuleImpl(nullptr, Buffer->getBufferIdentifier(), R, Context,
+      getBitcodeModuleImpl(Buffer->getBufferIdentifier(), R, Context,
                            MaterializeAll, ShouldLazyLoadMetadata);
   if (!Ret)
     return Ret;
 
   Buffer.release(); // The BitcodeReader owns it now.
   return Ret;
 }
 
 ErrorOr<std::unique_ptr<Module>>
 llvm::getLazyBitcodeModule(std::unique_ptr<MemoryBuffer> &&Buffer,
                            LLVMContext &Context, bool ShouldLazyLoadMetadata) {
   return getLazyBitcodeModuleImpl(std::move(Buffer), Context, false,
                                   ShouldLazyLoadMetadata);
 }
 
-ErrorOr<std::unique_ptr<Module>>
-llvm::getStreamedBitcodeModule(StringRef Name,
-                               std::unique_ptr<DataStreamer> Streamer,
-                               LLVMContext &Context) {
-  std::unique_ptr<Module> M = llvm::make_unique<Module>(Name, Context);
-  BitcodeReader *R = new BitcodeReader(Context);
-
-  return getBitcodeModuleImpl(std::move(Streamer), Name, R, Context, false,
-                              false);
-}
-
 ErrorOr<std::unique_ptr<Module>> llvm::parseBitcodeFile(MemoryBufferRef Buffer,
                                                         LLVMContext &Context) {
   std::unique_ptr<MemoryBuffer> Buf = MemoryBuffer::getMemBuffer(Buffer, false);
   return getLazyBitcodeModuleImpl(std::move(Buf), Context, true);
   // TODO: Restore the use-lists to the in-memory state when the bitcode was
   // written.  We must defer until the Module has been fully materialized.
 }
 
ErrorOr<std::unique_ptr<ModuleSummaryIndex>> llvm::getModuleSummaryIndex(
 
   auto Index = llvm::make_unique<ModuleSummaryIndex>();
 
   auto cleanupOnError = [&](std::error_code EC) {
     R.releaseBuffer(); // Never take ownership on error.
     return EC;
   };
 
-  if (std::error_code EC = R.parseSummaryIndexInto(nullptr, Index.get()))
+  if (std::error_code EC = R.parseSummaryIndexInto(Index.get()))
     return cleanupOnError(EC);
 
   Buf.release(); // The ModuleSummaryIndexBitcodeReader owns it now.
   return std::move(Index);
 }
 
 // Check if the given bitcode buffer contains a global value summary block.
 bool llvm::hasGlobalValueSummary(
     MemoryBufferRef Buffer,
     const DiagnosticHandlerFunction &DiagnosticHandler) {
   std::unique_ptr<MemoryBuffer> Buf = MemoryBuffer::getMemBuffer(Buffer, false);
   ModuleSummaryIndexBitcodeReader R(Buf.get(), DiagnosticHandler, true);
 
   auto cleanupOnError = [&](std::error_code EC) {
     R.releaseBuffer(); // Never take ownership on error.
     return false;
   };
 
-  if (std::error_code EC = R.parseSummaryIndexInto(nullptr, nullptr))
+  if (std::error_code EC = R.parseSummaryIndexInto(nullptr))
     return cleanupOnError(EC);
 
   Buf.release(); // The ModuleSummaryIndexBitcodeReader owns it now.
   return R.foundGlobalValSummary();
 }

llvm/trunk/test/Bitcode/Inputs/invalid-unexpected-eof.bc

-BC折!␌000000␋00000000000000
+BC折!␌000000␋000000000000000
 No newline at end of file

llvm/trunk/tools/llvm-bcanalyzer/llvm-bcanalyzer.cpp

static bool decodeMetadataStringsBlob(BitstreamReader &Reader, StringRef Indent,
   unsigned NumStrings = Record[0];
   unsigned StringsOffset = Record[1];
   outs() << " num-strings = " << NumStrings << " {\n";
 
   StringRef Lengths = Blob.slice(0, StringsOffset);
   SimpleBitstreamCursor R(Reader);
   R.jumpToPointer(Lengths.begin());
 
-  // Ensure that Blob doesn't get invalidated, even if this is reading from a
-  // StreamingMemoryObject with corrupt data.
-  R.setArtificialByteLimit(R.getCurrentByteNo() + StringsOffset);
-
   StringRef Strings = Blob.drop_front(StringsOffset);
   do {
     if (R.AtEndOfStream())
       return ReportError("bad length");
 
     unsigned Size = R.ReadVBR(6);
     if (Strings.size() < Size)
       return ReportError("truncated chars");
if (Dump) {
              << " Size=" << format_hex(Size, 10)
              << " CPUType=" << format_hex(CPUType, 10) << "/>\n";
     }
 
     if (SkipBitcodeWrapperHeader(BufPtr, EndBufPtr, true))
       return ReportError("Invalid bitcode wrapper header");
   }
 
-  StreamFile = BitstreamReader(BufPtr, EndBufPtr);
+  StreamFile = BitstreamReader(ArrayRef<uint8_t>(BufPtr, EndBufPtr));
   Stream = BitstreamCursor(StreamFile);
   StreamFile.CollectBlockInfoNames();
 
   // Read the stream signature.
   char Signature[6];
   Signature[0] = Stream.Read(8);
   Signature[1] = Stream.Read(8);
   Signature[2] = Stream.Read(4);
while (!Stream.AtEndOfStream()) {
 
     if (ParseBlock(Stream, BlockID, 0, CurStreamType))
       return true;
     ++NumTopBlocks;
   }
 
   if (Dump) outs() << "\n\n";
 
-  uint64_t BufferSizeBits = StreamFile.getBitcodeBytes().getExtent() * CHAR_BIT;
+  uint64_t BufferSizeBits = StreamFile.getBitcodeBytes().size() * CHAR_BIT;
   // Print a summary of the read file.
   outs() << "Summary of " << InputFilename << ":\n";
   outs() << "         Total size: ";
   PrintSize(BufferSizeBits);
   outs() << "\n";
   outs() << "        Stream type: ";
   switch (CurStreamType) {
   case UnknownBitstream: outs() << "unknown\n"; break;

llvm/trunk/tools/llvm-dis/llvm-dis.cpp

 #include "llvm/IR/AssemblyAnnotationWriter.h"
 #include "llvm/IR/DebugInfo.h"
 #include "llvm/IR/DiagnosticInfo.h"
 #include "llvm/IR/DiagnosticPrinter.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/Type.h"
 #include "llvm/Support/CommandLine.h"
-#include "llvm/Support/DataStream.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/FormattedStream.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/PrettyStackTrace.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/ToolOutputFile.h"
static void diagnosticHandler(const DiagnosticInfo &DI, void *Context) {
   DI.print(DP);
   OS << '\n';
 
   if (DI.getSeverity() == DS_Error)
     exit(1);
 }
 
 static Expected<std::unique_ptr<Module>> openInputFile(LLVMContext &Context) {
-  if (MaterializeMetadata) {
-    ErrorOr<std::unique_ptr<MemoryBuffer>> MBOrErr =
-        MemoryBuffer::getFileOrSTDIN(InputFilename);
-    if (!MBOrErr)
-      return errorCodeToError(MBOrErr.getError());
-    ErrorOr<std::unique_ptr<Module>> MOrErr =
-        getLazyBitcodeModule(std::move(*MBOrErr), Context,
-                             /*ShouldLazyLoadMetadata=*/true);
-    if (!MOrErr)
-      return errorCodeToError(MOrErr.getError());
+  if (MaterializeMetadata)
     (*MOrErr)->materializeMetadata();
-    return std::move(*MOrErr);
-  } else {
-    std::string ErrorMessage;
-    std::unique_ptr<DataStreamer> Streamer =
-        getDataFileStreamer(InputFilename, &ErrorMessage);
-    if (!Streamer)
-      return make_error<StringError>(ErrorMessage, inconvertibleErrorCode());
-    std::string DisplayFilename;
-    if (InputFilename == "-")
-      DisplayFilename = "<stdin>";
-    else
-      DisplayFilename = InputFilename;
-    ErrorOr<std::unique_ptr<Module>> MOrErr =
-        getStreamedBitcodeModule(DisplayFilename, std::move(Streamer), Context);
     (*MOrErr)->materializeAll();
-    return std::move(*MOrErr);
-  }
-}
 
 int main(int argc, char **argv) {
   // Print a stack trace if we signal out.
   sys::PrintStackTraceOnErrorSignal(argv[0]);
   PrettyStackTraceProgram X(argc, argv);
 
   LLVMContext Context;
   llvm_shutdown_obj Y;  // Call llvm_shutdown() on exit.

llvm/trunk/unittests/Bitcode/BitReaderTest.cpp

 #include "llvm/Bitcode/BitstreamReader.h"
 #include "llvm/Bitcode/BitstreamWriter.h"
 #include "llvm/Bitcode/ReaderWriter.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/Verifier.h"
-#include "llvm/Support/DataStream.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/SourceMgr.h"
-#include "llvm/Support/StreamingMemoryObject.h"
 #include "gtest/gtest.h"
 
 using namespace llvm;
 
 namespace {
 
 std::unique_ptr<Module> parseAssembly(LLVMContext &Context,
                                       const char *Assembly) {
static std::unique_ptr<Module> getLazyModuleFromAssembly(LLVMContext &Context,
   writeModuleToBuffer(parseAssembly(Context, Assembly), Mem);
   std::unique_ptr<MemoryBuffer> Buffer =
       MemoryBuffer::getMemBuffer(Mem.str(), "test", false);
   ErrorOr<std::unique_ptr<Module>> ModuleOrErr =
       getLazyBitcodeModule(std::move(Buffer), Context);
   return std::move(ModuleOrErr.get());
 }
 
-class BufferDataStreamer : public DataStreamer {
-  std::unique_ptr<MemoryBuffer> Buffer;
-  unsigned Pos = 0;
-  size_t GetBytes(unsigned char *Out, size_t Len) override {
-    StringRef Buf = Buffer->getBuffer();
-    size_t Left = Buf.size() - Pos;
-    Len = std::min(Left, Len);
-    memcpy(Out, Buffer->getBuffer().substr(Pos).data(), Len);
-    Pos += Len;
-    return Len;
-  }
-
-public:
-  BufferDataStreamer(std::unique_ptr<MemoryBuffer> Buffer)
-      : Buffer(std::move(Buffer)) {}
-};
-
-static std::unique_ptr<Module>
-getStreamedModuleFromAssembly(LLVMContext &Context, SmallString<1024> &Mem,
-                              const char *Assembly) {
-  writeModuleToBuffer(parseAssembly(Context, Assembly), Mem);
-  std::unique_ptr<MemoryBuffer> Buffer =
-      MemoryBuffer::getMemBuffer(Mem.str(), "test", false);
-  auto Streamer = llvm::make_unique<BufferDataStreamer>(std::move(Buffer));
-  ErrorOr<std::unique_ptr<Module>> ModuleOrErr =
-      getStreamedBitcodeModule("test", std::move(Streamer), Context);
-  return std::move(ModuleOrErr.get());
-}
-
-// Checks if we correctly detect eof if we try to read N bits when there are not
-// enough bits left on the input stream to read N bits, and we are using a data
-// streamer. In particular, it checks if we properly set the object size when
-// the eof is reached under such conditions.
-TEST(BitReaderTest, TestForEofAfterReadFailureOnDataStreamer) {
-  // Note: Because StreamingMemoryObject does a call to method GetBytes in it's
-  // constructor, using internal constant kChunkSize, we must fill the input
-  // with more characters than that amount.
-  static size_t InputSize = StreamingMemoryObject::kChunkSize + 5;
-  char *Text = new char[InputSize];
-  std::memset(Text, 'a', InputSize);
-  Text[InputSize - 1] = '\0';
-  StringRef Input(Text);
-
-  // Build bitsteam reader using data streamer.
-  auto MemoryBuf = MemoryBuffer::getMemBuffer(Input);
-  std::unique_ptr<DataStreamer> Streamer(
-      new BufferDataStreamer(std::move(MemoryBuf)));
-  auto OwnedBytes =
-      llvm::make_unique<StreamingMemoryObject>(std::move(Streamer));
-  auto Reader = llvm::make_unique<BitstreamReader>(std::move(OwnedBytes));
-  BitstreamCursor Cursor;
-  Cursor.init(Reader.get());
-
-  // Jump to two bytes before end of stream.
-  Cursor.JumpToBit((InputSize - 4) * CHAR_BIT);
-  // Try to read 4 bytes when only 2 are present, resulting in error value 0.
-  const size_t ReadErrorValue = 0;
-  EXPECT_EQ(ReadErrorValue, Cursor.Read(32));
-  // Should be at eof now.
-  EXPECT_TRUE(Cursor.AtEndOfStream());
-
-  delete[] Text;
-}
-
-TEST(BitReaderTest, MateralizeForwardRefWithStream) {
-  SmallString<1024> Mem;
-
-  LLVMContext Context;
-  std::unique_ptr<Module> M = getStreamedModuleFromAssembly(
-      Context, Mem, "@table = constant i8* blockaddress(@func, %bb)\n"
-                    "define void @func() {\n"
-                    "  unreachable\n"
-                    "bb:\n"
-                    "  unreachable\n"
-                    "}\n");
-  EXPECT_FALSE(M->getFunction("func")->empty());
-}
-
 // Tests that lazy evaluation can parse functions out of order.
 TEST(BitReaderTest, MaterializeFunctionsOutOfOrder) {
   SmallString<1024> Mem;
   LLVMContext Context;
   std::unique_ptr<Module> M = getLazyModuleFromAssembly(
       Context, Mem, "define void @f() {\n"
                     "  unreachable\n"
                     "}\n"
TEST(BitReaderTest, MaterializeFunctionsForBlockAddr) { // PR11677
   std::unique_ptr<Module> M = getLazyModuleFromAssembly(
       Context, Mem, "@table = constant i8* blockaddress(@func, %bb)\n"
                     "define void @func() {\n"
                     "  unreachable\n"
                     "bb:\n"
                     "  unreachable\n"
                     "}\n");
   EXPECT_FALSE(verifyModule(*M, &dbgs()));
+  EXPECT_FALSE(M->getFunction("func")->empty());
 }
 
 TEST(BitReaderTest, MaterializeFunctionsForBlockAddrInFunctionBefore) {
   SmallString<1024> Mem;
 
   LLVMContext Context;
   std::unique_ptr<Module> M = getLazyModuleFromAssembly(
       Context, Mem, "define i8* @before() {\n"

llvm/trunk/unittests/Bitcode/BitstreamReaderTest.cpp

 //===- BitstreamReaderTest.cpp - Tests for BitstreamReader ----------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Bitcode/BitstreamReader.h"
 #include "llvm/Bitcode/BitstreamWriter.h"
-#include "llvm/Support/StreamingMemoryObject.h"
 #include "gtest/gtest.h"
 
 using namespace llvm;
 
 namespace {
 
-class BufferStreamer : public DataStreamer {
-  StringRef Buffer;
-
-public:
-  BufferStreamer(StringRef Buffer) : Buffer(Buffer) {}
-  size_t GetBytes(unsigned char *OutBuffer, size_t Length) override {
-    if (Length >= Buffer.size())
-      Length = Buffer.size();
-
-    std::copy(Buffer.begin(), Buffer.begin() + Length, OutBuffer);
-    Buffer = Buffer.drop_front(Length);
-    return Length;
-  }
-};
-
 TEST(BitstreamReaderTest, AtEndOfStream) {
   uint8_t Bytes[4] = {
     0x00, 0x01, 0x02, 0x03
   };
-  BitstreamReader Reader(std::begin(Bytes), std::end(Bytes));
+  BitstreamReader Reader(Bytes);
   BitstreamCursor Cursor(Reader);
 
   EXPECT_FALSE(Cursor.AtEndOfStream());
   (void)Cursor.Read(8);
   EXPECT_FALSE(Cursor.AtEndOfStream());
   (void)Cursor.Read(24);
   EXPECT_TRUE(Cursor.AtEndOfStream());
 
   Cursor.JumpToBit(0);
   EXPECT_FALSE(Cursor.AtEndOfStream());
 
   Cursor.JumpToBit(32);
   EXPECT_TRUE(Cursor.AtEndOfStream());
 }
 
 TEST(BitstreamReaderTest, AtEndOfStreamJump) {
   uint8_t Bytes[4] = {
     0x00, 0x01, 0x02, 0x03
   };
-  BitstreamReader Reader(std::begin(Bytes), std::end(Bytes));
+  BitstreamReader Reader(Bytes);
   BitstreamCursor Cursor(Reader);
 
   Cursor.JumpToBit(32);
   EXPECT_TRUE(Cursor.AtEndOfStream());
 }
 
 TEST(BitstreamReaderTest, AtEndOfStreamEmpty) {
-  uint8_t Dummy = 0xFF;
-  BitstreamReader Reader(&Dummy, &Dummy);
+  BitstreamReader Reader(ArrayRef<uint8_t>{});
   BitstreamCursor Cursor(Reader);
 
   EXPECT_TRUE(Cursor.AtEndOfStream());
 }
 
 TEST(BitstreamReaderTest, getCurrentByteNo) {
   uint8_t Bytes[] = {0x00, 0x01, 0x02, 0x03};
-  BitstreamReader Reader(std::begin(Bytes), std::end(Bytes));
+  BitstreamReader Reader(Bytes);
   SimpleBitstreamCursor Cursor(Reader);
 
-  for (unsigned I = 0, E = 33; I != E; ++I) {
+  for (unsigned I = 0, E = 32; I != E; ++I) {
     EXPECT_EQ(I / 8, Cursor.getCurrentByteNo());
     (void)Cursor.Read(1);
   }
   EXPECT_EQ(4u, Cursor.getCurrentByteNo());
 }
 
 TEST(BitstreamReaderTest, getPointerToByte) {
   uint8_t Bytes[] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07};
-  BitstreamReader Reader(std::begin(Bytes), std::end(Bytes));
+  BitstreamReader Reader(Bytes);
   SimpleBitstreamCursor Cursor(Reader);
 
   for (unsigned I = 0, E = 8; I != E; ++I) {
     EXPECT_EQ(Bytes + I, Cursor.getPointerToByte(I, 1));
   }
 }
 
 TEST(BitstreamReaderTest, getPointerToBit) {
   uint8_t Bytes[] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07};
-  BitstreamReader Reader(std::begin(Bytes), std::end(Bytes));
+  BitstreamReader Reader(Bytes);
   SimpleBitstreamCursor Cursor(Reader);
 
   for (unsigned I = 0, E = 8; I != E; ++I) {
     EXPECT_EQ(Bytes + I, Cursor.getPointerToBit(I * 8, 1));
   }
 }
 
 TEST(BitstreamReaderTest, jumpToPointer) {
   uint8_t Bytes[] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07};
-  BitstreamReader Reader(std::begin(Bytes), std::end(Bytes));
+  BitstreamReader Reader(Bytes);
   SimpleBitstreamCursor Cursor(Reader);
 
   for (unsigned I : {0, 6, 2, 7}) {
     Cursor.jumpToPointer(Bytes + I);
     EXPECT_EQ(I, Cursor.getCurrentByteNo());
   }
 }
 
-TEST(BitstreamReaderTest, setArtificialByteLimit) {
-  uint8_t Bytes[] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
-                     0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f};
-  BitstreamReader Reader(std::begin(Bytes), std::end(Bytes));
-  SimpleBitstreamCursor Cursor(Reader);
-
-  Cursor.setArtificialByteLimit(8);
-  EXPECT_EQ(8u, Cursor.getSizeIfKnown());
-  while (!Cursor.AtEndOfStream())
-    (void)Cursor.Read(1);
-
-  EXPECT_EQ(8u, Cursor.getCurrentByteNo());
-}
-
-TEST(BitstreamReaderTest, setArtificialByteLimitNotWordBoundary) {
-  uint8_t Bytes[] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
-                     0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f};
-  BitstreamReader Reader(std::begin(Bytes), std::end(Bytes));
-  SimpleBitstreamCursor Cursor(Reader);
-
-  Cursor.setArtificialByteLimit(5);
-  EXPECT_EQ(8u, Cursor.getSizeIfKnown());
-  while (!Cursor.AtEndOfStream())
-    (void)Cursor.Read(1);
-
-  EXPECT_EQ(8u, Cursor.getCurrentByteNo());
-}
-
-TEST(BitstreamReaderTest, setArtificialByteLimitPastTheEnd) {
-  uint8_t Bytes[] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
-                     0x08, 0x09, 0x0a, 0x0b};
-  BitstreamReader Reader(std::begin(Bytes), std::end(Bytes));
-  SimpleBitstreamCursor Cursor(Reader);
-
-  // The size of the memory object isn't known yet.  Set it too high and
-  // confirm that we don't read too far.
-  Cursor.setArtificialByteLimit(24);
-  EXPECT_EQ(24u, Cursor.getSizeIfKnown());
-  while (!Cursor.AtEndOfStream())
-    (void)Cursor.Read(1);
-
-  EXPECT_EQ(12u, Cursor.getCurrentByteNo());
-  EXPECT_EQ(12u, Cursor.getSizeIfKnown());
-}
-
-TEST(BitstreamReaderTest, setArtificialByteLimitPastTheEndKnown) {
-  uint8_t Bytes[] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
-                     0x08, 0x09, 0x0a, 0x0b};
-  BitstreamReader Reader(std::begin(Bytes), std::end(Bytes));
-  SimpleBitstreamCursor Cursor(Reader);
-
-  // Save the size of the memory object in the cursor.
-  while (!Cursor.AtEndOfStream())
-    (void)Cursor.Read(1);
-  EXPECT_EQ(12u, Cursor.getCurrentByteNo());
-  EXPECT_EQ(12u, Cursor.getSizeIfKnown());
-
-  Cursor.setArtificialByteLimit(20);
-  EXPECT_TRUE(Cursor.AtEndOfStream());
-  EXPECT_EQ(12u, Cursor.getSizeIfKnown());
-}
-
 TEST(BitstreamReaderTest, readRecordWithBlobWhileStreaming) {
   SmallVector<uint8_t, 1> BlobData;
   for (unsigned I = 0, E = 1024; I != E; ++I)
     BlobData.push_back(I);
 
   // Try a bunch of different sizes.
   const unsigned Magic = 0x12345678;
   const unsigned BlockID = bitc::FIRST_APPLICATION_BLOCKID;
unsigned AbbrevID;
       AbbrevID = Stream.EmitAbbrev(Abbrev);
       unsigned Record[] = {RecordID};
       Stream.EmitRecordWithBlob(AbbrevID, makeArrayRef(Record), BlobIn);
 
       Stream.ExitBlock();
     }
 
     // Stream the buffer into the reader.
-    BitstreamReader R(llvm::make_unique<StreamingMemoryObject>(
-        llvm::make_unique<BufferStreamer>(
-            StringRef(Buffer.begin(), Buffer.size()))));
+    BitstreamReader R(
+        ArrayRef<uint8_t>((const uint8_t *)Buffer.begin(), Buffer.size()));
     BitstreamCursor Stream(R);
 
     // Header.  Included in test so that we can run llvm-bcanalyzer to debug
     // when there are problems.
     ASSERT_EQ(Magic, Stream.Read(32));
 
     // Block.
     BitstreamEntry Entry =