2012-01-16 23:50:58 +00:00
|
|
|
//===-- RuntimeDyld.cpp - Run-time dynamic linker for MC-JIT ----*- C++ -*-===//
|
2011-03-21 22:15:52 +00:00
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// Implementation of the MC-JIT runtime dynamic linker.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2011-03-23 19:52:00 +00:00
|
|
|
#define DEBUG_TYPE "dyld"
|
2012-10-02 21:18:39 +00:00
|
|
|
#include "ObjectImageCommon.h"
|
2011-07-13 07:57:58 +00:00
|
|
|
#include "RuntimeDyldImpl.h"
|
2012-01-22 07:05:02 +00:00
|
|
|
#include "RuntimeDyldELF.h"
|
|
|
|
#include "RuntimeDyldMachO.h"
|
2012-01-16 08:56:09 +00:00
|
|
|
#include "llvm/Support/Path.h"
|
2012-10-29 10:47:04 +00:00
|
|
|
#include "llvm/Support/MathExtras.h"
|
2012-01-22 07:05:02 +00:00
|
|
|
|
2011-03-21 22:15:52 +00:00
|
|
|
using namespace llvm;
|
|
|
|
using namespace llvm::object;
|
|
|
|
|
2011-04-05 23:54:31 +00:00
|
|
|
// Empty out-of-line virtual destructor as the key function.
|
|
|
|
RTDyldMemoryManager::~RTDyldMemoryManager() {}
|
2011-07-13 07:57:58 +00:00
|
|
|
RuntimeDyldImpl::~RuntimeDyldImpl() {}
|
2011-04-05 23:54:31 +00:00
|
|
|
|
2011-03-21 22:15:52 +00:00
|
|
|
namespace llvm {
|
|
|
|
|
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
|
|
|
// Resolve the relocations for all symbols we currently know about.
|
|
|
|
void RuntimeDyldImpl::resolveRelocations() {
|
2012-04-12 20:13:57 +00:00
|
|
|
// First, resolve relocations associated with external symbols.
|
2012-04-30 12:15:58 +00:00
|
|
|
resolveExternalSymbols();
|
2012-03-30 16:45:19 +00:00
|
|
|
|
2012-01-16 22:26:39 +00:00
|
|
|
// Just iterate over the sections we have and resolve all the relocations
|
|
|
|
// in them. Gross overkill, but it gets the job done.
|
|
|
|
for (int i = 0, e = Sections.size(); i != e; ++i) {
|
2012-03-30 16:45:19 +00:00
|
|
|
reassignSectionAddress(i, Sections[i].LoadAddress);
|
2012-01-16 22:26:39 +00:00
|
|
|
}
|
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
|
|
|
}
|
|
|
|
|
2012-09-13 21:50:06 +00:00
|
|
|
void RuntimeDyldImpl::mapSectionAddress(const void *LocalAddress,
|
2012-01-16 23:50:55 +00:00
|
|
|
uint64_t TargetAddress) {
|
2012-03-30 16:45:19 +00:00
|
|
|
for (unsigned i = 0, e = Sections.size(); i != e; ++i) {
|
|
|
|
if (Sections[i].Address == LocalAddress) {
|
|
|
|
reassignSectionAddress(i, TargetAddress);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
llvm_unreachable("Attempting to remap address of unknown section!");
|
|
|
|
}
|
|
|
|
|
2012-04-29 12:40:47 +00:00
|
|
|
// Subclasses can implement this method to create specialized image instances.
|
2012-07-23 08:51:15 +00:00
|
|
|
// The caller owns the pointer that is returned.
|
2012-10-02 21:18:39 +00:00
|
|
|
ObjectImage *RuntimeDyldImpl::createObjectImage(ObjectBuffer *InputBuffer) {
|
|
|
|
return new ObjectImageCommon(InputBuffer);
|
2012-04-16 22:12:58 +00:00
|
|
|
}
|
|
|
|
|
2012-10-02 21:18:39 +00:00
|
|
|
ObjectImage *RuntimeDyldImpl::loadObject(ObjectBuffer *InputBuffer) {
|
2012-04-16 22:12:58 +00:00
|
|
|
OwningPtr<ObjectImage> obj(createObjectImage(InputBuffer));
|
2012-04-12 20:13:57 +00:00
|
|
|
if (!obj)
|
|
|
|
report_fatal_error("Unable to create object image from memory buffer!");
|
2012-03-30 16:45:19 +00:00
|
|
|
|
|
|
|
Arch = (Triple::ArchType)obj->getArch();
|
|
|
|
|
2012-05-01 06:58:59 +00:00
|
|
|
// Symbols found in this object
|
|
|
|
StringMap<SymbolLoc> LocalSymbols;
|
|
|
|
// Used sections from the object file
|
|
|
|
ObjSectionToIDMap LocalSections;
|
|
|
|
|
2012-10-29 10:47:04 +00:00
|
|
|
// Common symbols requiring allocation, with their sizes and alignments
|
2012-05-01 06:58:59 +00:00
|
|
|
CommonSymbolMap CommonSymbols;
|
2012-10-29 10:47:04 +00:00
|
|
|
// Maximum required total memory to allocate all common symbols
|
2012-05-01 06:58:59 +00:00
|
|
|
uint64_t CommonSize = 0;
|
2012-03-30 16:45:19 +00:00
|
|
|
|
|
|
|
error_code err;
|
|
|
|
// Parse symbols
|
|
|
|
DEBUG(dbgs() << "Parse symbols:\n");
|
|
|
|
for (symbol_iterator i = obj->begin_symbols(), e = obj->end_symbols();
|
|
|
|
i != e; i.increment(err)) {
|
|
|
|
Check(err);
|
|
|
|
object::SymbolRef::Type SymType;
|
|
|
|
StringRef Name;
|
|
|
|
Check(i->getType(SymType));
|
|
|
|
Check(i->getName(Name));
|
|
|
|
|
2012-04-12 20:13:57 +00:00
|
|
|
uint32_t flags;
|
|
|
|
Check(i->getFlags(flags));
|
|
|
|
|
|
|
|
bool isCommon = flags & SymbolRef::SF_Common;
|
|
|
|
if (isCommon) {
|
|
|
|
// Add the common symbols to a list. We'll allocate them all below.
|
2012-10-29 10:47:04 +00:00
|
|
|
uint64_t Align = getCommonSymbolAlignment(*i);
|
2012-04-12 20:13:57 +00:00
|
|
|
uint64_t Size = 0;
|
|
|
|
Check(i->getSize(Size));
|
2012-10-29 10:47:04 +00:00
|
|
|
CommonSize += Size + Align;
|
|
|
|
CommonSymbols[*i] = CommonSymbolInfo(Size, Align);
|
2012-04-12 20:13:57 +00:00
|
|
|
} else {
|
|
|
|
if (SymType == object::SymbolRef::ST_Function ||
|
2012-08-17 21:28:04 +00:00
|
|
|
SymType == object::SymbolRef::ST_Data ||
|
|
|
|
SymType == object::SymbolRef::ST_Unknown) {
|
2012-04-12 20:13:57 +00:00
|
|
|
uint64_t FileOffset;
|
2012-04-29 12:40:47 +00:00
|
|
|
StringRef SectionData;
|
2012-04-12 20:13:57 +00:00
|
|
|
section_iterator si = obj->end_sections();
|
|
|
|
Check(i->getFileOffset(FileOffset));
|
|
|
|
Check(i->getSection(si));
|
|
|
|
if (si == obj->end_sections()) continue;
|
2012-04-29 12:40:47 +00:00
|
|
|
Check(si->getContents(SectionData));
|
2012-04-12 20:13:57 +00:00
|
|
|
const uint8_t* SymPtr = (const uint8_t*)InputBuffer->getBufferStart() +
|
|
|
|
(uintptr_t)FileOffset;
|
2012-04-29 12:40:47 +00:00
|
|
|
uintptr_t SectOffset = (uintptr_t)(SymPtr -
|
|
|
|
(const uint8_t*)SectionData.begin());
|
2012-04-12 20:13:57 +00:00
|
|
|
unsigned SectionID =
|
2012-04-16 22:12:58 +00:00
|
|
|
findOrEmitSection(*obj,
|
|
|
|
*si,
|
2012-04-12 20:13:57 +00:00
|
|
|
SymType == object::SymbolRef::ST_Function,
|
|
|
|
LocalSections);
|
|
|
|
LocalSymbols[Name.data()] = SymbolLoc(SectionID, SectOffset);
|
|
|
|
DEBUG(dbgs() << "\tFileOffset: " << format("%p", (uintptr_t)FileOffset)
|
|
|
|
<< " flags: " << flags
|
|
|
|
<< " SID: " << SectionID
|
|
|
|
<< " Offset: " << format("%p", SectOffset));
|
2012-04-29 12:40:47 +00:00
|
|
|
bool isGlobal = flags & SymbolRef::SF_Global;
|
2012-04-12 20:13:57 +00:00
|
|
|
if (isGlobal)
|
2012-05-01 06:58:59 +00:00
|
|
|
GlobalSymbolTable[Name] = SymbolLoc(SectionID, SectOffset);
|
2012-04-12 20:13:57 +00:00
|
|
|
}
|
2012-03-30 16:45:19 +00:00
|
|
|
}
|
|
|
|
DEBUG(dbgs() << "\tType: " << SymType << " Name: " << Name << "\n");
|
|
|
|
}
|
|
|
|
|
2012-04-12 20:13:57 +00:00
|
|
|
// Allocate common symbols
|
|
|
|
if (CommonSize != 0)
|
2012-04-16 22:12:58 +00:00
|
|
|
emitCommonSymbols(*obj, CommonSymbols, CommonSize, LocalSymbols);
|
2012-04-12 20:13:57 +00:00
|
|
|
|
2012-04-29 12:40:47 +00:00
|
|
|
// Parse and process relocations
|
2012-03-30 16:45:19 +00:00
|
|
|
DEBUG(dbgs() << "Parse relocations:\n");
|
|
|
|
for (section_iterator si = obj->begin_sections(),
|
|
|
|
se = obj->end_sections(); si != se; si.increment(err)) {
|
|
|
|
Check(err);
|
|
|
|
bool isFirstRelocation = true;
|
|
|
|
unsigned SectionID = 0;
|
|
|
|
StubMap Stubs;
|
|
|
|
|
|
|
|
for (relocation_iterator i = si->begin_relocations(),
|
|
|
|
e = si->end_relocations(); i != e; i.increment(err)) {
|
|
|
|
Check(err);
|
|
|
|
|
2012-04-29 12:40:47 +00:00
|
|
|
// If it's the first relocation in this section, find its SectionID
|
2012-03-30 16:45:19 +00:00
|
|
|
if (isFirstRelocation) {
|
2012-04-16 22:12:58 +00:00
|
|
|
SectionID = findOrEmitSection(*obj, *si, true, LocalSections);
|
2012-03-30 16:45:19 +00:00
|
|
|
DEBUG(dbgs() << "\tSectionID: " << SectionID << "\n");
|
|
|
|
isFirstRelocation = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
ObjRelocationInfo RI;
|
|
|
|
RI.SectionID = SectionID;
|
|
|
|
Check(i->getAdditionalInfo(RI.AdditionalInfo));
|
|
|
|
Check(i->getOffset(RI.Offset));
|
|
|
|
Check(i->getSymbol(RI.Symbol));
|
|
|
|
Check(i->getType(RI.Type));
|
|
|
|
|
|
|
|
DEBUG(dbgs() << "\t\tAddend: " << RI.AdditionalInfo
|
|
|
|
<< " Offset: " << format("%p", (uintptr_t)RI.Offset)
|
|
|
|
<< " Type: " << (uint32_t)(RI.Type & 0xffffffffL)
|
|
|
|
<< "\n");
|
|
|
|
processRelocationRef(RI, *obj, LocalSections, LocalSymbols, Stubs);
|
|
|
|
}
|
|
|
|
}
|
2012-04-16 22:12:58 +00:00
|
|
|
|
2012-10-02 21:18:39 +00:00
|
|
|
return obj.take();
|
2012-01-16 23:50:55 +00:00
|
|
|
}
|
|
|
|
|
2012-05-01 10:41:12 +00:00
|
|
|
void RuntimeDyldImpl::emitCommonSymbols(ObjectImage &Obj,
|
|
|
|
const CommonSymbolMap &CommonSymbols,
|
|
|
|
uint64_t TotalSize,
|
|
|
|
SymbolTableMap &SymbolTable) {
|
2012-04-12 20:13:57 +00:00
|
|
|
// Allocate memory for the section
|
|
|
|
unsigned SectionID = Sections.size();
|
|
|
|
uint8_t *Addr = MemMgr->allocateDataSection(TotalSize, sizeof(void*),
|
|
|
|
SectionID);
|
|
|
|
if (!Addr)
|
|
|
|
report_fatal_error("Unable to allocate memory for common symbols!");
|
|
|
|
uint64_t Offset = 0;
|
2012-10-25 13:13:48 +00:00
|
|
|
Sections.push_back(SectionEntry(StringRef(), Addr, TotalSize, TotalSize, 0));
|
2012-04-12 20:13:57 +00:00
|
|
|
memset(Addr, 0, TotalSize);
|
|
|
|
|
|
|
|
DEBUG(dbgs() << "emitCommonSection SectionID: " << SectionID
|
|
|
|
<< " new addr: " << format("%p", Addr)
|
|
|
|
<< " DataSize: " << TotalSize
|
|
|
|
<< "\n");
|
|
|
|
|
|
|
|
// Assign the address of each symbol
|
2012-05-01 10:41:12 +00:00
|
|
|
for (CommonSymbolMap::const_iterator it = CommonSymbols.begin(),
|
|
|
|
itEnd = CommonSymbols.end(); it != itEnd; it++) {
|
2012-10-29 10:47:04 +00:00
|
|
|
uint64_t Size = it->second.first;
|
|
|
|
uint64_t Align = it->second.second;
|
2012-04-12 20:13:57 +00:00
|
|
|
StringRef Name;
|
|
|
|
it->first.getName(Name);
|
2012-10-29 10:47:04 +00:00
|
|
|
if (Align) {
|
|
|
|
// This symbol has an alignment requirement.
|
|
|
|
uint64_t AlignOffset = OffsetToAlignment((uint64_t)Addr, Align);
|
|
|
|
Addr += AlignOffset;
|
|
|
|
Offset += AlignOffset;
|
|
|
|
DEBUG(dbgs() << "Allocating common symbol " << Name << " address " <<
|
|
|
|
format("0x%x\n", Addr));
|
|
|
|
}
|
2012-04-16 22:12:58 +00:00
|
|
|
Obj.updateSymbolAddress(it->first, (uint64_t)Addr);
|
2012-05-01 10:41:12 +00:00
|
|
|
SymbolTable[Name.data()] = SymbolLoc(SectionID, Offset);
|
2012-04-12 20:13:57 +00:00
|
|
|
Offset += Size;
|
|
|
|
Addr += Size;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-04-16 22:12:58 +00:00
|
|
|
unsigned RuntimeDyldImpl::emitSection(ObjectImage &Obj,
|
|
|
|
const SectionRef &Section,
|
2012-03-30 16:45:19 +00:00
|
|
|
bool IsCode) {
|
|
|
|
|
|
|
|
unsigned StubBufSize = 0,
|
|
|
|
StubSize = getMaxStubSize();
|
|
|
|
error_code err;
|
|
|
|
if (StubSize > 0) {
|
|
|
|
for (relocation_iterator i = Section.begin_relocations(),
|
2012-04-12 20:13:57 +00:00
|
|
|
e = Section.end_relocations(); i != e; i.increment(err), Check(err))
|
2012-03-30 16:45:19 +00:00
|
|
|
StubBufSize += StubSize;
|
|
|
|
}
|
|
|
|
StringRef data;
|
|
|
|
uint64_t Alignment64;
|
|
|
|
Check(Section.getContents(data));
|
|
|
|
Check(Section.getAlignment(Alignment64));
|
|
|
|
|
|
|
|
unsigned Alignment = (unsigned)Alignment64 & 0xffffffffL;
|
2012-04-12 20:13:57 +00:00
|
|
|
bool IsRequired;
|
|
|
|
bool IsVirtual;
|
|
|
|
bool IsZeroInit;
|
|
|
|
uint64_t DataSize;
|
2012-10-25 13:13:48 +00:00
|
|
|
StringRef Name;
|
2012-04-12 20:13:57 +00:00
|
|
|
Check(Section.isRequiredForExecution(IsRequired));
|
|
|
|
Check(Section.isVirtual(IsVirtual));
|
|
|
|
Check(Section.isZeroInit(IsZeroInit));
|
|
|
|
Check(Section.getSize(DataSize));
|
2012-10-25 13:13:48 +00:00
|
|
|
Check(Section.getName(Name));
|
2012-04-12 20:13:57 +00:00
|
|
|
|
|
|
|
unsigned Allocate;
|
2012-03-30 16:45:19 +00:00
|
|
|
unsigned SectionID = Sections.size();
|
2012-04-12 20:13:57 +00:00
|
|
|
uint8_t *Addr;
|
|
|
|
const char *pData = 0;
|
|
|
|
|
|
|
|
// Some sections, such as debug info, don't need to be loaded for execution.
|
|
|
|
// Leave those where they are.
|
|
|
|
if (IsRequired) {
|
|
|
|
Allocate = DataSize + StubBufSize;
|
|
|
|
Addr = IsCode
|
|
|
|
? MemMgr->allocateCodeSection(Allocate, Alignment, SectionID)
|
|
|
|
: MemMgr->allocateDataSection(Allocate, Alignment, SectionID);
|
|
|
|
if (!Addr)
|
|
|
|
report_fatal_error("Unable to allocate section memory!");
|
|
|
|
|
|
|
|
// Virtual sections have no data in the object image, so leave pData = 0
|
|
|
|
if (!IsVirtual)
|
|
|
|
pData = data.data();
|
|
|
|
|
|
|
|
// Zero-initialize or copy the data from the image
|
|
|
|
if (IsZeroInit || IsVirtual)
|
|
|
|
memset(Addr, 0, DataSize);
|
|
|
|
else
|
|
|
|
memcpy(Addr, pData, DataSize);
|
|
|
|
|
|
|
|
DEBUG(dbgs() << "emitSection SectionID: " << SectionID
|
2012-10-25 13:13:48 +00:00
|
|
|
<< " Name: " << Name
|
2012-04-12 20:13:57 +00:00
|
|
|
<< " obj addr: " << format("%p", pData)
|
|
|
|
<< " new addr: " << format("%p", Addr)
|
|
|
|
<< " DataSize: " << DataSize
|
|
|
|
<< " StubBufSize: " << StubBufSize
|
|
|
|
<< " Allocate: " << Allocate
|
|
|
|
<< "\n");
|
2012-04-16 22:12:58 +00:00
|
|
|
Obj.updateSectionAddress(Section, (uint64_t)Addr);
|
2012-04-12 20:13:57 +00:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
// Even if we didn't load the section, we need to record an entry for it
|
2012-04-29 12:40:47 +00:00
|
|
|
// to handle later processing (and by 'handle' I mean don't do anything
|
|
|
|
// with these sections).
|
2012-04-12 20:13:57 +00:00
|
|
|
Allocate = 0;
|
|
|
|
Addr = 0;
|
|
|
|
DEBUG(dbgs() << "emitSection SectionID: " << SectionID
|
2012-10-25 13:13:48 +00:00
|
|
|
<< " Name: " << Name
|
2012-04-12 20:13:57 +00:00
|
|
|
<< " obj addr: " << format("%p", data.data())
|
|
|
|
<< " new addr: 0"
|
|
|
|
<< " DataSize: " << DataSize
|
|
|
|
<< " StubBufSize: " << StubBufSize
|
|
|
|
<< " Allocate: " << Allocate
|
|
|
|
<< "\n");
|
|
|
|
}
|
|
|
|
|
2012-10-25 13:13:48 +00:00
|
|
|
Sections.push_back(SectionEntry(Name, Addr, Allocate, DataSize,
|
|
|
|
(uintptr_t)pData));
|
2012-03-30 16:45:19 +00:00
|
|
|
return SectionID;
|
|
|
|
}
|
|
|
|
|
2012-04-16 22:12:58 +00:00
|
|
|
unsigned RuntimeDyldImpl::findOrEmitSection(ObjectImage &Obj,
|
|
|
|
const SectionRef &Section,
|
2012-03-30 16:45:19 +00:00
|
|
|
bool IsCode,
|
|
|
|
ObjSectionToIDMap &LocalSections) {
|
|
|
|
|
|
|
|
unsigned SectionID = 0;
|
|
|
|
ObjSectionToIDMap::iterator i = LocalSections.find(Section);
|
|
|
|
if (i != LocalSections.end())
|
|
|
|
SectionID = i->second;
|
|
|
|
else {
|
2012-04-16 22:12:58 +00:00
|
|
|
SectionID = emitSection(Obj, Section, IsCode);
|
2012-03-30 16:45:19 +00:00
|
|
|
LocalSections[Section] = SectionID;
|
|
|
|
}
|
|
|
|
return SectionID;
|
|
|
|
}
|
|
|
|
|
2012-05-01 10:41:12 +00:00
|
|
|
void RuntimeDyldImpl::addRelocationForSection(const RelocationEntry &RE,
|
|
|
|
unsigned SectionID) {
|
|
|
|
Relocations[SectionID].push_back(RE);
|
|
|
|
}
|
2012-03-30 16:45:19 +00:00
|
|
|
|
2012-05-01 10:41:12 +00:00
|
|
|
void RuntimeDyldImpl::addRelocationForSymbol(const RelocationEntry &RE,
|
|
|
|
StringRef SymbolName) {
|
|
|
|
// Relocation by symbol. If the symbol is found in the global symbol table,
|
|
|
|
// create an appropriate section relocation. Otherwise, add it to
|
|
|
|
// ExternalSymbolRelocations.
|
|
|
|
SymbolTableMap::const_iterator Loc =
|
|
|
|
GlobalSymbolTable.find(SymbolName);
|
|
|
|
if (Loc == GlobalSymbolTable.end()) {
|
|
|
|
ExternalSymbolRelocations[SymbolName].push_back(RE);
|
2012-04-30 12:15:58 +00:00
|
|
|
} else {
|
2012-05-01 10:41:12 +00:00
|
|
|
// Copy the RE since we want to modify its addend.
|
|
|
|
RelocationEntry RECopy = RE;
|
|
|
|
RECopy.Addend += Loc->second.second;
|
|
|
|
Relocations[Loc->second.first].push_back(RECopy);
|
2012-04-30 12:15:58 +00:00
|
|
|
}
|
2012-03-30 16:45:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
uint8_t *RuntimeDyldImpl::createStubFunction(uint8_t *Addr) {
|
|
|
|
if (Arch == Triple::arm) {
|
2012-08-17 21:28:04 +00:00
|
|
|
// TODO: There is only ARM far stub now. We should add the Thumb stub,
|
|
|
|
// and stubs for branches Thumb - ARM and ARM - Thumb.
|
2012-03-30 16:45:19 +00:00
|
|
|
uint32_t *StubAddr = (uint32_t*)Addr;
|
|
|
|
*StubAddr = 0xe51ff004; // ldr pc,<label>
|
|
|
|
return (uint8_t*)++StubAddr;
|
2012-08-17 21:28:04 +00:00
|
|
|
} else if (Arch == Triple::mipsel) {
|
|
|
|
uint32_t *StubAddr = (uint32_t*)Addr;
|
|
|
|
// 0: 3c190000 lui t9,%hi(addr).
|
|
|
|
// 4: 27390000 addiu t9,t9,%lo(addr).
|
|
|
|
// 8: 03200008 jr t9.
|
|
|
|
// c: 00000000 nop.
|
|
|
|
const unsigned LuiT9Instr = 0x3c190000, AdduiT9Instr = 0x27390000;
|
|
|
|
const unsigned JrT9Instr = 0x03200008, NopInstr = 0x0;
|
|
|
|
|
|
|
|
*StubAddr = LuiT9Instr;
|
|
|
|
StubAddr++;
|
|
|
|
*StubAddr = AdduiT9Instr;
|
|
|
|
StubAddr++;
|
|
|
|
*StubAddr = JrT9Instr;
|
|
|
|
StubAddr++;
|
|
|
|
*StubAddr = NopInstr;
|
2012-10-25 13:13:48 +00:00
|
|
|
return Addr;
|
|
|
|
} else if (Arch == Triple::ppc64) {
|
|
|
|
// PowerPC64 stub: the address points to a function descriptor
|
|
|
|
// instead of the function itself. Load the function address
|
|
|
|
// on r11 and sets it to control register. Also loads the function
|
|
|
|
// TOC in r2 and environment pointer to r11.
|
|
|
|
writeInt32BE(Addr, 0x3D800000); // lis r12, highest(addr)
|
|
|
|
writeInt32BE(Addr+4, 0x618C0000); // ori r12, higher(addr)
|
|
|
|
writeInt32BE(Addr+8, 0x798C07C6); // sldi r12, r12, 32
|
|
|
|
writeInt32BE(Addr+12, 0x658C0000); // oris r12, r12, h(addr)
|
|
|
|
writeInt32BE(Addr+16, 0x618C0000); // ori r12, r12, l(addr)
|
|
|
|
writeInt32BE(Addr+20, 0xF8410028); // std r2, 40(r1)
|
|
|
|
writeInt32BE(Addr+24, 0xE96C0000); // ld r11, 0(r12)
|
|
|
|
writeInt32BE(Addr+28, 0xE84C0008); // ld r2, 0(r12)
|
|
|
|
writeInt32BE(Addr+32, 0x7D6903A6); // mtctr r11
|
|
|
|
writeInt32BE(Addr+36, 0xE96C0010); // ld r11, 16(r2)
|
|
|
|
writeInt32BE(Addr+40, 0x4E800420); // bctr
|
|
|
|
|
2012-03-30 16:45:19 +00:00
|
|
|
return Addr;
|
2012-08-17 21:28:04 +00:00
|
|
|
}
|
|
|
|
return Addr;
|
2012-03-30 16:45:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Assign an address to a symbol name and resolve all the relocations
|
|
|
|
// associated with it.
|
|
|
|
void RuntimeDyldImpl::reassignSectionAddress(unsigned SectionID,
|
|
|
|
uint64_t Addr) {
|
|
|
|
// The address to use for relocation resolution is not
|
|
|
|
// the address of the local section buffer. We must be doing
|
|
|
|
// a remote execution environment of some sort. Re-apply any
|
|
|
|
// relocations referencing this section with the given address.
|
|
|
|
//
|
|
|
|
// Addr is a uint64_t because we can't assume the pointer width
|
|
|
|
// of the target is the same as that of the host. Just use a generic
|
|
|
|
// "big enough" type.
|
|
|
|
Sections[SectionID].LoadAddress = Addr;
|
|
|
|
DEBUG(dbgs() << "Resolving relocations Section #" << SectionID
|
|
|
|
<< "\t" << format("%p", (uint8_t *)Addr)
|
|
|
|
<< "\n");
|
|
|
|
resolveRelocationList(Relocations[SectionID], Addr);
|
|
|
|
}
|
|
|
|
|
|
|
|
void RuntimeDyldImpl::resolveRelocationEntry(const RelocationEntry &RE,
|
|
|
|
uint64_t Value) {
|
2012-10-12 02:04:47 +00:00
|
|
|
// Ignore relocations for sections that were not loaded
|
|
|
|
if (Sections[RE.SectionID].Address != 0) {
|
|
|
|
uint8_t *Target = Sections[RE.SectionID].Address + RE.Offset;
|
|
|
|
DEBUG(dbgs() << "\tSectionID: " << RE.SectionID
|
|
|
|
<< " + " << RE.Offset << " (" << format("%p", Target) << ")"
|
|
|
|
<< " RelType: " << RE.RelType
|
|
|
|
<< " Addend: " << RE.Addend
|
|
|
|
<< "\n");
|
|
|
|
|
|
|
|
resolveRelocation(Target, Sections[RE.SectionID].LoadAddress + RE.Offset,
|
|
|
|
Value, RE.RelType, RE.Addend);
|
2012-04-12 20:13:57 +00:00
|
|
|
}
|
2012-03-30 16:45:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void RuntimeDyldImpl::resolveRelocationList(const RelocationList &Relocs,
|
|
|
|
uint64_t Value) {
|
|
|
|
for (unsigned i = 0, e = Relocs.size(); i != e; ++i) {
|
|
|
|
resolveRelocationEntry(Relocs[i], Value);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-04-30 12:15:58 +00:00
|
|
|
void RuntimeDyldImpl::resolveExternalSymbols() {
|
|
|
|
StringMap<RelocationList>::iterator i = ExternalSymbolRelocations.begin(),
|
|
|
|
e = ExternalSymbolRelocations.end();
|
2012-03-30 16:45:19 +00:00
|
|
|
for (; i != e; i++) {
|
|
|
|
StringRef Name = i->first();
|
|
|
|
RelocationList &Relocs = i->second;
|
2012-05-01 06:58:59 +00:00
|
|
|
SymbolTableMap::const_iterator Loc = GlobalSymbolTable.find(Name);
|
|
|
|
if (Loc == GlobalSymbolTable.end()) {
|
2012-03-30 16:45:19 +00:00
|
|
|
// This is an external symbol, try to get it address from
|
|
|
|
// MemoryManager.
|
|
|
|
uint8_t *Addr = (uint8_t*) MemMgr->getPointerToNamedFunction(Name.data(),
|
|
|
|
true);
|
|
|
|
DEBUG(dbgs() << "Resolving relocations Name: " << Name
|
|
|
|
<< "\t" << format("%p", Addr)
|
|
|
|
<< "\n");
|
|
|
|
resolveRelocationList(Relocs, (uintptr_t)Addr);
|
|
|
|
} else {
|
2012-04-30 12:15:58 +00:00
|
|
|
report_fatal_error("Expected external symbol");
|
2012-03-30 16:45:19 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-03-21 22:15:52 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// RuntimeDyld class implementation
|
2011-07-13 07:57:58 +00:00
|
|
|
RuntimeDyld::RuntimeDyld(RTDyldMemoryManager *mm) {
|
|
|
|
Dyld = 0;
|
|
|
|
MM = mm;
|
2011-03-21 22:15:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
RuntimeDyld::~RuntimeDyld() {
|
|
|
|
delete Dyld;
|
|
|
|
}
|
|
|
|
|
2012-10-02 21:18:39 +00:00
|
|
|
ObjectImage *RuntimeDyld::loadObject(ObjectBuffer *InputBuffer) {
|
2011-07-13 07:57:58 +00:00
|
|
|
if (!Dyld) {
|
2012-01-16 08:56:09 +00:00
|
|
|
sys::LLVMFileType type = sys::IdentifyFileType(
|
|
|
|
InputBuffer->getBufferStart(),
|
|
|
|
static_cast<unsigned>(InputBuffer->getBufferSize()));
|
|
|
|
switch (type) {
|
|
|
|
case sys::ELF_Relocatable_FileType:
|
|
|
|
case sys::ELF_Executable_FileType:
|
|
|
|
case sys::ELF_SharedObject_FileType:
|
|
|
|
case sys::ELF_Core_FileType:
|
|
|
|
Dyld = new RuntimeDyldELF(MM);
|
|
|
|
break;
|
|
|
|
case sys::Mach_O_Object_FileType:
|
|
|
|
case sys::Mach_O_Executable_FileType:
|
|
|
|
case sys::Mach_O_FixedVirtualMemorySharedLib_FileType:
|
|
|
|
case sys::Mach_O_Core_FileType:
|
|
|
|
case sys::Mach_O_PreloadExecutable_FileType:
|
|
|
|
case sys::Mach_O_DynamicallyLinkedSharedLib_FileType:
|
|
|
|
case sys::Mach_O_DynamicLinker_FileType:
|
|
|
|
case sys::Mach_O_Bundle_FileType:
|
|
|
|
case sys::Mach_O_DynamicallyLinkedSharedLibStub_FileType:
|
|
|
|
case sys::Mach_O_DSYMCompanion_FileType:
|
|
|
|
Dyld = new RuntimeDyldMachO(MM);
|
|
|
|
break;
|
|
|
|
case sys::Unknown_FileType:
|
|
|
|
case sys::Bitcode_FileType:
|
|
|
|
case sys::Archive_FileType:
|
|
|
|
case sys::COFF_FileType:
|
|
|
|
report_fatal_error("Incompatible object format!");
|
|
|
|
}
|
2011-07-13 07:57:58 +00:00
|
|
|
} else {
|
2012-01-16 08:56:09 +00:00
|
|
|
if (!Dyld->isCompatibleFormat(InputBuffer))
|
2011-07-13 07:57:58 +00:00
|
|
|
report_fatal_error("Incompatible object format!");
|
|
|
|
}
|
|
|
|
|
2011-03-21 22:15:52 +00:00
|
|
|
return Dyld->loadObject(InputBuffer);
|
|
|
|
}
|
|
|
|
|
2011-04-08 17:31:24 +00:00
|
|
|
void *RuntimeDyld::getSymbolAddress(StringRef Name) {
|
2011-03-21 22:15:52 +00:00
|
|
|
return Dyld->getSymbolAddress(Name);
|
|
|
|
}
|
|
|
|
|
2012-09-05 16:50:40 +00:00
|
|
|
uint64_t RuntimeDyld::getSymbolLoadAddress(StringRef Name) {
|
|
|
|
return Dyld->getSymbolLoadAddress(Name);
|
|
|
|
}
|
|
|
|
|
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 RuntimeDyld::resolveRelocations() {
|
|
|
|
Dyld->resolveRelocations();
|
|
|
|
}
|
|
|
|
|
2012-01-16 22:26:39 +00:00
|
|
|
void RuntimeDyld::reassignSectionAddress(unsigned SectionID,
|
|
|
|
uint64_t Addr) {
|
|
|
|
Dyld->reassignSectionAddress(SectionID, Addr);
|
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
|
|
|
}
|
|
|
|
|
2012-09-13 21:50:06 +00:00
|
|
|
void RuntimeDyld::mapSectionAddress(const void *LocalAddress,
|
2012-01-16 23:50:55 +00:00
|
|
|
uint64_t TargetAddress) {
|
|
|
|
Dyld->mapSectionAddress(LocalAddress, TargetAddress);
|
|
|
|
}
|
|
|
|
|
2011-03-22 18:22:27 +00:00
|
|
|
StringRef RuntimeDyld::getErrorString() {
|
2011-03-22 18:19:42 +00:00
|
|
|
return Dyld->getErrorString();
|
|
|
|
}
|
|
|
|
|
2011-03-21 22:15:52 +00:00
|
|
|
} // end namespace llvm
|