diff options
Diffstat (limited to 'lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp')
| -rw-r--r-- | lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp | 236 |
1 files changed, 135 insertions, 101 deletions
diff --git a/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp b/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp index 5b92867b47..7eae9c2145 100644 --- a/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp +++ b/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp @@ -13,7 +13,6 @@ #define DEBUG_TYPE "dyld" #include "RuntimeDyldMachO.h" -#include "llvm/ADT/OwningPtr.h" #include "llvm/ADT/STLExtras.h" #include "llvm/ADT/StringRef.h" using namespace llvm; @@ -21,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 @@ -41,16 +41,16 @@ static unsigned char *processFDE(unsigned char *P, intptr_t DeltaForText, intptr 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; } @@ -77,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(); @@ -104,9 +103,8 @@ void RuntimeDyldMachO::finalizeLoad(ObjSectionToIDMap &SectionMap) { 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 @@ -137,67 +135,49 @@ void RuntimeDyldMachO::resolveRelocation(const RelocationEntry &RE, } 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"); + DEBUG(dbgs() << "resolveRelocation LocalAddress: " + << 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; + case Triple::arm64: + resolveARM64Relocation(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 @@ -223,10 +203,8 @@ bool RuntimeDyldMachO::resolveI386Relocation(uint8_t *LocalAddress, 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. @@ -235,7 +213,7 @@ bool RuntimeDyldMachO::resolveX86_64Relocation(uint8_t *LocalAddress, // 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: @@ -247,7 +225,7 @@ bool RuntimeDyldMachO::resolveX86_64Relocation(uint8_t *LocalAddress, 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; @@ -264,10 +242,8 @@ bool RuntimeDyldMachO::resolveX86_64Relocation(uint8_t *LocalAddress, 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. @@ -279,13 +255,13 @@ bool RuntimeDyldMachO::resolveARMRelocation(uint8_t *LocalAddress, 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; @@ -295,7 +271,7 @@ bool RuntimeDyldMachO::resolveARMRelocation(uint8_t *LocalAddress, 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. @@ -321,15 +297,63 @@ bool RuntimeDyldMachO::resolveARMRelocation(uint8_t *LocalAddress, return false; } -void RuntimeDyldMachO::processRelocationRef(unsigned SectionID, - RelocationRef RelI, - ObjectImage &Obj, - ObjSectionToIDMap &ObjSectionToID, - const SymbolTableMap &Symbols, - StubMap &Stubs) { +bool RuntimeDyldMachO::resolveARM64Relocation(uint8_t *LocalAddress, + uint64_t FinalAddress, + 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. + if (isPCRel) + Value -= FinalAddress; + + switch (Type) { + default: + llvm_unreachable("Invalid relocation type!"); + case MachO::ARM64_RELOC_UNSIGNED: { + // 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; + for (unsigned i = 0; i < Size; ++i) { + *p++ = (uint8_t)Value; + Value >>= 8; + } + break; + } + case MachO::ARM64_RELOC_BRANCH26: { + // 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; + // The low two bits of the value are not encoded. + Value >>= 2; + // Mask the value to 26 bits. + Value &= 0x3ffffff; + // Insert the value into the instruction. + *p = (*p & ~0x3ffffff) | Value; + break; + } + case MachO::ARM64_RELOC_SUBTRACTOR: + case MachO::ARM64_RELOC_PAGE21: + case MachO::ARM64_RELOC_PAGEOFF12: + case MachO::ARM64_RELOC_GOT_LOAD_PAGE21: + case MachO::ARM64_RELOC_GOT_LOAD_PAGEOFF12: + case MachO::ARM64_RELOC_POINTER_TO_GOT: + case MachO::ARM64_RELOC_TLVP_LOAD_PAGE21: + case MachO::ARM64_RELOC_TLVP_LOAD_PAGEOFF12: + case MachO::ARM64_RELOC_ADDEND: + return Error("Relocation type not implemented yet!"); + } + return false; +} + +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); - MachO::any_relocation_info RE= MachO->getRelocation(RelI.getRawDataRefImpl()); + const MachOObjectFile *MachO = static_cast<const MachOObjectFile *>(OF); + MachO::any_relocation_info RE = + MachO->getRelocation(RelI->getRawDataRefImpl()); uint32_t RelType = MachO->getAnyRelocationType(RE); @@ -340,7 +364,7 @@ void RuntimeDyldMachO::processRelocationRef(unsigned SectionID, // Note: This will fail horribly where the relocations *do* need to be // applied, but that was already the case. if (MachO->isRelocationScattered(RE)) - return; + return ++RelI; RelocationValueRef Value; SectionEntry &Section = Sections[SectionID]; @@ -349,7 +373,7 @@ void RuntimeDyldMachO::processRelocationRef(unsigned SectionID, bool IsPCRel = MachO->getAnyRelocationPCRel(RE); unsigned Size = MachO->getAnyRelocationLength(RE); uint64_t Offset; - RelI.getOffset(Offset); + RelI->getOffset(Offset); uint8_t *LocalAddress = Section.Address + Offset; unsigned NumBytes = 1 << Size; uint64_t Addend = 0; @@ -357,7 +381,7 @@ void RuntimeDyldMachO::processRelocationRef(unsigned SectionID, if (isExtern) { // Obtain the symbol name which is referenced in the relocation - symbol_iterator Symbol = RelI.getSymbol(); + symbol_iterator Symbol = RelI->getSymbol(); StringRef TargetName; Symbol->getName(TargetName); // First search for the symbol in the local symbol table @@ -367,7 +391,8 @@ void RuntimeDyldMachO::processRelocationRef(unsigned SectionID, 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; @@ -378,10 +403,14 @@ void RuntimeDyldMachO::processRelocationRef(unsigned SectionID, } } else { SectionRef Sec = MachO->getRelocationSection(RE); - Value.SectionID = findOrEmitSection(Obj, Sec, true, ObjSectionToID); + bool IsCode = false; + Sec.isText(IsCode); + Value.SectionID = findOrEmitSection(Obj, Sec, IsCode, ObjSectionToID); uint64_t Addr; Sec.getAddress(Addr); Value.Addend = Addend - Addr; + if (IsPCRel) + Value.Addend += Offset + NumBytes; } if (Arch == Triple::x86_64 && (RelType == MachO::X86_64_RELOC_GOT || @@ -406,21 +435,19 @@ void RuntimeDyldMachO::processRelocationRef(unsigned SectionID, } 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) @@ -428,31 +455,38 @@ void RuntimeDyldMachO::processRelocationRef(unsigned SectionID, 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 addRelocationForSection(RE, Value.SectionID); } + 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 { + return Obj->isMachO(); +} + } // end namespace llvm |