mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2025-01-22 10:33:23 +00:00
da62155c11
MCJIT.
This patch decouples the two responsibilities of the RTDyldMemoryManager class,
memory management and symbol resolution, into two new classes:
RuntimeDyld::MemoryManager and RuntimeDyld::SymbolResolver.
The symbol resolution interface is modified slightly, from:
uint64_t getSymbolAddress(const std::string &Name);
to:
RuntimeDyld::SymbolInfo findSymbol(const std::string &Name);
The latter passes symbol flags along with symbol addresses, allowing RuntimeDyld
and others to reason about non-strong/non-exported symbols.
The memory management interface removes the following method:
void notifyObjectLoaded(ExecutionEngine *EE,
const object::ObjectFile &) {}
as it is not related to memory management. (Note: Backwards compatibility *is*
maintained for this method in MCJIT and OrcMCJITReplacement, see below).
The RTDyldMemoryManager class remains in-tree for backwards compatibility.
It inherits directly from RuntimeDyld::SymbolResolver, and indirectly from
RuntimeDyld::MemoryManager via the new MCJITMemoryManager class, which
just subclasses RuntimeDyld::MemoryManager and reintroduces the
notifyObjectLoaded method for backwards compatibility).
The EngineBuilder class retains the existing method:
EngineBuilder&
setMCJITMemoryManager(std::unique_ptr<RTDyldMemoryManager> mcjmm);
and includes two new methods:
EngineBuilder&
setMemoryManager(std::unique_ptr<MCJITMemoryManager> MM);
EngineBuilder&
setSymbolResolver(std::unique_ptr<RuntimeDyld::SymbolResolver> SR);
Clients should use EITHER:
A single call to setMCJITMemoryManager with an RTDyldMemoryManager.
OR (exclusive)
One call each to each of setMemoryManager and setSymbolResolver.
This patch should be fully compatible with existing uses of RTDyldMemoryManager.
If it is not it should be considered a bug, and the patch either fixed or
reverted.
If clients find the new API to be an improvement the goal will be to deprecate
and eventually remove the RTDyldMemoryManager class in favor of the new classes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@233509 91177308-0d34-0410-b5e6-96231b3b80d8
78 lines
2.5 KiB
C++
78 lines
2.5 KiB
C++
//===----------- JITSymbol.h - JIT symbol abstraction -----------*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// Abstraction for target process addresses.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLVM_EXECUTIONENGINE_ORC_JITSYMBOL_H
|
|
#define LLVM_EXECUTIONENGINE_ORC_JITSYMBOL_H
|
|
|
|
#include "llvm/ExecutionEngine/JITSymbolFlags.h"
|
|
#include "llvm/Support/DataTypes.h"
|
|
#include <cassert>
|
|
#include <functional>
|
|
|
|
namespace llvm {
|
|
namespace orc {
|
|
|
|
/// @brief Represents an address in the target process's address space.
|
|
typedef uint64_t TargetAddress;
|
|
|
|
/// @brief Represents a symbol in the JIT.
|
|
class JITSymbol : public JITSymbolBase {
|
|
public:
|
|
|
|
typedef std::function<TargetAddress()> GetAddressFtor;
|
|
|
|
/// @brief Create a 'null' symbol that represents failure to find a symbol
|
|
/// definition.
|
|
JITSymbol(std::nullptr_t)
|
|
: JITSymbolBase(JITSymbolFlags::None), CachedAddr(0) {}
|
|
|
|
/// @brief Create a symbol for a definition with a known address.
|
|
JITSymbol(TargetAddress Addr, JITSymbolFlags Flags)
|
|
: JITSymbolBase(Flags), CachedAddr(Addr) {}
|
|
|
|
/// @brief Create a symbol for a definition that doesn't have a known address
|
|
/// yet.
|
|
/// @param GetAddress A functor to materialize a definition (fixing the
|
|
/// address) on demand.
|
|
///
|
|
/// This constructor allows a JIT layer to provide a reference to a symbol
|
|
/// definition without actually materializing the definition up front. The
|
|
/// user can materialize the definition at any time by calling the getAddress
|
|
/// method.
|
|
JITSymbol(GetAddressFtor GetAddress, JITSymbolFlags Flags)
|
|
: JITSymbolBase(Flags), GetAddress(std::move(GetAddress)), CachedAddr(0) {}
|
|
|
|
/// @brief Returns true if the symbol exists, false otherwise.
|
|
explicit operator bool() const { return CachedAddr || GetAddress; }
|
|
|
|
/// @brief Get the address of the symbol in the target address space. Returns
|
|
/// '0' if the symbol does not exist.
|
|
TargetAddress getAddress() {
|
|
if (GetAddress) {
|
|
CachedAddr = GetAddress();
|
|
assert(CachedAddr && "Symbol could not be materialized.");
|
|
GetAddress = nullptr;
|
|
}
|
|
return CachedAddr;
|
|
}
|
|
|
|
private:
|
|
GetAddressFtor GetAddress;
|
|
TargetAddress CachedAddr;
|
|
};
|
|
|
|
} // End namespace orc.
|
|
} // End namespace llvm.
|
|
|
|
#endif // LLVM_EXECUTIONENGINE_ORC_JITSYMBOL_H
|