mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-09-03 18:29:48 +00:00
daf061cf05
This patch introduces a 'stub_addr' builtin that can be used to find the address
of the stub for a given (<file>, <section>, <symbol>) tuple. This address can be
used both to verify the contents of stubs (by loading from the returned address)
and to verify references to stubs (by comparing against the returned address).
Example (1) - Verifying stub contents:
Load 8 bytes (assuming a 64-bit target) from the stub for 'x' in the __text
section of f.o, and compare that value against the addres of 'x'.
# rtdyld-check: *{8}(stub_addr(f.o, __text, x) = x
Example (2) - Verifying references to stubs:
Decode the immediate of the instruction at label 'l', and verify that it's
equal to the offset from the next instruction's PC to the stub for 'y' in the
__text section of f.o (i.e. it's the correct PC-rel difference).
# rtdyld-check: decode_operand(l, 4) = stub_addr(f.o, __text, y) - next_pc(l)
l:
movq y@GOTPCREL(%rip), %rax
Since stub inspection requires cooperation with RuntimeDyldImpl this patch
pimpl-ifies RuntimeDyldChecker. Its implementation is moved in to a new class,
RuntimeDyldCheckerImpl, that has access to the definition of RuntimeDyldImpl.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@213698 91177308-0d34-0410-b5e6-96231b3b80d8
87 lines
3.0 KiB
C++
87 lines
3.0 KiB
C++
//===---- ObjectBuffer.h - Utility class to wrap object image memory -----===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file declares a wrapper class to hold the memory into which an
|
|
// object will be generated.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLVM_EXECUTIONENGINE_OBJECTBUFFER_H
|
|
#define LLVM_EXECUTIONENGINE_OBJECTBUFFER_H
|
|
|
|
#include "llvm/ADT/SmallVector.h"
|
|
#include "llvm/Support/MemoryBuffer.h"
|
|
#include "llvm/Support/raw_ostream.h"
|
|
|
|
namespace llvm {
|
|
|
|
/// ObjectBuffer - This class acts as a container for the memory buffer used during
|
|
/// generation and loading of executable objects using MCJIT and RuntimeDyld. The
|
|
/// underlying memory for the object will be owned by the ObjectBuffer instance
|
|
/// throughout its lifetime. The getMemBuffer() method provides a way to create a
|
|
/// MemoryBuffer wrapper object instance to be owned by other classes (such as
|
|
/// ObjectFile) as needed, but the MemoryBuffer instance returned does not own the
|
|
/// actual memory it points to.
|
|
class ObjectBuffer {
|
|
virtual void anchor();
|
|
public:
|
|
ObjectBuffer() {}
|
|
ObjectBuffer(MemoryBuffer* Buf) : Buffer(Buf) {}
|
|
virtual ~ObjectBuffer() {}
|
|
|
|
/// getMemBuffer - Like MemoryBuffer::getMemBuffer() this function
|
|
/// returns a pointer to an object that is owned by the caller. However,
|
|
/// the caller does not take ownership of the underlying memory.
|
|
MemoryBuffer *getMemBuffer() const {
|
|
return MemoryBuffer::getMemBuffer(Buffer->getBuffer(),
|
|
Buffer->getBufferIdentifier(), false);
|
|
}
|
|
|
|
const char *getBufferStart() const { return Buffer->getBufferStart(); }
|
|
size_t getBufferSize() const { return Buffer->getBufferSize(); }
|
|
StringRef getBuffer() const { return Buffer->getBuffer(); }
|
|
StringRef getBufferIdentifier() const {
|
|
return Buffer->getBufferIdentifier();
|
|
}
|
|
|
|
protected:
|
|
// The memory contained in an ObjectBuffer
|
|
std::unique_ptr<MemoryBuffer> Buffer;
|
|
};
|
|
|
|
/// ObjectBufferStream - This class encapsulates the SmallVector and
|
|
/// raw_svector_ostream needed to generate an object using MC code emission
|
|
/// while providing a common ObjectBuffer interface for access to the
|
|
/// memory once the object has been generated.
|
|
class ObjectBufferStream : public ObjectBuffer {
|
|
void anchor() override;
|
|
public:
|
|
ObjectBufferStream() : OS(SV) {}
|
|
virtual ~ObjectBufferStream() {}
|
|
|
|
raw_ostream &getOStream() { return OS; }
|
|
void flush()
|
|
{
|
|
OS.flush();
|
|
|
|
// Make the data accessible via the ObjectBuffer::Buffer
|
|
Buffer.reset(MemoryBuffer::getMemBuffer(StringRef(SV.data(), SV.size()),
|
|
"",
|
|
false));
|
|
}
|
|
|
|
protected:
|
|
SmallVector<char, 4096> SV; // Working buffer into which we JIT.
|
|
raw_svector_ostream OS; // streaming wrapper
|
|
};
|
|
|
|
} // namespace llvm
|
|
|
|
#endif
|