[llvm] r204507 - [RuntimeDyld] clang-format files.
Juergen Ributzka
juergen at apple.com
Fri Mar 21 13:28:42 PDT 2014
Author: ributzka
Date: Fri Mar 21 15:28:42 2014
New Revision: 204507
URL: http://llvm.org/viewvc/llvm-project?rev=204507&view=rev
Log:
[RuntimeDyld] clang-format files.
Modified:
llvm/trunk/lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp
llvm/trunk/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.cpp
llvm/trunk/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.h
llvm/trunk/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldImpl.h
llvm/trunk/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp
llvm/trunk/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.h
Modified: llvm/trunk/lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp?rev=204507&r1=204506&r2=204507&view=diff
==============================================================================
--- llvm/trunk/lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp (original)
+++ llvm/trunk/lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp Fri Mar 21 15:28:42 2014
@@ -35,11 +35,9 @@ void ObjectImageCommon::anchor() {}
namespace llvm {
-void RuntimeDyldImpl::registerEHFrames() {
-}
+void RuntimeDyldImpl::registerEHFrames() {}
-void RuntimeDyldImpl::deregisterEHFrames() {
-}
+void RuntimeDyldImpl::deregisterEHFrames() {}
// Resolve the relocations for all symbols we currently know about.
void RuntimeDyldImpl::resolveRelocations() {
@@ -55,9 +53,8 @@ void RuntimeDyldImpl::resolveRelocations
// symbol for the relocation is located. The SectionID in the relocation
// entry provides the section to which the relocation will be applied.
uint64_t Addr = Sections[i].LoadAddress;
- DEBUG(dbgs() << "Resolving relocations Section #" << i
- << "\t" << format("%p", (uint8_t *)Addr)
- << "\n");
+ DEBUG(dbgs() << "Resolving relocations Section #" << i << "\t"
+ << format("%p", (uint8_t *)Addr) << "\n");
resolveRelocationList(Relocations[i], Addr);
Relocations.erase(i);
}
@@ -75,7 +72,7 @@ void RuntimeDyldImpl::mapSectionAddress(
llvm_unreachable("Attempting to remap address of unknown section!");
}
-ObjectImage* RuntimeDyldImpl::loadObject(ObjectImage *InputObject) {
+ObjectImage *RuntimeDyldImpl::loadObject(ObjectImage *InputObject) {
MutexGuard locked(lock);
std::unique_ptr<ObjectImage> Obj(InputObject);
@@ -85,7 +82,7 @@ ObjectImage* RuntimeDyldImpl::loadObject
// Save information about our target
Arch = (Triple::ArchType)Obj->getArch();
IsTargetLittleEndian = Obj->getObjectFile()->isLittleEndian();
-
+
// Compute the memory size required to load all sections to be loaded
// and pass this information to the memory manager
if (MemMgr->needsToReserveAllocationSpace()) {
@@ -93,7 +90,7 @@ ObjectImage* RuntimeDyldImpl::loadObject
computeTotalAllocSize(*Obj, CodeSize, DataSizeRO, DataSizeRW);
MemMgr->reserveAllocationSpace(CodeSize, DataSizeRO, DataSizeRW);
}
-
+
// Symbols found in this object
StringMap<SymbolLoc> LocalSymbols;
// Used sections from the object file
@@ -134,18 +131,19 @@ ObjectImage* RuntimeDyldImpl::loadObject
section_iterator SI = Obj->end_sections();
Check(I->getFileOffset(FileOffset));
Check(I->getSection(SI));
- if (SI == Obj->end_sections()) continue;
+ if (SI == Obj->end_sections())
+ continue;
Check(SI->getContents(SectionData));
Check(SI->isText(IsCode));
- const uint8_t* SymPtr = (const uint8_t*)Obj->getData().data() +
- (uintptr_t)FileOffset;
- uintptr_t SectOffset = (uintptr_t)(SymPtr -
- (const uint8_t*)SectionData.begin());
- unsigned SectionID = findOrEmitSection(*Obj, *SI, IsCode, LocalSections);
+ const uint8_t *SymPtr =
+ (const uint8_t *)Obj->getData().data() + (uintptr_t)FileOffset;
+ uintptr_t SectOffset =
+ (uintptr_t)(SymPtr - (const uint8_t *)SectionData.begin());
+ unsigned SectionID =
+ findOrEmitSection(*Obj, *SI, IsCode, LocalSections);
LocalSymbols[Name.data()] = SymbolLoc(SectionID, SectOffset);
DEBUG(dbgs() << "\tFileOffset: " << format("%p", (uintptr_t)FileOffset)
- << " flags: " << Flags
- << " SID: " << SectionID
+ << " flags: " << Flags << " SID: " << SectionID
<< " Offset: " << format("%p", SectOffset));
GlobalSymbolTable[Name] = SymbolLoc(SectionID, SectOffset);
}
@@ -171,7 +169,7 @@ ObjectImage* RuntimeDyldImpl::loadObject
bool IsCode = false;
Check(RelocatedSection->isText(IsCode));
SectionID =
- findOrEmitSection(*Obj, *RelocatedSection, IsCode, LocalSections);
+ findOrEmitSection(*Obj, *RelocatedSection, IsCode, LocalSections);
DEBUG(dbgs() << "\tSectionID: " << SectionID << "\n");
for (relocation_iterator I = SI->relocation_begin(),
@@ -187,37 +185,41 @@ ObjectImage* RuntimeDyldImpl::loadObject
}
// A helper method for computeTotalAllocSize.
-// Computes the memory size required to allocate sections with the given sizes,
+// Computes the memory size required to allocate sections with the given sizes,
// assuming that all sections are allocated with the given alignment
-static uint64_t computeAllocationSizeForSections(std::vector<uint64_t>& SectionSizes,
- uint64_t Alignment) {
+static uint64_t
+computeAllocationSizeForSections(std::vector<uint64_t> &SectionSizes,
+ uint64_t Alignment) {
uint64_t TotalSize = 0;
for (size_t Idx = 0, Cnt = SectionSizes.size(); Idx < Cnt; Idx++) {
- uint64_t AlignedSize = (SectionSizes[Idx] + Alignment - 1) /
- Alignment * Alignment;
+ uint64_t AlignedSize =
+ (SectionSizes[Idx] + Alignment - 1) / Alignment * Alignment;
TotalSize += AlignedSize;
}
return TotalSize;
}
-// Compute an upper bound of the memory size that is required to load all sections
-void RuntimeDyldImpl::computeTotalAllocSize(ObjectImage &Obj,
- uint64_t& CodeSize, uint64_t& DataSizeRO, uint64_t& DataSizeRW) {
+// Compute an upper bound of the memory size that is required to load all
+// sections
+void RuntimeDyldImpl::computeTotalAllocSize(ObjectImage &Obj,
+ uint64_t &CodeSize,
+ uint64_t &DataSizeRO,
+ uint64_t &DataSizeRW) {
// Compute the size of all sections required for execution
std::vector<uint64_t> CodeSectionSizes;
std::vector<uint64_t> ROSectionSizes;
std::vector<uint64_t> RWSectionSizes;
- uint64_t MaxAlignment = sizeof(void*);
+ uint64_t MaxAlignment = sizeof(void *);
- // Collect sizes of all sections to be loaded;
+ // Collect sizes of all sections to be loaded;
// also determine the max alignment of all sections
- for (section_iterator SI = Obj.begin_sections(), SE = Obj.end_sections();
+ for (section_iterator SI = Obj.begin_sections(), SE = Obj.end_sections();
SI != SE; ++SI) {
const SectionRef &Section = *SI;
bool IsRequired;
Check(Section.isRequiredForExecution(IsRequired));
-
+
// Consider only the sections that are required to be loaded for execution
if (IsRequired) {
uint64_t DataSize = 0;
@@ -230,17 +232,19 @@ void RuntimeDyldImpl::computeTotalAllocS
Check(Section.isText(IsCode));
Check(Section.isReadOnlyData(IsReadOnly));
Check(Section.getName(Name));
- unsigned Alignment = (unsigned) Alignment64 & 0xffffffffL;
-
+ unsigned Alignment = (unsigned)Alignment64 & 0xffffffffL;
+
uint64_t StubBufSize = computeSectionStubBufSize(Obj, Section);
uint64_t SectionSize = DataSize + StubBufSize;
-
- // The .eh_frame section (at least on Linux) needs an extra four bytes padded
+
+ // The .eh_frame section (at least on Linux) needs an extra four bytes
+ // padded
// with zeroes added at the end. For MachO objects, this section has a
- // slightly different name, so this won't have any effect for MachO objects.
+ // slightly different name, so this won't have any effect for MachO
+ // objects.
if (Name == ".eh_frame")
SectionSize += 4;
-
+
if (SectionSize > 0) {
// save the total size of the section
if (IsCode) {
@@ -254,14 +258,14 @@ void RuntimeDyldImpl::computeTotalAllocS
if (Alignment > MaxAlignment) {
MaxAlignment = Alignment;
}
- }
+ }
}
}
// Compute the size of all common symbols
uint64_t CommonSize = 0;
- for (symbol_iterator I = Obj.begin_symbols(), E = Obj.end_symbols();
- I != E; ++I) {
+ for (symbol_iterator I = Obj.begin_symbols(), E = Obj.end_symbols(); I != E;
+ ++I) {
uint32_t Flags = I->getFlags();
if (Flags & SymbolRef::SF_Common) {
// Add the common symbols to a list. We'll allocate them all below.
@@ -274,29 +278,28 @@ void RuntimeDyldImpl::computeTotalAllocS
RWSectionSizes.push_back(CommonSize);
}
- // Compute the required allocation space for each different type of sections
- // (code, read-only data, read-write data) assuming that all sections are
+ // Compute the required allocation space for each different type of sections
+ // (code, read-only data, read-write data) assuming that all sections are
// allocated with the max alignment. Note that we cannot compute with the
- // individual alignments of the sections, because then the required size
+ // individual alignments of the sections, because then the required size
// depends on the order, in which the sections are allocated.
CodeSize = computeAllocationSizeForSections(CodeSectionSizes, MaxAlignment);
DataSizeRO = computeAllocationSizeForSections(ROSectionSizes, MaxAlignment);
- DataSizeRW = computeAllocationSizeForSections(RWSectionSizes, MaxAlignment);
+ DataSizeRW = computeAllocationSizeForSections(RWSectionSizes, MaxAlignment);
}
// compute stub buffer size for the given section
-unsigned RuntimeDyldImpl::computeSectionStubBufSize(ObjectImage &Obj,
+unsigned RuntimeDyldImpl::computeSectionStubBufSize(ObjectImage &Obj,
const SectionRef &Section) {
unsigned StubSize = getMaxStubSize();
if (StubSize == 0) {
- return 0;
+ return 0;
}
// FIXME: this is an inefficient way to handle this. We should computed the
// necessary section allocation size in loadObject by walking all the sections
// once.
unsigned StubBufSize = 0;
- for (section_iterator SI = Obj.begin_sections(),
- SE = Obj.end_sections();
+ for (section_iterator SI = Obj.begin_sections(), SE = Obj.end_sections();
SI != SE; ++SI) {
section_iterator RelSecI = SI->getRelocatedSection();
if (!(RelSecI == Section))
@@ -319,7 +322,7 @@ unsigned RuntimeDyldImpl::computeSection
unsigned StubAlignment = getStubAlignment();
unsigned EndAlignment = (DataSize | Alignment) & -(DataSize | Alignment);
if (StubAlignment > EndAlignment)
- StubBufSize += StubAlignment - EndAlignment;
+ StubBufSize += StubAlignment - EndAlignment;
return StubBufSize;
}
@@ -329,22 +332,20 @@ void RuntimeDyldImpl::emitCommonSymbols(
SymbolTableMap &SymbolTable) {
// Allocate memory for the section
unsigned SectionID = Sections.size();
- uint8_t *Addr = MemMgr->allocateDataSection(
- TotalSize, sizeof(void*), SectionID, StringRef(), false);
+ uint8_t *Addr = MemMgr->allocateDataSection(TotalSize, sizeof(void *),
+ SectionID, StringRef(), false);
if (!Addr)
report_fatal_error("Unable to allocate memory for common symbols!");
uint64_t Offset = 0;
Sections.push_back(SectionEntry(StringRef(), Addr, TotalSize, 0));
memset(Addr, 0, TotalSize);
- DEBUG(dbgs() << "emitCommonSection SectionID: " << SectionID
- << " new addr: " << format("%p", Addr)
- << " DataSize: " << TotalSize
- << "\n");
+ DEBUG(dbgs() << "emitCommonSection SectionID: " << SectionID << " new addr: "
+ << format("%p", Addr) << " DataSize: " << TotalSize << "\n");
// Assign the address of each symbol
for (CommonSymbolMap::const_iterator it = CommonSymbols.begin(),
- itEnd = CommonSymbols.end(); it != itEnd; it++) {
+ itEnd = CommonSymbols.end(); it != itEnd; ++it) {
uint64_t Size = it->second.first;
uint64_t Align = it->second.second;
StringRef Name;
@@ -354,8 +355,8 @@ void RuntimeDyldImpl::emitCommonSymbols(
uint64_t AlignOffset = OffsetToAlignment((uint64_t)Addr, Align);
Addr += AlignOffset;
Offset += AlignOffset;
- DEBUG(dbgs() << "Allocating common symbol " << Name << " address " <<
- format("%p\n", Addr));
+ DEBUG(dbgs() << "Allocating common symbol " << Name << " address "
+ << format("%p\n", Addr));
}
Obj.updateSymbolAddress(it->first, (uint64_t)Addr);
SymbolTable[Name.data()] = SymbolLoc(SectionID, Offset);
@@ -365,8 +366,7 @@ void RuntimeDyldImpl::emitCommonSymbols(
}
unsigned RuntimeDyldImpl::emitSection(ObjectImage &Obj,
- const SectionRef &Section,
- bool IsCode) {
+ const SectionRef &Section, bool IsCode) {
StringRef data;
uint64_t Alignment64;
@@ -388,8 +388,8 @@ unsigned RuntimeDyldImpl::emitSection(Ob
Check(Section.isReadOnlyData(IsReadOnly));
Check(Section.getSize(DataSize));
Check(Section.getName(Name));
-
- StubBufSize = computeSectionStubBufSize(Obj, Section);
+
+ StubBufSize = computeSectionStubBufSize(Obj, Section);
// The .eh_frame section (at least on Linux) needs an extra four bytes padded
// with zeroes added at the end. For MachO objects, this section has a
@@ -406,10 +406,10 @@ unsigned RuntimeDyldImpl::emitSection(Ob
// Leave those where they are.
if (IsRequired) {
Allocate = DataSize + PaddingSize + StubBufSize;
- Addr = IsCode
- ? MemMgr->allocateCodeSection(Allocate, Alignment, SectionID, Name)
- : MemMgr->allocateDataSection(Allocate, Alignment, SectionID, Name,
- IsReadOnly);
+ Addr = IsCode ? MemMgr->allocateCodeSection(Allocate, Alignment, SectionID,
+ Name)
+ : MemMgr->allocateDataSection(Allocate, Alignment, SectionID,
+ Name, IsReadOnly);
if (!Addr)
report_fatal_error("Unable to allocate section memory!");
@@ -430,30 +430,22 @@ unsigned RuntimeDyldImpl::emitSection(Ob
DataSize += PaddingSize;
}
- DEBUG(dbgs() << "emitSection SectionID: " << SectionID
- << " Name: " << Name
+ DEBUG(dbgs() << "emitSection SectionID: " << SectionID << " Name: " << Name
<< " obj addr: " << format("%p", pData)
<< " new addr: " << format("%p", Addr)
- << " DataSize: " << DataSize
- << " StubBufSize: " << StubBufSize
- << " Allocate: " << Allocate
- << "\n");
+ << " DataSize: " << DataSize << " StubBufSize: " << StubBufSize
+ << " Allocate: " << Allocate << "\n");
Obj.updateSectionAddress(Section, (uint64_t)Addr);
- }
- else {
+ } else {
// Even if we didn't load the section, we need to record an entry for it
// to handle later processing (and by 'handle' I mean don't do anything
// with these sections).
Allocate = 0;
Addr = 0;
- DEBUG(dbgs() << "emitSection SectionID: " << SectionID
- << " Name: " << Name
- << " obj addr: " << format("%p", data.data())
- << " new addr: 0"
- << " DataSize: " << DataSize
- << " StubBufSize: " << StubBufSize
- << " Allocate: " << Allocate
- << "\n");
+ DEBUG(dbgs() << "emitSection SectionID: " << SectionID << " Name: " << Name
+ << " obj addr: " << format("%p", data.data()) << " new addr: 0"
+ << " DataSize: " << DataSize << " StubBufSize: " << StubBufSize
+ << " Allocate: " << Allocate << "\n");
}
Sections.push_back(SectionEntry(Name, Addr, DataSize, (uintptr_t)pData));
@@ -486,8 +478,7 @@ void RuntimeDyldImpl::addRelocationForSy
// 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);
+ SymbolTableMap::const_iterator Loc = GlobalSymbolTable.find(SymbolName);
if (Loc == GlobalSymbolTable.end()) {
ExternalSymbolRelocations[SymbolName].push_back(RE);
} else {
@@ -503,7 +494,7 @@ uint8_t *RuntimeDyldImpl::createStubFunc
// This stub has to be able to access the full address space,
// since symbol lookup won't necessarily find a handy, in-range,
// PLT stub for functions which could be anywhere.
- uint32_t *StubAddr = (uint32_t*)Addr;
+ uint32_t *StubAddr = (uint32_t *)Addr;
// Stub can use ip0 (== x16) to calculate address
*StubAddr = 0xd2e00010; // movz ip0, #:abs_g3:<addr>
@@ -520,11 +511,11 @@ uint8_t *RuntimeDyldImpl::createStubFunc
} else if (Arch == Triple::arm) {
// TODO: There is only ARM far stub now. We should add the Thumb stub,
// and stubs for branches Thumb - ARM and ARM - Thumb.
- uint32_t *StubAddr = (uint32_t*)Addr;
+ uint32_t *StubAddr = (uint32_t *)Addr;
*StubAddr = 0xe51ff004; // ldr pc,<label>
- return (uint8_t*)++StubAddr;
+ return (uint8_t *)++StubAddr;
} else if (Arch == Triple::mipsel || Arch == Triple::mips) {
- uint32_t *StubAddr = (uint32_t*)Addr;
+ uint32_t *StubAddr = (uint32_t *)Addr;
// 0: 3c190000 lui t9,%hi(addr).
// 4: 27390000 addiu t9,t9,%lo(addr).
// 8: 03200008 jr t9.
@@ -602,29 +593,30 @@ void RuntimeDyldImpl::resolveRelocationL
}
void RuntimeDyldImpl::resolveExternalSymbols() {
- while(!ExternalSymbolRelocations.empty()) {
+ while (!ExternalSymbolRelocations.empty()) {
StringMap<RelocationList>::iterator i = ExternalSymbolRelocations.begin();
StringRef Name = i->first();
if (Name.size() == 0) {
// This is an absolute symbol, use an address of zero.
- DEBUG(dbgs() << "Resolving absolute relocations." << "\n");
+ DEBUG(dbgs() << "Resolving absolute relocations."
+ << "\n");
RelocationList &Relocs = i->second;
resolveRelocationList(Relocs, 0);
} else {
uint64_t Addr = 0;
SymbolTableMap::const_iterator Loc = GlobalSymbolTable.find(Name);
if (Loc == GlobalSymbolTable.end()) {
- // This is an external symbol, try to get its address from
- // MemoryManager.
- Addr = MemMgr->getSymbolAddress(Name.data());
- // The call to getSymbolAddress may have caused additional modules to
- // be loaded, which may have added new entries to the
- // ExternalSymbolRelocations map. Consquently, we need to update our
- // iterator. This is also why retrieval of the relocation list
- // associated with this symbol is deferred until below this point.
- // New entries may have been added to the relocation list.
- i = ExternalSymbolRelocations.find(Name);
+ // This is an external symbol, try to get its address from
+ // MemoryManager.
+ Addr = MemMgr->getSymbolAddress(Name.data());
+ // The call to getSymbolAddress may have caused additional modules to
+ // be loaded, which may have added new entries to the
+ // ExternalSymbolRelocations map. Consquently, we need to update our
+ // iterator. This is also why retrieval of the relocation list
+ // associated with this symbol is deferred until below this point.
+ // New entries may have been added to the relocation list.
+ i = ExternalSymbolRelocations.find(Name);
} else {
// We found the symbol in our global table. It was probably in a
// Module that we loaded previously.
@@ -635,12 +627,11 @@ void RuntimeDyldImpl::resolveExternalSym
// FIXME: Implement error handling that doesn't kill the host program!
if (!Addr)
report_fatal_error("Program used external function '" + Name +
- "' which could not be resolved!");
+ "' which could not be resolved!");
updateGOTEntries(Name, Addr);
- DEBUG(dbgs() << "Resolving relocations Name: " << Name
- << "\t" << format("0x%lx", Addr)
- << "\n");
+ DEBUG(dbgs() << "Resolving relocations Name: " << Name << "\t"
+ << format("0x%lx", Addr) << "\n");
// This list may have been updated when we called getSymbolAddress, so
// don't change this code to get the list earlier.
RelocationList &Relocs = i->second;
@@ -651,7 +642,6 @@ void RuntimeDyldImpl::resolveExternalSym
}
}
-
//===----------------------------------------------------------------------===//
// RuntimeDyld class implementation
RuntimeDyld::RuntimeDyld(RTDyldMemoryManager *mm) {
@@ -666,21 +656,17 @@ RuntimeDyld::RuntimeDyld(RTDyldMemoryMan
ProcessAllSections = false;
}
-RuntimeDyld::~RuntimeDyld() {
- delete Dyld;
-}
+RuntimeDyld::~RuntimeDyld() { delete Dyld; }
-static std::unique_ptr<RuntimeDyldELF> createRuntimeDyldELF(
- RTDyldMemoryManager *MM,
- bool ProcessAllSections) {
+static std::unique_ptr<RuntimeDyldELF>
+createRuntimeDyldELF(RTDyldMemoryManager *MM, bool ProcessAllSections) {
std::unique_ptr<RuntimeDyldELF> Dyld(new RuntimeDyldELF(MM));
Dyld->setProcessAllSections(ProcessAllSections);
return Dyld;
}
-static std::unique_ptr<RuntimeDyldMachO> createRuntimeDyldMachO(
- RTDyldMemoryManager *MM,
- bool ProcessAllSections) {
+static std::unique_ptr<RuntimeDyldMachO>
+createRuntimeDyldMachO(RTDyldMemoryManager *MM, bool ProcessAllSections) {
std::unique_ptr<RuntimeDyldMachO> Dyld(new RuntimeDyldMachO(MM));
Dyld->setProcessAllSections(ProcessAllSections);
return Dyld;
@@ -709,8 +695,7 @@ ObjectImage *RuntimeDyld::loadObject(Obj
ObjectImage *RuntimeDyld::loadObject(ObjectBuffer *InputBuffer) {
std::unique_ptr<ObjectImage> InputImage;
- sys::fs::file_magic Type =
- sys::fs::identify_magic(InputBuffer->getBuffer());
+ sys::fs::file_magic Type = sys::fs::identify_magic(InputBuffer->getBuffer());
switch (Type) {
case sys::fs::file_magic::elf_relocatable:
@@ -765,12 +750,9 @@ uint64_t RuntimeDyld::getSymbolLoadAddre
return Dyld->getSymbolLoadAddress(Name);
}
-void RuntimeDyld::resolveRelocations() {
- Dyld->resolveRelocations();
-}
+void RuntimeDyld::resolveRelocations() { Dyld->resolveRelocations(); }
-void RuntimeDyld::reassignSectionAddress(unsigned SectionID,
- uint64_t Addr) {
+void RuntimeDyld::reassignSectionAddress(unsigned SectionID, uint64_t Addr) {
Dyld->reassignSectionAddress(SectionID, Addr);
}
@@ -779,9 +761,7 @@ void RuntimeDyld::mapSectionAddress(cons
Dyld->mapSectionAddress(LocalAddress, TargetAddress);
}
-StringRef RuntimeDyld::getErrorString() {
- return Dyld->getErrorString();
-}
+StringRef RuntimeDyld::getErrorString() { return Dyld->getErrorString(); }
void RuntimeDyld::registerEHFrames() {
if (Dyld)
Modified: llvm/trunk/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.cpp?rev=204507&r1=204506&r2=204507&view=diff
==============================================================================
--- llvm/trunk/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.cpp (original)
+++ llvm/trunk/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.cpp Fri Mar 21 15:28:42 2014
@@ -31,30 +31,24 @@ using namespace llvm::object;
namespace {
-static inline
-error_code check(error_code Err) {
+static inline error_code check(error_code Err) {
if (Err) {
report_fatal_error(Err.message());
}
return Err;
}
-template<class ELFT>
-class DyldELFObject
- : public ELFObjectFile<ELFT> {
+template <class ELFT> class DyldELFObject : public ELFObjectFile<ELFT> {
LLVM_ELF_IMPORT_TYPES_ELFT(ELFT)
typedef Elf_Shdr_Impl<ELFT> Elf_Shdr;
typedef Elf_Sym_Impl<ELFT> Elf_Sym;
- typedef
- Elf_Rel_Impl<ELFT, false> Elf_Rel;
- typedef
- Elf_Rel_Impl<ELFT, true> Elf_Rela;
+ typedef Elf_Rel_Impl<ELFT, false> Elf_Rel;
+ typedef Elf_Rel_Impl<ELFT, true> Elf_Rela;
typedef Elf_Ehdr_Impl<ELFT> Elf_Ehdr;
- typedef typename ELFDataTypeTypedefHelper<
- ELFT>::value_type addr_type;
+ typedef typename ELFDataTypeTypedefHelper<ELFT>::value_type addr_type;
public:
DyldELFObject(MemoryBuffer *Wrapper, error_code &ec);
@@ -64,80 +58,74 @@ public:
// Methods for type inquiry through isa, cast and dyn_cast
static inline bool classof(const Binary *v) {
- return (isa<ELFObjectFile<ELFT> >(v)
- && classof(cast<ELFObjectFile
- <ELFT> >(v)));
+ return (isa<ELFObjectFile<ELFT>>(v) &&
+ classof(cast<ELFObjectFile<ELFT>>(v)));
}
- static inline bool classof(
- const ELFObjectFile<ELFT> *v) {
+ static inline bool classof(const ELFObjectFile<ELFT> *v) {
return v->isDyldType();
}
};
-template<class ELFT>
-class ELFObjectImage : public ObjectImageCommon {
- protected:
- DyldELFObject<ELFT> *DyldObj;
- bool Registered;
-
- public:
- ELFObjectImage(ObjectBuffer *Input,
- DyldELFObject<ELFT> *Obj)
- : ObjectImageCommon(Input, Obj),
- DyldObj(Obj),
- Registered(false) {}
-
- virtual ~ELFObjectImage() {
- if (Registered)
- deregisterWithDebugger();
- }
+template <class ELFT> class ELFObjectImage : public ObjectImageCommon {
+protected:
+ DyldELFObject<ELFT> *DyldObj;
+ bool Registered;
- // Subclasses can override these methods to update the image with loaded
- // addresses for sections and common symbols
- void updateSectionAddress(const SectionRef &Sec, uint64_t Addr) override {
- DyldObj->updateSectionAddress(Sec, Addr);
- }
+public:
+ ELFObjectImage(ObjectBuffer *Input, DyldELFObject<ELFT> *Obj)
+ : ObjectImageCommon(Input, Obj), DyldObj(Obj), Registered(false) {}
- void updateSymbolAddress(const SymbolRef &Sym, uint64_t Addr) override {
- DyldObj->updateSymbolAddress(Sym, Addr);
- }
+ virtual ~ELFObjectImage() {
+ if (Registered)
+ deregisterWithDebugger();
+ }
- void registerWithDebugger() override {
- JITRegistrar::getGDBRegistrar().registerObject(*Buffer);
- Registered = true;
- }
- void deregisterWithDebugger() override {
- JITRegistrar::getGDBRegistrar().deregisterObject(*Buffer);
- }
+ // Subclasses can override these methods to update the image with loaded
+ // addresses for sections and common symbols
+ void updateSectionAddress(const SectionRef &Sec, uint64_t Addr) override {
+ DyldObj->updateSectionAddress(Sec, Addr);
+ }
+
+ void updateSymbolAddress(const SymbolRef &Sym, uint64_t Addr) override {
+ DyldObj->updateSymbolAddress(Sym, Addr);
+ }
+
+ void registerWithDebugger() override {
+ JITRegistrar::getGDBRegistrar().registerObject(*Buffer);
+ Registered = true;
+ }
+ void deregisterWithDebugger() override {
+ JITRegistrar::getGDBRegistrar().deregisterObject(*Buffer);
+ }
};
// The MemoryBuffer passed into this constructor is just a wrapper around the
// actual memory. Ultimately, the Binary parent class will take ownership of
// this MemoryBuffer object but not the underlying memory.
-template<class ELFT>
+template <class ELFT>
DyldELFObject<ELFT>::DyldELFObject(MemoryBuffer *Wrapper, error_code &ec)
- : ELFObjectFile<ELFT>(Wrapper, ec) {
+ : ELFObjectFile<ELFT>(Wrapper, ec) {
this->isDyldELFObject = true;
}
-template<class ELFT>
+template <class ELFT>
void DyldELFObject<ELFT>::updateSectionAddress(const SectionRef &Sec,
uint64_t Addr) {
DataRefImpl ShdrRef = Sec.getRawDataRefImpl();
- Elf_Shdr *shdr = const_cast<Elf_Shdr*>(
- reinterpret_cast<const Elf_Shdr *>(ShdrRef.p));
+ Elf_Shdr *shdr =
+ const_cast<Elf_Shdr *>(reinterpret_cast<const Elf_Shdr *>(ShdrRef.p));
// This assumes the address passed in matches the target address bitness
// The template-based type cast handles everything else.
shdr->sh_addr = static_cast<addr_type>(Addr);
}
-template<class ELFT>
+template <class ELFT>
void DyldELFObject<ELFT>::updateSymbolAddress(const SymbolRef &SymRef,
uint64_t Addr) {
- Elf_Sym *sym = const_cast<Elf_Sym*>(
- ELFObjectFile<ELFT>::getSymbol(SymRef.getRawDataRefImpl()));
+ Elf_Sym *sym = const_cast<Elf_Sym *>(
+ ELFObjectFile<ELFT>::getSymbol(SymRef.getRawDataRefImpl()));
// This assumes the address passed in matches the target address bitness
// The template-based type cast handles everything else.
@@ -175,93 +163,85 @@ void RuntimeDyldELF::deregisterEHFrames(
RegisteredEHFrameSections.clear();
}
-ObjectImage *RuntimeDyldELF::createObjectImageFromFile(object::ObjectFile *ObjFile) {
+ObjectImage *
+RuntimeDyldELF::createObjectImageFromFile(object::ObjectFile *ObjFile) {
if (!ObjFile)
return NULL;
error_code ec;
- MemoryBuffer* Buffer = MemoryBuffer::getMemBuffer(ObjFile->getData(),
- "",
- false);
+ MemoryBuffer *Buffer =
+ MemoryBuffer::getMemBuffer(ObjFile->getData(), "", false);
if (ObjFile->getBytesInAddress() == 4 && ObjFile->isLittleEndian()) {
- DyldELFObject<ELFType<support::little, 2, false> > *Obj =
- new DyldELFObject<ELFType<support::little, 2, false> >(Buffer, ec);
- return new ELFObjectImage<ELFType<support::little, 2, false> >(NULL, Obj);
- }
- else if (ObjFile->getBytesInAddress() == 4 && !ObjFile->isLittleEndian()) {
- DyldELFObject<ELFType<support::big, 2, false> > *Obj =
- new DyldELFObject<ELFType<support::big, 2, false> >(Buffer, ec);
- return new ELFObjectImage<ELFType<support::big, 2, false> >(NULL, Obj);
- }
- else if (ObjFile->getBytesInAddress() == 8 && !ObjFile->isLittleEndian()) {
- DyldELFObject<ELFType<support::big, 2, true> > *Obj =
- new DyldELFObject<ELFType<support::big, 2, true> >(Buffer, ec);
- return new ELFObjectImage<ELFType<support::big, 2, true> >(NULL, Obj);
- }
- else if (ObjFile->getBytesInAddress() == 8 && ObjFile->isLittleEndian()) {
- DyldELFObject<ELFType<support::little, 2, true> > *Obj =
- new DyldELFObject<ELFType<support::little, 2, true> >(Buffer, ec);
- return new ELFObjectImage<ELFType<support::little, 2, true> >(NULL, Obj);
- }
- else
+ DyldELFObject<ELFType<support::little, 2, false>> *Obj =
+ new DyldELFObject<ELFType<support::little, 2, false>>(Buffer, ec);
+ return new ELFObjectImage<ELFType<support::little, 2, false>>(NULL, Obj);
+ } else if (ObjFile->getBytesInAddress() == 4 && !ObjFile->isLittleEndian()) {
+ DyldELFObject<ELFType<support::big, 2, false>> *Obj =
+ new DyldELFObject<ELFType<support::big, 2, false>>(Buffer, ec);
+ return new ELFObjectImage<ELFType<support::big, 2, false>>(NULL, Obj);
+ } else if (ObjFile->getBytesInAddress() == 8 && !ObjFile->isLittleEndian()) {
+ DyldELFObject<ELFType<support::big, 2, true>> *Obj =
+ new DyldELFObject<ELFType<support::big, 2, true>>(Buffer, ec);
+ return new ELFObjectImage<ELFType<support::big, 2, true>>(NULL, Obj);
+ } else if (ObjFile->getBytesInAddress() == 8 && ObjFile->isLittleEndian()) {
+ DyldELFObject<ELFType<support::little, 2, true>> *Obj =
+ new DyldELFObject<ELFType<support::little, 2, true>>(Buffer, ec);
+ return new ELFObjectImage<ELFType<support::little, 2, true>>(NULL, Obj);
+ } else
llvm_unreachable("Unexpected ELF format");
}
ObjectImage *RuntimeDyldELF::createObjectImage(ObjectBuffer *Buffer) {
if (Buffer->getBufferSize() < ELF::EI_NIDENT)
llvm_unreachable("Unexpected ELF object size");
- std::pair<unsigned char, unsigned char> Ident = std::make_pair(
- (uint8_t)Buffer->getBufferStart()[ELF::EI_CLASS],
- (uint8_t)Buffer->getBufferStart()[ELF::EI_DATA]);
+ std::pair<unsigned char, unsigned char> Ident =
+ std::make_pair((uint8_t)Buffer->getBufferStart()[ELF::EI_CLASS],
+ (uint8_t)Buffer->getBufferStart()[ELF::EI_DATA]);
error_code ec;
if (Ident.first == ELF::ELFCLASS32 && Ident.second == ELF::ELFDATA2LSB) {
- DyldELFObject<ELFType<support::little, 4, false> > *Obj =
- new DyldELFObject<ELFType<support::little, 4, false> >(
- Buffer->getMemBuffer(), ec);
- return new ELFObjectImage<ELFType<support::little, 4, false> >(Buffer, Obj);
- }
- else if (Ident.first == ELF::ELFCLASS32 && Ident.second == ELF::ELFDATA2MSB) {
- DyldELFObject<ELFType<support::big, 4, false> > *Obj =
- new DyldELFObject<ELFType<support::big, 4, false> >(
- Buffer->getMemBuffer(), ec);
- return new ELFObjectImage<ELFType<support::big, 4, false> >(Buffer, Obj);
- }
- else if (Ident.first == ELF::ELFCLASS64 && Ident.second == ELF::ELFDATA2MSB) {
- DyldELFObject<ELFType<support::big, 8, true> > *Obj =
- new DyldELFObject<ELFType<support::big, 8, true> >(
- Buffer->getMemBuffer(), ec);
- return new ELFObjectImage<ELFType<support::big, 8, true> >(Buffer, Obj);
- }
- else if (Ident.first == ELF::ELFCLASS64 && Ident.second == ELF::ELFDATA2LSB) {
- DyldELFObject<ELFType<support::little, 8, true> > *Obj =
- new DyldELFObject<ELFType<support::little, 8, true> >(
- Buffer->getMemBuffer(), ec);
- return new ELFObjectImage<ELFType<support::little, 8, true> >(Buffer, Obj);
- }
- else
+ DyldELFObject<ELFType<support::little, 4, false>> *Obj =
+ new DyldELFObject<ELFType<support::little, 4, false>>(
+ Buffer->getMemBuffer(), ec);
+ return new ELFObjectImage<ELFType<support::little, 4, false>>(Buffer, Obj);
+ } else if (Ident.first == ELF::ELFCLASS32 &&
+ Ident.second == ELF::ELFDATA2MSB) {
+ DyldELFObject<ELFType<support::big, 4, false>> *Obj =
+ new DyldELFObject<ELFType<support::big, 4, false>>(
+ Buffer->getMemBuffer(), ec);
+ return new ELFObjectImage<ELFType<support::big, 4, false>>(Buffer, Obj);
+ } else if (Ident.first == ELF::ELFCLASS64 &&
+ Ident.second == ELF::ELFDATA2MSB) {
+ DyldELFObject<ELFType<support::big, 8, true>> *Obj =
+ new DyldELFObject<ELFType<support::big, 8, true>>(
+ Buffer->getMemBuffer(), ec);
+ return new ELFObjectImage<ELFType<support::big, 8, true>>(Buffer, Obj);
+ } else if (Ident.first == ELF::ELFCLASS64 &&
+ Ident.second == ELF::ELFDATA2LSB) {
+ DyldELFObject<ELFType<support::little, 8, true>> *Obj =
+ new DyldELFObject<ELFType<support::little, 8, true>>(
+ Buffer->getMemBuffer(), ec);
+ return new ELFObjectImage<ELFType<support::little, 8, true>>(Buffer, Obj);
+ } else
llvm_unreachable("Unexpected ELF format");
}
-RuntimeDyldELF::~RuntimeDyldELF() {
-}
+RuntimeDyldELF::~RuntimeDyldELF() {}
void RuntimeDyldELF::resolveX86_64Relocation(const SectionEntry &Section,
- uint64_t Offset,
- uint64_t Value,
- uint32_t Type,
- int64_t Addend,
+ uint64_t Offset, uint64_t Value,
+ uint32_t Type, int64_t Addend,
uint64_t SymOffset) {
switch (Type) {
default:
llvm_unreachable("Relocation type not implemented yet!");
- break;
+ break;
case ELF::R_X86_64_64: {
- uint64_t *Target = reinterpret_cast<uint64_t*>(Section.Address + Offset);
+ uint64_t *Target = reinterpret_cast<uint64_t *>(Section.Address + Offset);
*Target = Value + Addend;
- DEBUG(dbgs() << "Writing " << format("%p", (Value + Addend))
- << " at " << format("%p\n",Target));
+ DEBUG(dbgs() << "Writing " << format("%p", (Value + Addend)) << " at "
+ << format("%p\n", Target));
break;
}
case ELF::R_X86_64_32:
@@ -269,20 +249,20 @@ void RuntimeDyldELF::resolveX86_64Reloca
Value += Addend;
assert((Type == ELF::R_X86_64_32 && (Value <= UINT32_MAX)) ||
(Type == ELF::R_X86_64_32S &&
- ((int64_t)Value <= INT32_MAX && (int64_t)Value >= INT32_MIN)));
+ ((int64_t)Value <= INT32_MAX && (int64_t)Value >= INT32_MIN)));
uint32_t TruncatedAddr = (Value & 0xFFFFFFFF);
- uint32_t *Target = reinterpret_cast<uint32_t*>(Section.Address + Offset);
+ uint32_t *Target = reinterpret_cast<uint32_t *>(Section.Address + Offset);
*Target = TruncatedAddr;
- DEBUG(dbgs() << "Writing " << format("%p", TruncatedAddr)
- << " at " << format("%p\n",Target));
+ DEBUG(dbgs() << "Writing " << format("%p", TruncatedAddr) << " at "
+ << format("%p\n", Target));
break;
}
case ELF::R_X86_64_GOTPCREL: {
// findGOTEntry returns the 'G + GOT' part of the relocation calculation
// based on the load/target address of the GOT (not the current/local addr).
uint64_t GOTAddr = findGOTEntry(Value, SymOffset);
- uint32_t *Target = reinterpret_cast<uint32_t*>(Section.Address + Offset);
- uint64_t FinalAddress = Section.LoadAddress + Offset;
+ uint32_t *Target = reinterpret_cast<uint32_t *>(Section.Address + Offset);
+ uint64_t FinalAddress = Section.LoadAddress + Offset;
// The processRelocationRef method combines the symbol offset and the addend
// and in most cases that's what we want. For this relocation type, we need
// the raw addend, so we subtract the symbol offset to get it.
@@ -295,10 +275,10 @@ void RuntimeDyldELF::resolveX86_64Reloca
case ELF::R_X86_64_PC32: {
// Get the placeholder value from the generated object since
// a previous relocation attempt may have overwritten the loaded version
- uint32_t *Placeholder = reinterpret_cast<uint32_t*>(Section.ObjAddress
- + Offset);
- uint32_t *Target = reinterpret_cast<uint32_t*>(Section.Address + Offset);
- uint64_t FinalAddress = Section.LoadAddress + Offset;
+ uint32_t *Placeholder =
+ reinterpret_cast<uint32_t *>(Section.ObjAddress + Offset);
+ uint32_t *Target = reinterpret_cast<uint32_t *>(Section.Address + Offset);
+ uint64_t FinalAddress = Section.LoadAddress + Offset;
int64_t RealOffset = *Placeholder + Value + Addend - FinalAddress;
assert(RealOffset <= INT32_MAX && RealOffset >= INT32_MIN);
int32_t TruncOffset = (RealOffset & 0xFFFFFFFF);
@@ -308,10 +288,10 @@ void RuntimeDyldELF::resolveX86_64Reloca
case ELF::R_X86_64_PC64: {
// Get the placeholder value from the generated object since
// a previous relocation attempt may have overwritten the loaded version
- uint64_t *Placeholder = reinterpret_cast<uint64_t*>(Section.ObjAddress
- + Offset);
- uint64_t *Target = reinterpret_cast<uint64_t*>(Section.Address + Offset);
- uint64_t FinalAddress = Section.LoadAddress + Offset;
+ uint64_t *Placeholder =
+ reinterpret_cast<uint64_t *>(Section.ObjAddress + Offset);
+ uint64_t *Target = reinterpret_cast<uint64_t *>(Section.Address + Offset);
+ uint64_t FinalAddress = Section.LoadAddress + Offset;
*Target = *Placeholder + Value + Addend - FinalAddress;
break;
}
@@ -319,53 +299,48 @@ void RuntimeDyldELF::resolveX86_64Reloca
}
void RuntimeDyldELF::resolveX86Relocation(const SectionEntry &Section,
- uint64_t Offset,
- uint32_t Value,
- uint32_t Type,
- int32_t Addend) {
+ uint64_t Offset, uint32_t Value,
+ uint32_t Type, int32_t Addend) {
switch (Type) {
case ELF::R_386_32: {
// Get the placeholder value from the generated object since
// a previous relocation attempt may have overwritten the loaded version
- uint32_t *Placeholder = reinterpret_cast<uint32_t*>(Section.ObjAddress
- + Offset);
- uint32_t *Target = reinterpret_cast<uint32_t*>(Section.Address + Offset);
+ uint32_t *Placeholder =
+ reinterpret_cast<uint32_t *>(Section.ObjAddress + Offset);
+ uint32_t *Target = reinterpret_cast<uint32_t *>(Section.Address + Offset);
*Target = *Placeholder + Value + Addend;
break;
}
case ELF::R_386_PC32: {
// Get the placeholder value from the generated object since
// a previous relocation attempt may have overwritten the loaded version
- uint32_t *Placeholder = reinterpret_cast<uint32_t*>(Section.ObjAddress
- + Offset);
- uint32_t *Target = reinterpret_cast<uint32_t*>(Section.Address + Offset);
- uint32_t FinalAddress = ((Section.LoadAddress + Offset) & 0xFFFFFFFF);
+ uint32_t *Placeholder =
+ reinterpret_cast<uint32_t *>(Section.ObjAddress + Offset);
+ uint32_t *Target = reinterpret_cast<uint32_t *>(Section.Address + Offset);
+ uint32_t FinalAddress = ((Section.LoadAddress + Offset) & 0xFFFFFFFF);
uint32_t RealOffset = *Placeholder + Value + Addend - FinalAddress;
*Target = RealOffset;
break;
- }
- default:
- // There are other relocation types, but it appears these are the
- // only ones currently used by the LLVM ELF object writer
- llvm_unreachable("Relocation type not implemented yet!");
- break;
+ }
+ default:
+ // There are other relocation types, but it appears these are the
+ // only ones currently used by the LLVM ELF object writer
+ llvm_unreachable("Relocation type not implemented yet!");
+ break;
}
}
void RuntimeDyldELF::resolveAArch64Relocation(const SectionEntry &Section,
- uint64_t Offset,
- uint64_t Value,
- uint32_t Type,
- int64_t Addend) {
- uint32_t *TargetPtr = reinterpret_cast<uint32_t*>(Section.Address + Offset);
+ uint64_t Offset, uint64_t Value,
+ uint32_t Type, int64_t Addend) {
+ uint32_t *TargetPtr = reinterpret_cast<uint32_t *>(Section.Address + Offset);
uint64_t FinalAddress = Section.LoadAddress + Offset;
DEBUG(dbgs() << "resolveAArch64Relocation, LocalAddress: 0x"
<< format("%llx", Section.Address + Offset)
- << " FinalAddress: 0x" << format("%llx",FinalAddress)
- << " Value: 0x" << format("%llx",Value)
- << " Type: 0x" << format("%x",Type)
- << " Addend: 0x" << format("%llx",Addend)
+ << " FinalAddress: 0x" << format("%llx", FinalAddress)
+ << " Value: 0x" << format("%llx", Value) << " Type: 0x"
+ << format("%x", Type) << " Addend: 0x" << format("%llx", Addend)
<< "\n");
switch (Type) {
@@ -373,7 +348,8 @@ void RuntimeDyldELF::resolveAArch64Reloc
llvm_unreachable("Relocation type not implemented yet!");
break;
case ELF::R_AARCH64_ABS64: {
- uint64_t *TargetPtr = reinterpret_cast<uint64_t*>(Section.Address + Offset);
+ uint64_t *TargetPtr =
+ reinterpret_cast<uint64_t *>(Section.Address + Offset);
*TargetPtr = Value + Addend;
break;
}
@@ -451,7 +427,8 @@ void RuntimeDyldELF::resolveAArch64Reloc
}
case ELF::R_AARCH64_ADR_PREL_PG_HI21: {
// Operation: Page(S+A) - Page(P)
- uint64_t Result = ((Value + Addend) & ~0xfffULL) - (FinalAddress & ~0xfffULL);
+ uint64_t Result =
+ ((Value + Addend) & ~0xfffULL) - (FinalAddress & ~0xfffULL);
// Check that -2^32 <= X < 2^32
assert(static_cast<int64_t>(Result) >= (-1LL << 32) &&
@@ -495,26 +472,22 @@ void RuntimeDyldELF::resolveAArch64Reloc
}
void RuntimeDyldELF::resolveARMRelocation(const SectionEntry &Section,
- uint64_t Offset,
- uint32_t Value,
- uint32_t Type,
- int32_t Addend) {
+ uint64_t Offset, uint32_t Value,
+ uint32_t Type, int32_t Addend) {
// TODO: Add Thumb relocations.
- uint32_t *Placeholder = reinterpret_cast<uint32_t*>(Section.ObjAddress +
- Offset);
- uint32_t* TargetPtr = (uint32_t*)(Section.Address + Offset);
+ uint32_t *Placeholder =
+ reinterpret_cast<uint32_t *>(Section.ObjAddress + Offset);
+ uint32_t *TargetPtr = (uint32_t *)(Section.Address + Offset);
uint32_t FinalAddress = ((Section.LoadAddress + Offset) & 0xFFFFFFFF);
Value += Addend;
DEBUG(dbgs() << "resolveARMRelocation, LocalAddress: "
<< Section.Address + Offset
- << " FinalAddress: " << format("%p",FinalAddress)
- << " Value: " << format("%x",Value)
- << " Type: " << format("%x",Type)
- << " Addend: " << format("%x",Addend)
- << "\n");
+ << " FinalAddress: " << format("%p", FinalAddress) << " Value: "
+ << format("%x", Value) << " Type: " << format("%x", Type)
+ << " Addend: " << format("%x", Addend) << "\n");
- switch(Type) {
+ switch (Type) {
default:
llvm_unreachable("Not implemented relocation type!");
@@ -550,8 +523,8 @@ void RuntimeDyldELF::resolveARMRelocatio
*TargetPtr |= ((Value >> 12) & 0xF) << 16;
break;
// Write 24 bit relative value to the branch instruction.
- case ELF::R_ARM_PC24 : // Fall through.
- case ELF::R_ARM_CALL : // Fall through.
+ case ELF::R_ARM_PC24: // Fall through.
+ case ELF::R_ARM_CALL: // Fall through.
case ELF::R_ARM_JUMP24: {
int32_t RelValue = static_cast<int32_t>(Value - FinalAddress - 8);
RelValue = (RelValue & 0x03FFFFFC) >> 2;
@@ -571,25 +544,20 @@ void RuntimeDyldELF::resolveARMRelocatio
}
void RuntimeDyldELF::resolveMIPSRelocation(const SectionEntry &Section,
- uint64_t Offset,
- uint32_t Value,
- uint32_t Type,
- int32_t Addend) {
- uint32_t *Placeholder = reinterpret_cast<uint32_t*>(Section.ObjAddress +
- Offset);
- uint32_t* TargetPtr = (uint32_t*)(Section.Address + Offset);
+ uint64_t Offset, uint32_t Value,
+ uint32_t Type, int32_t Addend) {
+ uint32_t *Placeholder =
+ reinterpret_cast<uint32_t *>(Section.ObjAddress + Offset);
+ uint32_t *TargetPtr = (uint32_t *)(Section.Address + Offset);
Value += Addend;
DEBUG(dbgs() << "resolveMipselocation, LocalAddress: "
- << Section.Address + Offset
- << " FinalAddress: "
- << format("%p",Section.LoadAddress + Offset)
- << " Value: " << format("%x",Value)
- << " Type: " << format("%x",Type)
- << " Addend: " << format("%x",Addend)
- << "\n");
+ << Section.Address + Offset << " FinalAddress: "
+ << format("%p", Section.LoadAddress + Offset) << " Value: "
+ << format("%x", Value) << " Type: " << format("%x", Type)
+ << " Addend: " << format("%x", Addend) << "\n");
- switch(Type) {
+ switch (Type) {
default:
llvm_unreachable("Not implemented relocation type!");
break;
@@ -597,13 +565,13 @@ void RuntimeDyldELF::resolveMIPSRelocati
*TargetPtr = Value + (*Placeholder);
break;
case ELF::R_MIPS_26:
- *TargetPtr = ((*Placeholder) & 0xfc000000) | (( Value & 0x0fffffff) >> 2);
+ *TargetPtr = ((*Placeholder) & 0xfc000000) | ((Value & 0x0fffffff) >> 2);
break;
case ELF::R_MIPS_HI16:
// Get the higher 16-bits. Also add 1 if bit 15 is 1.
Value += ((*Placeholder) & 0x0000ffff) << 16;
- *TargetPtr = ((*Placeholder) & 0xffff0000) |
- (((Value + 0x8000) >> 16) & 0xffff);
+ *TargetPtr =
+ ((*Placeholder) & 0xffff0000) | (((Value + 0x8000) >> 16) & 0xffff);
break;
case ELF::R_MIPS_LO16:
Value += ((*Placeholder) & 0x0000ffff);
@@ -614,13 +582,13 @@ void RuntimeDyldELF::resolveMIPSRelocati
// are used for internal JIT purpose. These relocations are similar to
// R_MIPS_HI16 and R_MIPS_LO16, but they do not take any addend into
// account.
- *TargetPtr = ((*TargetPtr) & 0xffff0000) |
- (((Value + 0x8000) >> 16) & 0xffff);
+ *TargetPtr =
+ ((*TargetPtr) & 0xffff0000) | (((Value + 0x8000) >> 16) & 0xffff);
break;
case ELF::R_MIPS_UNUSED2:
*TargetPtr = ((*TargetPtr) & 0xffff0000) | (Value & 0xffff);
break;
- }
+ }
}
// Return the .TOC. section address to R_PPC64_TOC relocations.
@@ -630,9 +598,7 @@ uint64_t RuntimeDyldELF::findPPC64TOC()
SectionList::const_iterator it = Sections.begin();
SectionList::const_iterator ite = Sections.end();
for (; it != ite; ++it) {
- if (it->Name == ".got" ||
- it->Name == ".toc" ||
- it->Name == ".tocbss" ||
+ if (it->Name == ".got" || it->Name == ".toc" || it->Name == ".tocbss" ||
it->Name == ".plt")
break;
}
@@ -645,7 +611,7 @@ uint64_t RuntimeDyldELF::findPPC64TOC()
// directly.
it = Sections.begin();
}
- assert (it != ite);
+ assert(it != ite);
// Per the ppc64-elf-linux ABI, The TOC base is TOC value plus 0x8000
// thus permitting a full 64 Kbytes segment.
return it->LoadAddress + 0x8000;
@@ -670,7 +636,8 @@ void RuntimeDyldELF::findOPDEntrySection
continue;
for (relocation_iterator i = si->relocation_begin(),
- e = si->relocation_end(); i != e;) {
+ e = si->relocation_end();
+ i != e;) {
// The R_PPC64_ADDR64 relocation indicates the first field
// of a .opd entry
uint64_t TypeFunc;
@@ -718,65 +685,53 @@ void RuntimeDyldELF::findOPDEntrySection
// and #highest(value) macros defined in section 4.5.1. Relocation Types
// in PPC-elf64abi document.
//
-static inline
-uint16_t applyPPClo (uint64_t value)
-{
- return value & 0xffff;
-}
+static inline uint16_t applyPPClo(uint64_t value) { return value & 0xffff; }
-static inline
-uint16_t applyPPChi (uint64_t value)
-{
+static inline uint16_t applyPPChi(uint64_t value) {
return (value >> 16) & 0xffff;
}
-static inline
-uint16_t applyPPChigher (uint64_t value)
-{
+static inline uint16_t applyPPChigher(uint64_t value) {
return (value >> 32) & 0xffff;
}
-static inline
-uint16_t applyPPChighest (uint64_t value)
-{
+static inline uint16_t applyPPChighest(uint64_t value) {
return (value >> 48) & 0xffff;
}
void RuntimeDyldELF::resolvePPC64Relocation(const SectionEntry &Section,
- uint64_t Offset,
- uint64_t Value,
- uint32_t Type,
- int64_t Addend) {
- uint8_t* LocalAddress = Section.Address + Offset;
+ uint64_t Offset, uint64_t Value,
+ uint32_t Type, int64_t Addend) {
+ uint8_t *LocalAddress = Section.Address + Offset;
switch (Type) {
default:
llvm_unreachable("Relocation type not implemented yet!");
- break;
- case ELF::R_PPC64_ADDR16_LO :
- writeInt16BE(LocalAddress, applyPPClo (Value + Addend));
break;
- case ELF::R_PPC64_ADDR16_HI :
- writeInt16BE(LocalAddress, applyPPChi (Value + Addend));
+ case ELF::R_PPC64_ADDR16_LO:
+ writeInt16BE(LocalAddress, applyPPClo(Value + Addend));
+ break;
+ case ELF::R_PPC64_ADDR16_HI:
+ writeInt16BE(LocalAddress, applyPPChi(Value + Addend));
break;
- case ELF::R_PPC64_ADDR16_HIGHER :
- writeInt16BE(LocalAddress, applyPPChigher (Value + Addend));
+ case ELF::R_PPC64_ADDR16_HIGHER:
+ writeInt16BE(LocalAddress, applyPPChigher(Value + Addend));
break;
- case ELF::R_PPC64_ADDR16_HIGHEST :
- writeInt16BE(LocalAddress, applyPPChighest (Value + Addend));
+ case ELF::R_PPC64_ADDR16_HIGHEST:
+ writeInt16BE(LocalAddress, applyPPChighest(Value + Addend));
break;
- case ELF::R_PPC64_ADDR14 : {
+ case ELF::R_PPC64_ADDR14: {
assert(((Value + Addend) & 3) == 0);
// Preserve the AA/LK bits in the branch instruction
- uint8_t aalk = *(LocalAddress+3);
+ uint8_t aalk = *(LocalAddress + 3);
writeInt16BE(LocalAddress + 2, (aalk & 3) | ((Value + Addend) & 0xfffc));
} break;
- case ELF::R_PPC64_ADDR32 : {
+ case ELF::R_PPC64_ADDR32: {
int32_t Result = static_cast<int32_t>(Value + Addend);
if (SignExtend32<32>(Result) != Result)
llvm_unreachable("Relocation R_PPC64_ADDR32 overflow");
writeInt32BE(LocalAddress, Result);
} break;
- case ELF::R_PPC64_REL24 : {
+ case ELF::R_PPC64_REL24: {
uint64_t FinalAddress = (Section.LoadAddress + Offset);
int32_t delta = static_cast<int32_t>(Value - FinalAddress + Addend);
if (SignExtend32<24>(delta) != delta)
@@ -784,7 +739,7 @@ void RuntimeDyldELF::resolvePPC64Relocat
// Generates a 'bl <address>' instruction
writeInt32BE(LocalAddress, 0x48000001 | (delta & 0x03FFFFFC));
} break;
- case ELF::R_PPC64_REL32 : {
+ case ELF::R_PPC64_REL32: {
uint64_t FinalAddress = (Section.LoadAddress + Offset);
int32_t delta = static_cast<int32_t>(Value - FinalAddress + Addend);
if (SignExtend32<32>(delta) != delta)
@@ -796,18 +751,18 @@ void RuntimeDyldELF::resolvePPC64Relocat
uint64_t Delta = Value - FinalAddress + Addend;
writeInt64BE(LocalAddress, Delta);
} break;
- case ELF::R_PPC64_ADDR64 :
+ case ELF::R_PPC64_ADDR64:
writeInt64BE(LocalAddress, Value + Addend);
break;
- case ELF::R_PPC64_TOC :
+ case ELF::R_PPC64_TOC:
writeInt64BE(LocalAddress, findPPC64TOC());
break;
- case ELF::R_PPC64_TOC16 : {
+ case ELF::R_PPC64_TOC16: {
uint64_t TOCStart = findPPC64TOC();
Value = applyPPClo((Value + Addend) - TOCStart);
writeInt16BE(LocalAddress, applyPPClo(Value));
} break;
- case ELF::R_PPC64_TOC16_DS : {
+ case ELF::R_PPC64_TOC16_DS: {
uint64_t TOCStart = findPPC64TOC();
Value = ((Value + Addend) - TOCStart);
writeInt16BE(LocalAddress, applyPPClo(Value));
@@ -816,10 +771,8 @@ void RuntimeDyldELF::resolvePPC64Relocat
}
void RuntimeDyldELF::resolveSystemZRelocation(const SectionEntry &Section,
- uint64_t Offset,
- uint64_t Value,
- uint32_t Type,
- int64_t Addend) {
+ uint64_t Offset, uint64_t Value,
+ uint32_t Type, int64_t Addend) {
uint8_t *LocalAddress = Section.Address + Offset;
switch (Type) {
default:
@@ -879,53 +832,46 @@ void RuntimeDyldELF::resolveRelocation(c
}
void RuntimeDyldELF::resolveRelocation(const SectionEntry &Section,
- uint64_t Offset,
- uint64_t Value,
- uint32_t Type,
- int64_t Addend,
+ uint64_t Offset, uint64_t Value,
+ uint32_t Type, int64_t Addend,
uint64_t SymOffset) {
switch (Arch) {
case Triple::x86_64:
resolveX86_64Relocation(Section, Offset, Value, Type, Addend, SymOffset);
break;
case Triple::x86:
- resolveX86Relocation(Section, Offset,
- (uint32_t)(Value & 0xffffffffL), Type,
+ resolveX86Relocation(Section, Offset, (uint32_t)(Value & 0xffffffffL), Type,
(uint32_t)(Addend & 0xffffffffL));
break;
case Triple::aarch64:
resolveAArch64Relocation(Section, Offset, Value, Type, Addend);
break;
- case Triple::arm: // Fall through.
+ case Triple::arm: // Fall through.
case Triple::thumb:
- resolveARMRelocation(Section, Offset,
- (uint32_t)(Value & 0xffffffffL), Type,
+ resolveARMRelocation(Section, Offset, (uint32_t)(Value & 0xffffffffL), Type,
(uint32_t)(Addend & 0xffffffffL));
break;
- case Triple::mips: // Fall through.
+ case Triple::mips: // Fall through.
case Triple::mipsel:
- resolveMIPSRelocation(Section, Offset,
- (uint32_t)(Value & 0xffffffffL), Type,
- (uint32_t)(Addend & 0xffffffffL));
+ resolveMIPSRelocation(Section, Offset, (uint32_t)(Value & 0xffffffffL),
+ Type, (uint32_t)(Addend & 0xffffffffL));
break;
- case Triple::ppc64: // Fall through.
+ case Triple::ppc64: // Fall through.
case Triple::ppc64le:
resolvePPC64Relocation(Section, Offset, Value, Type, Addend);
break;
case Triple::systemz:
resolveSystemZRelocation(Section, Offset, Value, Type, Addend);
break;
- default: llvm_unreachable("Unsupported CPU type!");
+ default:
+ llvm_unreachable("Unsupported CPU type!");
}
}
-relocation_iterator
-RuntimeDyldELF::processRelocationRef(unsigned SectionID,
- relocation_iterator RelI,
- ObjectImage &Obj,
- ObjSectionToIDMap &ObjSectionToID,
- const SymbolTableMap &Symbols,
- StubMap &Stubs) {
+relocation_iterator RuntimeDyldELF::processRelocationRef(
+ unsigned SectionID, relocation_iterator RelI, ObjectImage &Obj,
+ ObjSectionToIDMap &ObjSectionToID, const SymbolTableMap &Symbols,
+ StubMap &Stubs) {
uint64_t RelType;
Check(RelI->getType(RelType));
int64_t Addend;
@@ -936,10 +882,8 @@ RuntimeDyldELF::processRelocationRef(uns
StringRef TargetName;
if (Symbol != Obj.end_symbols())
Symbol->getName(TargetName);
- DEBUG(dbgs() << "\t\tRelType: " << RelType
- << " Addend: " << Addend
- << " TargetName: " << TargetName
- << "\n");
+ DEBUG(dbgs() << "\t\tRelType: " << RelType << " Addend: " << Addend
+ << " TargetName: " << TargetName << "\n");
RelocationValueRef Value;
// First search for the symbol in the local symbol table
SymbolTableMap::const_iterator lsi = Symbols.end();
@@ -963,53 +907,48 @@ RuntimeDyldELF::processRelocationRef(uns
Value.Addend = gsi->second.second + Addend;
} else {
switch (SymType) {
- case SymbolRef::ST_Debug: {
- // TODO: Now ELF SymbolRef::ST_Debug = STT_SECTION, it's not obviously
- // and can be changed by another developers. Maybe best way is add
- // a new symbol type ST_Section to SymbolRef and use it.
- section_iterator si(Obj.end_sections());
- Symbol->getSection(si);
- if (si == Obj.end_sections())
- llvm_unreachable("Symbol section not found, bad object file format!");
- DEBUG(dbgs() << "\t\tThis is section symbol\n");
- // Default to 'true' in case isText fails (though it never does).
- bool isCode = true;
- si->isText(isCode);
- Value.SectionID = findOrEmitSection(Obj,
- (*si),
- isCode,
- ObjSectionToID);
- Value.Addend = Addend;
- break;
- }
- case SymbolRef::ST_Data:
- case SymbolRef::ST_Unknown: {
- Value.SymbolName = TargetName.data();
- Value.Addend = Addend;
-
- // Absolute relocations will have a zero symbol ID (STN_UNDEF), which
- // will manifest here as a NULL symbol name.
- // We can set this as a valid (but empty) symbol name, and rely
- // on addRelocationForSymbol to handle this.
- if (!Value.SymbolName)
- Value.SymbolName = "";
- break;
- }
- default:
- llvm_unreachable("Unresolved symbol type!");
- break;
+ case SymbolRef::ST_Debug: {
+ // TODO: Now ELF SymbolRef::ST_Debug = STT_SECTION, it's not obviously
+ // and can be changed by another developers. Maybe best way is add
+ // a new symbol type ST_Section to SymbolRef and use it.
+ section_iterator si(Obj.end_sections());
+ Symbol->getSection(si);
+ if (si == Obj.end_sections())
+ llvm_unreachable("Symbol section not found, bad object file format!");
+ DEBUG(dbgs() << "\t\tThis is section symbol\n");
+ // Default to 'true' in case isText fails (though it never does).
+ bool isCode = true;
+ si->isText(isCode);
+ Value.SectionID = findOrEmitSection(Obj, (*si), isCode, ObjSectionToID);
+ Value.Addend = Addend;
+ break;
+ }
+ case SymbolRef::ST_Data:
+ case SymbolRef::ST_Unknown: {
+ Value.SymbolName = TargetName.data();
+ Value.Addend = Addend;
+
+ // Absolute relocations will have a zero symbol ID (STN_UNDEF), which
+ // will manifest here as a NULL symbol name.
+ // We can set this as a valid (but empty) symbol name, and rely
+ // on addRelocationForSymbol to handle this.
+ if (!Value.SymbolName)
+ Value.SymbolName = "";
+ break;
+ }
+ default:
+ llvm_unreachable("Unresolved symbol type!");
+ break;
}
}
}
uint64_t Offset;
Check(RelI->getOffset(Offset));
- DEBUG(dbgs() << "\t\tSectionID: " << SectionID
- << " Offset: " << Offset
+ DEBUG(dbgs() << "\t\tSectionID: " << SectionID << " Offset: " << Offset
<< "\n");
if (Arch == Triple::aarch64 &&
- (RelType == ELF::R_AARCH64_CALL26 ||
- RelType == ELF::R_AARCH64_JUMP26)) {
+ (RelType == ELF::R_AARCH64_CALL26 || RelType == ELF::R_AARCH64_JUMP26)) {
// This is an AArch64 branch relocation, need to use a stub function.
DEBUG(dbgs() << "\t\tThis is an AArch64 branch relocation.");
SectionEntry &Section = Sections[SectionID];
@@ -1017,24 +956,21 @@ RuntimeDyldELF::processRelocationRef(uns
// Look for an existing stub.
StubMap::const_iterator i = Stubs.find(Value);
if (i != Stubs.end()) {
- resolveRelocation(Section, Offset,
- (uint64_t)Section.Address + i->second, RelType, 0);
+ resolveRelocation(Section, Offset, (uint64_t)Section.Address + i->second,
+ RelType, 0);
DEBUG(dbgs() << " Stub function found\n");
} else {
// Create a new stub function.
DEBUG(dbgs() << " Create a new stub function\n");
Stubs[Value] = Section.StubOffset;
- uint8_t *StubTargetAddr = createStubFunction(Section.Address +
- Section.StubOffset);
+ uint8_t *StubTargetAddr =
+ createStubFunction(Section.Address + Section.StubOffset);
- RelocationEntry REmovz_g3(SectionID,
- StubTargetAddr - Section.Address,
+ RelocationEntry REmovz_g3(SectionID, StubTargetAddr - Section.Address,
ELF::R_AARCH64_MOVW_UABS_G3, Value.Addend);
- RelocationEntry REmovk_g2(SectionID,
- StubTargetAddr - Section.Address + 4,
+ RelocationEntry REmovk_g2(SectionID, StubTargetAddr - Section.Address + 4,
ELF::R_AARCH64_MOVW_UABS_G2_NC, Value.Addend);
- RelocationEntry REmovk_g1(SectionID,
- StubTargetAddr - Section.Address + 8,
+ RelocationEntry REmovk_g1(SectionID, StubTargetAddr - Section.Address + 8,
ELF::R_AARCH64_MOVW_UABS_G1_NC, Value.Addend);
RelocationEntry REmovk_g0(SectionID,
StubTargetAddr - Section.Address + 12,
@@ -1052,14 +988,13 @@ RuntimeDyldELF::processRelocationRef(uns
addRelocationForSection(REmovk_g0, Value.SectionID);
}
resolveRelocation(Section, Offset,
- (uint64_t)Section.Address + Section.StubOffset,
- RelType, 0);
+ (uint64_t)Section.Address + Section.StubOffset, RelType,
+ 0);
Section.StubOffset += getMaxStubSize();
}
} else if (Arch == Triple::arm &&
- (RelType == ELF::R_ARM_PC24 ||
- RelType == ELF::R_ARM_CALL ||
- RelType == ELF::R_ARM_JUMP24)) {
+ (RelType == ELF::R_ARM_PC24 || RelType == ELF::R_ARM_CALL ||
+ RelType == ELF::R_ARM_JUMP24)) {
// This is an ARM branch relocation, need to use a stub function.
DEBUG(dbgs() << "\t\tThis is an ARM branch relocation.");
SectionEntry &Section = Sections[SectionID];
@@ -1067,15 +1002,15 @@ RuntimeDyldELF::processRelocationRef(uns
// Look for an existing stub.
StubMap::const_iterator i = Stubs.find(Value);
if (i != Stubs.end()) {
- resolveRelocation(Section, Offset,
- (uint64_t)Section.Address + i->second, RelType, 0);
+ resolveRelocation(Section, Offset, (uint64_t)Section.Address + i->second,
+ RelType, 0);
DEBUG(dbgs() << " Stub function found\n");
} else {
// Create a new stub function.
DEBUG(dbgs() << " Create a new stub function\n");
Stubs[Value] = Section.StubOffset;
- uint8_t *StubTargetAddr = createStubFunction(Section.Address +
- Section.StubOffset);
+ uint8_t *StubTargetAddr =
+ createStubFunction(Section.Address + Section.StubOffset);
RelocationEntry RE(SectionID, StubTargetAddr - Section.Address,
ELF::R_ARM_PRIVATE_0, Value.Addend);
if (Value.SymbolName)
@@ -1084,8 +1019,8 @@ RuntimeDyldELF::processRelocationRef(uns
addRelocationForSection(RE, Value.SectionID);
resolveRelocation(Section, Offset,
- (uint64_t)Section.Address + Section.StubOffset,
- RelType, 0);
+ (uint64_t)Section.Address + Section.StubOffset, RelType,
+ 0);
Section.StubOffset += getMaxStubSize();
}
} else if ((Arch == Triple::mipsel || Arch == Triple::mips) &&
@@ -1111,15 +1046,13 @@ RuntimeDyldELF::processRelocationRef(uns
// Create a new stub function.
DEBUG(dbgs() << " Create a new stub function\n");
Stubs[Value] = Section.StubOffset;
- uint8_t *StubTargetAddr = createStubFunction(Section.Address +
- Section.StubOffset);
+ uint8_t *StubTargetAddr =
+ createStubFunction(Section.Address + Section.StubOffset);
// Creating Hi and Lo relocations for the filled stub instructions.
- RelocationEntry REHi(SectionID,
- StubTargetAddr - Section.Address,
+ RelocationEntry REHi(SectionID, StubTargetAddr - Section.Address,
ELF::R_MIPS_UNUSED1, Value.Addend);
- RelocationEntry RELo(SectionID,
- StubTargetAddr - Section.Address + 4,
+ RelocationEntry RELo(SectionID, StubTargetAddr - Section.Address + 4,
ELF::R_MIPS_UNUSED2, Value.Addend);
if (Value.SymbolName) {
@@ -1143,7 +1076,8 @@ RuntimeDyldELF::processRelocationRef(uns
uint8_t *Target = Section.Address + Offset;
bool RangeOverflow = false;
if (SymType != SymbolRef::ST_Unknown) {
- // A function call may points to the .opd entry, so the final symbol value
+ // A function call may points to the .opd entry, so the final symbol
+ // value
// in calculated based in the relocation values in .opd section.
findOPDEntrySection(Obj, ObjSectionToID, Value);
uint8_t *RelocTarget = Sections[Value.SectionID].Address + Value.Addend;
@@ -1172,36 +1106,32 @@ RuntimeDyldELF::processRelocationRef(uns
// Create a new stub function.
DEBUG(dbgs() << " Create a new stub function\n");
Stubs[Value] = Section.StubOffset;
- uint8_t *StubTargetAddr = createStubFunction(Section.Address +
- Section.StubOffset);
+ uint8_t *StubTargetAddr =
+ createStubFunction(Section.Address + Section.StubOffset);
RelocationEntry RE(SectionID, StubTargetAddr - Section.Address,
ELF::R_PPC64_ADDR64, Value.Addend);
// Generates the 64-bits address loads as exemplified in section
// 4.5.1 in PPC64 ELF ABI.
- RelocationEntry REhst(SectionID,
- StubTargetAddr - Section.Address + 2,
+ RelocationEntry REhst(SectionID, StubTargetAddr - Section.Address + 2,
ELF::R_PPC64_ADDR16_HIGHEST, Value.Addend);
- RelocationEntry REhr(SectionID,
- StubTargetAddr - Section.Address + 6,
+ RelocationEntry REhr(SectionID, StubTargetAddr - Section.Address + 6,
ELF::R_PPC64_ADDR16_HIGHER, Value.Addend);
- RelocationEntry REh(SectionID,
- StubTargetAddr - Section.Address + 14,
+ RelocationEntry REh(SectionID, StubTargetAddr - Section.Address + 14,
ELF::R_PPC64_ADDR16_HI, Value.Addend);
- RelocationEntry REl(SectionID,
- StubTargetAddr - Section.Address + 18,
+ RelocationEntry REl(SectionID, StubTargetAddr - Section.Address + 18,
ELF::R_PPC64_ADDR16_LO, Value.Addend);
if (Value.SymbolName) {
addRelocationForSymbol(REhst, Value.SymbolName);
- addRelocationForSymbol(REhr, Value.SymbolName);
- addRelocationForSymbol(REh, Value.SymbolName);
- addRelocationForSymbol(REl, Value.SymbolName);
+ addRelocationForSymbol(REhr, Value.SymbolName);
+ addRelocationForSymbol(REh, Value.SymbolName);
+ addRelocationForSymbol(REl, Value.SymbolName);
} else {
addRelocationForSection(REhst, Value.SectionID);
- addRelocationForSection(REhr, Value.SectionID);
- addRelocationForSection(REh, Value.SectionID);
- addRelocationForSection(REl, Value.SectionID);
+ addRelocationForSection(REhr, Value.SectionID);
+ addRelocationForSection(REh, Value.SectionID);
+ addRelocationForSection(REl, Value.SectionID);
}
resolveRelocation(Section, Offset,
@@ -1211,7 +1141,7 @@ RuntimeDyldELF::processRelocationRef(uns
}
if (SymType == SymbolRef::ST_Unknown)
// Restore the TOC for external calls
- writeInt32BE(Target+4, 0xE8410028); // ld r2,40(r1)
+ writeInt32BE(Target + 4, 0xE8410028); // ld r2,40(r1)
}
} else {
RelocationEntry RE(SectionID, Offset, RelType, Value.Addend);
@@ -1226,8 +1156,7 @@ RuntimeDyldELF::processRelocationRef(uns
addRelocationForSection(RE, Value.SectionID);
}
} else if (Arch == Triple::systemz &&
- (RelType == ELF::R_390_PLT32DBL ||
- RelType == ELF::R_390_GOTENT)) {
+ (RelType == ELF::R_390_PLT32DBL || RelType == ELF::R_390_GOTENT)) {
// Create function stubs for both PLT and GOT references, regardless of
// whether the GOT reference is to data or code. The stub contains the
// full address of the symbol, as needed by GOT references, and the
@@ -1252,14 +1181,14 @@ RuntimeDyldELF::processRelocationRef(uns
uintptr_t BaseAddress = uintptr_t(Section.Address);
uintptr_t StubAlignment = getStubAlignment();
- StubAddress = (BaseAddress + Section.StubOffset +
- StubAlignment - 1) & -StubAlignment;
+ StubAddress = (BaseAddress + Section.StubOffset + StubAlignment - 1) &
+ -StubAlignment;
unsigned StubOffset = StubAddress - BaseAddress;
Stubs[Value] = StubOffset;
createStubFunction((uint8_t *)StubAddress);
- RelocationEntry RE(SectionID, StubOffset + 8,
- ELF::R_390_64, Value.Addend - Addend);
+ RelocationEntry RE(SectionID, StubOffset + 8, ELF::R_390_64,
+ Value.Addend - Addend);
if (Value.SymbolName)
addRelocationForSymbol(RE, Value.SymbolName);
else
@@ -1268,15 +1197,17 @@ RuntimeDyldELF::processRelocationRef(uns
}
if (RelType == ELF::R_390_GOTENT)
- resolveRelocation(Section, Offset, StubAddress + 8,
- ELF::R_390_PC32DBL, Addend);
+ resolveRelocation(Section, Offset, StubAddress + 8, ELF::R_390_PC32DBL,
+ Addend);
else
resolveRelocation(Section, Offset, StubAddress, RelType, Addend);
} else if (Arch == Triple::x86_64 && RelType == ELF::R_X86_64_PLT32) {
- // The way the PLT relocations normally work is that the linker allocates the
+ // The way the PLT relocations normally work is that the linker allocates
+ // the
// PLT and this relocation makes a PC-relative call into the PLT. The PLT
- // entry will then jump to an address provided by the GOT. On first call, the
- // GOT address will point back into PLT code that resolves the symbol. After
+ // entry will then jump to an address provided by the GOT. On first call,
+ // the
+ // GOT address will point back into PLT code that resolves the symbol. After
// the first call, the GOT entry points to the actual function.
//
// For local functions we're ignoring all of that here and just replacing
@@ -1302,8 +1233,8 @@ RuntimeDyldELF::processRelocationRef(uns
uintptr_t BaseAddress = uintptr_t(Section.Address);
uintptr_t StubAlignment = getStubAlignment();
- StubAddress = (BaseAddress + Section.StubOffset +
- StubAlignment - 1) & -StubAlignment;
+ StubAddress = (BaseAddress + Section.StubOffset + StubAlignment - 1) &
+ -StubAlignment;
unsigned StubOffset = StubAddress - BaseAddress;
Stubs[Value] = StubOffset;
createStubFunction((uint8_t *)StubAddress);
@@ -1312,8 +1243,8 @@ RuntimeDyldELF::processRelocationRef(uns
GOTEntries.push_back(Value);
// Make our stub function a relative call to the GOT entry.
- RelocationEntry RE(SectionID, StubOffset + 2,
- ELF::R_X86_64_GOTPCREL, -4);
+ RelocationEntry RE(SectionID, StubOffset + 2, ELF::R_X86_64_GOTPCREL,
+ -4);
addRelocationForSymbol(RE, Value.SymbolName);
// Bump our stub offset counter
@@ -1321,8 +1252,8 @@ RuntimeDyldELF::processRelocationRef(uns
}
// Make the target call a call into the stub table.
- resolveRelocation(Section, Offset, StubAddress,
- ELF::R_X86_64_PC32, Addend);
+ resolveRelocation(Section, Offset, StubAddress, ELF::R_X86_64_PC32,
+ Addend);
} else {
RelocationEntry RE(SectionID, Offset, ELF::R_X86_64_PC32, Value.Addend,
Value.Offset);
@@ -1343,8 +1274,8 @@ RuntimeDyldELF::processRelocationRef(uns
void RuntimeDyldELF::updateGOTEntries(StringRef Name, uint64_t Addr) {
- SmallVectorImpl<std::pair<SID, GOTRelocations> >::iterator it;
- SmallVectorImpl<std::pair<SID, GOTRelocations> >::iterator end = GOTs.end();
+ SmallVectorImpl<std::pair<SID, GOTRelocations>>::iterator it;
+ SmallVectorImpl<std::pair<SID, GOTRelocations>>::iterator end = GOTs.end();
for (it = GOTs.begin(); it != end; ++it) {
GOTRelocations &GOTEntries = it->second;
@@ -1375,18 +1306,19 @@ size_t RuntimeDyldELF::getGOTEntrySize()
case Triple::mipsel:
Result = sizeof(uint32_t);
break;
- default: llvm_unreachable("Unsupported CPU type!");
+ default:
+ llvm_unreachable("Unsupported CPU type!");
}
return Result;
}
-uint64_t RuntimeDyldELF::findGOTEntry(uint64_t LoadAddress,
- uint64_t Offset) {
+uint64_t RuntimeDyldELF::findGOTEntry(uint64_t LoadAddress, uint64_t Offset) {
const size_t GOTEntrySize = getGOTEntrySize();
- SmallVectorImpl<std::pair<SID, GOTRelocations> >::const_iterator it;
- SmallVectorImpl<std::pair<SID, GOTRelocations> >::const_iterator end = GOTs.end();
+ SmallVectorImpl<std::pair<SID, GOTRelocations>>::const_iterator it;
+ SmallVectorImpl<std::pair<SID, GOTRelocations>>::const_iterator end =
+ GOTs.end();
int GOTIndex = -1;
for (it = GOTs.begin(); it != end; ++it) {
@@ -1416,11 +1348,11 @@ uint64_t RuntimeDyldELF::findGOTEntry(ui
if (GOTIndex != -1) {
if (GOTEntrySize == sizeof(uint64_t)) {
- uint64_t *LocalGOTAddr = (uint64_t*)getSectionAddress(GOTSectionID);
+ uint64_t *LocalGOTAddr = (uint64_t *)getSectionAddress(GOTSectionID);
// Fill in this entry with the address of the symbol being referenced.
LocalGOTAddr[GOTIndex] = LoadAddress + SymbolOffset;
} else {
- uint32_t *LocalGOTAddr = (uint32_t*)getSectionAddress(GOTSectionID);
+ uint32_t *LocalGOTAddr = (uint32_t *)getSectionAddress(GOTSectionID);
// Fill in this entry with the address of the symbol being referenced.
LocalGOTAddr[GOTIndex] = (uint32_t)(LoadAddress + SymbolOffset);
}
@@ -1454,8 +1386,7 @@ void RuntimeDyldELF::finalizeLoad(ObjSec
// needed when GOT-based relocations are applied.
memset(Addr, 0, TotalSize);
}
- }
- else {
+ } else {
report_fatal_error("Unable to allocate memory for GOT!");
}
@@ -1475,7 +1406,8 @@ void RuntimeDyldELF::finalizeLoad(ObjSec
bool RuntimeDyldELF::isCompatibleFormat(const ObjectBuffer *Buffer) const {
if (Buffer->getBufferSize() < strlen(ELF::ElfMagic))
return false;
- return (memcmp(Buffer->getBufferStart(), ELF::ElfMagic, strlen(ELF::ElfMagic))) == 0;
+ return (memcmp(Buffer->getBufferStart(), ELF::ElfMagic,
+ strlen(ELF::ElfMagic))) == 0;
}
bool RuntimeDyldELF::isCompatibleFile(const object::ObjectFile *Obj) const {
Modified: llvm/trunk/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.h?rev=204507&r1=204506&r2=204507&view=diff
==============================================================================
--- llvm/trunk/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.h (original)
+++ llvm/trunk/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.h Fri Mar 21 15:28:42 2014
@@ -22,65 +22,41 @@ using namespace llvm;
namespace llvm {
namespace {
- // Helper for extensive error checking in debug builds.
- error_code Check(error_code Err) {
- if (Err) {
- report_fatal_error(Err.message());
- }
- return Err;
+// Helper for extensive error checking in debug builds.
+error_code Check(error_code Err) {
+ if (Err) {
+ report_fatal_error(Err.message());
}
+ return Err;
+}
} // end anonymous namespace
class RuntimeDyldELF : public RuntimeDyldImpl {
- void resolveRelocation(const SectionEntry &Section,
- uint64_t Offset,
- uint64_t Value,
- uint32_t Type,
- int64_t Addend,
- uint64_t SymOffset=0);
-
- void resolveX86_64Relocation(const SectionEntry &Section,
- uint64_t Offset,
- uint64_t Value,
- uint32_t Type,
- int64_t Addend,
+ void resolveRelocation(const SectionEntry &Section, uint64_t Offset,
+ uint64_t Value, uint32_t Type, int64_t Addend,
+ uint64_t SymOffset = 0);
+
+ void resolveX86_64Relocation(const SectionEntry &Section, uint64_t Offset,
+ uint64_t Value, uint32_t Type, int64_t Addend,
uint64_t SymOffset);
- void resolveX86Relocation(const SectionEntry &Section,
- uint64_t Offset,
- uint32_t Value,
- uint32_t Type,
- int32_t Addend);
-
- void resolveAArch64Relocation(const SectionEntry &Section,
- uint64_t Offset,
- uint64_t Value,
- uint32_t Type,
- int64_t Addend);
-
- void resolveARMRelocation(const SectionEntry &Section,
- uint64_t Offset,
- uint32_t Value,
- uint32_t Type,
- int32_t Addend);
-
- void resolveMIPSRelocation(const SectionEntry &Section,
- uint64_t Offset,
- uint32_t Value,
- uint32_t Type,
- int32_t Addend);
-
- void resolvePPC64Relocation(const SectionEntry &Section,
- uint64_t Offset,
- uint64_t Value,
- uint32_t Type,
- int64_t Addend);
-
- void resolveSystemZRelocation(const SectionEntry &Section,
- uint64_t Offset,
- uint64_t Value,
- uint32_t Type,
- int64_t Addend);
+ void resolveX86Relocation(const SectionEntry &Section, uint64_t Offset,
+ uint32_t Value, uint32_t Type, int32_t Addend);
+
+ void resolveAArch64Relocation(const SectionEntry &Section, uint64_t Offset,
+ uint64_t Value, uint32_t Type, int64_t Addend);
+
+ void resolveARMRelocation(const SectionEntry &Section, uint64_t Offset,
+ uint32_t Value, uint32_t Type, int32_t Addend);
+
+ void resolveMIPSRelocation(const SectionEntry &Section, uint64_t Offset,
+ uint32_t Value, uint32_t Type, int32_t Addend);
+
+ void resolvePPC64Relocation(const SectionEntry &Section, uint64_t Offset,
+ uint64_t Value, uint32_t Type, int64_t Addend);
+
+ void resolveSystemZRelocation(const SectionEntry &Section, uint64_t Offset,
+ uint64_t Value, uint32_t Type, int64_t Addend);
unsigned getMaxStubSize() override {
if (Arch == Triple::aarch64)
@@ -107,8 +83,7 @@ class RuntimeDyldELF : public RuntimeDyl
}
uint64_t findPPC64TOC() const;
- void findOPDEntrySection(ObjectImage &Obj,
- ObjSectionToIDMap &LocalSections,
+ void findOPDEntrySection(ObjectImage &Obj, ObjSectionToIDMap &LocalSections,
RelocationValueRef &Rel);
uint64_t findGOTEntry(uint64_t LoadAddr, uint64_t Offset);
@@ -129,8 +104,7 @@ class RuntimeDyldELF : public RuntimeDyl
SmallVector<SID, 2> RegisteredEHFrameSections;
public:
- RuntimeDyldELF(RTDyldMemoryManager *mm) : RuntimeDyldImpl(mm)
- {}
+ RuntimeDyldELF(RTDyldMemoryManager *mm) : RuntimeDyldImpl(mm) {}
void resolveRelocation(const RelocationEntry &RE, uint64_t Value) override;
relocation_iterator
Modified: llvm/trunk/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldImpl.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldImpl.h?rev=204507&r1=204506&r2=204507&view=diff
==============================================================================
--- llvm/trunk/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldImpl.h (original)
+++ llvm/trunk/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldImpl.h Fri Mar 21 15:28:42 2014
@@ -39,7 +39,6 @@ namespace llvm {
class ObjectBuffer;
class Twine;
-
/// SectionEntry - represents a section emitted into memory by the dynamic
/// linker.
class SectionEntry {
@@ -69,8 +68,9 @@ public:
SectionEntry(StringRef name, uint8_t *address, size_t size,
uintptr_t objAddress)
- : Name(name), Address(address), Size(size), LoadAddress((uintptr_t)address),
- StubOffset(size), ObjAddress(objAddress) {}
+ : Name(name), Address(address), Size(size),
+ LoadAddress((uintptr_t)address), StubOffset(size),
+ ObjAddress(objAddress) {}
};
/// RelocationEntry - used to represent relocations internally in the dynamic
@@ -101,33 +101,33 @@ public:
unsigned Size;
RelocationEntry(unsigned id, uint64_t offset, uint32_t type, int64_t addend)
- : SectionID(id), Offset(offset), RelType(type), Addend(addend),
- SymOffset(0), IsPCRel(false), Size(0) {}
+ : SectionID(id), Offset(offset), RelType(type), Addend(addend),
+ SymOffset(0), IsPCRel(false), Size(0) {}
RelocationEntry(unsigned id, uint64_t offset, uint32_t type, int64_t addend,
uint64_t symoffset)
- : SectionID(id), Offset(offset), RelType(type), Addend(addend),
- SymOffset(symoffset), IsPCRel(false), Size(0) {}
+ : SectionID(id), Offset(offset), RelType(type), Addend(addend),
+ SymOffset(symoffset), IsPCRel(false), Size(0) {}
RelocationEntry(unsigned id, uint64_t offset, uint32_t type, int64_t addend,
bool IsPCRel, unsigned Size)
- : SectionID(id), Offset(offset), RelType(type), Addend(addend),
- SymOffset(0), IsPCRel(IsPCRel), Size(Size) {}
+ : SectionID(id), Offset(offset), RelType(type), Addend(addend),
+ SymOffset(0), IsPCRel(IsPCRel), Size(Size) {}
};
class RelocationValueRef {
public:
- unsigned SectionID;
- uint64_t Offset;
- int64_t Addend;
+ unsigned SectionID;
+ uint64_t Offset;
+ int64_t Addend;
const char *SymbolName;
- RelocationValueRef(): SectionID(0), Offset(0), Addend(0), SymbolName(0) {}
+ RelocationValueRef() : SectionID(0), Offset(0), Addend(0), SymbolName(0) {}
inline bool operator==(const RelocationValueRef &Other) const {
return SectionID == Other.SectionID && Offset == Other.Offset &&
Addend == Other.Addend && SymbolName == Other.SymbolName;
}
- inline bool operator <(const RelocationValueRef &Other) const {
+ inline bool operator<(const RelocationValueRef &Other) const {
if (SectionID != Other.SectionID)
return SectionID < Other.SectionID;
if (Offset != Other.Offset)
@@ -149,7 +149,7 @@ protected:
SectionList Sections;
typedef unsigned SID; // Type for SectionIDs
- #define RTDYLD_INVALID_SECTION_ID ((SID)(-1))
+#define RTDYLD_INVALID_SECTION_ID ((SID)(-1))
// Keep a map of sections from object file to the SectionID which
// references it.
@@ -221,52 +221,49 @@ protected:
}
uint8_t *getSectionAddress(unsigned SectionID) {
- return (uint8_t*)Sections[SectionID].Address;
+ return (uint8_t *)Sections[SectionID].Address;
}
void writeInt16BE(uint8_t *Addr, uint16_t Value) {
if (IsTargetLittleEndian)
Value = sys::SwapByteOrder(Value);
- *Addr = (Value >> 8) & 0xFF;
- *(Addr+1) = Value & 0xFF;
+ *Addr = (Value >> 8) & 0xFF;
+ *(Addr + 1) = Value & 0xFF;
}
void writeInt32BE(uint8_t *Addr, uint32_t Value) {
if (IsTargetLittleEndian)
Value = sys::SwapByteOrder(Value);
- *Addr = (Value >> 24) & 0xFF;
- *(Addr+1) = (Value >> 16) & 0xFF;
- *(Addr+2) = (Value >> 8) & 0xFF;
- *(Addr+3) = Value & 0xFF;
+ *Addr = (Value >> 24) & 0xFF;
+ *(Addr + 1) = (Value >> 16) & 0xFF;
+ *(Addr + 2) = (Value >> 8) & 0xFF;
+ *(Addr + 3) = Value & 0xFF;
}
void writeInt64BE(uint8_t *Addr, uint64_t Value) {
if (IsTargetLittleEndian)
Value = sys::SwapByteOrder(Value);
- *Addr = (Value >> 56) & 0xFF;
- *(Addr+1) = (Value >> 48) & 0xFF;
- *(Addr+2) = (Value >> 40) & 0xFF;
- *(Addr+3) = (Value >> 32) & 0xFF;
- *(Addr+4) = (Value >> 24) & 0xFF;
- *(Addr+5) = (Value >> 16) & 0xFF;
- *(Addr+6) = (Value >> 8) & 0xFF;
- *(Addr+7) = Value & 0xFF;
+ *Addr = (Value >> 56) & 0xFF;
+ *(Addr + 1) = (Value >> 48) & 0xFF;
+ *(Addr + 2) = (Value >> 40) & 0xFF;
+ *(Addr + 3) = (Value >> 32) & 0xFF;
+ *(Addr + 4) = (Value >> 24) & 0xFF;
+ *(Addr + 5) = (Value >> 16) & 0xFF;
+ *(Addr + 6) = (Value >> 8) & 0xFF;
+ *(Addr + 7) = Value & 0xFF;
}
/// \brief Given the common symbols discovered in the object file, emit a
/// new section for them and update the symbol mappings in the object and
/// symbol table.
- void emitCommonSymbols(ObjectImage &Obj,
- const CommonSymbolMap &CommonSymbols,
- uint64_t TotalSize,
- SymbolTableMap &SymbolTable);
+ void emitCommonSymbols(ObjectImage &Obj, const CommonSymbolMap &CommonSymbols,
+ uint64_t TotalSize, SymbolTableMap &SymbolTable);
/// \brief Emits section data from the object file to the MemoryManager.
/// \param IsCode if it's true then allocateCodeSection() will be
/// used for emits, else allocateDataSection() will be used.
/// \return SectionID.
- unsigned emitSection(ObjectImage &Obj,
- const SectionRef &Section,
+ unsigned emitSection(ObjectImage &Obj, const SectionRef &Section,
bool IsCode);
/// \brief Find Section in LocalSections. If the secton is not found - emit
@@ -274,10 +271,8 @@ protected:
/// \param IsCode if it's true then allocateCodeSection() will be
/// used for emmits, else allocateDataSection() will be used.
/// \return SectionID.
- unsigned findOrEmitSection(ObjectImage &Obj,
- const SectionRef &Section,
- bool IsCode,
- ObjSectionToIDMap &LocalSections);
+ unsigned findOrEmitSection(ObjectImage &Obj, const SectionRef &Section,
+ bool IsCode, ObjSectionToIDMap &LocalSections);
// \brief Add a relocation entry that uses the given section.
void addRelocationForSection(const RelocationEntry &RE, unsigned SectionID);
@@ -288,7 +283,7 @@ protected:
/// \brief Emits long jump instruction to Addr.
/// \return Pointer to the memory area for emitting target address.
- uint8_t* createStubFunction(uint8_t *Addr);
+ uint8_t *createStubFunction(uint8_t *Addr);
/// \brief Resolves relocations from Relocs list with address from Value.
void resolveRelocationList(const RelocationList &Relocs, uint64_t Value);
@@ -312,19 +307,18 @@ protected:
// The base class does nothing. ELF overrides this.
virtual void updateGOTEntries(StringRef Name, uint64_t Addr) {}
- // \brief Compute an upper bound of the memory that is required to load all sections
- void computeTotalAllocSize(ObjectImage &Obj,
- uint64_t& CodeSize,
- uint64_t& DataSizeRO,
- uint64_t& DataSizeRW);
-
+ // \brief Compute an upper bound of the memory that is required to load all
+ // sections
+ void computeTotalAllocSize(ObjectImage &Obj, uint64_t &CodeSize,
+ uint64_t &DataSizeRO, uint64_t &DataSizeRW);
+
// \brief Compute the stub buffer size required for a section
unsigned computeSectionStubBufSize(ObjectImage &Obj,
const SectionRef &Section);
public:
RuntimeDyldImpl(RTDyldMemoryManager *mm)
- : MemMgr(mm), ProcessAllSections(false), HasError(false) {}
+ : MemMgr(mm), ProcessAllSections(false), HasError(false) {}
virtual ~RuntimeDyldImpl();
@@ -332,7 +326,7 @@ public:
this->ProcessAllSections = ProcessAllSections;
}
- ObjectImage* loadObject(ObjectImage* InputObject);
+ ObjectImage *loadObject(ObjectImage *InputObject);
void *getSymbolAddress(StringRef Name) {
// FIXME: Just look up as a function for now. Overly simple of course.
Modified: llvm/trunk/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp?rev=204507&r1=204506&r2=204507&view=diff
==============================================================================
--- llvm/trunk/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp (original)
+++ llvm/trunk/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp Fri Mar 21 15:28:42 2014
@@ -20,18 +20,19 @@ using namespace llvm::object;
namespace llvm {
-static unsigned char *processFDE(unsigned char *P, intptr_t DeltaForText, intptr_t DeltaForEH) {
- uint32_t Length = *((uint32_t*)P);
+static unsigned char *processFDE(unsigned char *P, intptr_t DeltaForText,
+ intptr_t DeltaForEH) {
+ uint32_t Length = *((uint32_t *)P);
P += 4;
unsigned char *Ret = P + Length;
- uint32_t Offset = *((uint32_t*)P);
+ uint32_t Offset = *((uint32_t *)P);
if (Offset == 0) // is a CIE
return Ret;
P += 4;
- intptr_t FDELocation = *((intptr_t*)P);
+ intptr_t FDELocation = *((intptr_t *)P);
intptr_t NewLocation = FDELocation - DeltaForText;
- *((intptr_t*)P) = NewLocation;
+ *((intptr_t *)P) = NewLocation;
P += sizeof(intptr_t);
// Skip the FDE address range
@@ -40,16 +41,16 @@ static unsigned char *processFDE(unsigne
uint8_t Augmentationsize = *P;
P += 1;
if (Augmentationsize != 0) {
- intptr_t LSDA = *((intptr_t*)P);
+ intptr_t LSDA = *((intptr_t *)P);
intptr_t NewLSDA = LSDA - DeltaForEH;
- *((intptr_t*)P) = NewLSDA;
+ *((intptr_t *)P) = NewLSDA;
}
return Ret;
}
static intptr_t computeDelta(SectionEntry *A, SectionEntry *B) {
- intptr_t ObjDistance = A->ObjAddress - B->ObjAddress;
+ intptr_t ObjDistance = A->ObjAddress - B->ObjAddress;
intptr_t MemDistance = A->LoadAddress - B->LoadAddress;
return ObjDistance - MemDistance;
}
@@ -76,12 +77,11 @@ void RuntimeDyldMachO::registerEHFrames(
unsigned char *P = EHFrame->Address;
unsigned char *End = P + EHFrame->Size;
- do {
+ do {
P = processFDE(P, DeltaForText, DeltaForEH);
- } while(P != End);
+ } while (P != End);
- MemMgr->registerEHFrames(EHFrame->Address,
- EHFrame->LoadAddress,
+ MemMgr->registerEHFrames(EHFrame->Address, EHFrame->LoadAddress,
EHFrame->Size);
}
UnregisteredEHFrameSections.clear();
@@ -103,9 +103,8 @@ void RuntimeDyldMachO::finalizeLoad(ObjS
else if (Name == "__gcc_except_tab")
ExceptTabSID = i->second;
}
- UnregisteredEHFrameSections.push_back(EHFrameRelatedSections(EHFrameSID,
- TextSID,
- ExceptTabSID));
+ UnregisteredEHFrameSections.push_back(
+ EHFrameRelatedSections(EHFrameSID, TextSID, ExceptTabSID));
}
// The target location for the relocation is described by RE.SectionID and
@@ -136,67 +135,45 @@ void RuntimeDyldMachO::resolveRelocation
}
void RuntimeDyldMachO::resolveRelocation(const SectionEntry &Section,
- uint64_t Offset,
- uint64_t Value,
- uint32_t Type,
- int64_t Addend,
- bool isPCRel,
- unsigned LogSize) {
+ uint64_t Offset, uint64_t Value,
+ uint32_t Type, int64_t Addend,
+ bool isPCRel, unsigned LogSize) {
uint8_t *LocalAddress = Section.Address + Offset;
uint64_t FinalAddress = Section.LoadAddress + Offset;
unsigned MachoType = Type;
unsigned Size = 1 << LogSize;
DEBUG(dbgs() << "resolveRelocation LocalAddress: "
- << format("%p", LocalAddress)
- << " FinalAddress: " << format("%p", FinalAddress)
- << " Value: " << format("%p", Value)
- << " Addend: " << Addend
- << " isPCRel: " << isPCRel
- << " MachoType: " << MachoType
- << " Size: " << Size
- << "\n");
+ << format("%p", LocalAddress)
+ << " FinalAddress: " << format("%p", FinalAddress)
+ << " Value: " << format("%p", Value) << " Addend: " << Addend
+ << " isPCRel: " << isPCRel << " MachoType: " << MachoType
+ << " Size: " << Size << "\n");
// This just dispatches to the proper target specific routine.
switch (Arch) {
- default: llvm_unreachable("Unsupported CPU type!");
+ default:
+ llvm_unreachable("Unsupported CPU type!");
case Triple::x86_64:
- resolveX86_64Relocation(LocalAddress,
- FinalAddress,
- (uintptr_t)Value,
- isPCRel,
- MachoType,
- Size,
- Addend);
+ resolveX86_64Relocation(LocalAddress, FinalAddress, (uintptr_t)Value,
+ isPCRel, MachoType, Size, Addend);
break;
case Triple::x86:
- resolveI386Relocation(LocalAddress,
- FinalAddress,
- (uintptr_t)Value,
- isPCRel,
- MachoType,
- Size,
- Addend);
+ resolveI386Relocation(LocalAddress, FinalAddress, (uintptr_t)Value, isPCRel,
+ MachoType, Size, Addend);
break;
- case Triple::arm: // Fall through.
+ case Triple::arm: // Fall through.
case Triple::thumb:
- resolveARMRelocation(LocalAddress,
- FinalAddress,
- (uintptr_t)Value,
- isPCRel,
- MachoType,
- Size,
- Addend);
+ resolveARMRelocation(LocalAddress, FinalAddress, (uintptr_t)Value, isPCRel,
+ MachoType, Size, Addend);
break;
}
}
bool RuntimeDyldMachO::resolveI386Relocation(uint8_t *LocalAddress,
uint64_t FinalAddress,
- uint64_t Value,
- bool isPCRel,
- unsigned Type,
- unsigned Size,
+ uint64_t Value, bool isPCRel,
+ unsigned Type, unsigned Size,
int64_t Addend) {
if (isPCRel)
Value -= FinalAddress + 4; // see resolveX86_64Relocation
@@ -222,10 +199,8 @@ bool RuntimeDyldMachO::resolveI386Reloca
bool RuntimeDyldMachO::resolveX86_64Relocation(uint8_t *LocalAddress,
uint64_t FinalAddress,
- uint64_t Value,
- bool isPCRel,
- unsigned Type,
- unsigned Size,
+ uint64_t Value, bool isPCRel,
+ unsigned Type, unsigned Size,
int64_t Addend) {
// If the relocation is PC-relative, the value to be encoded is the
// pointer difference.
@@ -234,7 +209,7 @@ bool RuntimeDyldMachO::resolveX86_64Relo
// address. Is that expected? Only for branches, perhaps?
Value -= FinalAddress + 4;
- switch(Type) {
+ switch (Type) {
default:
llvm_unreachable("Invalid relocation type!");
case MachO::X86_64_RELOC_SIGNED_1:
@@ -246,7 +221,7 @@ bool RuntimeDyldMachO::resolveX86_64Relo
Value += Addend;
// Mask in the target value a byte at a time (we don't have an alignment
// guarantee for the target address, so this is safest).
- uint8_t *p = (uint8_t*)LocalAddress;
+ uint8_t *p = (uint8_t *)LocalAddress;
for (unsigned i = 0; i < Size; ++i) {
*p++ = (uint8_t)Value;
Value >>= 8;
@@ -263,10 +238,8 @@ bool RuntimeDyldMachO::resolveX86_64Relo
bool RuntimeDyldMachO::resolveARMRelocation(uint8_t *LocalAddress,
uint64_t FinalAddress,
- uint64_t Value,
- bool isPCRel,
- unsigned Type,
- unsigned Size,
+ uint64_t Value, bool isPCRel,
+ unsigned Type, unsigned Size,
int64_t Addend) {
// If the relocation is PC-relative, the value to be encoded is the
// pointer difference.
@@ -278,13 +251,13 @@ bool RuntimeDyldMachO::resolveARMRelocat
Value -= 8;
}
- switch(Type) {
+ switch (Type) {
default:
llvm_unreachable("Invalid relocation type!");
case MachO::ARM_RELOC_VANILLA: {
// Mask in the target value a byte at a time (we don't have an alignment
// guarantee for the target address, so this is safest).
- uint8_t *p = (uint8_t*)LocalAddress;
+ uint8_t *p = (uint8_t *)LocalAddress;
for (unsigned i = 0; i < Size; ++i) {
*p++ = (uint8_t)Value;
Value >>= 8;
@@ -294,7 +267,7 @@ bool RuntimeDyldMachO::resolveARMRelocat
case MachO::ARM_RELOC_BR24: {
// Mask the value into the target address. We know instructions are
// 32-bit aligned, so we can do it all at once.
- uint32_t *p = (uint32_t*)LocalAddress;
+ uint32_t *p = (uint32_t *)LocalAddress;
// The low two bits of the value are not encoded.
Value >>= 2;
// Mask the value to 24 bits.
@@ -320,17 +293,14 @@ bool RuntimeDyldMachO::resolveARMRelocat
return false;
}
-relocation_iterator
-RuntimeDyldMachO::processRelocationRef(unsigned SectionID,
- relocation_iterator RelI,
- ObjectImage &Obj,
- ObjSectionToIDMap &ObjSectionToID,
- const SymbolTableMap &Symbols,
- StubMap &Stubs) {
+relocation_iterator RuntimeDyldMachO::processRelocationRef(
+ unsigned SectionID, relocation_iterator RelI, ObjectImage &Obj,
+ ObjSectionToIDMap &ObjSectionToID, const SymbolTableMap &Symbols,
+ StubMap &Stubs) {
const ObjectFile *OF = Obj.getObjectFile();
- const MachOObjectFile *MachO = static_cast<const MachOObjectFile*>(OF);
+ const MachOObjectFile *MachO = static_cast<const MachOObjectFile *>(OF);
MachO::any_relocation_info RE =
- MachO->getRelocation(RelI->getRawDataRefImpl());
+ MachO->getRelocation(RelI->getRawDataRefImpl());
uint32_t RelType = MachO->getAnyRelocationType(RE);
@@ -368,7 +338,8 @@ RuntimeDyldMachO::processRelocationRef(u
Value.Addend = lsi->second.second + Addend;
} else {
// Search for the symbol in the global symbol table
- SymbolTableMap::const_iterator gsi = GlobalSymbolTable.find(TargetName.data());
+ SymbolTableMap::const_iterator gsi =
+ GlobalSymbolTable.find(TargetName.data());
if (gsi != GlobalSymbolTable.end()) {
Value.SectionID = gsi->second.first;
Value.Addend = gsi->second.second + Addend;
@@ -411,21 +382,19 @@ RuntimeDyldMachO::processRelocationRef(u
}
resolveRelocation(Section, Offset, (uint64_t)Addr,
MachO::X86_64_RELOC_UNSIGNED, Value.Addend, true, 2);
- } else if (Arch == Triple::arm &&
- (RelType & 0xf) == MachO::ARM_RELOC_BR24) {
+ } else if (Arch == Triple::arm && (RelType & 0xf) == MachO::ARM_RELOC_BR24) {
// This is an ARM branch relocation, need to use a stub function.
// Look up for existing stub.
StubMap::const_iterator i = Stubs.find(Value);
if (i != Stubs.end())
- resolveRelocation(Section, Offset,
- (uint64_t)Section.Address + i->second,
+ resolveRelocation(Section, Offset, (uint64_t)Section.Address + i->second,
RelType, 0, IsPCRel, Size);
else {
// Create a new stub function.
Stubs[Value] = Section.StubOffset;
- uint8_t *StubTargetAddr = createStubFunction(Section.Address +
- Section.StubOffset);
+ uint8_t *StubTargetAddr =
+ createStubFunction(Section.Address + Section.StubOffset);
RelocationEntry RE(SectionID, StubTargetAddr - Section.Address,
MachO::GENERIC_RELOC_VANILLA, Value.Addend);
if (Value.SymbolName)
@@ -433,13 +402,12 @@ RuntimeDyldMachO::processRelocationRef(u
else
addRelocationForSection(RE, Value.SectionID);
resolveRelocation(Section, Offset,
- (uint64_t)Section.Address + Section.StubOffset,
- RelType, 0, IsPCRel, Size);
+ (uint64_t)Section.Address + Section.StubOffset, RelType,
+ 0, IsPCRel, Size);
Section.StubOffset += getMaxStubSize();
}
} else {
- RelocationEntry RE(SectionID, Offset, RelType, Value.Addend,
- IsPCRel, Size);
+ RelocationEntry RE(SectionID, Offset, RelType, Value.Addend, IsPCRel, Size);
if (Value.SymbolName)
addRelocationForSymbol(RE, Value.SymbolName);
else
@@ -448,21 +416,23 @@ RuntimeDyldMachO::processRelocationRef(u
return ++RelI;
}
-
-bool RuntimeDyldMachO::isCompatibleFormat(
- const ObjectBuffer *InputBuffer) const {
+bool
+RuntimeDyldMachO::isCompatibleFormat(const ObjectBuffer *InputBuffer) const {
if (InputBuffer->getBufferSize() < 4)
return false;
StringRef Magic(InputBuffer->getBufferStart(), 4);
- if (Magic == "\xFE\xED\xFA\xCE") return true;
- if (Magic == "\xCE\xFA\xED\xFE") return true;
- if (Magic == "\xFE\xED\xFA\xCF") return true;
- if (Magic == "\xCF\xFA\xED\xFE") return true;
+ if (Magic == "\xFE\xED\xFA\xCE")
+ return true;
+ if (Magic == "\xCE\xFA\xED\xFE")
+ return true;
+ if (Magic == "\xFE\xED\xFA\xCF")
+ return true;
+ if (Magic == "\xCF\xFA\xED\xFE")
+ return true;
return false;
}
-bool RuntimeDyldMachO::isCompatibleFile(
- const object::ObjectFile *Obj) const {
+bool RuntimeDyldMachO::isCompatibleFile(const object::ObjectFile *Obj) const {
return Obj->isMachO();
}
Modified: llvm/trunk/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.h?rev=204507&r1=204506&r2=204507&view=diff
==============================================================================
--- llvm/trunk/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.h (original)
+++ llvm/trunk/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.h Fri Mar 21 15:28:42 2014
@@ -23,38 +23,21 @@
using namespace llvm;
using namespace llvm::object;
-
namespace llvm {
class RuntimeDyldMachO : public RuntimeDyldImpl {
- bool resolveI386Relocation(uint8_t *LocalAddress,
- uint64_t FinalAddress,
- uint64_t Value,
- bool isPCRel,
- unsigned Type,
- unsigned Size,
- int64_t Addend);
- bool resolveX86_64Relocation(uint8_t *LocalAddress,
- uint64_t FinalAddress,
- uint64_t Value,
- bool isPCRel,
- unsigned Type,
- unsigned Size,
- int64_t Addend);
- bool resolveARMRelocation(uint8_t *LocalAddress,
- uint64_t FinalAddress,
- uint64_t Value,
- bool isPCRel,
- unsigned Type,
- unsigned Size,
- int64_t Addend);
-
- void resolveRelocation(const SectionEntry &Section,
- uint64_t Offset,
- uint64_t Value,
- uint32_t Type,
- int64_t Addend,
- bool isPCRel,
- unsigned Size);
+ bool resolveI386Relocation(uint8_t *LocalAddress, uint64_t FinalAddress,
+ uint64_t Value, bool isPCRel, unsigned Type,
+ unsigned Size, int64_t Addend);
+ bool resolveX86_64Relocation(uint8_t *LocalAddress, uint64_t FinalAddress,
+ uint64_t Value, bool isPCRel, unsigned Type,
+ unsigned Size, int64_t Addend);
+ bool resolveARMRelocation(uint8_t *LocalAddress, uint64_t FinalAddress,
+ uint64_t Value, bool isPCRel, unsigned Type,
+ unsigned Size, int64_t Addend);
+
+ void resolveRelocation(const SectionEntry &Section, uint64_t Offset,
+ uint64_t Value, uint32_t Type, int64_t Addend,
+ bool isPCRel, unsigned Size);
unsigned getMaxStubSize() override {
if (Arch == Triple::arm || Arch == Triple::thumb)
@@ -65,16 +48,15 @@ class RuntimeDyldMachO : public RuntimeD
return 0;
}
- unsigned getStubAlignment() override {
- return 1;
- }
+ unsigned getStubAlignment() override { return 1; }
struct EHFrameRelatedSections {
- EHFrameRelatedSections() : EHFrameSID(RTDYLD_INVALID_SECTION_ID),
- TextSID(RTDYLD_INVALID_SECTION_ID),
- ExceptTabSID(RTDYLD_INVALID_SECTION_ID) {}
+ EHFrameRelatedSections()
+ : EHFrameSID(RTDYLD_INVALID_SECTION_ID),
+ TextSID(RTDYLD_INVALID_SECTION_ID),
+ ExceptTabSID(RTDYLD_INVALID_SECTION_ID) {}
EHFrameRelatedSections(SID EH, SID T, SID Ex)
- : EHFrameSID(EH), TextSID(T), ExceptTabSID(Ex) {}
+ : EHFrameSID(EH), TextSID(T), ExceptTabSID(Ex) {}
SID EHFrameSID;
SID TextSID;
SID ExceptTabSID;
@@ -84,6 +66,7 @@ class RuntimeDyldMachO : public RuntimeD
// in a table until we receive a request to register all unregistered
// EH frame sections with the memory manager.
SmallVector<EHFrameRelatedSections, 2> UnregisteredEHFrameSections;
+
public:
RuntimeDyldMachO(RTDyldMemoryManager *mm) : RuntimeDyldImpl(mm) {}
@@ -97,12 +80,12 @@ public:
void registerEHFrames() override;
void finalizeLoad(ObjSectionToIDMap &SectionMap) override;
-
static ObjectImage *createObjectImage(ObjectBuffer *InputBuffer) {
return new ObjectImageCommon(InputBuffer);
}
- static ObjectImage *createObjectImageFromFile(object::ObjectFile *InputObject) {
+ static ObjectImage *
+ createObjectImageFromFile(object::ObjectFile *InputObject) {
return new ObjectImageCommon(InputObject);
}
};
More information about the llvm-commits
mailing list