diff options
Diffstat (limited to 'ELF/InputSection.cpp')
| -rw-r--r-- | ELF/InputSection.cpp | 755 |
1 files changed, 442 insertions, 313 deletions
diff --git a/ELF/InputSection.cpp b/ELF/InputSection.cpp index 6b1e92891b98..aff57551a8b3 100644 --- a/ELF/InputSection.cpp +++ b/ELF/InputSection.cpp @@ -22,6 +22,7 @@ #include "llvm/Object/Decompressor.h" #include "llvm/Support/Compression.h" #include "llvm/Support/Endian.h" +#include "llvm/Support/Path.h" #include <mutex> using namespace llvm; @@ -29,16 +30,17 @@ using namespace llvm::ELF; using namespace llvm::object; using namespace llvm::support; using namespace llvm::support::endian; +using namespace llvm::sys; using namespace lld; using namespace lld::elf; +std::vector<InputSectionBase *> elf::InputSections; + // Returns a string to construct an error message. -template <class ELFT> -std::string lld::toString(const InputSectionBase<ELFT> *Sec) { +std::string lld::toString(const InputSectionBase *Sec) { // File can be absent if section is synthetic. - std::string FileName = - Sec->getFile() ? Sec->getFile()->getName() : "<internal>"; + std::string FileName = Sec->File ? Sec->File->getName() : "<internal>"; return (FileName + ":(" + Sec->Name + ")").str(); } @@ -50,91 +52,118 @@ static ArrayRef<uint8_t> getSectionContents(elf::ObjectFile<ELFT> *File, return check(File->getObj().getSectionContents(Hdr)); } -template <class ELFT> -InputSectionBase<ELFT>::InputSectionBase(elf::ObjectFile<ELFT> *File, - uintX_t Flags, uint32_t Type, - uintX_t Entsize, uint32_t Link, - uint32_t Info, uintX_t Addralign, - ArrayRef<uint8_t> Data, StringRef Name, - Kind SectionKind) - : InputSectionData(SectionKind, Name, Data, - !Config->GcSections || !(Flags & SHF_ALLOC)), - File(File), Flags(Flags), Entsize(Entsize), Type(Type), Link(Link), - Info(Info), Repl(this) { +InputSectionBase::InputSectionBase(InputFile *File, uint64_t Flags, + uint32_t Type, uint64_t Entsize, + uint32_t Link, uint32_t Info, + uint32_t Alignment, ArrayRef<uint8_t> Data, + StringRef Name, Kind SectionKind) + : SectionBase(SectionKind, Name, Flags, Entsize, Alignment, Type, Info, + Link), + File(File), Data(Data), Repl(this) { + Live = !Config->GcSections || !(Flags & SHF_ALLOC); + Assigned = false; NumRelocations = 0; AreRelocsRela = false; // The ELF spec states that a value of 0 means the section has // no alignment constraits. - uint64_t V = std::max<uint64_t>(Addralign, 1); + uint32_t V = std::max<uint64_t>(Alignment, 1); if (!isPowerOf2_64(V)) fatal(toString(File) + ": section sh_addralign is not a power of 2"); + this->Alignment = V; +} +// GNU assembler 2.24 and LLVM 4.0.0's MC (the newest release as of +// March 2017) fail to infer section types for sections starting with +// ".init_array." or ".fini_array.". They set SHT_PROGBITS instead of +// SHF_INIT_ARRAY. As a result, the following assembler directive +// creates ".init_array.100" with SHT_PROGBITS, for example. +// +// .section .init_array.100, "aw" +// +// This function forces SHT_{INIT,FINI}_ARRAY so that we can handle +// incorrect inputs as if they were correct from the beginning. +static uint64_t getType(uint64_t Type, StringRef Name) { + if (Type == SHT_PROGBITS && Name.startswith(".init_array.")) + return SHT_INIT_ARRAY; + if (Type == SHT_PROGBITS && Name.startswith(".fini_array.")) + return SHT_FINI_ARRAY; + return Type; +} + +template <class ELFT> +InputSectionBase::InputSectionBase(elf::ObjectFile<ELFT> *File, + const typename ELFT::Shdr *Hdr, + StringRef Name, Kind SectionKind) + : InputSectionBase(File, Hdr->sh_flags & ~SHF_INFO_LINK, + getType(Hdr->sh_type, Name), Hdr->sh_entsize, + Hdr->sh_link, Hdr->sh_info, Hdr->sh_addralign, + getSectionContents(File, Hdr), Name, SectionKind) { // We reject object files having insanely large alignments even though // they are allowed by the spec. I think 4GB is a reasonable limitation. // We might want to relax this in the future. - if (V > UINT32_MAX) + if (Hdr->sh_addralign > UINT32_MAX) fatal(toString(File) + ": section sh_addralign is too large"); - Alignment = V; - - // If it is not a mergeable section, overwrite the flag so that the flag - // is consistent with the class. This inconsistency could occur when - // string merging is disabled using -O0 flag. - if (!Config->Relocatable && !isa<MergeInputSection<ELFT>>(this)) - this->Flags &= ~(SHF_MERGE | SHF_STRINGS); } -template <class ELFT> -InputSectionBase<ELFT>::InputSectionBase(elf::ObjectFile<ELFT> *File, - const Elf_Shdr *Hdr, StringRef Name, - Kind SectionKind) - : InputSectionBase(File, Hdr->sh_flags & ~SHF_INFO_LINK, Hdr->sh_type, - Hdr->sh_entsize, Hdr->sh_link, Hdr->sh_info, - Hdr->sh_addralign, getSectionContents(File, Hdr), Name, - SectionKind) { - this->Offset = Hdr->sh_offset; -} - -template <class ELFT> size_t InputSectionBase<ELFT>::getSize() const { - if (auto *S = dyn_cast<SyntheticSection<ELFT>>(this)) +size_t InputSectionBase::getSize() const { + if (auto *S = dyn_cast<SyntheticSection>(this)) return S->getSize(); - if (auto *D = dyn_cast<InputSection<ELFT>>(this)) - if (D->getThunksSize() > 0) - return D->getThunkOff() + D->getThunksSize(); - return Data.size(); } -template <class ELFT> -typename ELFT::uint InputSectionBase<ELFT>::getOffset(uintX_t Offset) const { +uint64_t InputSectionBase::getOffsetInFile() const { + const uint8_t *FileStart = (const uint8_t *)File->MB.getBufferStart(); + const uint8_t *SecStart = Data.begin(); + return SecStart - FileStart; +} + +uint64_t SectionBase::getOffset(uint64_t Offset) const { switch (kind()) { + case Output: { + auto *OS = cast<OutputSection>(this); + // For output sections we treat offset -1 as the end of the section. + return Offset == uint64_t(-1) ? OS->Size : Offset; + } case Regular: - return cast<InputSection<ELFT>>(this)->OutSecOff + Offset; - case Synthetic: + return cast<InputSection>(this)->OutSecOff + Offset; + case Synthetic: { + auto *IS = cast<InputSection>(this); // For synthetic sections we treat offset -1 as the end of the section. - // The same approach is used for synthetic symbols (DefinedSynthetic). - return cast<InputSection<ELFT>>(this)->OutSecOff + - (Offset == uintX_t(-1) ? getSize() : Offset); + return IS->OutSecOff + (Offset == uint64_t(-1) ? IS->getSize() : Offset); + } case EHFrame: // The file crtbeginT.o has relocations pointing to the start of an empty // .eh_frame that is known to be the first in the link. It does that to // identify the start of the output .eh_frame. return Offset; case Merge: - return cast<MergeInputSection<ELFT>>(this)->getOffset(Offset); + const MergeInputSection *MS = cast<MergeInputSection>(this); + if (MS->MergeSec) + return MS->MergeSec->OutSecOff + MS->getOffset(Offset); + return MS->getOffset(Offset); } llvm_unreachable("invalid section kind"); } +OutputSection *SectionBase::getOutputSection() { + if (auto *IS = dyn_cast<InputSection>(this)) + return IS->OutSec; + if (auto *MS = dyn_cast<MergeInputSection>(this)) + return MS->MergeSec ? MS->MergeSec->OutSec : nullptr; + if (auto *EH = dyn_cast<EhInputSection>(this)) + return EH->EHSec->OutSec; + return cast<OutputSection>(this); +} + // Uncompress section contents. Note that this function is called // from parallel_for_each, so it must be thread-safe. -template <class ELFT> void InputSectionBase<ELFT>::uncompress() { - Decompressor Decompressor = check(Decompressor::create( - Name, toStringRef(Data), ELFT::TargetEndianness == llvm::support::little, - ELFT::Is64Bits)); +void InputSectionBase::uncompress() { + Decompressor Dec = check(Decompressor::create(Name, toStringRef(Data), + Config->IsLE, Config->Is64)); - size_t Size = Decompressor.getDecompressedSize(); + size_t Size = Dec.getDecompressedSize(); char *OutputBuf; { static std::mutex Mu; @@ -142,41 +171,44 @@ template <class ELFT> void InputSectionBase<ELFT>::uncompress() { OutputBuf = BAlloc.Allocate<char>(Size); } - if (Error E = Decompressor.decompress({OutputBuf, Size})) - fatal(E, toString(this)); + if (Error E = Dec.decompress({OutputBuf, Size})) + fatal(toString(this) + + ": decompress failed: " + llvm::toString(std::move(E))); Data = ArrayRef<uint8_t>((uint8_t *)OutputBuf, Size); } -template <class ELFT> -typename ELFT::uint -InputSectionBase<ELFT>::getOffset(const DefinedRegular<ELFT> &Sym) const { +uint64_t SectionBase::getOffset(const DefinedRegular &Sym) const { return getOffset(Sym.Value); } -template <class ELFT> -InputSectionBase<ELFT> *InputSectionBase<ELFT>::getLinkOrderDep() const { +InputSectionBase *InputSectionBase::getLinkOrderDep() const { if ((Flags & SHF_LINK_ORDER) && Link != 0) - return getFile()->getSections()[Link]; + return File->getSections()[Link]; return nullptr; } // Returns a source location string. Used to construct an error message. template <class ELFT> -std::string InputSectionBase<ELFT>::getLocation(typename ELFT::uint Offset) { +std::string InputSectionBase::getLocation(uint64_t Offset) { + // We don't have file for synthetic sections. + if (getFile<ELFT>() == nullptr) + return (Config->OutputFile + ":(" + Name + "+0x" + utohexstr(Offset) + ")") + .str(); + // First check if we can get desired values from debugging information. - std::string LineInfo = File->getLineInfo(this, Offset); + std::string LineInfo = getFile<ELFT>()->getLineInfo(this, Offset); if (!LineInfo.empty()) return LineInfo; // File->SourceFile contains STT_FILE symbol that contains a // source file name. If it's missing, we use an object file name. - std::string SrcFile = File->SourceFile; + std::string SrcFile = getFile<ELFT>()->SourceFile; if (SrcFile.empty()) SrcFile = toString(File); // Find a function symbol that encloses a given location. - for (SymbolBody *B : File->getSymbols()) - if (auto *D = dyn_cast<DefinedRegular<ELFT>>(B)) + for (SymbolBody *B : getFile<ELFT>()->getSymbols()) + if (auto *D = dyn_cast<DefinedRegular>(B)) if (D->Section == this && D->Type == STT_FUNC) if (D->Value <= Offset && Offset < D->Value + D->Size) return SrcFile + ":(function " + toString(*D) + ")"; @@ -185,69 +217,144 @@ std::string InputSectionBase<ELFT>::getLocation(typename ELFT::uint Offset) { return (SrcFile + ":(" + Name + "+0x" + utohexstr(Offset) + ")").str(); } -template <class ELFT> -InputSection<ELFT>::InputSection() : InputSectionBase<ELFT>() {} +// Returns a source location string. This function is intended to be +// used for constructing an error message. The returned message looks +// like this: +// +// foo.c:42 (/home/alice/possibly/very/long/path/foo.c:42) +// +// Returns an empty string if there's no way to get line info. +template <class ELFT> std::string InputSectionBase::getSrcMsg(uint64_t Offset) { + // Synthetic sections don't have input files. + elf::ObjectFile<ELFT> *File = getFile<ELFT>(); + if (!File) + return ""; + + Optional<DILineInfo> Info = File->getDILineInfo(this, Offset); + + // File->SourceFile contains STT_FILE symbol, and that is a last resort. + if (!Info) + return File->SourceFile; + + std::string Path = Info->FileName; + std::string Filename = path::filename(Path); + std::string Lineno = ":" + std::to_string(Info->Line); + if (Filename == Path) + return Filename + Lineno; + return Filename + Lineno + " (" + Path + Lineno + ")"; +} + +// Returns a filename string along with an optional section name. This +// function is intended to be used for constructing an error +// message. The returned message looks like this: +// +// path/to/foo.o:(function bar) +// +// or +// +// path/to/foo.o:(function bar) in archive path/to/bar.a +template <class ELFT> std::string InputSectionBase::getObjMsg(uint64_t Off) { + // Synthetic sections don't have input files. + elf::ObjectFile<ELFT> *File = getFile<ELFT>(); + std::string Filename = File ? File->getName() : "(internal)"; + + std::string Archive; + if (!File->ArchiveName.empty()) + Archive = (" in archive " + File->ArchiveName).str(); + + // Find a symbol that encloses a given location. + for (SymbolBody *B : getFile<ELFT>()->getSymbols()) + if (auto *D = dyn_cast<DefinedRegular>(B)) + if (D->Section == this && D->Value <= Off && Off < D->Value + D->Size) + return Filename + ":(" + toString(*D) + ")" + Archive; -template <class ELFT> -InputSection<ELFT>::InputSection(uintX_t Flags, uint32_t Type, - uintX_t Addralign, ArrayRef<uint8_t> Data, - StringRef Name, Kind K) - : InputSectionBase<ELFT>(nullptr, Flags, Type, - /*Entsize*/ 0, /*Link*/ 0, /*Info*/ 0, Addralign, - Data, Name, K) {} + // If there's no symbol, print out the offset in the section. + return (Filename + ":(" + Name + "+0x" + utohexstr(Off) + ")" + Archive) + .str(); +} -template <class ELFT> -InputSection<ELFT>::InputSection(elf::ObjectFile<ELFT> *F, - const Elf_Shdr *Header, StringRef Name) - : InputSectionBase<ELFT>(F, Header, Name, Base::Regular) {} +InputSectionBase InputSectionBase::Discarded; -template <class ELFT> -bool InputSection<ELFT>::classof(const InputSectionData *S) { - return S->kind() == Base::Regular || S->kind() == Base::Synthetic; -} +InputSection::InputSection(uint64_t Flags, uint32_t Type, uint32_t Alignment, + ArrayRef<uint8_t> Data, StringRef Name, Kind K) + : InputSectionBase(nullptr, Flags, Type, + /*Entsize*/ 0, /*Link*/ 0, /*Info*/ 0, Alignment, Data, + Name, K) {} template <class ELFT> -InputSectionBase<ELFT> *InputSection<ELFT>::getRelocatedSection() { - assert(this->Type == SHT_RELA || this->Type == SHT_REL); - ArrayRef<InputSectionBase<ELFT> *> Sections = this->File->getSections(); - return Sections[this->Info]; -} +InputSection::InputSection(elf::ObjectFile<ELFT> *F, + const typename ELFT::Shdr *Header, StringRef Name) + : InputSectionBase(F, Header, Name, InputSectionBase::Regular) {} -template <class ELFT> void InputSection<ELFT>::addThunk(const Thunk<ELFT> *T) { - Thunks.push_back(T); +bool InputSection::classof(const SectionBase *S) { + return S->kind() == SectionBase::Regular || + S->kind() == SectionBase::Synthetic; } -template <class ELFT> uint64_t InputSection<ELFT>::getThunkOff() const { - return this->Data.size(); +bool InputSectionBase::classof(const SectionBase *S) { + return S->kind() != Output; } -template <class ELFT> uint64_t InputSection<ELFT>::getThunksSize() const { - uint64_t Total = 0; - for (const Thunk<ELFT> *T : Thunks) - Total += T->size(); - return Total; +InputSectionBase *InputSection::getRelocatedSection() { + assert(this->Type == SHT_RELA || this->Type == SHT_REL); + ArrayRef<InputSectionBase *> Sections = this->File->getSections(); + return Sections[this->Info]; } -// This is used for -r. We can't use memcpy to copy relocations because we need -// to update symbol table offset and section index for each relocation. So we -// copy relocations one by one. -template <class ELFT> -template <class RelTy> -void InputSection<ELFT>::copyRelocations(uint8_t *Buf, ArrayRef<RelTy> Rels) { - InputSectionBase<ELFT> *RelocatedSection = getRelocatedSection(); +// This is used for -r and --emit-relocs. We can't use memcpy to copy +// relocations because we need to update symbol table offset and section index +// for each relocation. So we copy relocations one by one. +template <class ELFT, class RelTy> +void InputSection::copyRelocations(uint8_t *Buf, ArrayRef<RelTy> Rels) { + InputSectionBase *RelocatedSection = getRelocatedSection(); + // Loop is slow and have complexity O(N*M), where N - amount of + // relocations and M - amount of symbols in symbol table. + // That happens because getSymbolIndex(...) call below performs + // simple linear search. for (const RelTy &Rel : Rels) { - uint32_t Type = Rel.getType(Config->Mips64EL); - SymbolBody &Body = this->File->getRelocTargetSym(Rel); + uint32_t Type = Rel.getType(Config->IsMips64EL); + SymbolBody &Body = this->getFile<ELFT>()->getRelocTargetSym(Rel); - Elf_Rela *P = reinterpret_cast<Elf_Rela *>(Buf); + auto *P = reinterpret_cast<typename ELFT::Rela *>(Buf); Buf += sizeof(RelTy); - if (Config->Rela) + if (Config->IsRela) P->r_addend = getAddend<ELFT>(Rel); - P->r_offset = RelocatedSection->getOffset(Rel.r_offset); + + // Output section VA is zero for -r, so r_offset is an offset within the + // section, but for --emit-relocs it is an virtual address. + P->r_offset = RelocatedSection->OutSec->Addr + + RelocatedSection->getOffset(Rel.r_offset); P->setSymbolAndType(In<ELFT>::SymTab->getSymbolIndex(&Body), Type, - Config->Mips64EL); + Config->IsMips64EL); + + if (Body.Type == STT_SECTION) { + // We combine multiple section symbols into only one per + // section. This means we have to update the addend. That is + // trivial for Elf_Rela, but for Elf_Rel we have to write to the + // section data. We do that by adding to the Relocation vector. + + // .eh_frame is horribly special and can reference discarded sections. To + // avoid having to parse and recreate .eh_frame, we just replace any + // relocation in it pointing to discarded sections with R_*_NONE, which + // hopefully creates a frame that is ignored at runtime. + SectionBase *Section = cast<DefinedRegular>(Body).Section; + if (Section == &InputSection::Discarded) { + P->setSymbolAndType(0, 0, false); + continue; + } + + if (Config->IsRela) { + P->r_addend += Body.getVA() - Section->getOutputSection()->Addr; + } else if (Config->Relocatable) { + const uint8_t *BufLoc = RelocatedSection->Data.begin() + Rel.r_offset; + RelocatedSection->Relocations.push_back( + {R_ABS, Type, Rel.r_offset, Target->getImplicitAddend(BufLoc, Type), + &Body}); + } + } + } } @@ -287,85 +394,52 @@ static uint64_t getAArch64UndefinedRelativeWeakVA(uint64_t Type, uint64_t A, template <class ELFT> static typename ELFT::uint -getRelocTargetVA(uint32_t Type, typename ELFT::uint A, typename ELFT::uint P, +getRelocTargetVA(uint32_t Type, int64_t A, typename ELFT::uint P, const SymbolBody &Body, RelExpr Expr) { switch (Expr) { - case R_HINT: - case R_TLSDESC_CALL: - llvm_unreachable("cannot relocate hint relocs"); - case R_TLSLD: - return In<ELFT>::Got->getTlsIndexOff() + A - In<ELFT>::Got->getSize(); - case R_TLSLD_PC: - return In<ELFT>::Got->getTlsIndexVA() + A - P; - case R_THUNK_ABS: - return Body.getThunkVA<ELFT>() + A; - case R_THUNK_PC: - case R_THUNK_PLT_PC: - return Body.getThunkVA<ELFT>() + A - P; - case R_PPC_TOC: - return getPPC64TocBase() + A; - case R_TLSGD: - return In<ELFT>::Got->getGlobalDynOffset(Body) + A - - In<ELFT>::Got->getSize(); - case R_TLSGD_PC: - return In<ELFT>::Got->getGlobalDynAddr(Body) + A - P; - case R_TLSDESC: - return In<ELFT>::Got->getGlobalDynAddr(Body) + A; - case R_TLSDESC_PAGE: - return getAArch64Page(In<ELFT>::Got->getGlobalDynAddr(Body) + A) - - getAArch64Page(P); - case R_PLT: - return Body.getPltVA<ELFT>() + A; - case R_PLT_PC: - case R_PPC_PLT_OPD: - return Body.getPltVA<ELFT>() + A - P; - case R_SIZE: - return Body.getSize<ELFT>() + A; - case R_GOTREL: - return Body.getVA<ELFT>(A) - In<ELFT>::Got->getVA(); - case R_GOTREL_FROM_END: - return Body.getVA<ELFT>(A) - In<ELFT>::Got->getVA() - - In<ELFT>::Got->getSize(); - case R_RELAX_TLS_GD_TO_IE_END: - case R_GOT_FROM_END: - return Body.getGotOffset<ELFT>() + A - In<ELFT>::Got->getSize(); - case R_RELAX_TLS_GD_TO_IE_ABS: + case R_ABS: + case R_RELAX_GOT_PC_NOPIC: + return Body.getVA(A); case R_GOT: + case R_RELAX_TLS_GD_TO_IE_ABS: return Body.getGotVA<ELFT>() + A; - case R_RELAX_TLS_GD_TO_IE_PAGE_PC: - case R_GOT_PAGE_PC: - return getAArch64Page(Body.getGotVA<ELFT>() + A) - getAArch64Page(P); - case R_RELAX_TLS_GD_TO_IE: - case R_GOT_PC: - return Body.getGotVA<ELFT>() + A - P; case R_GOTONLY_PC: return In<ELFT>::Got->getVA() + A - P; case R_GOTONLY_PC_FROM_END: return In<ELFT>::Got->getVA() + A - P + In<ELFT>::Got->getSize(); - case R_RELAX_TLS_LD_TO_LE: - case R_RELAX_TLS_IE_TO_LE: - case R_RELAX_TLS_GD_TO_LE: - case R_TLS: - // A weak undefined TLS symbol resolves to the base of the TLS - // block, i.e. gets a value of zero. If we pass --gc-sections to - // lld and .tbss is not referenced, it gets reclaimed and we don't - // create a TLS program header. Therefore, we resolve this - // statically to zero. - if (Body.isTls() && (Body.isLazy() || Body.isUndefined()) && - Body.symbol()->isWeak()) - return 0; - if (Target->TcbSize) - return Body.getVA<ELFT>(A) + - alignTo(Target->TcbSize, Out<ELFT>::TlsPhdr->p_align); - return Body.getVA<ELFT>(A) - Out<ELFT>::TlsPhdr->p_memsz; - case R_RELAX_TLS_GD_TO_LE_NEG: - case R_NEG_TLS: - return Out<ELF32LE>::TlsPhdr->p_memsz - Body.getVA<ELFT>(A); - case R_ABS: - case R_RELAX_GOT_PC_NOPIC: - return Body.getVA<ELFT>(A); + case R_GOTREL: + return Body.getVA(A) - In<ELFT>::Got->getVA(); + case R_GOTREL_FROM_END: + return Body.getVA(A) - In<ELFT>::Got->getVA() - In<ELFT>::Got->getSize(); + case R_GOT_FROM_END: + case R_RELAX_TLS_GD_TO_IE_END: + return Body.getGotOffset() + A - In<ELFT>::Got->getSize(); case R_GOT_OFF: - return Body.getGotOffset<ELFT>() + A; + return Body.getGotOffset() + A; + case R_GOT_PAGE_PC: + case R_RELAX_TLS_GD_TO_IE_PAGE_PC: + return getAArch64Page(Body.getGotVA<ELFT>() + A) - getAArch64Page(P); + case R_GOT_PC: + case R_RELAX_TLS_GD_TO_IE: + return Body.getGotVA<ELFT>() + A - P; + case R_HINT: + case R_NONE: + case R_TLSDESC_CALL: + llvm_unreachable("cannot relocate hint relocs"); + case R_MIPS_GOTREL: + return Body.getVA(A) - In<ELFT>::MipsGot->getGp(); + case R_MIPS_GOT_GP: + return In<ELFT>::MipsGot->getGp() + A; + case R_MIPS_GOT_GP_PC: { + // R_MIPS_LO16 expression has R_MIPS_GOT_GP_PC type iif the target + // is _gp_disp symbol. In that case we should use the following + // formula for calculation "AHL + GP - P + 4". For details see p. 4-19 at + // ftp://www.linux-mips.org/pub/linux/mips/doc/ABI/mipsabi.pdf + uint64_t V = In<ELFT>::MipsGot->getGp() + A - P; + if (Type == R_MIPS_LO16) + V += 4; + return V; + } case R_MIPS_GOT_LOCAL_PAGE: // If relocation against MIPS local symbol requires GOT entry, this entry // should be initialized by 'page address'. This address is high 16-bits @@ -381,8 +455,6 @@ getRelocTargetVA(uint32_t Type, typename ELFT::uint A, typename ELFT::uint P, return In<ELFT>::MipsGot->getVA() + In<ELFT>::MipsGot->getBodyEntryOffset(Body, A) - In<ELFT>::MipsGot->getGp(); - case R_MIPS_GOTREL: - return Body.getVA<ELFT>(A) - In<ELFT>::MipsGot->getGp(); case R_MIPS_TLSGD: return In<ELFT>::MipsGot->getVA() + In<ELFT>::MipsGot->getTlsOffset() + In<ELFT>::MipsGot->getGlobalDynOffset(Body) - @@ -390,40 +462,82 @@ getRelocTargetVA(uint32_t Type, typename ELFT::uint A, typename ELFT::uint P, case R_MIPS_TLSLD: return In<ELFT>::MipsGot->getVA() + In<ELFT>::MipsGot->getTlsOffset() + In<ELFT>::MipsGot->getTlsIndexOff() - In<ELFT>::MipsGot->getGp(); + case R_PAGE_PC: + case R_PLT_PAGE_PC: + if (Body.isUndefined() && !Body.isLocal() && Body.symbol()->isWeak()) + return getAArch64Page(A); + return getAArch64Page(Body.getVA(A)) - getAArch64Page(P); + case R_PC: + if (Body.isUndefined() && !Body.isLocal() && Body.symbol()->isWeak()) { + // On ARM and AArch64 a branch to an undefined weak resolves to the + // next instruction, otherwise the place. + if (Config->EMachine == EM_ARM) + return getARMUndefinedRelativeWeakVA(Type, A, P); + if (Config->EMachine == EM_AARCH64) + return getAArch64UndefinedRelativeWeakVA(Type, A, P); + } + return Body.getVA(A) - P; + case R_PLT: + return Body.getPltVA() + A; + case R_PLT_PC: + case R_PPC_PLT_OPD: + return Body.getPltVA() + A - P; case R_PPC_OPD: { - uint64_t SymVA = Body.getVA<ELFT>(A); + uint64_t SymVA = Body.getVA(A); // If we have an undefined weak symbol, we might get here with a symbol // address of zero. That could overflow, but the code must be unreachable, // so don't bother doing anything at all. if (!SymVA) return 0; - if (Out<ELF64BE>::Opd) { + if (Out::Opd) { // If this is a local call, and we currently have the address of a // function-descriptor, get the underlying code address instead. - uint64_t OpdStart = Out<ELF64BE>::Opd->Addr; - uint64_t OpdEnd = OpdStart + Out<ELF64BE>::Opd->Size; + uint64_t OpdStart = Out::Opd->Addr; + uint64_t OpdEnd = OpdStart + Out::Opd->Size; bool InOpd = OpdStart <= SymVA && SymVA < OpdEnd; if (InOpd) - SymVA = read64be(&Out<ELF64BE>::OpdBuf[SymVA - OpdStart]); + SymVA = read64be(&Out::OpdBuf[SymVA - OpdStart]); } return SymVA - P; } - case R_PC: - if (Body.isUndefined() && !Body.isLocal() && Body.symbol()->isWeak()) { - // On ARM and AArch64 a branch to an undefined weak resolves to the - // next instruction, otherwise the place. - if (Config->EMachine == EM_ARM) - return getARMUndefinedRelativeWeakVA(Type, A, P); - if (Config->EMachine == EM_AARCH64) - return getAArch64UndefinedRelativeWeakVA(Type, A, P); - } + case R_PPC_TOC: + return getPPC64TocBase() + A; case R_RELAX_GOT_PC: - return Body.getVA<ELFT>(A) - P; - case R_PLT_PAGE_PC: - case R_PAGE_PC: - if (Body.isUndefined() && !Body.isLocal() && Body.symbol()->isWeak()) - return getAArch64Page(A); - return getAArch64Page(Body.getVA<ELFT>(A)) - getAArch64Page(P); + return Body.getVA(A) - P; + case R_RELAX_TLS_GD_TO_LE: + case R_RELAX_TLS_IE_TO_LE: + case R_RELAX_TLS_LD_TO_LE: + case R_TLS: + // A weak undefined TLS symbol resolves to the base of the TLS + // block, i.e. gets a value of zero. If we pass --gc-sections to + // lld and .tbss is not referenced, it gets reclaimed and we don't + // create a TLS program header. Therefore, we resolve this + // statically to zero. + if (Body.isTls() && (Body.isLazy() || Body.isUndefined()) && + Body.symbol()->isWeak()) + return 0; + if (Target->TcbSize) + return Body.getVA(A) + alignTo(Target->TcbSize, Out::TlsPhdr->p_align); + return Body.getVA(A) - Out::TlsPhdr->p_memsz; + case R_RELAX_TLS_GD_TO_LE_NEG: + case R_NEG_TLS: + return Out::TlsPhdr->p_memsz - Body.getVA(A); + case R_SIZE: + return Body.getSize<ELFT>() + A; + case R_TLSDESC: + return In<ELFT>::Got->getGlobalDynAddr(Body) + A; + case R_TLSDESC_PAGE: + return getAArch64Page(In<ELFT>::Got->getGlobalDynAddr(Body) + A) - + getAArch64Page(P); + case R_TLSGD: + return In<ELFT>::Got->getGlobalDynOffset(Body) + A - + In<ELFT>::Got->getSize(); + case R_TLSGD_PC: + return In<ELFT>::Got->getGlobalDynAddr(Body) + A - P; + case R_TLSLD: + return In<ELFT>::Got->getTlsIndexOff() + A - In<ELFT>::Got->getSize(); + case R_TLSLD_PC: + return In<ELFT>::Got->getTlsIndexVA() + A - P; } llvm_unreachable("Invalid expression"); } @@ -435,57 +549,62 @@ getRelocTargetVA(uint32_t Type, typename ELFT::uint A, typename ELFT::uint P, // treatement such as GOT or PLT (because at runtime no one refers them). // So, we handle relocations for non-alloc sections directly in this // function as a performance optimization. -template <class ELFT> -template <class RelTy> -void InputSection<ELFT>::relocateNonAlloc(uint8_t *Buf, ArrayRef<RelTy> Rels) { +template <class ELFT, class RelTy> +void InputSection::relocateNonAlloc(uint8_t *Buf, ArrayRef<RelTy> Rels) { for (const RelTy &Rel : Rels) { - uint32_t Type = Rel.getType(Config->Mips64EL); - uintX_t Offset = this->getOffset(Rel.r_offset); + uint32_t Type = Rel.getType(Config->IsMips64EL); + uint64_t Offset = getOffset(Rel.r_offset); uint8_t *BufLoc = Buf + Offset; - uintX_t Addend = getAddend<ELFT>(Rel); + int64_t Addend = getAddend<ELFT>(Rel); if (!RelTy::IsRela) Addend += Target->getImplicitAddend(BufLoc, Type); - SymbolBody &Sym = this->File->getRelocTargetSym(Rel); - if (Target->getRelExpr(Type, Sym) != R_ABS) { - error(this->getLocation(Offset) + ": has non-ABS reloc"); + SymbolBody &Sym = this->getFile<ELFT>()->getRelocTargetSym(Rel); + RelExpr Expr = Target->getRelExpr(Type, Sym, BufLoc); + if (Expr == R_NONE) + continue; + if (Expr != R_ABS) { + error(this->getLocation<ELFT>(Offset) + ": has non-ABS reloc"); return; } - uintX_t AddrLoc = this->OutSec->Addr + Offset; + uint64_t AddrLoc = this->OutSec->Addr + Offset; uint64_t SymVA = 0; - if (!Sym.isTls() || Out<ELFT>::TlsPhdr) - SymVA = SignExtend64<sizeof(uintX_t) * 8>( + if (!Sym.isTls() || Out::TlsPhdr) + SymVA = SignExtend64<sizeof(typename ELFT::uint) * 8>( getRelocTargetVA<ELFT>(Type, Addend, AddrLoc, Sym, R_ABS)); Target->relocateOne(BufLoc, Type, SymVA); } } +template <class ELFT> elf::ObjectFile<ELFT> *InputSectionBase::getFile() const { + return cast_or_null<elf::ObjectFile<ELFT>>(File); +} + template <class ELFT> -void InputSectionBase<ELFT>::relocate(uint8_t *Buf, uint8_t *BufEnd) { +void InputSectionBase::relocate(uint8_t *Buf, uint8_t *BufEnd) { // scanReloc function in Writer.cpp constructs Relocations // vector only for SHF_ALLOC'ed sections. For other sections, // we handle relocations directly here. - auto *IS = dyn_cast<InputSection<ELFT>>(this); + auto *IS = dyn_cast<InputSection>(this); if (IS && !(IS->Flags & SHF_ALLOC)) { if (IS->AreRelocsRela) - IS->relocateNonAlloc(Buf, IS->relas()); + IS->relocateNonAlloc<ELFT>(Buf, IS->template relas<ELFT>()); else - IS->relocateNonAlloc(Buf, IS->rels()); + IS->relocateNonAlloc<ELFT>(Buf, IS->template rels<ELFT>()); return; } - const unsigned Bits = sizeof(uintX_t) * 8; + const unsigned Bits = sizeof(typename ELFT::uint) * 8; for (const Relocation &Rel : Relocations) { - uintX_t Offset = getOffset(Rel.Offset); + uint64_t Offset = getOffset(Rel.Offset); uint8_t *BufLoc = Buf + Offset; uint32_t Type = Rel.Type; - uintX_t A = Rel.Addend; - uintX_t AddrLoc = OutSec->Addr + Offset; + uint64_t AddrLoc = getOutputSection()->Addr + Offset; RelExpr Expr = Rel.Expr; uint64_t TargetVA = SignExtend64<Bits>( - getRelocTargetVA<ELFT>(Type, A, AddrLoc, *Rel.Sym, Expr)); + getRelocTargetVA<ELFT>(Type, Rel.Addend, AddrLoc, *Rel.Sym, Expr)); switch (Expr) { case R_RELAX_GOT_PC: @@ -520,67 +639,54 @@ void InputSectionBase<ELFT>::relocate(uint8_t *Buf, uint8_t *BufEnd) { } } -template <class ELFT> void InputSection<ELFT>::writeTo(uint8_t *Buf) { +template <class ELFT> void InputSection::writeTo(uint8_t *Buf) { if (this->Type == SHT_NOBITS) return; - if (auto *S = dyn_cast<SyntheticSection<ELFT>>(this)) { + if (auto *S = dyn_cast<SyntheticSection>(this)) { S->writeTo(Buf + OutSecOff); return; } - // If -r is given, then an InputSection may be a relocation section. + // If -r or --emit-relocs is given, then an InputSection + // may be a relocation section. if (this->Type == SHT_RELA) { - copyRelocations(Buf + OutSecOff, this->template getDataAs<Elf_Rela>()); + copyRelocations<ELFT>(Buf + OutSecOff, + this->template getDataAs<typename ELFT::Rela>()); return; } if (this->Type == SHT_REL) { - copyRelocations(Buf + OutSecOff, this->template getDataAs<Elf_Rel>()); + copyRelocations<ELFT>(Buf + OutSecOff, + this->template getDataAs<typename ELFT::Rel>()); return; } - // Copy section contents from source object file to output file. - ArrayRef<uint8_t> Data = this->Data; + // Copy section contents from source object file to output file + // and then apply relocations. memcpy(Buf + OutSecOff, Data.data(), Data.size()); - - // Iterate over all relocation sections that apply to this section. uint8_t *BufEnd = Buf + OutSecOff + Data.size(); - this->relocate(Buf, BufEnd); - - // The section might have a data/code generated by the linker and need - // to be written after the section. Usually these are thunks - small piece - // of code used to jump between "incompatible" functions like PIC and non-PIC - // or if the jump target too far and its address does not fit to the short - // jump istruction. - if (!Thunks.empty()) { - Buf += OutSecOff + getThunkOff(); - for (const Thunk<ELFT> *T : Thunks) { - T->writeTo(Buf); - Buf += T->size(); - } - } + this->relocate<ELFT>(Buf, BufEnd); } -template <class ELFT> -void InputSection<ELFT>::replace(InputSection<ELFT> *Other) { +void InputSection::replace(InputSection *Other) { this->Alignment = std::max(this->Alignment, Other->Alignment); Other->Repl = this->Repl; Other->Live = false; } template <class ELFT> -EhInputSection<ELFT>::EhInputSection(elf::ObjectFile<ELFT> *F, - const Elf_Shdr *Header, StringRef Name) - : InputSectionBase<ELFT>(F, Header, Name, InputSectionBase<ELFT>::EHFrame) { +EhInputSection::EhInputSection(elf::ObjectFile<ELFT> *F, + const typename ELFT::Shdr *Header, + StringRef Name) + : InputSectionBase(F, Header, Name, InputSectionBase::EHFrame) { // Mark .eh_frame sections as live by default because there are // usually no relocations that point to .eh_frames. Otherwise, // the garbage collector would drop all .eh_frame sections. this->Live = true; } -template <class ELFT> -bool EhInputSection<ELFT>::classof(const InputSectionData *S) { - return S->kind() == InputSectionBase<ELFT>::EHFrame; +bool EhInputSection::classof(const SectionBase *S) { + return S->kind() == InputSectionBase::EHFrame; } // Returns the index of the first relocation that points to a region between @@ -604,24 +710,23 @@ static unsigned getReloc(IntTy Begin, IntTy Size, const ArrayRef<RelTy> &Rels, // .eh_frame is a sequence of CIE or FDE records. // This function splits an input section into records and returns them. -template <class ELFT> void EhInputSection<ELFT>::split() { +template <class ELFT> void EhInputSection::split() { // Early exit if already split. if (!this->Pieces.empty()) return; if (this->NumRelocations) { if (this->AreRelocsRela) - split(this->relas()); + split<ELFT>(this->relas<ELFT>()); else - split(this->rels()); + split<ELFT>(this->rels<ELFT>()); return; } - split(makeArrayRef<typename ELFT::Rela>(nullptr, nullptr)); + split<ELFT>(makeArrayRef<typename ELFT::Rela>(nullptr, nullptr)); } -template <class ELFT> -template <class RelTy> -void EhInputSection<ELFT>::split(ArrayRef<RelTy> Rels) { +template <class ELFT, class RelTy> +void EhInputSection::split(ArrayRef<RelTy> Rels) { ArrayRef<uint8_t> Data = this->Data; unsigned RelI = 0; for (size_t Off = 0, End = Data.size(); Off != End;) { @@ -650,9 +755,7 @@ static size_t findNull(ArrayRef<uint8_t> A, size_t EntSize) { // Split SHF_STRINGS section. Such section is a sequence of // null-terminated strings. -template <class ELFT> -void MergeInputSection<ELFT>::splitStrings(ArrayRef<uint8_t> Data, - size_t EntSize) { +void MergeInputSection::splitStrings(ArrayRef<uint8_t> Data, size_t EntSize) { size_t Off = 0; bool IsAlloc = this->Flags & SHF_ALLOC; while (!Data.empty()) { @@ -669,9 +772,8 @@ void MergeInputSection<ELFT>::splitStrings(ArrayRef<uint8_t> Data, // Split non-SHF_STRINGS section. Such section is a sequence of // fixed size records. -template <class ELFT> -void MergeInputSection<ELFT>::splitNonStrings(ArrayRef<uint8_t> Data, - size_t EntSize) { +void MergeInputSection::splitNonStrings(ArrayRef<uint8_t> Data, + size_t EntSize) { size_t Size = Data.size(); assert((Size % EntSize) == 0); bool IsAlloc = this->Flags & SHF_ALLOC; @@ -682,10 +784,10 @@ void MergeInputSection<ELFT>::splitNonStrings(ArrayRef<uint8_t> Data, } template <class ELFT> -MergeInputSection<ELFT>::MergeInputSection(elf::ObjectFile<ELFT> *F, - const Elf_Shdr *Header, - StringRef Name) - : InputSectionBase<ELFT>(F, Header, Name, InputSectionBase<ELFT>::Merge) {} +MergeInputSection::MergeInputSection(elf::ObjectFile<ELFT> *F, + const typename ELFT::Shdr *Header, + StringRef Name) + : InputSectionBase(F, Header, Name, InputSectionBase::Merge) {} // This function is called after we obtain a complete list of input sections // that need to be linked. This is responsible to split section contents @@ -693,28 +795,26 @@ MergeInputSection<ELFT>::MergeInputSection(elf::ObjectFile<ELFT> *F, // // Note that this function is called from parallel_for_each. This must be // thread-safe (i.e. no memory allocation from the pools). -template <class ELFT> void MergeInputSection<ELFT>::splitIntoPieces() { +void MergeInputSection::splitIntoPieces() { ArrayRef<uint8_t> Data = this->Data; - uintX_t EntSize = this->Entsize; + uint64_t EntSize = this->Entsize; if (this->Flags & SHF_STRINGS) splitStrings(Data, EntSize); else splitNonStrings(Data, EntSize); if (Config->GcSections && (this->Flags & SHF_ALLOC)) - for (uintX_t Off : LiveOffsets) + for (uint64_t Off : LiveOffsets) this->getSectionPiece(Off)->Live = true; } -template <class ELFT> -bool MergeInputSection<ELFT>::classof(const InputSectionData *S) { - return S->kind() == InputSectionBase<ELFT>::Merge; +bool MergeInputSection::classof(const SectionBase *S) { + return S->kind() == InputSectionBase::Merge; } // Do binary search to get a section piece at a given input offset. -template <class ELFT> -SectionPiece *MergeInputSection<ELFT>::getSectionPiece(uintX_t Offset) { - auto *This = static_cast<const MergeInputSection<ELFT> *>(this); +SectionPiece *MergeInputSection::getSectionPiece(uint64_t Offset) { + auto *This = static_cast<const MergeInputSection *>(this); return const_cast<SectionPiece *>(This->getSectionPiece(Offset)); } @@ -731,17 +831,15 @@ static It fastUpperBound(It First, It Last, const T &Value, Compare Comp) { return Comp(Value, *First) ? First : First + 1; } -template <class ELFT> -const SectionPiece * -MergeInputSection<ELFT>::getSectionPiece(uintX_t Offset) const { - uintX_t Size = this->Data.size(); +const SectionPiece *MergeInputSection::getSectionPiece(uint64_t Offset) const { + uint64_t Size = this->Data.size(); if (Offset >= Size) fatal(toString(this) + ": entry is past the end of the section"); // Find the element this offset points to. auto I = fastUpperBound( Pieces.begin(), Pieces.end(), Offset, - [](const uintX_t &A, const SectionPiece &B) { return A < B.InputOff; }); + [](const uint64_t &A, const SectionPiece &B) { return A < B.InputOff; }); --I; return &*I; } @@ -749,8 +847,7 @@ MergeInputSection<ELFT>::getSectionPiece(uintX_t Offset) const { // Returns the offset in an output section for a given input offset. // Because contents of a mergeable section is not contiguous in output, // it is not just an addition to a base output offset. -template <class ELFT> -typename ELFT::uint MergeInputSection<ELFT>::getOffset(uintX_t Offset) const { +uint64_t MergeInputSection::getOffset(uint64_t Offset) const { // Initialize OffsetMap lazily. std::call_once(InitOffsetMap, [&] { OffsetMap.reserve(Pieces.size()); @@ -772,31 +869,63 @@ typename ELFT::uint MergeInputSection<ELFT>::getOffset(uintX_t Offset) const { if (!Piece.Live) return 0; - uintX_t Addend = Offset - Piece.InputOff; + uint64_t Addend = Offset - Piece.InputOff; return Piece.OutputOff + Addend; } -template class elf::InputSectionBase<ELF32LE>; -template class elf::InputSectionBase<ELF32BE>; -template class elf::InputSectionBase<ELF64LE>; -template class elf::InputSectionBase<ELF64BE>; - -template class elf::InputSection<ELF32LE>; -template class elf::InputSection<ELF32BE>; -template class elf::InputSection<ELF64LE>; -template class elf::InputSection<ELF64BE>; - -template class elf::EhInputSection<ELF32LE>; -template class elf::EhInputSection<ELF32BE>; -template class elf::EhInputSection<ELF64LE>; -template class elf::EhInputSection<ELF64BE>; - -template class elf::MergeInputSection<ELF32LE>; -template class elf::MergeInputSection<ELF32BE>; -template class elf::MergeInputSection<ELF64LE>; -template class elf::MergeInputSection<ELF64BE>; - -template std::string lld::toString(const InputSectionBase<ELF32LE> *); -template std::string lld::toString(const InputSectionBase<ELF32BE> *); -template std::string lld::toString(const InputSectionBase<ELF64LE> *); -template std::string lld::toString(const InputSectionBase<ELF64BE> *); +template InputSection::InputSection(elf::ObjectFile<ELF32LE> *, + const ELF32LE::Shdr *, StringRef); +template InputSection::InputSection(elf::ObjectFile<ELF32BE> *, + const ELF32BE::Shdr *, StringRef); +template InputSection::InputSection(elf::ObjectFile<ELF64LE> *, + const ELF64LE::Shdr *, StringRef); +template InputSection::InputSection(elf::ObjectFile<ELF64BE> *, + const ELF64BE::Shdr *, StringRef); + +template std::string InputSectionBase::getLocation<ELF32LE>(uint64_t); +template std::string InputSectionBase::getLocation<ELF32BE>(uint64_t); +template std::string InputSectionBase::getLocation<ELF64LE>(uint64_t); +template std::string InputSectionBase::getLocation<ELF64BE>(uint64_t); + +template std::string InputSectionBase::getSrcMsg<ELF32LE>(uint64_t); +template std::string InputSectionBase::getSrcMsg<ELF32BE>(uint64_t); +template std::string InputSectionBase::getSrcMsg<ELF64LE>(uint64_t); +template std::string InputSectionBase::getSrcMsg<ELF64BE>(uint64_t); + +template std::string InputSectionBase::getObjMsg<ELF32LE>(uint64_t); +template std::string InputSectionBase::getObjMsg<ELF32BE>(uint64_t); +template std::string InputSectionBase::getObjMsg<ELF64LE>(uint64_t); +template std::string InputSectionBase::getObjMsg<ELF64BE>(uint64_t); + +template void InputSection::writeTo<ELF32LE>(uint8_t *); +template void InputSection::writeTo<ELF32BE>(uint8_t *); +template void InputSection::writeTo<ELF64LE>(uint8_t *); +template void InputSection::writeTo<ELF64BE>(uint8_t *); + +template elf::ObjectFile<ELF32LE> *InputSectionBase::getFile<ELF32LE>() const; +template elf::ObjectFile<ELF32BE> *InputSectionBase::getFile<ELF32BE>() const; +template elf::ObjectFile<ELF64LE> *InputSectionBase::getFile<ELF64LE>() const; +template elf::ObjectFile<ELF64BE> *InputSectionBase::getFile<ELF64BE>() const; + +template MergeInputSection::MergeInputSection(elf::ObjectFile<ELF32LE> *, + const ELF32LE::Shdr *, StringRef); +template MergeInputSection::MergeInputSection(elf::ObjectFile<ELF32BE> *, + const ELF32BE::Shdr *, StringRef); +template MergeInputSection::MergeInputSection(elf::ObjectFile<ELF64LE> *, + const ELF64LE::Shdr *, StringRef); +template MergeInputSection::MergeInputSection(elf::ObjectFile<ELF64BE> *, + const ELF64BE::Shdr *, StringRef); + +template EhInputSection::EhInputSection(elf::ObjectFile<ELF32LE> *, + const ELF32LE::Shdr *, StringRef); +template EhInputSection::EhInputSection(elf::ObjectFile<ELF32BE> *, + const ELF32BE::Shdr *, StringRef); +template EhInputSection::EhInputSection(elf::ObjectFile<ELF64LE> *, + const ELF64LE::Shdr *, StringRef); +template EhInputSection::EhInputSection(elf::ObjectFile<ELF64BE> *, + const ELF64BE::Shdr *, StringRef); + +template void EhInputSection::split<ELF32LE>(); +template void EhInputSection::split<ELF32BE>(); +template void EhInputSection::split<ELF64LE>(); +template void EhInputSection::split<ELF64BE>(); |