contrib/llvm/include/llvm/Support/StreamingMemoryObject.h

   1 //===- StreamingMemoryObject.h - Streamable data interface -----*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #ifndef LLVM_SUPPORT_STREAMINGMEMORYOBJECT_H
  11 #define LLVM_SUPPORT_STREAMINGMEMORYOBJECT_H
  12
  13 #include "llvm/Support/Compiler.h"
  14 #include "llvm/Support/DataStream.h"
  15 #include "llvm/Support/ErrorHandling.h"
  16 #include "llvm/Support/MemoryObject.h"
  17 #include <memory>
  18 #include <vector>
  19
  20 namespace llvm {
  21
  22 /// Interface to data which is actually streamed from a DataStreamer. In
  23 /// addition to inherited members, it has the dropLeadingBytes and
  24 /// setKnownObjectSize methods which are not applicable to non-streamed objects.
  25 class StreamingMemoryObject : public MemoryObject {
  26 public:
  27   StreamingMemoryObject(std::unique_ptr<DataStreamer> Streamer);
  28   uint64_t getExtent() const override;
  29   uint64_t readBytes(uint8_t *Buf, uint64_t Size,
  30                      uint64_t Address) const override;
  31   const uint8_t *getPointer(uint64_t Address, uint64_t Size) const override;
  32   bool isValidAddress(uint64_t address) const override;
  33
  34   /// Drop s bytes from the front of the stream, pushing the positions of the
  35   /// remaining bytes down by s. This is used to skip past the bitcode header,
  36   /// since we don't know a priori if it's present, and we can't put bytes
  37   /// back into the stream once we've read them.
  38   bool dropLeadingBytes(size_t s);
  39
  40   /// If the data object size is known in advance, many of the operations can
  41   /// be made more efficient, so this method should be called before reading
  42   /// starts (although it can be called anytime).
  43   void setKnownObjectSize(size_t size);
  44
  45   /// The number of bytes read at a time from the data streamer.
  46   static const uint32_t kChunkSize = 4096 * 4;
  47
  48 private:
  49   mutable std::vector<unsigned char> Bytes;
  50   std::unique_ptr<DataStreamer> Streamer;
  51   mutable size_t BytesRead;   // Bytes read from stream
  52   size_t BytesSkipped;// Bytes skipped at start of stream (e.g. wrapper/header)
  53   mutable size_t ObjectSize; // 0 if unknown, set if wrapper seen or EOF reached
  54   mutable bool EOFReached;
  55
  56   // Fetch enough bytes such that Pos can be read (i.e. BytesRead >
  57   // Pos). Returns true if Pos can be read.  Unlike most of the
  58   // functions in BitcodeReader, returns true on success.  Most of the
  59   // requests will be small, but we fetch at kChunkSize bytes at a
  60   // time to avoid making too many potentially expensive GetBytes
  61   // calls.
  62   bool fetchToPos(size_t Pos) const {
  63     while (Pos >= BytesRead) {
  64       if (EOFReached)
  65         return false;
  66       Bytes.resize(BytesRead + BytesSkipped + kChunkSize);
  67       size_t bytes = Streamer->GetBytes(&Bytes[BytesRead + BytesSkipped],
  68                                         kChunkSize);
  69       BytesRead += bytes;
  70       if (bytes == 0) { // reached EOF/ran out of bytes
  71         if (ObjectSize == 0)
  72           ObjectSize = BytesRead;
  73         EOFReached = true;
  74       }
  75     }
  76     return !ObjectSize || Pos < ObjectSize;
  77   }
  78
  79   StreamingMemoryObject(const StreamingMemoryObject&) = delete;
  80   void operator=(const StreamingMemoryObject&) = delete;
  81 };
  82
  83 MemoryObject *getNonStreamedMemoryObject(
  84     const unsigned char *Start, const unsigned char *End);
  85
  86 }
  87 #endif  // STREAMINGMEMORYOBJECT_H_