summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--lld/ELF/ICF.cpp4
-rw-r--r--lld/ELF/InputFiles.cpp4
-rw-r--r--lld/ELF/InputSection.cpp14
-rw-r--r--lld/ELF/InputSection.h5
-rw-r--r--lld/ELF/LinkerScript.cpp9
-rw-r--r--lld/ELF/MapFile.cpp2
-rw-r--r--lld/ELF/MarkLive.cpp4
-rw-r--r--lld/ELF/OutputSections.h2
-rw-r--r--lld/ELF/Relocations.cpp4
-rw-r--r--lld/ELF/SymbolTable.cpp24
-rw-r--r--lld/ELF/SymbolTable.h10
-rw-r--r--lld/ELF/Symbols.cpp28
-rw-r--r--lld/ELF/Symbols.h42
-rw-r--r--lld/ELF/SyntheticSections.cpp23
-rw-r--r--lld/ELF/Target.cpp6
-rw-r--r--lld/ELF/Thunks.cpp2
-rw-r--r--lld/ELF/Writer.cpp43
17 files changed, 107 insertions, 119 deletions
diff --git a/lld/ELF/ICF.cpp b/lld/ELF/ICF.cpp
index f88fdca22a6..81c6a89e20d 100644
--- a/lld/ELF/ICF.cpp
+++ b/lld/ELF/ICF.cpp
@@ -244,8 +244,8 @@ bool ICF<ELFT>::variableEq(const InputSection *A, ArrayRef<RelTy> RelsA,
if (&SA == &SB)
return true;
- auto *DA = dyn_cast<DefinedRegular<ELFT>>(&SA);
- auto *DB = dyn_cast<DefinedRegular<ELFT>>(&SB);
+ auto *DA = dyn_cast<DefinedRegular>(&SA);
+ auto *DB = dyn_cast<DefinedRegular>(&SB);
if (!DA || !DB)
return false;
if (DA->Value != DB->Value)
diff --git a/lld/ELF/InputFiles.cpp b/lld/ELF/InputFiles.cpp
index 1ec5394d8a8..a9f1f860aba 100644
--- a/lld/ELF/InputFiles.cpp
+++ b/lld/ELF/InputFiles.cpp
@@ -514,8 +514,8 @@ SymbolBody *elf::ObjectFile<ELFT>::createSymbolBody(const Elf_Sym *Sym) {
return new (BAlloc)
Undefined(Name, /*IsLocal=*/true, StOther, Type, this);
- return new (BAlloc) DefinedRegular<ELFT>(Name, /*IsLocal=*/true, StOther,
- Type, Value, Size, Sec, this);
+ return new (BAlloc) DefinedRegular(Name, /*IsLocal=*/true, StOther, Type,
+ Value, Size, Sec, this);
}
StringRef Name = check(Sym->getName(this->StringTable));
diff --git a/lld/ELF/InputSection.cpp b/lld/ELF/InputSection.cpp
index a0660194d60..8a390fdc8fe 100644
--- a/lld/ELF/InputSection.cpp
+++ b/lld/ELF/InputSection.cpp
@@ -150,7 +150,7 @@ template <class ELFT> void InputSectionBase::uncompress() {
}
template <class ELFT>
-uint64_t InputSectionBase::getOffset(const DefinedRegular<ELFT> &Sym) const {
+uint64_t InputSectionBase::getOffset(const DefinedRegular &Sym) const {
return getOffset<ELFT>(Sym.Value);
}
@@ -177,7 +177,7 @@ std::string InputSectionBase::getLocation(uint64_t Offset) {
// Find a function symbol that encloses a given location.
for (SymbolBody *B : getFile<ELFT>()->getSymbols())
- if (auto *D = dyn_cast<DefinedRegular<ELFT>>(B))
+ 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) + ")";
@@ -250,7 +250,7 @@ void InputSection::copyRelocations(uint8_t *Buf, ArrayRef<RelTy> Rels) {
// 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.
- InputSectionBase *Section = cast<DefinedRegular<ELFT>>(Body).Section;
+ InputSectionBase *Section = cast<DefinedRegular>(Body).Section;
if (Section == &InputSection::Discarded) {
P->setSymbolAndType(0, 0, false);
continue;
@@ -840,13 +840,13 @@ template InputSectionBase *InputSection::getRelocatedSection<ELF64LE>();
template InputSectionBase *InputSection::getRelocatedSection<ELF64BE>();
template uint64_t
-InputSectionBase::getOffset(const DefinedRegular<ELF32LE> &Sym) const;
+InputSectionBase::getOffset<ELF32LE>(const DefinedRegular &Sym) const;
template uint64_t
-InputSectionBase::getOffset(const DefinedRegular<ELF32BE> &Sym) const;
+InputSectionBase::getOffset<ELF32BE>(const DefinedRegular &Sym) const;
template uint64_t
-InputSectionBase::getOffset(const DefinedRegular<ELF64LE> &Sym) const;
+InputSectionBase::getOffset<ELF64LE>(const DefinedRegular &Sym) const;
template uint64_t
-InputSectionBase::getOffset(const DefinedRegular<ELF64BE> &Sym) const;
+InputSectionBase::getOffset<ELF64BE>(const DefinedRegular &Sym) const;
template uint64_t InputSectionBase::getOffset<ELF32LE>(uint64_t Offset) const;
template uint64_t InputSectionBase::getOffset<ELF32BE>(uint64_t Offset) const;
diff --git a/lld/ELF/InputSection.h b/lld/ELF/InputSection.h
index 98a3d9d4cb0..d0170d4f011 100644
--- a/lld/ELF/InputSection.h
+++ b/lld/ELF/InputSection.h
@@ -27,7 +27,7 @@ class DefinedCommon;
class SymbolBody;
struct SectionPiece;
-template <class ELFT> class DefinedRegular;
+class DefinedRegular;
template <class ELFT> class EhFrameSection;
template <class ELFT> class MergeSyntheticSection;
template <class ELFT> class ObjectFile;
@@ -117,8 +117,7 @@ public:
return getFile<ELFT>()->getObj();
}
- template <class ELFT>
- uint64_t getOffset(const DefinedRegular<ELFT> &Sym) const;
+ template <class ELFT> uint64_t getOffset(const DefinedRegular &Sym) const;
template <class ELFT> InputSectionBase *getLinkOrderDep() const;
// Translate an offset in the input section to an offset in the output
diff --git a/lld/ELF/LinkerScript.cpp b/lld/ELF/LinkerScript.cpp
index 7e1185aeb66..caf6fcb643f 100644
--- a/lld/ELF/LinkerScript.cpp
+++ b/lld/ELF/LinkerScript.cpp
@@ -63,9 +63,8 @@ template <class ELFT> static SymbolBody *addRegular(SymbolAssignment *Cmd) {
Cmd->Name, /*Type*/ 0, Visibility, /*CanOmitFromDynSym*/ false,
/*File*/ nullptr);
Sym->Binding = STB_GLOBAL;
- replaceBody<DefinedRegular<ELFT>>(Sym, Cmd->Name, /*IsLocal=*/false,
- Visibility, STT_NOTYPE, 0, 0, nullptr,
- nullptr);
+ replaceBody<DefinedRegular>(Sym, Cmd->Name, /*IsLocal=*/false, Visibility,
+ STT_NOTYPE, 0, 0, nullptr, nullptr);
return Sym->body();
}
@@ -131,7 +130,7 @@ void LinkerScript<ELFT>::assignSymbol(SymbolAssignment *Cmd, bool InSec) {
return;
}
- cast<DefinedRegular<ELFT>>(Cmd->Sym)->Value = Cmd->Expression(Dot);
+ cast<DefinedRegular>(Cmd->Sym)->Value = Cmd->Expression(Dot);
}
template <class ELFT>
@@ -973,7 +972,7 @@ template <class ELFT> bool LinkerScript<ELFT>::isDefined(StringRef S) {
template <class ELFT> bool LinkerScript<ELFT>::isAbsolute(StringRef S) {
SymbolBody *Sym = Symtab<ELFT>::X->find(S);
- auto *DR = dyn_cast_or_null<DefinedRegular<ELFT>>(Sym);
+ auto *DR = dyn_cast_or_null<DefinedRegular>(Sym);
return DR && !DR->Section;
}
diff --git a/lld/ELF/MapFile.cpp b/lld/ELF/MapFile.cpp
index 576e3dc878b..07e1fa39115 100644
--- a/lld/ELF/MapFile.cpp
+++ b/lld/ELF/MapFile.cpp
@@ -80,7 +80,7 @@ static void writeInputSection(raw_fd_ostream &OS, const InputSection *IS,
OS << '\n';
for (SymbolBody *Sym : File->getSymbols()) {
- auto *DR = dyn_cast<DefinedRegular<ELFT>>(Sym);
+ auto *DR = dyn_cast<DefinedRegular>(Sym);
if (!DR)
continue;
if (DR->Section != IS)
diff --git a/lld/ELF/MarkLive.cpp b/lld/ELF/MarkLive.cpp
index dde92d276d5..8f75de6dc30 100644
--- a/lld/ELF/MarkLive.cpp
+++ b/lld/ELF/MarkLive.cpp
@@ -66,7 +66,7 @@ static typename ELFT::uint getAddend(InputSectionBase &Sec,
template <class ELFT, class RelT>
static ResolvedReloc resolveReloc(InputSectionBase &Sec, RelT &Rel) {
SymbolBody &B = Sec.getFile<ELFT>()->getRelocTargetSym(Rel);
- auto *D = dyn_cast<DefinedRegular<ELFT>>(&B);
+ auto *D = dyn_cast<DefinedRegular>(&B);
if (!D || !D->Section)
return {nullptr, 0};
typename ELFT::uint Offset = D->Value;
@@ -215,7 +215,7 @@ template <class ELFT> void elf::markLive() {
};
auto MarkSymbol = [&](const SymbolBody *Sym) {
- if (auto *D = dyn_cast_or_null<DefinedRegular<ELFT>>(Sym))
+ if (auto *D = dyn_cast_or_null<DefinedRegular>(Sym))
Enqueue({D->Section, D->Value});
};
diff --git a/lld/ELF/OutputSections.h b/lld/ELF/OutputSections.h
index aeb4617facc..e45e91e028e 100644
--- a/lld/ELF/OutputSections.h
+++ b/lld/ELF/OutputSections.h
@@ -31,7 +31,7 @@ class OutputSection;
template <class ELFT> class ObjectFile;
template <class ELFT> class SharedFile;
class SharedSymbol;
-template <class ELFT> class DefinedRegular;
+class DefinedRegular;
// This represents a section in an output file.
// It is composed of multiple InputSections.
diff --git a/lld/ELF/Relocations.cpp b/lld/ELF/Relocations.cpp
index 9cb5da32eaf..6bc8748fee5 100644
--- a/lld/ELF/Relocations.cpp
+++ b/lld/ELF/Relocations.cpp
@@ -292,7 +292,7 @@ static int32_t findMipsPairedAddend(const uint8_t *Buf, const uint8_t *BufLoc,
template <class ELFT> static bool isAbsolute(const SymbolBody &Body) {
if (Body.isUndefined())
return !Body.isLocal() && Body.symbol()->isWeak();
- if (const auto *DR = dyn_cast<DefinedRegular<ELFT>>(&Body))
+ if (const auto *DR = dyn_cast<DefinedRegular>(&Body))
return DR->Section == nullptr; // Absolute symbol.
return false;
}
@@ -352,7 +352,7 @@ isStaticLinkTimeConstant(RelExpr E, uint32_t Type, const SymbolBody &Body,
if (AbsVal && RelE) {
if (Body.isUndefined() && !Body.isLocal() && Body.symbol()->isWeak())
return true;
- if (&Body == ElfSym<ELFT>::MipsGpDisp)
+ if (&Body == ElfSym::MipsGpDisp)
return true;
error(S.getLocation<ELFT>(RelOff) + ": relocation " + toString(Type) +
" cannot refer to absolute symbol '" + toString(Body) +
diff --git a/lld/ELF/SymbolTable.cpp b/lld/ELF/SymbolTable.cpp
index 3b4ecd504e1..62d76dd6a7c 100644
--- a/lld/ELF/SymbolTable.cpp
+++ b/lld/ELF/SymbolTable.cpp
@@ -126,19 +126,19 @@ template <class ELFT> void SymbolTable<ELFT>::addCombinedLTOObject() {
}
template <class ELFT>
-DefinedRegular<ELFT> *SymbolTable<ELFT>::addAbsolute(StringRef Name,
- uint8_t Visibility,
- uint8_t Binding) {
+DefinedRegular *SymbolTable<ELFT>::addAbsolute(StringRef Name,
+ uint8_t Visibility,
+ uint8_t Binding) {
Symbol *Sym =
addRegular(Name, Visibility, STT_NOTYPE, 0, 0, Binding, nullptr, nullptr);
- return cast<DefinedRegular<ELFT>>(Sym->body());
+ return cast<DefinedRegular>(Sym->body());
}
// Add Name as an "ignored" symbol. An ignored symbol is a regular
// linker-synthesized defined symbol, but is only defined if needed.
template <class ELFT>
-DefinedRegular<ELFT> *SymbolTable<ELFT>::addIgnored(StringRef Name,
- uint8_t Visibility) {
+DefinedRegular *SymbolTable<ELFT>::addIgnored(StringRef Name,
+ uint8_t Visibility) {
SymbolBody *S = find(Name);
if (!S || S->isInCurrentDSO())
return nullptr;
@@ -309,7 +309,7 @@ static int compareDefinedNonCommon(Symbol *S, bool WasInserted, uint8_t Binding,
if (Config->WarnCommon)
warn("common " + S->body()->getName() + " is overridden");
return 1;
- } else if (auto *R = dyn_cast<DefinedRegular<ELFT>>(B)) {
+ } else if (auto *R = dyn_cast<DefinedRegular>(B)) {
if (R->Section == nullptr && Binding == STB_GLOBAL && IsAbsolute &&
R->Value == Value)
return -1;
@@ -363,7 +363,7 @@ static void reportDuplicate(SymbolBody *Existing, InputFile *NewFile) {
template <class ELFT>
static void reportDuplicate(SymbolBody *Existing, InputSectionBase *ErrSec,
typename ELFT::uint ErrOffset) {
- DefinedRegular<ELFT> *D = dyn_cast<DefinedRegular<ELFT>>(Existing);
+ DefinedRegular *D = dyn_cast<DefinedRegular>(Existing);
if (!D || !D->Section || !ErrSec) {
reportDuplicate(Existing, ErrSec ? ErrSec->getFile<ELFT>() : nullptr);
return;
@@ -388,8 +388,8 @@ SymbolTable<ELFT>::addRegular(StringRef Name, uint8_t StOther, uint8_t Type,
int Cmp = compareDefinedNonCommon<ELFT>(S, WasInserted, Binding,
Section == nullptr, Value);
if (Cmp > 0)
- replaceBody<DefinedRegular<ELFT>>(S, Name, /*IsLocal=*/false, StOther, Type,
- Value, Size, Section, File);
+ replaceBody<DefinedRegular>(S, Name, /*IsLocal=*/false, StOther, Type,
+ Value, Size, Section, File);
else if (Cmp == 0)
reportDuplicate<ELFT>(S->body(), Section, Value);
return S;
@@ -446,8 +446,8 @@ Symbol *SymbolTable<ELFT>::addBitcode(StringRef Name, uint8_t Binding,
int Cmp = compareDefinedNonCommon<ELFT>(S, WasInserted, Binding,
/*IsAbs*/ false, /*Value*/ 0);
if (Cmp > 0)
- replaceBody<DefinedRegular<ELFT>>(S, Name, /*IsLocal=*/false, StOther, Type,
- 0, 0, nullptr, F);
+ replaceBody<DefinedRegular>(S, Name, /*IsLocal=*/false, StOther, Type, 0, 0,
+ nullptr, F);
else if (Cmp == 0)
reportDuplicate(S->body(), F);
return S;
diff --git a/lld/ELF/SymbolTable.h b/lld/ELF/SymbolTable.h
index e2db444f3f1..c4b21098b10 100644
--- a/lld/ELF/SymbolTable.h
+++ b/lld/ELF/SymbolTable.h
@@ -46,11 +46,11 @@ public:
ArrayRef<BinaryFile *> getBinaryFiles() const { return BinaryFiles; }
ArrayRef<SharedFile<ELFT> *> getSharedFiles() const { return SharedFiles; }
- DefinedRegular<ELFT> *addAbsolute(StringRef Name,
- uint8_t Visibility = llvm::ELF::STV_HIDDEN,
- uint8_t Binding = llvm::ELF::STB_GLOBAL);
- DefinedRegular<ELFT> *addIgnored(StringRef Name,
- uint8_t Visibility = llvm::ELF::STV_HIDDEN);
+ DefinedRegular *addAbsolute(StringRef Name,
+ uint8_t Visibility = llvm::ELF::STV_HIDDEN,
+ uint8_t Binding = llvm::ELF::STB_GLOBAL);
+ DefinedRegular *addIgnored(StringRef Name,
+ uint8_t Visibility = llvm::ELF::STV_HIDDEN);
Symbol *addUndefined(StringRef Name);
Symbol *addUndefined(StringRef Name, bool IsLocal, uint8_t Binding,
diff --git a/lld/ELF/Symbols.cpp b/lld/ELF/Symbols.cpp
index 7427663ee94..59e43d3854a 100644
--- a/lld/ELF/Symbols.cpp
+++ b/lld/ELF/Symbols.cpp
@@ -28,6 +28,18 @@ using namespace llvm::ELF;
using namespace lld;
using namespace lld::elf;
+InputSectionBase *DefinedRegular::NullInputSection;
+
+DefinedSynthetic *ElfSym::Etext;
+DefinedSynthetic *ElfSym::Etext2;
+DefinedSynthetic *ElfSym::Edata;
+DefinedSynthetic *ElfSym::Edata2;
+DefinedSynthetic *ElfSym::End;
+DefinedSynthetic *ElfSym::End2;
+DefinedRegular *ElfSym::MipsGpDisp;
+DefinedRegular *ElfSym::MipsLocalGp;
+DefinedRegular *ElfSym::MipsGp;
+
template <class ELFT>
static typename ELFT::uint getSymVA(const SymbolBody &Body, int64_t &Addend) {
typedef typename ELFT::uint uintX_t;
@@ -43,7 +55,7 @@ static typename ELFT::uint getSymVA(const SymbolBody &Body, int64_t &Addend) {
return Sec->Addr + D.Value;
}
case SymbolBody::DefinedRegularKind: {
- auto &D = cast<DefinedRegular<ELFT>>(Body);
+ auto &D = cast<DefinedRegular>(Body);
InputSectionBase *IS = D.Section;
// According to the ELF spec reference to a local symbol from outside
@@ -188,7 +200,7 @@ template <class ELFT> typename ELFT::uint SymbolBody::getPltVA() const {
template <class ELFT> typename ELFT::uint SymbolBody::getSize() const {
if (const auto *C = dyn_cast<DefinedCommon>(this))
return C->Size;
- if (const auto *DR = dyn_cast<DefinedRegular<ELFT>>(this))
+ if (const auto *DR = dyn_cast<DefinedRegular>(this))
return DR->Size;
if (const auto *S = dyn_cast<SharedSymbol>(this))
return S->getSize<ELFT>();
@@ -197,7 +209,7 @@ template <class ELFT> typename ELFT::uint SymbolBody::getSize() const {
template <class ELFT>
const OutputSection *SymbolBody::getOutputSection() const {
- if (auto *S = dyn_cast<DefinedRegular<ELFT>>(this)) {
+ if (auto *S = dyn_cast<DefinedRegular>(this)) {
if (S->Section)
return S->Section->template getOutputSection<ELFT>();
return nullptr;
@@ -263,7 +275,7 @@ Defined::Defined(Kind K, StringRefZ Name, bool IsLocal, uint8_t StOther,
uint8_t Type)
: SymbolBody(K, Name, IsLocal, StOther, Type) {}
-template <class ELFT> bool DefinedRegular<ELFT>::isMipsPIC() const {
+template <class ELFT> bool DefinedRegular::isMipsPIC() const {
if (!Section || !isFunc())
return false;
return (this->StOther & STO_MIPS_MIPS16) == STO_MIPS_PIC ||
@@ -416,10 +428,10 @@ template const OutputSection *
template const OutputSection *
SymbolBody::template getOutputSection<ELF64BE>() const;
-template class elf::DefinedRegular<ELF32LE>;
-template class elf::DefinedRegular<ELF32BE>;
-template class elf::DefinedRegular<ELF64LE>;
-template class elf::DefinedRegular<ELF64BE>;
+template bool DefinedRegular::template isMipsPIC<ELF32LE>() const;
+template bool DefinedRegular::template isMipsPIC<ELF32BE>() const;
+template bool DefinedRegular::template isMipsPIC<ELF64LE>() const;
+template bool DefinedRegular::template isMipsPIC<ELF64BE>() const;
template uint64_t SharedSymbol::template getAlignment<ELF32LE>() const;
template uint64_t SharedSymbol::template getAlignment<ELF32BE>() const;
diff --git a/lld/ELF/Symbols.h b/lld/ELF/Symbols.h
index 269b461db53..696a30cb390 100644
--- a/lld/ELF/Symbols.h
+++ b/lld/ELF/Symbols.h
@@ -174,13 +174,10 @@ public:
};
// Regular defined symbols read from object file symbol tables.
-template <class ELFT> class DefinedRegular : public Defined {
- typedef typename ELFT::Sym Elf_Sym;
- typedef typename ELFT::uint uintX_t;
-
+class DefinedRegular : public Defined {
public:
DefinedRegular(StringRefZ Name, bool IsLocal, uint8_t StOther, uint8_t Type,
- uintX_t Value, uintX_t Size, InputSectionBase *Section,
+ uint64_t Value, uint64_t Size, InputSectionBase *Section,
InputFile *File)
: Defined(SymbolBody::DefinedRegularKind, Name, IsLocal, StOther, Type),
Value(Value), Size(Size),
@@ -189,14 +186,14 @@ public:
}
// Return true if the symbol is a PIC function.
- bool isMipsPIC() const;
+ template <class ELFT> bool isMipsPIC() const;
static bool classof(const SymbolBody *S) {
return S->kind() == SymbolBody::DefinedRegularKind;
}
- uintX_t Value;
- uintX_t Size;
+ uint64_t Value;
+ uint64_t Size;
// The input section this symbol belongs to. Notice that this is
// a reference to a pointer. We are using two levels of indirections
@@ -210,8 +207,6 @@ private:
static InputSectionBase *NullInputSection;
};
-template <class ELFT> InputSectionBase *DefinedRegular<ELFT>::NullInputSection;
-
// DefinedSynthetic is a class to represent linker-generated ELF symbols.
// The difference from the regular symbol is that DefinedSynthetic symbols
// don't belong to any input files or sections. Thus, its constructor
@@ -337,7 +332,7 @@ public:
// Some linker-generated symbols need to be created as
// DefinedRegular symbols.
-template <class ELFT> struct ElfSym {
+struct ElfSym {
// The content for _etext and etext symbols.
static DefinedSynthetic *Etext;
static DefinedSynthetic *Etext2;
@@ -351,21 +346,11 @@ template <class ELFT> struct ElfSym {
static DefinedSynthetic *End2;
// The content for _gp_disp/__gnu_local_gp symbols for MIPS target.
- static DefinedRegular<ELFT> *MipsGpDisp;
- static DefinedRegular<ELFT> *MipsLocalGp;
- static DefinedRegular<ELFT> *MipsGp;
+ static DefinedRegular *MipsGpDisp;
+ static DefinedRegular *MipsLocalGp;
+ static DefinedRegular *MipsGp;
};
-template <class ELFT> DefinedSynthetic *ElfSym<ELFT>::Etext;
-template <class ELFT> DefinedSynthetic *ElfSym<ELFT>::Etext2;
-template <class ELFT> DefinedSynthetic *ElfSym<ELFT>::Edata;
-template <class ELFT> DefinedSynthetic *ElfSym<ELFT>::Edata2;
-template <class ELFT> DefinedSynthetic *ElfSym<ELFT>::End;
-template <class ELFT> DefinedSynthetic *ElfSym<ELFT>::End2;
-template <class ELFT> DefinedRegular<ELFT> *ElfSym<ELFT>::MipsGpDisp;
-template <class ELFT> DefinedRegular<ELFT> *ElfSym<ELFT>::MipsLocalGp;
-template <class ELFT> DefinedRegular<ELFT> *ElfSym<ELFT>::MipsGp;
-
// A real symbol object, SymbolBody, is usually stored within a Symbol. There's
// always one Symbol for each symbol name. The resolver updates the SymbolBody
// stored in the Body field of this object as it resolves symbols. Symbol also
@@ -409,12 +394,9 @@ struct Symbol {
// This field is used to store the Symbol's SymbolBody. This instantiation of
// AlignedCharArrayUnion gives us a struct with a char array field that is
- // large and aligned enough to store any derived class of SymbolBody. We
- // assume that the size and alignment of ELF64LE symbols is sufficient for any
- // ELFT, and we verify this with the static_asserts in replaceBody.
- llvm::AlignedCharArrayUnion<
- DefinedCommon, DefinedRegular<llvm::object::ELF64LE>, DefinedSynthetic,
- Undefined, SharedSymbol, LazyArchive, LazyObject>
+ // large and aligned enough to store any derived class of SymbolBody.
+ llvm::AlignedCharArrayUnion<DefinedCommon, DefinedRegular, DefinedSynthetic,
+ Undefined, SharedSymbol, LazyArchive, LazyObject>
Body;
SymbolBody *body() { return reinterpret_cast<SymbolBody *>(Body.buffer); }
diff --git a/lld/ELF/SyntheticSections.cpp b/lld/ELF/SyntheticSections.cpp
index 62d0c0d10e5..946914619bc 100644
--- a/lld/ELF/SyntheticSections.cpp
+++ b/lld/ELF/SyntheticSections.cpp
@@ -298,8 +298,8 @@ InputSection *elf::createInterpSection() {
template <class ELFT>
SymbolBody *elf::addSyntheticLocal(StringRef Name, uint8_t Type, uint64_t Value,
uint64_t Size, InputSectionBase *Section) {
- auto *S = make<DefinedRegular<ELFT>>(Name, /*IsLocal*/ true, STV_DEFAULT,
- Type, Value, Size, Section, nullptr);
+ auto *S = make<DefinedRegular>(Name, /*IsLocal*/ true, STV_DEFAULT, Type,
+ Value, Size, Section, nullptr);
if (In<ELFT>::SymTab)
In<ELFT>::SymTab->addSymbol(S);
return S;
@@ -448,7 +448,7 @@ bool EhFrameSection<ELFT>::isFdeLive(EhSectionPiece &Piece,
return false;
const RelTy &Rel = Rels[FirstRelI];
SymbolBody &B = Sec->template getFile<ELFT>()->getRelocTargetSym(Rel);
- auto *D = dyn_cast<DefinedRegular<ELFT>>(&B);
+ auto *D = dyn_cast<DefinedRegular>(&B);
if (!D || !D->Section)
return false;
InputSectionBase *Target = D->Section->Repl;
@@ -700,7 +700,7 @@ void MipsGotSection<ELFT>::addEntry(SymbolBody &Sym, int64_t Addend,
// sections referenced by GOT relocations. Then later in the `finalize`
// method calculate number of "pages" required to cover all saved output
// section and allocate appropriate number of GOT entries.
- auto *DefSym = cast<DefinedRegular<ELFT>>(&Sym);
+ auto *DefSym = cast<DefinedRegular>(&Sym);
PageIndexMap.insert(
{DefSym->Section->template getOutputSection<ELFT>(), 0});
return;
@@ -773,8 +773,7 @@ typename MipsGotSection<ELFT>::uintX_t
MipsGotSection<ELFT>::getPageEntryOffset(const SymbolBody &B,
int64_t Addend) const {
const OutputSection *OutSec =
- cast<DefinedRegular<ELFT>>(&B)
- ->Section->template getOutputSection<ELFT>();
+ cast<DefinedRegular>(&B)->Section->template getOutputSection<ELFT>();
uintX_t SecAddr = getMipsPageAddr(OutSec->Addr);
uintX_t SymAddr = getMipsPageAddr(B.getVA<ELFT>(Addend));
uintX_t Index = PageIndexMap.lookup(OutSec) + (SymAddr - SecAddr) / 0xffff;
@@ -852,7 +851,7 @@ template <class ELFT> bool MipsGotSection<ELFT>::empty() const {
template <class ELFT>
typename MipsGotSection<ELFT>::uintX_t MipsGotSection<ELFT>::getGp() const {
- return ElfSym<ELFT>::MipsGp->template getVA<ELFT>(0);
+ return ElfSym::MipsGp->template getVA<ELFT>(0);
}
template <class ELFT>
@@ -1344,8 +1343,8 @@ size_t SymbolTableSection<ELFT>::getSymbolIndex(SymbolBody *Body) {
// This is used for -r, so we have to handle multiple section
// symbols being combined.
if (Body->Type == STT_SECTION && E.Symbol->Type == STT_SECTION)
- return cast<DefinedRegular<ELFT>>(Body)->Section->OutSec ==
- cast<DefinedRegular<ELFT>>(E.Symbol)->Section->OutSec;
+ return cast<DefinedRegular>(Body)->Section->OutSec ==
+ cast<DefinedRegular>(E.Symbol)->Section->OutSec;
return false;
});
if (I == Symbols.end())
@@ -1377,7 +1376,7 @@ template <class ELFT> void SymbolTableSection<ELFT>::writeTo(uint8_t *Buf) {
// Set a section index.
if (const OutputSection *OutSec = Body->getOutputSection<ELFT>())
ESym->st_shndx = OutSec->SectionIndex;
- else if (isa<DefinedRegular<ELFT>>(Body))
+ else if (isa<DefinedRegular>(Body))
ESym->st_shndx = SHN_ABS;
else if (isa<DefinedCommon>(Body))
ESym->st_shndx = SHN_COMMON;
@@ -1406,8 +1405,8 @@ template <class ELFT> void SymbolTableSection<ELFT>::writeTo(uint8_t *Buf) {
ESym->st_other |= STO_MIPS_PLT;
if (Config->Relocatable)
- if (auto *D = dyn_cast<DefinedRegular<ELFT>>(Body))
- if (D->isMipsPIC())
+ if (auto *D = dyn_cast<DefinedRegular>(Body))
+ if (D->isMipsPIC<ELFT>())
ESym->st_other |= STO_MIPS_PIC;
++ESym;
}
diff --git a/lld/ELF/Target.cpp b/lld/ELF/Target.cpp
index 54768711b65..85cac56967e 100644
--- a/lld/ELF/Target.cpp
+++ b/lld/ELF/Target.cpp
@@ -2086,7 +2086,7 @@ RelExpr MipsTargetInfo<ELFT>::getRelExpr(uint32_t Type,
// offset between start of function and 'gp' value which by default
// equal to the start of .got section. In that case we consider these
// relocations as relative.
- if (&S == ElfSym<ELFT>::MipsGpDisp)
+ if (&S == ElfSym::MipsGpDisp)
return R_PC;
return R_ABS;
case R_MIPS_PC32:
@@ -2245,10 +2245,10 @@ bool MipsTargetInfo<ELFT>::needsThunk(RelExpr Expr, uint32_t Type,
// If current file has PIC code, LA25 stub is not required.
if (F->getObj().getHeader()->e_flags & EF_MIPS_PIC)
return false;
- auto *D = dyn_cast<DefinedRegular<ELFT>>(&S);
+ auto *D = dyn_cast<DefinedRegular>(&S);
// LA25 is required if target file has PIC code
// or target symbol is a PIC symbol.
- return D && D->isMipsPIC();
+ return D && D->isMipsPIC<ELFT>();
}
template <class ELFT>
diff --git a/lld/ELF/Thunks.cpp b/lld/ELF/Thunks.cpp
index 099ac2c1fc3..3fcf225949d 100644
--- a/lld/ELF/Thunks.cpp
+++ b/lld/ELF/Thunks.cpp
@@ -225,7 +225,7 @@ template <class ELFT> void MipsThunk<ELFT>::addSymbols(ThunkSection<ELFT> &IS) {
template <class ELFT>
InputSection *MipsThunk<ELFT>::getTargetInputSection() const {
- auto *DR = dyn_cast<DefinedRegular<ELFT>>(&this->Destination);
+ auto *DR = dyn_cast<DefinedRegular>(&this->Destination);
return dyn_cast<InputSection>(DR->Section);
}
diff --git a/lld/ELF/Writer.cpp b/lld/ELF/Writer.cpp
index 1971bf77c39..cc12e5ce35f 100644
--- a/lld/ELF/Writer.cpp
+++ b/lld/ELF/Writer.cpp
@@ -483,7 +483,7 @@ template <class ELFT> static bool includeInSymtab(const SymbolBody &B) {
if (!B.isLocal() && !B.symbol()->IsUsedInRegularObj)
return false;
- if (auto *D = dyn_cast<DefinedRegular<ELFT>>(&B)) {
+ if (auto *D = dyn_cast<DefinedRegular>(&B)) {
// Always include absolute symbols.
if (!D->Section)
return true;
@@ -507,7 +507,7 @@ template <class ELFT> void Writer<ELFT>::copyLocalSymbols() {
if (!B->IsLocal)
fatal(toString(F) +
": broken object: getLocalSymbols returns a non-local symbol");
- auto *DR = dyn_cast<DefinedRegular<ELFT>>(B);
+ auto *DR = dyn_cast<DefinedRegular>(B);
// No reason to keep local undefined symbol in symtab.
if (!DR)
@@ -534,8 +534,8 @@ template <class ELFT> void Writer<ELFT>::addSectionSymbols() {
IS->Type == SHT_RELA)
continue;
auto *B = new (BAlloc)
- DefinedRegular<ELFT>("", /*IsLocal=*/true, /*StOther*/ 0, STT_SECTION,
- /*Value*/ 0, /*Size*/ 0, IS, nullptr);
+ DefinedRegular("", /*IsLocal=*/true, /*StOther*/ 0, STT_SECTION,
+ /*Value*/ 0, /*Size*/ 0, IS, nullptr);
In<ELFT>::SymTab->addSymbol(B);
}
@@ -788,15 +788,14 @@ template <class ELFT> void Writer<ELFT>::addReservedSymbols() {
// to GOT. Default offset is 0x7ff0.
// See "Global Data Symbols" in Chapter 6 in the following document:
// ftp://www.linux-mips.org/pub/linux/mips/doc/ABI/mipsabi.pdf
- ElfSym<ELFT>::MipsGp =
- Symtab<ELFT>::X->addAbsolute("_gp", STV_HIDDEN, STB_LOCAL);
+ ElfSym::MipsGp = Symtab<ELFT>::X->addAbsolute("_gp", STV_HIDDEN, STB_LOCAL);
// On MIPS O32 ABI, _gp_disp is a magic symbol designates offset between
// start of function and 'gp' pointer into GOT. To simplify relocation
// calculation we assign _gp value to it and calculate corresponding
// relocations as relative to this value.
if (Symtab<ELFT>::X->find("_gp_disp"))
- ElfSym<ELFT>::MipsGpDisp =
+ ElfSym::MipsGpDisp =
Symtab<ELFT>::X->addAbsolute("_gp_disp", STV_HIDDEN, STB_LOCAL);
// The __gnu_local_gp is a magic symbol equal to the current value of 'gp'
@@ -804,7 +803,7 @@ template <class ELFT> void Writer<ELFT>::addReservedSymbols() {
// in case of using -mno-shared option.
// https://sourceware.org/ml/binutils/2004-12/msg00094.html
if (Symtab<ELFT>::X->find("__gnu_local_gp"))
- ElfSym<ELFT>::MipsLocalGp =
+ ElfSym::MipsLocalGp =
Symtab<ELFT>::X->addAbsolute("__gnu_local_gp", STV_HIDDEN, STB_LOCAL);
}
@@ -847,9 +846,9 @@ template <class ELFT> void Writer<ELFT>::addReservedSymbols() {
Sym2 = addOptionalSynthetic<ELFT>(S, nullptr, 0, STV_DEFAULT);
};
- Define("_end", ElfSym<ELFT>::End, ElfSym<ELFT>::End2);
- Define("_etext", ElfSym<ELFT>::Etext, ElfSym<ELFT>::Etext2);
- Define("_edata", ElfSym<ELFT>::Edata, ElfSym<ELFT>::Edata2);
+ Define("_end", ElfSym::End, ElfSym::End2);
+ Define("_etext", ElfSym::Etext, ElfSym::Etext2);
+ Define("_edata", ElfSym::Edata, ElfSym::Edata2);
}
// Sort input sections by section name suffixes for
@@ -883,7 +882,7 @@ static void sortBySymbolsOrder(ArrayRef<OutputSection *> OutputSections) {
DenseMap<InputSectionBase *, int> SectionOrder;
for (elf::ObjectFile<ELFT> *File : Symtab<ELFT>::X->getObjectFiles()) {
for (SymbolBody *Body : File->getSymbols()) {
- auto *D = dyn_cast<DefinedRegular<ELFT>>(Body);
+ auto *D = dyn_cast<DefinedRegular>(Body);
if (!D || !D->Section)
continue;
int &Priority = SectionOrder[D->Section];
@@ -1652,18 +1651,16 @@ template <class ELFT> void Writer<ELFT>::fixPredefinedSymbols() {
LastRO = &P;
}
if (Last)
- Set(ElfSym<ELFT>::End, ElfSym<ELFT>::End2, Last->First, Last->p_memsz);
+ Set(ElfSym::End, ElfSym::End2, Last->First, Last->p_memsz);
if (LastRO)
- Set(ElfSym<ELFT>::Etext, ElfSym<ELFT>::Etext2, LastRO->First,
- LastRO->p_filesz);
+ Set(ElfSym::Etext, ElfSym::Etext2, LastRO->First, LastRO->p_filesz);
if (LastRW)
- Set(ElfSym<ELFT>::Edata, ElfSym<ELFT>::Edata2, LastRW->First,
- LastRW->p_filesz);
+ Set(ElfSym::Edata, ElfSym::Edata2, LastRW->First, LastRW->p_filesz);
// Setup MIPS _gp_disp/__gnu_local_gp symbols which should
// be equal to the _gp symbol's value.
if (Config->EMachine == EM_MIPS) {
- if (!ElfSym<ELFT>::MipsGp->Value) {
+ if (!ElfSym::MipsGp->Value) {
// Find GP-relative section with the lowest address
// and use this address to calculate default _gp value.
uintX_t Gp = -1;
@@ -1671,12 +1668,12 @@ template <class ELFT> void Writer<ELFT>::fixPredefinedSymbols() {
if ((OS->Flags & SHF_MIPS_GPREL) && OS->Addr < Gp)
Gp = OS->Addr;
if (Gp != (uintX_t)-1)
- ElfSym<ELFT>::MipsGp->Value = Gp + 0x7ff0;
+ ElfSym::MipsGp->Value = Gp + 0x7ff0;
}
- if (ElfSym<ELFT>::MipsGpDisp)
- ElfSym<ELFT>::MipsGpDisp->Value = ElfSym<ELFT>::MipsGp->Value;
- if (ElfSym<ELFT>::MipsLocalGp)
- ElfSym<ELFT>::MipsLocalGp->Value = ElfSym<ELFT>::MipsGp->Value;
+ if (ElfSym::MipsGpDisp)
+ ElfSym::MipsGpDisp->Value = ElfSym::MipsGp->Value;
+ if (ElfSym::MipsLocalGp)
+ ElfSym::MipsLocalGp->Value = ElfSym::MipsGp->Value;
}
}
OpenPOWER on IntegriCloud