2011-03-21 22:15:52 +00:00
|
|
|
//===-- RuntimeDyld.h - Run-time dynamic linker for MC-JIT ------*- C++ -*-===//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// Interface for the runtime dynamic linker facilities of the MC-JIT.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2013-01-10 00:45:19 +00:00
|
|
|
#ifndef LLVM_EXECUTIONENGINE_RUNTIMEDYLD_H
|
|
|
|
#define LLVM_EXECUTIONENGINE_RUNTIMEDYLD_H
|
2011-03-21 22:15:52 +00:00
|
|
|
|
|
|
|
#include "llvm/ADT/StringRef.h"
|
2012-10-02 21:18:39 +00:00
|
|
|
#include "llvm/ExecutionEngine/ObjectBuffer.h"
|
2013-05-21 20:24:07 +00:00
|
|
|
#include "llvm/ExecutionEngine/RTDyldMemoryManager.h"
|
2011-03-21 22:15:52 +00:00
|
|
|
#include "llvm/Support/Memory.h"
|
|
|
|
|
|
|
|
namespace llvm {
|
|
|
|
|
2014-01-08 04:09:09 +00:00
|
|
|
namespace object {
|
|
|
|
class ObjectFile;
|
|
|
|
}
|
|
|
|
|
2011-03-21 22:15:52 +00:00
|
|
|
class RuntimeDyldImpl;
|
[MCJIT] Refactor and add stub inspection to the RuntimeDyldChecker framework.
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
2014-07-22 22:47:39 +00:00
|
|
|
class RuntimeDyldCheckerImpl;
|
2012-10-02 21:18:39 +00:00
|
|
|
class ObjectImage;
|
2011-04-04 23:04:39 +00:00
|
|
|
|
2011-03-21 22:15:52 +00:00
|
|
|
class RuntimeDyld {
|
[MCJIT] Refactor and add stub inspection to the RuntimeDyldChecker framework.
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
2014-07-22 22:47:39 +00:00
|
|
|
friend class RuntimeDyldCheckerImpl;
|
2014-06-27 20:20:57 +00:00
|
|
|
|
2012-09-18 02:01:41 +00:00
|
|
|
RuntimeDyld(const RuntimeDyld &) LLVM_DELETED_FUNCTION;
|
|
|
|
void operator=(const RuntimeDyld &) LLVM_DELETED_FUNCTION;
|
2011-03-21 22:15:52 +00:00
|
|
|
|
|
|
|
// RuntimeDyldImpl is the actual class. RuntimeDyld is just the public
|
|
|
|
// interface.
|
2014-09-04 18:37:29 +00:00
|
|
|
std::unique_ptr<RuntimeDyldImpl> Dyld;
|
2011-07-13 07:57:58 +00:00
|
|
|
RTDyldMemoryManager *MM;
|
2014-03-20 21:06:46 +00:00
|
|
|
bool ProcessAllSections;
|
[MCJIT] Refactor and add stub inspection to the RuntimeDyldChecker framework.
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
2014-07-22 22:47:39 +00:00
|
|
|
RuntimeDyldCheckerImpl *Checker;
|
2012-01-16 23:50:55 +00:00
|
|
|
protected:
|
|
|
|
// Change the address associated with a section when resolving relocations.
|
|
|
|
// Any relocations already associated with the symbol will be re-resolved.
|
|
|
|
void reassignSectionAddress(unsigned SectionID, uint64_t Addr);
|
2011-03-21 22:15:52 +00:00
|
|
|
public:
|
2012-10-16 23:46:19 +00:00
|
|
|
RuntimeDyld(RTDyldMemoryManager *);
|
2011-03-21 22:15:52 +00:00
|
|
|
~RuntimeDyld();
|
|
|
|
|
2012-11-27 22:53:57 +00:00
|
|
|
/// Prepare the object contained in the input buffer for execution.
|
|
|
|
/// Ownership of the input buffer is transferred to the ObjectImage
|
|
|
|
/// instance returned from this function if successful. In the case of load
|
|
|
|
/// failure, the input buffer will be deleted.
|
2014-09-03 19:48:09 +00:00
|
|
|
std::unique_ptr<ObjectImage>
|
|
|
|
loadObject(std::unique_ptr<ObjectBuffer> InputBuffer);
|
2012-04-29 12:40:47 +00:00
|
|
|
|
2014-01-08 04:09:09 +00:00
|
|
|
/// Prepare the referenced object file for execution.
|
|
|
|
/// Ownership of the input object is transferred to the ObjectImage
|
|
|
|
/// instance returned from this function if successful. In the case of load
|
|
|
|
/// failure, the input object will be deleted.
|
2014-09-03 19:48:09 +00:00
|
|
|
std::unique_ptr<ObjectImage>
|
|
|
|
loadObject(std::unique_ptr<object::ObjectFile> InputObject);
|
2014-01-08 04:09:09 +00:00
|
|
|
|
2012-04-29 12:40:47 +00:00
|
|
|
/// Get the address of our local copy of the symbol. This may or may not
|
|
|
|
/// be the address used for relocation (clients can copy the data around
|
|
|
|
/// and resolve relocatons based on where they put it).
|
2014-09-05 18:00:16 +00:00
|
|
|
void *getSymbolAddress(StringRef Name) const;
|
2012-04-29 12:40:47 +00:00
|
|
|
|
2012-09-05 16:50:40 +00:00
|
|
|
/// Get the address of the target copy of the symbol. This is the address
|
|
|
|
/// used for relocation.
|
2014-09-05 18:00:16 +00:00
|
|
|
uint64_t getSymbolLoadAddress(StringRef Name) const;
|
2012-09-05 16:50:40 +00:00
|
|
|
|
2012-04-29 12:40:47 +00:00
|
|
|
/// Resolve the relocations for all symbols we currently know about.
|
MCJIT lazy relocation resolution and symbol address re-assignment.
Add handling for tracking the relocations on symbols and resolving them.
Keep track of the relocations even after they are resolved so that if
the RuntimeDyld client moves the object, it can update the address and any
relocations to that object will be updated.
For our trival object file load/run test harness (llvm-rtdyld), this enables
relocations between functions located in the same object module. It should
be trivially extendable to load multiple objects with mutual references.
As a simple example, the following now works (running on x86_64 Darwin 10.6):
$ cat t.c
int bar() {
return 65;
}
int main() {
return bar();
}
$ clang t.c -fno-asynchronous-unwind-tables -o t.o -c
$ otool -vt t.o
t.o:
(__TEXT,__text) section
_bar:
0000000000000000 pushq %rbp
0000000000000001 movq %rsp,%rbp
0000000000000004 movl $0x00000041,%eax
0000000000000009 popq %rbp
000000000000000a ret
000000000000000b nopl 0x00(%rax,%rax)
_main:
0000000000000010 pushq %rbp
0000000000000011 movq %rsp,%rbp
0000000000000014 subq $0x10,%rsp
0000000000000018 movl $0x00000000,0xfc(%rbp)
000000000000001f callq 0x00000024
0000000000000024 addq $0x10,%rsp
0000000000000028 popq %rbp
0000000000000029 ret
$ llvm-rtdyld t.o -debug-only=dyld ; echo $?
Function sym: '_bar' @ 0
Function sym: '_main' @ 16
Extracting function: _bar from [0, 15]
allocated to 0x100153000
Extracting function: _main from [16, 41]
allocated to 0x100154000
Relocation at '_main' + 16 from '_bar(Word1: 0x2d000000)
Resolving relocation at '_main' + 16 (0x100154010) from '_bar (0x100153000)(pcrel, type: 2, Size: 4).
loaded '_main' at: 0x100154000
65
$
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@129388 91177308-0d34-0410-b5e6-96231b3b80d8
2011-04-12 21:20:41 +00:00
|
|
|
void resolveRelocations();
|
2012-01-16 23:50:55 +00:00
|
|
|
|
2012-11-27 22:53:57 +00:00
|
|
|
/// Map a section to its target address space value.
|
2012-01-16 23:50:55 +00:00
|
|
|
/// Map the address of a JIT section as returned from the memory manager
|
|
|
|
/// to the address in the target process as the running code will see it.
|
|
|
|
/// This is the address which will be used for relocation resolution.
|
2012-09-13 21:50:06 +00:00
|
|
|
void mapSectionAddress(const void *LocalAddress, uint64_t TargetAddress);
|
2012-01-16 23:50:55 +00:00
|
|
|
|
2013-10-11 21:25:48 +00:00
|
|
|
/// Register any EH frame sections that have been loaded but not previously
|
|
|
|
/// registered with the memory manager. Note, RuntimeDyld is responsible
|
|
|
|
/// for identifying the EH frame and calling the memory manager with the
|
|
|
|
/// EH frame section data. However, the memory manager itself will handle
|
|
|
|
/// the actual target-specific EH frame registration.
|
|
|
|
void registerEHFrames();
|
2013-05-05 20:43:10 +00:00
|
|
|
|
2013-10-16 00:14:21 +00:00
|
|
|
void deregisterEHFrames();
|
|
|
|
|
2014-03-26 18:19:27 +00:00
|
|
|
bool hasError();
|
2013-10-11 21:25:48 +00:00
|
|
|
StringRef getErrorString();
|
2014-03-20 21:06:46 +00:00
|
|
|
|
|
|
|
/// By default, only sections that are "required for execution" are passed to
|
|
|
|
/// the RTDyldMemoryManager, and other sections are discarded. Passing 'true'
|
|
|
|
/// to this method will cause RuntimeDyld to pass all sections to its
|
|
|
|
/// memory manager regardless of whether they are "required to execute" in the
|
|
|
|
/// usual sense. This is useful for inspecting metadata sections that may not
|
|
|
|
/// contain relocations, E.g. Debug info, stackmaps.
|
|
|
|
///
|
|
|
|
/// Must be called before the first object file is loaded.
|
|
|
|
void setProcessAllSections(bool ProcessAllSections) {
|
|
|
|
assert(!Dyld && "setProcessAllSections must be called before loadObject.");
|
|
|
|
this->ProcessAllSections = ProcessAllSections;
|
|
|
|
}
|
2011-03-21 22:15:52 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
} // end namespace llvm
|
|
|
|
|
|
|
|
#endif
|