mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-12-15 20:29:48 +00:00
49e139b7f7
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@203442 91177308-0d34-0410-b5e6-96231b3b80d8
178 lines
8.4 KiB
C++
178 lines
8.4 KiB
C++
//===- StreamableMemoryObject.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_STREAMABLEMEMORYOBJECT_H
|
|
#define LLVM_SUPPORT_STREAMABLEMEMORYOBJECT_H
|
|
|
|
#include "llvm/Support/Compiler.h"
|
|
#include "llvm/Support/DataStream.h"
|
|
#include "llvm/Support/MemoryObject.h"
|
|
#include <cassert>
|
|
#include <memory>
|
|
#include <vector>
|
|
|
|
namespace llvm {
|
|
|
|
/// StreamableMemoryObject - 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:
|
|
/// Destructor - Override as necessary.
|
|
virtual ~StreamableMemoryObject();
|
|
|
|
/// getBase - Returns the lowest valid address in the region.
|
|
///
|
|
/// @result - The lowest valid address.
|
|
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
|
|
/// is getBase() + getExtent() - 1).
|
|
/// May block until all bytes in the stream have been read
|
|
///
|
|
/// @result - The size of the region.
|
|
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
|
|
/// @param address - The address of the byte, in the same space as getBase().
|
|
/// @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.
|
|
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.
|
|
/// May block until (address - base + size) bytes have
|
|
/// been read. Additionally, StreamableMemoryObjects will
|
|
/// not do partial reads - if size bytes cannot be read,
|
|
/// readBytes will fail.
|
|
///
|
|
/// @param address - The address of the first byte, in the same space as
|
|
/// getBase().
|
|
/// @param size - The number of bytes to copy.
|
|
/// @param buf - A pointer to a buffer to be filled in. Must be non-NULL
|
|
/// 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.
|
|
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
|
|
/// 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;
|
|
|
|
/// isValidAddress - 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;
|
|
|
|
/// isObjectEnd - 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;
|
|
};
|
|
|
|
/// StreamingMemoryObject - 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 {
|
|
public:
|
|
StreamingMemoryObject(DataStreamer *streamer);
|
|
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;
|
|
}
|
|
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,
|
|
/// 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);
|
|
|
|
/// 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);
|
|
|
|
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;
|
|
|
|
// Fetch enough bytes such that Pos can be read or EOF is reached
|
|
// (i.e. BytesRead > Pos). Return true if Pos can be read.
|
|
// Unlike most of the functions in BitcodeReader, returns true on success.
|
|
// Most of the requests will be small, but we fetch at kChunkSize bytes
|
|
// at a time to avoid making too many potentially expensive GetBytes calls
|
|
bool fetchToPos(size_t Pos) const {
|
|
if (EOFReached) return Pos < ObjectSize;
|
|
while (Pos >= BytesRead) {
|
|
Bytes.resize(BytesRead + BytesSkipped + kChunkSize);
|
|
size_t bytes = Streamer->GetBytes(&Bytes[BytesRead + BytesSkipped],
|
|
kChunkSize);
|
|
BytesRead += bytes;
|
|
if (bytes < kChunkSize) {
|
|
if (ObjectSize && BytesRead < Pos)
|
|
assert(0 && "Unexpected short read fetching bitcode");
|
|
if (BytesRead <= Pos) { // reached EOF/ran out of bytes
|
|
ObjectSize = BytesRead;
|
|
EOFReached = true;
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
StreamingMemoryObject(const StreamingMemoryObject&) LLVM_DELETED_FUNCTION;
|
|
void operator=(const StreamingMemoryObject&) LLVM_DELETED_FUNCTION;
|
|
};
|
|
|
|
StreamableMemoryObject *getNonStreamedMemoryObject(
|
|
const unsigned char *Start, const unsigned char *End);
|
|
|
|
}
|
|
#endif // STREAMABLEMEMORYOBJECT_H_
|