summary | shortlog | log | commit | commitdiff | tree
raw | patch | inline | side by side (parent: 64f62a0)
raw | patch | inline | side by side (parent: 64f62a0)
author | Rafael Espindola <rafael.espindola@gmail.com> | |
Wed, 12 Nov 2014 03:55:46 +0000 (03:55 +0000) | ||
committer | Rafael Espindola <rafael.espindola@gmail.com> | |
Wed, 12 Nov 2014 03:55:46 +0000 (03:55 +0000) |
Every MemoryObject is a StreamableMemoryObject since the removal of
StringRefMemoryObject, so just merge the two.
I will clean up the MemoryObject interface in the upcoming commits.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@221766 91177308-0d34-0410-b5e6-96231b3b80d8
StringRefMemoryObject, so just merge the two.
I will clean up the MemoryObject interface in the upcoming commits.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@221766 91177308-0d34-0410-b5e6-96231b3b80d8
include/llvm/Bitcode/BitstreamReader.h | patch | blob | history | |
include/llvm/Support/MemoryObject.h | patch | blob | history | |
include/llvm/Support/StreamingMemoryObject.h | [moved from include/llvm/Support/StreamableMemoryObject.h with 59% similarity] | patch | blob | history |
lib/Support/CMakeLists.txt | patch | blob | history | |
lib/Support/DataStream.cpp | patch | blob | history | |
lib/Support/StreamingMemoryObject.cpp | [moved from lib/Support/StreamableMemoryObject.cpp with 91% similarity] | patch | blob | history |
index b42f559e13b44f57a9f0fb797028f6182b36491c..6965da36ee236f7ac3738a2da8f39a4a813d1160 100644 (file)
#include "llvm/Bitcode/BitCodes.h"
#include "llvm/Support/Endian.h"
-#include "llvm/Support/StreamableMemoryObject.h"
+#include "llvm/Support/StreamingMemoryObject.h"
#include <climits>
#include <string>
#include <vector>
std::vector<std::pair<unsigned, std::string> > RecordNames;
};
private:
- std::unique_ptr<StreamableMemoryObject> BitcodeBytes;
+ std::unique_ptr<MemoryObject> BitcodeBytes;
std::vector<BlockInfo> BlockInfoRecords;
init(Start, End);
}
- BitstreamReader(StreamableMemoryObject *bytes) : IgnoreBlockInfoNames(true) {
+ BitstreamReader(MemoryObject *bytes) : IgnoreBlockInfoNames(true) {
BitcodeBytes.reset(bytes);
}
BitcodeBytes.reset(getNonStreamedMemoryObject(Start, End));
}
- StreamableMemoryObject &getBitcodeBytes() { return *BitcodeBytes; }
+ MemoryObject &getBitcodeBytes() { return *BitcodeBytes; }
/// This is called by clients that want block/record name information.
void CollectBlockInfoNames() { IgnoreBlockInfoNames = false; }
index 6208772532c3fe8065c218423b301ac3087080ff..584a2c55c04005d84f19928dc12b82eac84339b8 100644 (file)
namespace llvm {
-/// Abstract base class for contiguous addressable memory. Necessary for cases
-/// in which the memory is in another process, in a file, or on a remote
-/// machine. All size and offset parameters are uint64_ts, to allow 32-bit
-/// processes access to 64-bit address spaces.
+/// Interface to data which might be streamed. Streamability has 2 important
+/// implications/restrictions. First, the data might not yet exist in memory
+/// when the request is made. This just means that readByte/readBytes might have
+/// to block or do some work to get it. More significantly, the exact size of
+/// the object might not be known until it has all been fetched. This means that
+/// to return the right result, getExtent must also wait for all the data to
+/// arrive; therefore it should not be called on objects which are actually
+/// streamed (this would defeat the purpose of streaming). Instead,
+/// isValidAddress and isObjectEnd can be used to test addresses without knowing
+/// the exact size of the stream. Finally, getPointer can be used instead of
+/// readBytes to avoid extra copying.
class MemoryObject {
public:
virtual ~MemoryObject();
/// bounds violation or an implementation-specific error.
virtual int readBytes(uint64_t address, uint64_t size,
uint8_t *buf) const = 0;
+
+ /// Ensures that the requested data is in memory, and returns a pointer to it.
+ /// More efficient than using readBytes if the data is already in memory. May
+ /// block until (address - base + size) bytes have been read
+ /// @param address - address of the byte, in the same space as getBase()
+ /// @param size - amount of data that must be available on return
+ /// @result - valid pointer to the requested data
+ virtual const uint8_t *getPointer(uint64_t address, uint64_t size) const = 0;
+
+ /// Returns true if the address is within the object (i.e. between base and
+ /// base + extent - 1 inclusive). May block until (address - base) bytes have
+ /// been read
+ /// @param address - address of the byte, in the same space as getBase()
+ /// @result - true if the address may be read with readByte()
+ virtual bool isValidAddress(uint64_t address) const = 0;
+
+ /// Returns true if the address is one past the end of the object (i.e. if it
+ /// is equal to base + extent). May block until (address - base) bytes have
+ /// been read
+ /// @param address - address of the byte, in the same space as getBase()
+ /// @result - true if the address is equal to base + extent
+ virtual bool isObjectEnd(uint64_t address) const = 0;
};
}
diff --git a/include/llvm/Support/StreamableMemoryObject.h b/include/llvm/Support/StreamingMemoryObject.h
similarity index 59%
rename from include/llvm/Support/StreamableMemoryObject.h
rename to include/llvm/Support/StreamingMemoryObject.h
index 618610d084cc22f6a778051251299fbd0300c20e..da1b88738d0924757335c957beafb2bd14b3b157 100644 (file)
rename from include/llvm/Support/StreamableMemoryObject.h
rename to include/llvm/Support/StreamingMemoryObject.h
index 618610d084cc22f6a778051251299fbd0300c20e..da1b88738d0924757335c957beafb2bd14b3b157 100644 (file)
-//===- StreamableMemoryObject.h - Streamable data interface -----*- C++ -*-===//
+//===- StreamingMemoryObject.h - Streamable data interface -----*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
//
//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_SUPPORT_STREAMABLEMEMORYOBJECT_H
-#define LLVM_SUPPORT_STREAMABLEMEMORYOBJECT_H
+#ifndef LLVM_SUPPORT_STREAMINGMEMORYOBJECT_H
+#define LLVM_SUPPORT_STREAMINGMEMORYOBJECT_H
#include "llvm/Support/Compiler.h"
#include "llvm/Support/DataStream.h"
namespace llvm {
-/// Interface to data which might be streamed. Streamability has 2 important
-/// implications/restrictions. First, the data might not yet exist in memory
-/// when the request is made. This just means that readByte/readBytes might have
-/// to block or do some work to get it. More significantly, the exact size of
-/// the object might not be known until it has all been fetched. This means that
-/// to return the right result, getExtent must also wait for all the data to
-/// arrive; therefore it should not be called on objects which are actually
-/// streamed (this would defeat the purpose of streaming). Instead,
-/// isValidAddress and isObjectEnd can be used to test addresses without knowing
-/// the exact size of the stream. Finally, getPointer can be used instead of
-/// readBytes to avoid extra copying.
-class StreamableMemoryObject : public MemoryObject {
- public:
- virtual ~StreamableMemoryObject();
-
- /// Ensures that the requested data is in memory, and returns a pointer to it.
- /// More efficient than using readBytes if the data is already in memory. May
- /// block until (address - base + size) bytes have been read
- /// @param address - address of the byte, in the same space as getBase()
- /// @param size - amount of data that must be available on return
- /// @result - valid pointer to the requested data
- virtual const uint8_t *getPointer(uint64_t address, uint64_t size) const = 0;
-
- /// Returns true if the address is within the object (i.e. between base and
- /// base + extent - 1 inclusive). May block until (address - base) bytes have
- /// been read
- /// @param address - address of the byte, in the same space as getBase()
- /// @result - true if the address may be read with readByte()
- virtual bool isValidAddress(uint64_t address) const = 0;
-
- /// Returns true if the address is one past the end of the object (i.e. if it
- /// is equal to base + extent). May block until (address - base) bytes have
- /// been read
- /// @param address - address of the byte, in the same space as getBase()
- /// @result - true if the address is equal to base + extent
- virtual bool isObjectEnd(uint64_t address) const = 0;
-};
-
/// 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.
-class StreamingMemoryObject : public StreamableMemoryObject {
+class StreamingMemoryObject : public MemoryObject {
public:
StreamingMemoryObject(DataStreamer *streamer);
uint64_t getExtent() const override;
void operator=(const StreamingMemoryObject&) LLVM_DELETED_FUNCTION;
};
-StreamableMemoryObject *getNonStreamedMemoryObject(
+MemoryObject *getNonStreamedMemoryObject(
const unsigned char *Start, const unsigned char *End);
}
-#endif // STREAMABLEMEMORYOBJECT_H_
+#endif // STREAMINGMEMORYOBJECT_H_
index 794372d172c2070827face5416b03f38ce3fa369..fa62591191db309da74717553862cbb9225a0785 100644 (file)
SourceMgr.cpp
SpecialCaseList.cpp
Statistic.cpp
- StreamableMemoryObject.cpp
+ StreamingMemoryObject.cpp
StringExtras.cpp
StringMap.cpp
StringPool.cpp
index 32653de5194383549de9bb6b88b427383cca9f1f..dbf6465189decd9a084654b7474b11af0397a386 100644 (file)
#define DEBUG_TYPE "Data-stream"
// Interface goals:
-// * StreamableMemoryObject doesn't care about complexities like using
+// * StreamingMemoryObject doesn't care about complexities like using
// threads/async callbacks to actually overlap download+compile
// * Don't want to duplicate Data in memory
// * Don't need to know total Data len in advance
// Non-goals:
-// StreamableMemoryObject already has random access so this interface only does
+// StreamingMemoryObject already has random access so this interface only does
// in-order streaming (no arbitrary seeking, else we'd have to buffer all the
// Data here in addition to MemoryObject). This also means that if we want
// to be able to to free Data, BitstreamBytes/BitcodeReader will implement it
similarity index 91%
rename from lib/Support/StreamableMemoryObject.cpp
rename to lib/Support/StreamingMemoryObject.cpp
index 1a11f5b0cde9c5fca3925ec81de256147810f5ef..7187ce013faf62d8c32812918f721411c74431fa 100644 (file)
rename from lib/Support/StreamableMemoryObject.cpp
rename to lib/Support/StreamingMemoryObject.cpp
index 1a11f5b0cde9c5fca3925ec81de256147810f5ef..7187ce013faf62d8c32812918f721411c74431fa 100644 (file)
-//===- StreamableMemoryObject.cpp - Streamable data interface -------------===//
+//===- StreamingMemoryObject.cpp - Streamable data interface -------------===//
//
// The LLVM Compiler Infrastructure
//
//
//===----------------------------------------------------------------------===//
-#include "llvm/Support/StreamableMemoryObject.h"
+#include "llvm/Support/StreamingMemoryObject.h"
#include "llvm/Support/Compiler.h"
#include <cassert>
#include <cstddef>
namespace {
-class RawMemoryObject : public StreamableMemoryObject {
+class RawMemoryObject : public MemoryObject {
public:
RawMemoryObject(const unsigned char *Start, const unsigned char *End) :
FirstChar(Start), LastChar(End) {
Bytes.reserve(size);
}
-StreamableMemoryObject *getNonStreamedMemoryObject(
- const unsigned char *Start, const unsigned char *End) {
+MemoryObject *getNonStreamedMemoryObject(const unsigned char *Start,
+ const unsigned char *End) {
return new RawMemoryObject(Start, End);
}
-StreamableMemoryObject::~StreamableMemoryObject() { }
-
StreamingMemoryObject::StreamingMemoryObject(DataStreamer *streamer) :
Bytes(kChunkSize), Streamer(streamer), BytesRead(0), BytesSkipped(0),
ObjectSize(0), EOFReached(false) {