[ dwarfdump ] Add symbolic dump of known DWARF attribute values.

[oota-llvm.git] / include / llvm / Support / StreamableMemoryObject.h

diff --git a/include/llvm/Support/StreamableMemoryObject.h b/include/llvm/Support/StreamableMemoryObject.h
index 1eb4c32dbc44b16780aee389bb8d0a99524414aa..6e71ad47c8dd58401fde807abca4e0026bea2685 100644 (file)
--- a/include/llvm/Support/StreamableMemoryObject.h
+++ b/include/llvm/Support/StreamableMemoryObject.h
@@ -11,10 +11,12 @@
 #ifndef LLVM_SUPPORT_STREAMABLEMEMORYOBJECT_H
 #define LLVM_SUPPORT_STREAMABLEMEMORYOBJECT_H
 
-#include "llvm/ADT/OwningPtr.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 {
@@ -38,7 +40,7 @@ class StreamableMemoryObject : public MemoryObject {
   /// getBase         - Returns the lowest valid address in the region.
   ///
   /// @result         - The lowest valid address.
-  virtual uint64_t getBase() const override = 0;
+  uint64_t getBase() const override = 0;
 
   /// getExtent       - Returns the size of the region in bytes.  (The region is
   ///                   contiguous, so the highest valid address of the region
@@ -46,7 +48,7 @@ class StreamableMemoryObject : public MemoryObject {
   ///                   May block until all bytes in the stream have been read
   ///
   /// @result         - The size of the region.
-  virtual uint64_t getExtent() const override = 0;
+  uint64_t getExtent() const override = 0;
 
   /// readByte        - Tries to read a single byte from the region.
   ///                   May block until (address - base) bytes have been read
@@ -54,7 +56,7 @@ class StreamableMemoryObject : public MemoryObject {
   /// @param ptr      - A pointer to a byte to be filled in.  Must be non-NULL.
   /// @result         - 0 if successful; -1 if not.  Failure may be due to a
   ///                   bounds violation or an implementation-specific error.
-  virtual int readByte(uint64_t address, uint8_t *ptr) const override = 0;
+  int readByte(uint64_t address, uint8_t *ptr) const override = 0;
 
   /// readBytes       - Tries to read a contiguous range of bytes from the
   ///                   region, up to the end of the region.
@@ -70,9 +72,8 @@ class StreamableMemoryObject : public MemoryObject {
   ///                   and large enough to hold size bytes.
   /// @result         - 0 if successful; -1 if not.  Failure may be due to a
   ///                   bounds violation or an implementation-specific error.
-  virtual int readBytes(uint64_t address,
-                        uint64_t size,
-                        uint8_t *buf) const override = 0;
+  int readBytes(uint64_t address, uint64_t size,
+                uint8_t *buf) const override = 0;
 
   /// getPointer  - Ensures that the requested data is in memory, and returns
   ///               A pointer to it. More efficient than using readBytes if the
@@ -105,23 +106,21 @@ class StreamableMemoryObject : public MemoryObject {
 class StreamingMemoryObject : public StreamableMemoryObject {
 public:
   StreamingMemoryObject(DataStreamer *streamer);
-  virtual uint64_t getBase() const override { return 0; }
-  virtual uint64_t getExtent() const override;
-  virtual int readByte(uint64_t address, uint8_t *ptr) const override;
-  virtual int readBytes(uint64_t address,
-                        uint64_t size,
-                        uint8_t *buf) const override;
-  virtual const uint8_t *getPointer(uint64_t address,
-                                    uint64_t size) const override {
+  uint64_t getBase() const override { return 0; }
+  uint64_t getExtent() const override;
+  int readByte(uint64_t address, uint8_t *ptr) const override;
+  int readBytes(uint64_t address, uint64_t size,
+                uint8_t *buf) 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.
-    assert(0 && "getPointer in streaming memory objects not allowed");
-    return NULL;
+    llvm_unreachable("getPointer in streaming memory objects not allowed");
+    return nullptr;
   }
-  virtual bool isValidAddress(uint64_t address) const override;
-  virtual bool isObjectEnd(uint64_t address) const override;
+  bool isValidAddress(uint64_t address) const override;
+  bool isObjectEnd(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,
@@ -137,7 +136,7 @@ public:
 private:
   const static uint32_t kChunkSize = 4096 * 4;
   mutable std::vector<unsigned char> Bytes;
-  OwningPtr<DataStreamer> Streamer;
+  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
@@ -156,8 +155,8 @@ private:
                                         kChunkSize);
       BytesRead += bytes;
       if (bytes < kChunkSize) {
-        if (ObjectSize && BytesRead < Pos)
-          assert(0 && "Unexpected short read fetching bitcode");
+        assert((!ObjectSize || BytesRead >= Pos) &&
+               "Unexpected short read fetching bitcode");
         if (BytesRead <= Pos) { // reached EOF/ran out of bytes
           ObjectSize = BytesRead;
           EOFReached = true;