diff options
Diffstat (limited to 'lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.cpp')
| -rw-r--r-- | lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.cpp | 692 |
1 files changed, 312 insertions, 380 deletions
diff --git a/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.cpp b/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.cpp index 6510bd0a2e..861c9beb1e 100644 --- a/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.cpp +++ b/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.cpp @@ -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_64Relocation(const SectionEntry &Section, 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_64Relocation(const SectionEntry &Section, 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_64Relocation(const SectionEntry &Section, 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_64Relocation(const SectionEntry &Section, } 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::resolveAArch64Relocation(const SectionEntry &Section, 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::resolveAArch64Relocation(const SectionEntry &Section, } 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::resolveAArch64Relocation(const SectionEntry &Section, } 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::resolveARMRelocation(const SectionEntry &Section, *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::resolveARMRelocation(const SectionEntry &Section, } 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::resolveMIPSRelocation(const SectionEntry &Section, *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::resolveMIPSRelocation(const SectionEntry &Section, // 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() const { 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() const { // 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(ObjectImage &Obj, 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(ObjectImage &Obj, // 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::resolvePPC64Relocation(const SectionEntry &Section, // 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::resolvePPC64Relocation(const SectionEntry &Section, 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::resolvePPC64Relocation(const SectionEntry &Section, } 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(const RelocationEntry &RE, } 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(unsigned SectionID, 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(unsigned SectionID, 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(unsigned SectionID, // 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(unsigned SectionID, 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(unsigned SectionID, // 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(unsigned SectionID, 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(unsigned SectionID, // 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(unsigned SectionID, 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(unsigned SectionID, // 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(unsigned SectionID, } 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(unsigned SectionID, 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(unsigned SectionID, 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(unsigned SectionID, } 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(unsigned SectionID, 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(unsigned SectionID, 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(unsigned SectionID, } // 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(unsigned SectionID, 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(uint64_t LoadAddress, 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(ObjSectionToIDMap &SectionMap) { // 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(ObjSectionToIDMap &SectionMap) { 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 { |