Rebased PNaCl localmods in LLVM to 223109

include/llvm/Support/StreamingMemoryObject.h

 //===- StreamingMemoryObject.h - Streamable data interface -----*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_SUPPORT_STREAMINGMEMORYOBJECT_H
 #define LLVM_SUPPORT_STREAMINGMEMORYOBJECT_H
 
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/DataStream.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MemoryObject.h"
 #include <cassert>
 #include <memory>
 #include <vector>
 
 namespace llvm {
 
 /// Interface to data which is actually streamed from a DataStreamer. In
 /// addition to inherited members, it has the dropLeadingBytes and
 /// setKnownObjectSize methods which are not applicable to non-streamed objects.
+/// @LOCALMOD -- Made dropLeadingBytes/setKnownObjectSize virtual.
 class StreamingMemoryObject : public MemoryObject {
+ public:
+  /// Drop s bytes from the front of the stream, pushing the positions of the
+  /// remaining bytes down by s. This is used to skip past the bitcode header,
+  /// since we don't know a priori if it's present, and we can't put bytes
+  /// back into the stream once we've read them.
+  virtual bool dropLeadingBytes(size_t s) = 0;
+
+  /// If the data object size is known in advance, many of the operations can
+  /// be made more efficient, so this method should be called before reading
+  /// starts (although it can be called anytime).
+  virtual void setKnownObjectSize(size_t size) = 0;
+};
+
+/// @LOCALMOD -- split out StreamingMemoryObjectImpl from StreamingMemoryObject.
+/// StreamingMemoryObjectImpl - an implementation of a StreamingMemoryObject.
+class StreamingMemoryObjectImpl : public StreamingMemoryObject {
 public:
-  StreamingMemoryObject(DataStreamer *streamer);
+  StreamingMemoryObjectImpl(DataStreamer *streamer);
   uint64_t getExtent() const override;
   uint64_t readBytes(uint8_t *Buf, uint64_t Size,
                      uint64_t Address) const override;
   const uint8_t *getPointer(uint64_t address, uint64_t size) const override {
     // This could be fixed by ensuring the bytes are fetched and making a copy,
     // requiring that the bitcode size be known, or otherwise ensuring that
     // the memory doesn't go away/get reallocated, but it's
     // not currently necessary. Users that need the pointer don't stream.
     llvm_unreachable("getPointer in streaming memory objects not allowed");
     return nullptr;
   }
   bool isValidAddress(uint64_t address) const override;
 
   /// Drop s bytes from the front of the stream, pushing the positions of the
   /// remaining bytes down by s. This is used to skip past the bitcode header,
   /// since we don't know a priori if it's present, and we can't put bytes
   /// back into the stream once we've read them.
-  bool dropLeadingBytes(size_t s);
+  bool dropLeadingBytes(size_t s) override;
 
   /// If the data object size is known in advance, many of the operations can
   /// be made more efficient, so this method should be called before reading
   /// starts (although it can be called anytime).
-  void setKnownObjectSize(size_t size);
+  void setKnownObjectSize(size_t size) override;
 
 private:
   const static uint32_t kChunkSize = 4096 * 4;
   mutable std::vector<unsigned char> Bytes;
   std::unique_ptr<DataStreamer> Streamer;
   mutable size_t BytesRead;   // Bytes read from stream
   size_t BytesSkipped;// Bytes skipped at start of stream (e.g. wrapper/header)
   mutable size_t ObjectSize; // 0 if unknown, set if wrapper seen or EOF reached
   mutable bool EOFReached;
 
@@ skipping 12 matching lines @@
       BytesRead += bytes;
       if (bytes != kChunkSize) { // reached EOF/ran out of bytes
         ObjectSize = BytesRead;
         EOFReached = true;
         break;
       }
     }
     return Pos < BytesRead;
   }
 
-  StreamingMemoryObject(const StreamingMemoryObject&) LLVM_DELETED_FUNCTION;
-  void operator=(const StreamingMemoryObject&) LLVM_DELETED_FUNCTION;
+  StreamingMemoryObjectImpl(
+      const StreamingMemoryObjectImpl&) LLVM_DELETED_FUNCTION;
+  void operator=(
+      const StreamingMemoryObjectImpl&) LLVM_DELETED_FUNCTION;
 };
 
 MemoryObject *getNonStreamedMemoryObject(
     const unsigned char *Start, const unsigned char *End);
 
 }
 #endif  // STREAMINGMEMORYOBJECT_H_