Rebased PNaCl localmods in LLVM to 223109

lib/Support/StreamingMemoryObject.cpp

 //===- StreamingMemoryObject.cpp - Streamable data interface -------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Support/StreamingMemoryObject.h"
@@ skipping 56 matching lines @@
 
 const uint8_t *RawMemoryObject::getPointer(uint64_t address,
                                            uint64_t size) const {
   return FirstChar + address;
 }
 } // anonymous namespace
 
 namespace llvm {
 // If the bitcode has a header, then its size is known, and we don't have to
 // block until we actually want to read it.
-bool StreamingMemoryObject::isValidAddress(uint64_t address) const {
+// @LOCALMOD -- separated into Impl (revisit after merge)
+bool StreamingMemoryObjectImpl::isValidAddress(uint64_t address) const {
   if (ObjectSize && address < ObjectSize) return true;
     return fetchToPos(address);
 }
 
-uint64_t StreamingMemoryObject::getExtent() const {
+// @LOCALMOD -- separated into Impl
+uint64_t StreamingMemoryObjectImpl::getExtent() const {
   if (ObjectSize) return ObjectSize;
   size_t pos = BytesRead + kChunkSize;
   // keep fetching until we run out of bytes
   while (fetchToPos(pos)) pos += kChunkSize;
   return ObjectSize;
 }
 
-uint64_t StreamingMemoryObject::readBytes(uint8_t *Buf, uint64_t Size,
+// @LOCALMOD --separated into Impl
+uint64_t StreamingMemoryObjectImpl::readBytes(uint8_t *Buf, uint64_t Size,
                                           uint64_t Address) const {
   fetchToPos(Address + Size - 1);
   if (Address >= BytesRead)
     return 0;
 
   uint64_t End = Address + Size;
   if (End > BytesRead)
     End = BytesRead;
   assert(static_cast<int64_t>(End - Address) >= 0);
   Size = End - Address;
   memcpy(Buf, &Bytes[Address + BytesSkipped], Size);
   return Size;
 }
 
-bool StreamingMemoryObject::dropLeadingBytes(size_t s) {
+// @LOCALMOD -- separated into Impl
+bool StreamingMemoryObjectImpl::dropLeadingBytes(size_t s) {
   if (BytesRead < s) return true;
   BytesSkipped = s;
   BytesRead -= s;
   return false;
 }
 
-void StreamingMemoryObject::setKnownObjectSize(size_t size) {
+// @LOCALMOD -- separated into Impl
+void StreamingMemoryObjectImpl::setKnownObjectSize(size_t size) {
   ObjectSize = size;
   Bytes.reserve(size);
 }
 
 MemoryObject *getNonStreamedMemoryObject(const unsigned char *Start,
                                          const unsigned char *End) {
   return new RawMemoryObject(Start, End);
 }
 
-StreamingMemoryObject::StreamingMemoryObject(DataStreamer *streamer) :
+// @LOCALMOD -- separated into Impl
+StreamingMemoryObjectImpl::StreamingMemoryObjectImpl(
+    DataStreamer *streamer) :
   Bytes(kChunkSize), Streamer(streamer), BytesRead(0), BytesSkipped(0),
   ObjectSize(0), EOFReached(false) {
   BytesRead = streamer->GetBytes(&Bytes[0], kChunkSize);
 }
 }