ELF: Merge DefinedRegular and Defined.

[pcc]

Summary

Now that DefinedRegular is the only remaining derived class of
Defined, we can merge the two classes.

Depends on D39666

[ruiu]

LGTM

lld/ELF/Symbols.h

95–97 ↗

(On Diff #121665)

(off topic)

We should remove these functions and use isa<> instead. I think we needed them because some symbol subclasses were template classes, but not anymore.

104 ↗

(On Diff #121665)

I expect you'll remove this function in a follow-up patch.

[pcc]

lld/ELF/Symbols.h

104 ↗

(On Diff #121665)

Right.

lld/trunk/ELF/Arch/Mips.cpp

if (Type != R_MIPS_26 && Type != R_MICROMIPS_26_S1 &&
       Type != R_MICROMIPS_PC26_S1)
     return false;
   auto *F = dyn_cast_or_null<ELFFileBase<ELFT>>(File);
   if (!F)
     return false;
   // 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>(&S);
+  auto *D = dyn_cast<Defined>(&S);
   // LA25 is required if target file has PIC code
   // or target symbol is a PIC symbol.
   return D && D->isMipsPIC<ELFT>();
 }
 
 template <class ELFT>
 int64_t MIPS<ELFT>::getImplicitAddend(const uint8_t *Buf, RelType Type) const {
   const endianness E = ELFT::TargetEndianness;

lld/trunk/ELF/GdbIndex.cpp

if (It == Rels.end() || It->r_offset != Pos)
     return None;
   const RelTy &Rel = *It;
 
   const ObjFile<ELFT> *File = Sec.getFile<ELFT>();
   uint32_t SymIndex = Rel.getSymbol(Config->IsMips64EL);
   const typename ELFT::Sym &Sym = File->getELFSyms()[SymIndex];
   uint32_t SecIndex = File->getSectionIndex(Sym);
   Symbol &B = File->getRelocTargetSym(Rel);
-  auto &DR = cast<DefinedRegular>(B);
+  auto &DR = cast<Defined>(B);
   uint64_t Val = DR.Value + getAddend<ELFT>(Rel);
 
   // FIXME: We should be consistent about always adding the file
   // offset or not.
   if (DR.Section->Flags & ELF::SHF_ALLOC)
     Val += cast<InputSection>(DR.Section)->getOffsetInFile();
 
   return RelocAddrEntry{SecIndex, Val};

lld/trunk/ELF/ICF.cpp

for (size_t I = 0; I < RA.size(); ++I) {
     Symbol &SA = SecA->template getFile<ELFT>()->getRelocTargetSym(RA[I]);
     Symbol &SB = SecB->template getFile<ELFT>()->getRelocTargetSym(RB[I]);
     if (&SA == &SB) {
       if (AddA == AddB)
         continue;
       return false;
     }
 
-    auto *DA = dyn_cast<DefinedRegular>(&SA);
-    auto *DB = dyn_cast<DefinedRegular>(&SB);
+    auto *DA = dyn_cast<Defined>(&SA);
+    auto *DB = dyn_cast<Defined>(&SB);
     if (!DA || !DB)
       return false;
 
     // Relocations referring to absolute symbols are constant-equal if their
     // values are equal.
     if (!DA->Section && !DB->Section && DA->Value + AddA == DB->Value + AddB)
       continue;
     if (!DA->Section || !DB->Section)
bool ICF<ELFT>::variableEq(const InputSection *SecA, ArrayRef<RelTy> RA,
 
   for (size_t I = 0; I < RA.size(); ++I) {
     // The two sections must be identical.
     Symbol &SA = SecA->template getFile<ELFT>()->getRelocTargetSym(RA[I]);
     Symbol &SB = SecB->template getFile<ELFT>()->getRelocTargetSym(RB[I]);
     if (&SA == &SB)
       continue;
 
-    auto *DA = cast<DefinedRegular>(&SA);
-    auto *DB = cast<DefinedRegular>(&SB);
+    auto *DA = cast<Defined>(&SA);
+    auto *DB = cast<Defined>(&SB);
 
     // We already dealt with absolute and non-InputSection symbols in
     // constantEq, and for InputSections we have already checked everything
     // except the equivalence class.
     if (!DA->Section)
       continue;
     auto *X = dyn_cast<InputSection>(DA->Section);
     if (!X)

lld/trunk/ELF/InputFiles.cpp

if (Binding == STB_LOCAL) {
 
     if (this->StringTable.size() <= Sym->st_name)
       fatal(toString(this) + ": invalid symbol name offset");
 
     StringRefZ Name = this->StringTable.data() + Sym->st_name;
     if (Sym->st_shndx == SHN_UNDEF)
       return make<Undefined>(Name, /*IsLocal=*/true, StOther, Type);
 
-    return make<DefinedRegular>(Name, /*IsLocal=*/true, StOther, Type, Value,
-                                Size, Sec);
+    return make<Defined>(Name, /*IsLocal=*/true, StOther, Type, Value, Size,
+                         Sec);
   }
 
   StringRef Name = check(Sym->getName(this->StringTable), toString(this));
 
   switch (Sym->st_shndx) {
   case SHN_UNDEF:
     return Symtab->addUndefined<ELFT>(Name, /*IsLocal=*/false, Binding, StOther,
                                       Type,

lld/trunk/ELF/InputSection.h

 #include <mutex>
 
 namespace lld {
 namespace elf {
 
 class Symbol;
 struct SectionPiece;
 
-class DefinedRegular;
+class Defined;
 class SyntheticSection;
 class MergeSyntheticSection;
 template <class ELFT> class ObjFile;
 class OutputSection;
 
 // This is the base class of all sections that lld handles. Some are sections in
 // input files, some are sections in the produced output file and some exist
 // just as a convenience for implementing special ways of combining some
public:
   const OutputSection *getOutputSection() const {
     return const_cast<SectionBase *>(this)->getOutputSection();
   }
 
   // Translate an offset in the input section to an offset in the output
   // section.
   uint64_t getOffset(uint64_t Offset) const;
 
-  uint64_t getOffset(const DefinedRegular &Sym) const;
+  uint64_t getOffset(const Defined &Sym) const;
 
 protected:
   SectionBase(Kind SectionKind, StringRef Name, uint64_t Flags,
               uint64_t Entsize, uint64_t Alignment, uint32_t Type,
               uint32_t Info, uint32_t Link)
       : Name(Name), SectionKind(SectionKind), Live(false), Bss(false),
         Alignment(Alignment), Flags(Flags), Entsize(Entsize), Type(Type),
         Link(Link), Info(Info) {}

lld/trunk/ELF/InputSection.cpp

DenseMap<SectionBase *, int> elf::buildSectionOrder() {
   DenseMap<StringRef, int> SymbolOrder;
   int Priority = -Config->SymbolOrderingFile.size();
   for (StringRef S : Config->SymbolOrderingFile)
     SymbolOrder.insert({S, Priority++});
 
   // Build a map from sections to their priorities.
   for (InputFile *File : ObjectFiles) {
     for (Symbol *Sym : File->getSymbols()) {
-      auto *D = dyn_cast<DefinedRegular>(Sym);
+      auto *D = dyn_cast<Defined>(Sym);
       if (!D || !D->Section)
         continue;
       int &Priority = SectionOrder[D->Section];
       Priority = std::min(Priority, SymbolOrder.lookup(D->getName()));
     }
   }
   return SectionOrder;
 }
void InputSectionBase::maybeUncompress() {
   if (Error E = Dec.decompress({UncompressBuf.get(), Size}))
     fatal(toString(this) +
           ": decompress failed: " + llvm::toString(std::move(E)));
 
   this->Data = makeArrayRef((uint8_t *)UncompressBuf.get(), Size);
   this->Flags &= ~(uint64_t)SHF_COMPRESSED;
 }
 
-uint64_t SectionBase::getOffset(const DefinedRegular &Sym) const {
+uint64_t SectionBase::getOffset(const Defined &Sym) const {
   return getOffset(Sym.Value);
 }
 
 InputSection *InputSectionBase::getLinkOrderDep() const {
   if ((Flags & SHF_LINK_ORDER) && Link != 0) {
     InputSectionBase *L = File->getSections()[Link];
     if (auto *IS = dyn_cast<InputSection>(L))
       return IS;
std::string InputSectionBase::getLocation(uint64_t Offset) {
   // 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 = getFile<ELFT>()->SourceFile;
   if (SrcFile.empty())
     SrcFile = toString(File);
 
   // Find a function symbol that encloses a given location.
   for (Symbol *B : File->getSymbols())
-    if (auto *D = dyn_cast<DefinedRegular>(B))
+    if (auto *D = dyn_cast<Defined>(B))
       if (D->Section == this && D->Type == STT_FUNC)
         if (D->Value <= Offset && Offset < D->Value + D->Size)
           return SrcFile + ":(function " + toString(*D) + ")";
 
   // If there's no symbol, print out the offset in the section.
   return (SrcFile + ":(" + Name + "+0x" + utohexstr(Offset) + ")").str();
 }
 
std::string InputSectionBase::getObjMsg(uint64_t Off) {
   std::string Filename = File->getName();
 
   std::string Archive;
   if (!File->ArchiveName.empty())
     Archive = (" in archive " + File->ArchiveName).str();
 
   // Find a symbol that encloses a given location.
   for (Symbol *B : File->getSymbols())
-    if (auto *D = dyn_cast<DefinedRegular>(B))
+    if (auto *D = dyn_cast<Defined>(B))
       if (D->Section == this && D->Value <= Off && Off < D->Value + D->Size)
         return Filename + ":(" + toString(*D) + ")" + Archive;
 
   // If there's no symbol, print out the offset in the section.
   return (Filename + ":(" + Name + "+0x" + utohexstr(Off) + ")" + Archive)
       .str();
 }
 
if (Sym.Type == STT_SECTION) {
       // 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>(Sym).Section;
+      SectionBase *Section = cast<Defined>(Sym).Section;
       if (Section == &InputSection::Discarded) {
         P->setSymbolAndType(0, 0, false);
         continue;
       }
 
       if (Config->IsRela) {
         P->r_addend += Sym.getVA() - Section->getOutputSection()->Addr;
       } else if (Config->Relocatable) {

lld/trunk/ELF/LinkerScript.h

 #include <cstdint>
 #include <functional>
 #include <memory>
 #include <vector>
 
 namespace lld {
 namespace elf {
 
-class DefinedRegular;
+class Defined;
 class Symbol;
 class InputSectionBase;
 class InputSection;
 class OutputSection;
 class OutputSectionFactory;
 class InputSectionBase;
 class SectionBase;
 
SymbolAssignment(StringRef Name, Expr E, std::string Loc)
       : BaseCommand(AssignmentKind), Name(Name), Expression(E), Location(Loc) {}
 
   static bool classof(const BaseCommand *C) {
     return C->Kind == AssignmentKind;
   }
 
   // The LHS of an expression. Name is either a symbol name or ".".
   StringRef Name;
-  DefinedRegular *Sym = nullptr;
+  Defined *Sym = nullptr;
 
   // The RHS of an expression.
   Expr Expression;
 
   // Command attributes for PROVIDE, HIDDEN and PROVIDE_HIDDEN.
   bool Provide = false;
   bool Hidden = false;
 

lld/trunk/ELF/LinkerScript.cpp

void LinkerScript::addSymbol(SymbolAssignment *Cmd) {
   // However, if an expression is `x = .`, there's no way to know its
   // value at the moment.
   //
   // We want to set symbol values early if we can. This allows us to
   // use symbols as variables in linker scripts. Doing so allows us to
   // write expressions like this: `alignment = 16; . = ALIGN(., alignment)`.
   uint64_t SymValue = Value.Sec ? 0 : Value.getValue();
 
-  replaceSymbol<DefinedRegular>(Sym, nullptr, Cmd->Name, /*IsLocal=*/false,
-                                Visibility, STT_NOTYPE, SymValue, 0, Sec);
-  Cmd->Sym = cast<DefinedRegular>(Sym);
+  replaceSymbol<Defined>(Sym, nullptr, Cmd->Name, /*IsLocal=*/false, Visibility,
+                         STT_NOTYPE, SymValue, 0, Sec);
+  Cmd->Sym = cast<Defined>(Sym);
 }
 
 // This function is called from assignAddresses, while we are
 // fixing the output section addresses. This function is supposed
 // to set the final value for a given symbol assignment.
 void LinkerScript::assignSymbol(SymbolAssignment *Cmd, bool InSec) {
   if (Cmd->Name == ".") {
     setDot(Cmd->Expression, Cmd->Location, InSec);

 ExprValue LinkerScript::getSymbolValue(StringRef Name, const Twine &Loc) {
   if (Name == ".") {
     if (Ctx)
       return {Ctx->OutSec, false, Dot - Ctx->OutSec->Addr, Loc};
     error(Loc + ": unable to get location counter value");
     return 0;
   }
 
-  if (auto *Sym = dyn_cast_or_null<DefinedRegular>(Symtab->find(Name)))
+  if (auto *Sym = dyn_cast_or_null<Defined>(Symtab->find(Name)))
     return {Sym->Section, false, Sym->Value, Loc};
 
   error(Loc + ": symbol not found: " + Name);
   return 0;
 }
 
 // Returns the index of the segment named Name.
 static Optional<size_t> getPhdrIndex(ArrayRef<PhdrsCommand> Vec,

lld/trunk/ELF/MapFile.cpp

 
 static std::string indent(int Depth) { return std::string(Depth * 8, ' '); }
 
 // Returns a list of all symbols that we want to print out.
 static std::vector<Defined *> getSymbols() {
   std::vector<Defined *> V;
   for (InputFile *File : ObjectFiles)
     for (Symbol *B : File->getSymbols())
-      if (auto *DR = dyn_cast<DefinedRegular>(B))
+      if (auto *DR = dyn_cast<Defined>(B))
         if (DR->getFile() == File && !DR->isSection() && DR->Section &&
             DR->Section->Live)
           V.push_back(DR);
   return V;
 }
 
 // Returns a map from sections to their symbols.
 static SymbolMapTy getSectionSyms(ArrayRef<Defined *> Syms) {
   SymbolMapTy Ret;
   for (Defined *S : Syms)
-    if (auto *DR = dyn_cast<DefinedRegular>(S))
+    if (auto *DR = dyn_cast<Defined>(S))
       Ret[DR->Section].push_back(S);
 
   // Sort symbols by address. We want to print out symbols in the
   // order in the output file rather than the order they appeared
   // in the input files.
   for (auto &It : Ret) {
     SmallVectorImpl<Defined *> &V = It.second;
     std::sort(V.begin(), V.end(),

lld/trunk/ELF/MarkLive.cpp

 // identifiers, so we just store a std::vector instead of a multimap.
 static DenseMap<StringRef, std::vector<InputSectionBase *>> CNamedSections;
 
 template <class ELFT, class RelT>
 static void resolveReloc(InputSectionBase &Sec, RelT &Rel,
                          std::function<void(InputSectionBase *, uint64_t)> Fn) {
   Symbol &B = Sec.getFile<ELFT>()->getRelocTargetSym(Rel);
 
-  if (auto *D = dyn_cast<DefinedRegular>(&B)) {
+  if (auto *D = dyn_cast<Defined>(&B)) {
     if (!D->Section)
       return;
     uint64_t Offset = D->Value;
     if (D->isSection())
       Offset += getAddend<ELFT>(Sec, Rel);
     Fn(cast<InputSectionBase>(D->Section), Offset);
     return;
   }
auto Enqueue = [&](InputSectionBase *Sec, uint64_t Offset) {
     Sec->Live = true;
 
     // Add input section to the queue.
     if (InputSection *S = dyn_cast<InputSection>(Sec))
       Q.push_back(S);
   };
 
   auto MarkSymbol = [&](Symbol *Sym) {
-    if (auto *D = dyn_cast_or_null<DefinedRegular>(Sym))
+    if (auto *D = dyn_cast_or_null<Defined>(Sym))
       if (auto *IS = cast_or_null<InputSectionBase>(D->Section))
         Enqueue(IS, D->Value);
   };
 
   // Add GC root symbols.
   MarkSymbol(Symtab->find(Config->Entry));
   MarkSymbol(Symtab->find(Config->Init));
   MarkSymbol(Symtab->find(Config->Fini));

lld/trunk/ELF/OutputSections.h

 class EhInputSection;
 class InputSection;
 class InputSectionBase;
 class MergeInputSection;
 class OutputSection;
 template <class ELFT> class ObjFile;
 template <class ELFT> class SharedFile;
 class SharedSymbol;
-class DefinedRegular;
+class Defined;
 
 // This represents a section in an output file.
 // It is composed of multiple InputSections.
 // The writer creates multiple OutputSections and assign them unique,
 // non-overlapping file offsets and VAs.
 class OutputSection final : public BaseCommand, public SectionBase {
 public:
   OutputSection(StringRef Name, uint32_t Type, uint64_t Flags);

lld/trunk/ELF/Relocations.cpp

static RelType getMipsPairType(RelType Type, bool IsLocal) {
   }
 }
 
 // True if non-preemptable symbol always has the same value regardless of where
 // the DSO is loaded.
 static bool isAbsolute(const Symbol &Sym) {
   if (Sym.isUndefWeak())
     return true;
-  if (const auto *DR = dyn_cast<DefinedRegular>(&Sym))
+  if (const auto *DR = dyn_cast<Defined>(&Sym))
     return DR->Section == nullptr; // Absolute symbol.
   return false;
 }
 
 static bool isAbsoluteValue(const Symbol &Sym) {
   return isAbsolute(Sym) || Sym.isTls();
 }
 

lld/trunk/ELF/SymbolTable.h

public:
   template <class ELFT> void addFile(InputFile *File);
   template <class ELFT> void addCombinedLTOObject();
   template <class ELFT> void addSymbolWrap(StringRef Name);
   void applySymbolWrap();
 
   ArrayRef<Symbol *> getSymbols() const { return SymVector; }
 
   template <class ELFT>
-  DefinedRegular *addAbsolute(StringRef Name,
-                              uint8_t Visibility = llvm::ELF::STV_HIDDEN,
-                              uint8_t Binding = llvm::ELF::STB_GLOBAL);
+  Defined *addAbsolute(StringRef Name,
 
   template <class ELFT> Symbol *addUndefined(StringRef Name);
   template <class ELFT>
   Symbol *addUndefined(StringRef Name, bool IsLocal, uint8_t Binding,
                        uint8_t StOther, uint8_t Type, bool CanOmitFromDynSym,
                        InputFile *File);
   template <class ELFT>
   Symbol *addRegular(StringRef Name, uint8_t StOther, uint8_t Type,

lld/trunk/ELF/SymbolTable.cpp

template <class ELFT> void SymbolTable::addCombinedLTOObject() {
   for (InputFile *File : LTO->compile()) {
     DenseSet<CachedHashStringRef> DummyGroups;
     cast<ObjFile<ELFT>>(File)->parse(DummyGroups);
     ObjectFiles.push_back(File);
   }
 }
 
 template <class ELFT>
-DefinedRegular *SymbolTable::addAbsolute(StringRef Name, uint8_t Visibility,
-                                         uint8_t Binding) {
+Defined *SymbolTable::addAbsolute(StringRef Name, uint8_t Visibility,
   Symbol *Sym = addRegular<ELFT>(Name, Visibility, STT_NOTYPE, 0, 0, Binding,
                                  nullptr, nullptr);
-  return cast<DefinedRegular>(Sym);
+  return cast<Defined>(Sym);
 }
 
 // Set a flag for --trace-symbol so that we can print out a log message
 // if a new symbol with the same name is inserted into the symbol table.
 void SymbolTable::trace(StringRef Name) {
   Symtab.insert({CachedHashStringRef(Name), {-1, true}});
 }
 

 static int compareDefinedNonCommon(Symbol *S, bool WasInserted, uint8_t Binding,
                                    bool IsAbsolute, uint64_t Value,
                                    StringRef Name) {
   if (int Cmp = compareDefined(S, WasInserted, Binding, Name)) {
     if (Cmp > 0)
       S->Binding = Binding;
     return Cmp;
   }
-  if (auto *R = dyn_cast<DefinedRegular>(S)) {
+  if (auto *R = dyn_cast<Defined>(S)) {
     if (R->Section && isa<BssSection>(R->Section)) {
       // Non-common symbols take precedence over common symbols.
       if (Config->WarnCommon)
         warn("common " + S->getName() + " is overridden");
       return 1;
     }
     if (R->Section == nullptr && Binding == STB_GLOBAL && IsAbsolute &&
         R->Value == Value)
Symbol *SymbolTable::addCommon(StringRef N, uint64_t Size, uint32_t Alignment,
   int Cmp = compareDefined(S, WasInserted, Binding, N);
   if (Cmp > 0) {
     auto *Bss = make<BssSection>("COMMON", Size, Alignment);
     Bss->File = File;
     Bss->Live = !Config->GcSections;
     InputSections.push_back(Bss);
 
     S->Binding = Binding;
-    replaceSymbol<DefinedRegular>(S, File, N, /*IsLocal=*/false, StOther, Type,
-                                  0, Size, Bss);
+    replaceSymbol<Defined>(S, File, N, /*IsLocal=*/false, StOther, Type, 0,
+                           Size, Bss);
   } else if (Cmp == 0) {
-    auto *D = cast<DefinedRegular>(S);
+    auto *D = cast<Defined>(S);
     auto *Bss = dyn_cast_or_null<BssSection>(D->Section);
     if (!Bss) {
       // Non-common symbols take precedence over common symbols.
       if (Config->WarnCommon)
         warn("common " + S->getName() + " is overridden");
       return S;
     }
 
static void reportDuplicate(Symbol *Sym, InputFile *NewFile) {
   warnOrError("duplicate symbol: " + toString(*Sym) + "\n>>> defined in " +
               toString(Sym->getFile()) + "\n>>> defined in " +
               toString(NewFile));
 }
 
 template <class ELFT>
 static void reportDuplicate(Symbol *Sym, InputSectionBase *ErrSec,
                             typename ELFT::uint ErrOffset) {
-  DefinedRegular *D = dyn_cast<DefinedRegular>(Sym);
+  Defined *D = dyn_cast<Defined>(Sym);
   if (!D || !D->Section || !ErrSec) {
     reportDuplicate(Sym, ErrSec ? ErrSec->File : nullptr);
     return;
   }
 
   // Construct and print an error message in the form of:
   //
   //   ld.lld: error: duplicate symbol: foo
Symbol *SymbolTable::addRegular(StringRef Name, uint8_t StOther, uint8_t Type,
                                 SectionBase *Section, InputFile *File) {
   Symbol *S;
   bool WasInserted;
   std::tie(S, WasInserted) = insert(Name, Type, getVisibility(StOther),
                                     /*CanOmitFromDynSym*/ false, File);
   int Cmp = compareDefinedNonCommon(S, WasInserted, Binding, Section == nullptr,
                                     Value, Name);
   if (Cmp > 0)
-    replaceSymbol<DefinedRegular>(S, File, Name, /*IsLocal=*/false, StOther,
-                                  Type, Value, Size, Section);
+    replaceSymbol<Defined>(S, File, Name, /*IsLocal=*/false, StOther, Type,
+                           Value, Size, Section);
   else if (Cmp == 0)
     reportDuplicate<ELFT>(S, dyn_cast_or_null<InputSectionBase>(Section),
                           Value);
   return S;
 }
 
 template <typename ELFT>
 void SymbolTable::addShared(StringRef Name, SharedFile<ELFT> *File,
Symbol *SymbolTable::addBitcode(StringRef Name, uint8_t Binding,
                                 bool CanOmitFromDynSym, BitcodeFile *F) {
   Symbol *S;
   bool WasInserted;
   std::tie(S, WasInserted) =
       insert(Name, Type, getVisibility(StOther), CanOmitFromDynSym, F);
   int Cmp = compareDefinedNonCommon(S, WasInserted, Binding,
                                     /*IsAbs*/ false, /*Value*/ 0, Name);
   if (Cmp > 0)
-    replaceSymbol<DefinedRegular>(S, F, Name, /*IsLocal=*/false, StOther, Type,
-                                  0, 0, nullptr);
+    replaceSymbol<Defined>(S, F, Name, /*IsLocal=*/false, StOther, Type, 0, 0,
+                           nullptr);
   else if (Cmp == 0)
     reportDuplicate(S, F);
   return S;
 }
 
 Symbol *SymbolTable::find(StringRef Name) {
   auto It = Symtab.find(CachedHashStringRef(Name));
   if (It == Symtab.end())
template Symbol *SymbolTable::addRegular<ELF32BE>(StringRef, uint8_t, uint8_t,
                                                   SectionBase *, InputFile *);
 template Symbol *SymbolTable::addRegular<ELF64LE>(StringRef, uint8_t, uint8_t,
                                                   uint64_t, uint64_t, uint8_t,
                                                   SectionBase *, InputFile *);
 template Symbol *SymbolTable::addRegular<ELF64BE>(StringRef, uint8_t, uint8_t,
                                                   uint64_t, uint64_t, uint8_t,
                                                   SectionBase *, InputFile *);
 
-template DefinedRegular *SymbolTable::addAbsolute<ELF32LE>(StringRef, uint8_t,
-                                                           uint8_t);
-template DefinedRegular *SymbolTable::addAbsolute<ELF32BE>(StringRef, uint8_t,
-                                                           uint8_t);
-template DefinedRegular *SymbolTable::addAbsolute<ELF64LE>(StringRef, uint8_t,
-                                                           uint8_t);
-template DefinedRegular *SymbolTable::addAbsolute<ELF64BE>(StringRef, uint8_t,
-                                                           uint8_t);
+template Defined *SymbolTable::addAbsolute<ELF32LE>(StringRef, uint8_t,
+template Defined *SymbolTable::addAbsolute<ELF32BE>(StringRef, uint8_t,
+template Defined *SymbolTable::addAbsolute<ELF64LE>(StringRef, uint8_t,
+template Defined *SymbolTable::addAbsolute<ELF64BE>(StringRef, uint8_t,
 
 template Symbol *
 SymbolTable::addLazyArchive<ELF32LE>(StringRef, ArchiveFile *,
                                      const object::Archive::Symbol);
 template Symbol *
 SymbolTable::addLazyArchive<ELF32BE>(StringRef, ArchiveFile *,
                                      const object::Archive::Symbol);
 template Symbol *

lld/trunk/ELF/Symbols.h

 template <class ELFT> class ObjFile;
 class OutputSection;
 template <class ELFT> class SharedFile;
 
 // The base class for real symbol classes.
 class Symbol {
 public:
   enum Kind {
-    DefinedFirst,
-    DefinedRegularKind = DefinedFirst,
-    DefinedLast = DefinedRegularKind,
+    DefinedKind,
     SharedKind,
     UndefinedKind,
     LazyArchiveKind,
     LazyObjectKind,
   };
 
   Symbol(Kind K) : SymbolKind(K) {}
   Kind kind() const { return static_cast<Kind>(SymbolKind); }
public:
   // The file from which this symbol was created.
   InputFile *File = nullptr;
 
   bool includeInDynsym() const;
   uint8_t computeBinding() const;
   bool isWeak() const { return Binding == llvm::ELF::STB_WEAK; }
 
   bool isUndefined() const { return SymbolKind == UndefinedKind; }
-  bool isDefined() const { return SymbolKind <= DefinedLast; }
+  bool isDefined() const { return SymbolKind == DefinedKind; }
   bool isShared() const { return SymbolKind == SharedKind; }
   bool isLocal() const { return IsLocal; }
 
   bool isLazy() const {
     return SymbolKind == LazyArchiveKind || SymbolKind == LazyObjectKind;
   }
 
-  bool isInCurrentOutput() const {
-    return SymbolKind == DefinedRegularKind;
-  }
+  bool isInCurrentOutput() const { return isDefined(); }
 
   // True is this is an undefined weak symbol. This only works once
   // all input files have been added.
   bool isUndefWeak() const;
 
   InputFile *getFile() const;
   StringRef getName() const { return Name; }
   uint8_t getVisibility() const { return StOther & 0x3; }
public:
   bool isGnuIFunc() const { return Type == llvm::ELF::STT_GNU_IFUNC; }
   bool isObject() const { return Type == llvm::ELF::STT_OBJECT; }
   bool isFile() const { return Type == llvm::ELF::STT_FILE; }
 
 protected:
   StringRefZ Name;
 };
 
-// The base class for any defined symbols.
+// Represents a symbol that is defined in the current output file.
 class Defined : public Symbol {
 public:
-  Defined(Kind K, StringRefZ Name, bool IsLocal, uint8_t StOther, uint8_t Type)
-      : Symbol(K, Name, IsLocal, StOther, Type) {}
-
-  static bool classof(const Symbol *S) { return S->isDefined(); }
-};
-
-// Regular defined symbols read from object file symbol tables.
-class DefinedRegular : public Defined {
-public:
-  DefinedRegular(StringRefZ Name, bool IsLocal, uint8_t StOther, uint8_t Type,
-                 uint64_t Value, uint64_t Size, SectionBase *Section)
-      : Defined(DefinedRegularKind, Name, IsLocal, StOther, Type), Value(Value),
+  Defined(StringRefZ Name, bool IsLocal, uint8_t StOther, uint8_t Type,
+      : Symbol(DefinedKind, Name, IsLocal, StOther, Type), Value(Value),
         Size(Size), Section(Section) {}
 
   // Return true if the symbol is a PIC function.
   template <class ELFT> bool isMipsPIC() const;
 
-  static bool classof(const Symbol *S) {
-    return S->kind() == DefinedRegularKind;
-  }
+  static bool classof(const Symbol *S) { return S->isDefined(); }
 
   uint64_t Value;
   uint64_t Size;
   SectionBase *Section;
 };
 
 class Undefined : public Symbol {
 public:
public:
 
   static bool classof(const Symbol *S) { return S->kind() == LazyObjectKind; }
 
   LazyObjFile *getFile();
   InputFile *fetch();
 };
 
 // Some linker-generated symbols need to be created as
-// DefinedRegular symbols.
+// Defined symbols.
 struct ElfSym {
   // __bss_start
-  static DefinedRegular *Bss;
+  static Defined *Bss;
 
   // etext and _etext
-  static DefinedRegular *Etext1;
-  static DefinedRegular *Etext2;
+  static Defined *Etext1;
+  static Defined *Etext2;
 
   // edata and _edata
-  static DefinedRegular *Edata1;
-  static DefinedRegular *Edata2;
+  static Defined *Edata1;
+  static Defined *Edata2;
 
   // end and _end
-  static DefinedRegular *End1;
-  static DefinedRegular *End2;
+  static Defined *End1;
+  static Defined *End2;
 
   // The _GLOBAL_OFFSET_TABLE_ symbol is defined by target convention to
   // be at some offset from the base of the .got section, usually 0 or
   // the end of the .got.
-  static DefinedRegular *GlobalOffsetTable;
+  static Defined *GlobalOffsetTable;
 
   // _gp, _gp_disp and __gnu_local_gp symbols. Only for MIPS.
-  static DefinedRegular *MipsGp;
-  static DefinedRegular *MipsGpDisp;
-  static DefinedRegular *MipsLocalGp;
+  static Defined *MipsGp;
+  static Defined *MipsGpDisp;
+  static Defined *MipsLocalGp;
 };
 
 // A buffer class that is large enough to hold any Symbol-derived
 // object. We allocate memory using this class and instantiate a symbol
 // using the placement new.
 union SymbolUnion {
-  alignas(DefinedRegular) char A[sizeof(DefinedRegular)];
+  alignas(Defined) char A[sizeof(Defined)];
   alignas(Undefined) char C[sizeof(Undefined)];
   alignas(SharedSymbol) char D[sizeof(SharedSymbol)];
   alignas(LazyArchive) char E[sizeof(LazyArchive)];
   alignas(LazyObject) char F[sizeof(LazyObject)];
 };
 
 void printTraceSymbol(Symbol *Sym);
 

lld/trunk/ELF/Symbols.cpp

 
 using namespace llvm;
 using namespace llvm::object;
 using namespace llvm::ELF;
 
 using namespace lld;
 using namespace lld::elf;
 
-DefinedRegular *ElfSym::Bss;
-DefinedRegular *ElfSym::Etext1;
-DefinedRegular *ElfSym::Etext2;
-DefinedRegular *ElfSym::Edata1;
-DefinedRegular *ElfSym::Edata2;
-DefinedRegular *ElfSym::End1;
-DefinedRegular *ElfSym::End2;
-DefinedRegular *ElfSym::GlobalOffsetTable;
-DefinedRegular *ElfSym::MipsGp;
-DefinedRegular *ElfSym::MipsGpDisp;
-DefinedRegular *ElfSym::MipsLocalGp;
+Defined *ElfSym::Bss;
+Defined *ElfSym::Etext1;
+Defined *ElfSym::Etext2;
+Defined *ElfSym::Edata1;
+Defined *ElfSym::Edata2;
+Defined *ElfSym::End1;
+Defined *ElfSym::End2;
+Defined *ElfSym::GlobalOffsetTable;
+Defined *ElfSym::MipsGp;
+Defined *ElfSym::MipsGpDisp;
+Defined *ElfSym::MipsLocalGp;
 
 static uint64_t getSymVA(const Symbol &Sym, int64_t &Addend) {
   switch (Sym.kind()) {
-  case Symbol::DefinedRegularKind: {
-    auto &D = cast<DefinedRegular>(Sym);
+  case Symbol::DefinedKind: {
+    auto &D = cast<Defined>(Sym);
     SectionBase *IS = D.Section;
     if (auto *ISB = dyn_cast_or_null<InputSectionBase>(IS))
       IS = ISB->Repl;
 
     // According to the ELF spec reference to a local symbol from outside
     // the group are not allowed. Unfortunately .eh_frame breaks that rule
     // and must be treated specially. For now we just replace the symbol with
     // 0.

 // Returns true if this is a weak undefined symbol.
 bool Symbol::isUndefWeak() const {
   // See comment on Lazy in Symbols.h for the details.
   return !isLocal() && isWeak() && (isUndefined() || isLazy());
 }
 
 InputFile *Symbol::getFile() const {
   if (isLocal()) {
-    const SectionBase *Sec = cast<DefinedRegular>(this)->Section;
+    const SectionBase *Sec = cast<Defined>(this)->Section;
     // Local absolute symbols actually have a file, but that is not currently
     // used. We could support that by having a mostly redundant InputFile in
     // Symbol, or having a special absolute section if needed.
     return Sec ? cast<InputSectionBase>(Sec)->File : nullptr;
   }
   return File;
 }
 

 uint64_t Symbol::getPltVA() const {
   if (this->IsInIplt)
     return InX::Iplt->getVA() + PltIndex * Target->PltEntrySize;
   return InX::Plt->getVA() + Target->PltHeaderSize +
          PltIndex * Target->PltEntrySize;
 }
 
 uint64_t Symbol::getSize() const {
-  if (const auto *DR = dyn_cast<DefinedRegular>(this))
+  if (const auto *DR = dyn_cast<Defined>(this))
     return DR->Size;
   if (const auto *S = dyn_cast<SharedSymbol>(this))
     return S->Size;
   return 0;
 }
 
 OutputSection *Symbol::getOutputSection() const {
-  if (auto *S = dyn_cast<DefinedRegular>(this)) {
+  if (auto *S = dyn_cast<Defined>(this)) {
     if (S->Section)
       return S->Section->getOutputSection();
     return nullptr;
   }
 
   if (auto *S = dyn_cast<SharedSymbol>(this)) {
     if (S->CopyRelSec)
       return S->CopyRelSec->getParent();
void Symbol::parseSymbolVersion() {
   // Usually version script is not provided when linking executable,
   // but we may still want to override a versioned symbol from DSO,
   // so we do not report error in this case.
   if (Config->Shared)
     error(toString(getFile()) + ": symbol " + S + " has undefined version " +
           Verstr);
 }
 
-template <class ELFT> bool DefinedRegular::isMipsPIC() const {
+template <class ELFT> bool Defined::isMipsPIC() const {
   typedef typename ELFT::Ehdr Elf_Ehdr;
   if (!Section || !isFunc())
     return false;
 
   auto *Sec = cast<InputSectionBase>(Section);
   const Elf_Ehdr *Hdr = Sec->template getFile<ELFT>()->getObj().getHeader();
   return (this->StOther & STO_MIPS_MIPS16) == STO_MIPS_PIC ||
          (Hdr->e_flags & EF_MIPS_PIC);

 void elf::printTraceSymbol(Symbol *Sym) {
   std::string S;
   if (Sym->isUndefined())
     S = ": reference to ";
   else if (Sym->isLazy())
     S = ": lazy definition of ";
   else if (Sym->isShared())
     S = ": shared definition of ";
-  else if (dyn_cast_or_null<BssSection>(cast<DefinedRegular>(Sym)->Section))
+  else if (dyn_cast_or_null<BssSection>(cast<Defined>(Sym)->Section))
     S = ": common definition of ";
   else
     S = ": definition of ";
 
   message(toString(Sym->File) + S + Sym->getName());
 }
 
 // Returns a symbol for an error message.
 std::string lld::toString(const Symbol &B) {
   if (Config->Demangle)
     if (Optional<std::string> S = demangle(B.getName()))
       return *S;
   return B.getName();
 }
 
-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 bool Defined::template isMipsPIC<ELF32LE>() const;
+template bool Defined::template isMipsPIC<ELF32BE>() const;
+template bool Defined::template isMipsPIC<ELF64LE>() const;
+template bool Defined::template isMipsPIC<ELF64BE>() const;

lld/trunk/ELF/SyntheticSections.cpp

InputSection *elf::createInterpSection() {
   auto *Sec =
       make<InputSection>(SHF_ALLOC, SHT_PROGBITS, 1, Contents, ".interp");
   Sec->Live = true;
   return Sec;
 }
 
 Symbol *elf::addSyntheticLocal(StringRef Name, uint8_t Type, uint64_t Value,
                                uint64_t Size, InputSectionBase *Section) {
-  auto *S = make<DefinedRegular>(Name, /*IsLocal*/ true, STV_DEFAULT, Type,
-                                 Value, Size, Section);
+  auto *S = make<Defined>(Name, /*IsLocal*/ true, STV_DEFAULT, Type, Value,
+                          Size, Section);
   if (InX::SymTab)
     InX::SymTab->addSymbol(S);
   return S;
 }
 
 static size_t getHashSize() {
   switch (Config->BuildId) {
   case BuildIdKind::Fast:
bool EhFrameSection::isFdeLive(EhSectionPiece &Fde, ArrayRef<RelTy> Rels) {
   // To deal with that, we ignore such FDEs.
   if (FirstRelI == (unsigned)-1)
     return false;
 
   const RelTy &Rel = Rels[FirstRelI];
   Symbol &B = Sec->template getFile<ELFT>()->getRelocTargetSym(Rel);
 
   // FDEs for garbage-collected or merged-by-ICF sections are dead.
-  if (auto *D = dyn_cast<DefinedRegular>(&B))
+  if (auto *D = dyn_cast<Defined>(&B))
     if (auto *Sec = cast_or_null<InputSectionBase>(D->Section))
       return Sec->Live && (Sec == Sec->Repl);
   return false;
 }
 
 // .eh_frame is a sequence of CIE or FDE records. In general, there
 // is one CIE record per input object file which is followed by
 // a list of FDEs. This function searches an existing CIE or create a new
if (Sym->isLocal()) {
       ESym->setVisibility(Sym->Visibility);
     }
 
     ESym->st_name = Ent.StrTabOffset;
 
     // Set a section index.
     BssSection *CommonSec = nullptr;
     if (!Config->DefineCommon)
-      if (auto *D = dyn_cast<DefinedRegular>(Sym))
+      if (auto *D = dyn_cast<Defined>(Sym))
         CommonSec = dyn_cast_or_null<BssSection>(D->Section);
     if (CommonSec)
       ESym->st_shndx = SHN_COMMON;
     else if (const OutputSection *OutSec = Sym->getOutputSection())
       ESym->st_shndx = OutSec->SectionIndex;
-    else if (isa<DefinedRegular>(Sym))
+    else if (isa<Defined>(Sym))
       ESym->st_shndx = SHN_ABS;
     else
       ESym->st_shndx = SHN_UNDEF;
 
     // Copy symbol size if it is a defined symbol. st_size is not significant
     // for undefined symbols, so whether copying it or not is up to us if that's
     // the case. We'll leave it as zero because by not setting a value, we can
     // get the exact same outputs for two sets of input files that differ only
if (Config->EMachine == EM_MIPS) {
     auto *ESym = reinterpret_cast<Elf_Sym *>(Buf);
 
     for (SymbolTableEntry &Ent : Symbols) {
       Symbol *Sym = Ent.Sym;
       if (Sym->isInPlt() && Sym->NeedsPltAddr)
         ESym->st_other |= STO_MIPS_PLT;
 
       if (Config->Relocatable)
-        if (auto *D = dyn_cast<DefinedRegular>(Sym))
+        if (auto *D = dyn_cast<Defined>(Sym))
           if (D->isMipsPIC<ELFT>())
             ESym->st_other |= STO_MIPS_PIC;
       ++ESym;
     }
   }
 }
 
 // .hash and .gnu.hash sections contain on-disk hash tables that map

lld/trunk/ELF/Thunks.h

 class ThunkSection;
 // Class to describe an instance of a Thunk.
 // A Thunk is a code-sequence inserted by the linker in between a caller and
 // the callee. The relocation to the callee is redirected to the Thunk, which
 // after executing transfers control to the callee. Typical uses of Thunks
 // include transferring control from non-pi to pi and changing state on
 // targets like ARM.
 //
-// Thunks can be created for DefinedRegular, Shared and Undefined Symbols.
+// Thunks can be created for Defined, Shared and Undefined Symbols.
 // Thunks are assigned to synthetic ThunkSections
 class Thunk {
 public:
   Thunk(Symbol &Destination);
   virtual ~Thunk();
 
   virtual uint32_t size() const { return 0; }
   virtual void writeTo(uint8_t *Buf, ThunkSection &IS) const {}

lld/trunk/ELF/Thunks.cpp

 
 void MipsThunk::addSymbols(ThunkSection &IS) {
   ThunkSym =
       addSyntheticLocal(Saver.save("__LA25Thunk_" + Destination.getName()),
                         STT_FUNC, Offset, size(), &IS);
 }
 
 InputSection *MipsThunk::getTargetInputSection() const {
-  auto *DR = dyn_cast<DefinedRegular>(&Destination);
+  auto *DR = dyn_cast<Defined>(&Destination);
   return dyn_cast<InputSection>(DR->Section);
 }
 
 // Write microMIPS R2-R5 LA25 thunk code
 // to call PIC function from the non-PIC one.
 void MicroMipsThunk::writeTo(uint8_t *Buf, ThunkSection &) const {
   uint64_t S = Destination.getVA();
   write16(Buf, 0x41b9, Config->Endianness);       // lui   $25, %hi(func)
   write16(Buf + 4, 0xd400, Config->Endianness);   // j     func
   write16(Buf + 8, 0x3339, Config->Endianness);   // addiu $25, $25, %lo(func)
   write16(Buf + 12, 0x0c00, Config->Endianness);  // nop
   Target->relocateOne(Buf, R_MICROMIPS_HI16, S);
   Target->relocateOne(Buf + 4, R_MICROMIPS_26_S1, S);
   Target->relocateOne(Buf + 8, R_MICROMIPS_LO16, S);
 }
 
 void MicroMipsThunk::addSymbols(ThunkSection &IS) {
   ThunkSym =
       addSyntheticLocal(Saver.save("__microLA25Thunk_" + Destination.getName()),
                         STT_FUNC, Offset, size(), &IS);
   ThunkSym->StOther |= STO_MIPS_MICROMIPS;
 }
 
 InputSection *MicroMipsThunk::getTargetInputSection() const {
-  auto *DR = dyn_cast<DefinedRegular>(&Destination);
+  auto *DR = dyn_cast<Defined>(&Destination);
   return dyn_cast<InputSection>(DR->Section);
 }
 
 // Write microMIPS R6 LA25 thunk code
 // to call PIC function from the non-PIC one.
 void MicroMipsR6Thunk::writeTo(uint8_t *Buf, ThunkSection &) const {
   uint64_t S = Destination.getVA();
   uint64_t P = ThunkSym->getVA();
   write16(Buf, 0x1320, Config->Endianness);       // lui   $25, %hi(func)
   write16(Buf + 4, 0x3339, Config->Endianness);   // addiu $25, $25, %lo(func)
   write16(Buf + 8, 0x9400, Config->Endianness);   // bc    func
   Target->relocateOne(Buf, R_MICROMIPS_HI16, S);
   Target->relocateOne(Buf + 4, R_MICROMIPS_LO16, S);
   Target->relocateOne(Buf + 8, R_MICROMIPS_PC26_S1, S - P - 12);
 }
 
 void MicroMipsR6Thunk::addSymbols(ThunkSection &IS) {
   ThunkSym =
       addSyntheticLocal(Saver.save("__microLA25Thunk_" + Destination.getName()),
                         STT_FUNC, Offset, size(), &IS);
   ThunkSym->StOther |= STO_MIPS_MICROMIPS;
 }
 
 InputSection *MicroMipsR6Thunk::getTargetInputSection() const {
-  auto *DR = dyn_cast<DefinedRegular>(&Destination);
+  auto *DR = dyn_cast<Defined>(&Destination);
   return dyn_cast<InputSection>(DR->Section);
 }
 
 Thunk::Thunk(Symbol &D) : Destination(D), Offset(0) {}
 
 Thunk::~Thunk() = default;
 
 // Creates a thunk for Thumb-ARM interworking.

lld/trunk/ELF/Writer.cpp

static bool shouldKeepInSymtab(SectionBase *Sec, StringRef SymName,
 
   return !Sec || !(Sec->Flags & SHF_MERGE);
 }
 
 static bool includeInSymtab(const Symbol &B) {
   if (!B.isLocal() && !B.IsUsedInRegularObj)
     return false;
 
-  if (auto *D = dyn_cast<DefinedRegular>(&B)) {
+  if (auto *D = dyn_cast<Defined>(&B)) {
     // Always include absolute symbols.
     SectionBase *Sec = D->Section;
     if (!Sec)
       return true;
     if (auto *IS = dyn_cast<InputSectionBase>(Sec)) {
       Sec = IS->Repl;
       IS = cast<InputSectionBase>(Sec);
       // Exclude symbols pointing to garbage-collected sections.
template <class ELFT> void Writer<ELFT>::copyLocalSymbols() {
   if (!InX::SymTab)
     return;
   for (InputFile *File : ObjectFiles) {
     ObjFile<ELFT> *F = cast<ObjFile<ELFT>>(File);
     for (Symbol *B : F->getLocalSymbols()) {
       if (!B->isLocal())
         fatal(toString(F) +
               ": broken object: getLocalSymbols returns a non-local symbol");
-      auto *DR = dyn_cast<DefinedRegular>(B);
+      auto *DR = dyn_cast<Defined>(B);
 
       // No reason to keep local undefined symbol in symtab.
       if (!DR)
         continue;
       if (!includeInSymtab(*B))
         continue;
 
       SectionBase *Sec = DR->Section;
for (BaseCommand *Base : Script->SectionCommands) {
     });
     if (I == Sec->SectionCommands.end())
       continue;
     InputSection *IS = cast<InputSectionDescription>(*I)->Sections[0];
     if (isa<SyntheticSection>(IS) || IS->Type == SHT_REL ||
         IS->Type == SHT_RELA)
       continue;
 
-    auto *Sym =
-        make<DefinedRegular>("", /*IsLocal=*/true, /*StOther=*/0, STT_SECTION,
+    auto *Sym = make<Defined>("", /*IsLocal=*/true, /*StOther=*/0, STT_SECTION,
                               /*Value=*/0, /*Size=*/0, IS);
     InX::SymTab->addSymbol(Sym);
   }
 }
 
 // Today's loaders have a feature to make segments read-only after
 // processing dynamic relocations to enhance security. PT_GNU_RELRO
 // is defined for that.
 //
void PhdrEntry::add(OutputSection *Sec) {
   if (!FirstSec)
     FirstSec = Sec;
   p_align = std::max(p_align, Sec->Alignment);
   if (p_type == PT_LOAD)
     Sec->PtLoad = this;
 }
 
 template <class ELFT>
-static DefinedRegular *
-addOptionalRegular(StringRef Name, SectionBase *Sec, uint64_t Val,
-                   uint8_t StOther = STV_HIDDEN, uint8_t Binding = STB_GLOBAL) {
+static Defined *addOptionalRegular(StringRef Name, SectionBase *Sec,
+                                   uint64_t Val, uint8_t StOther = STV_HIDDEN,
+                                   uint8_t Binding = STB_GLOBAL) {
   Symbol *S = Symtab->find(Name);
   if (!S || S->isInCurrentOutput())
     return nullptr;
   Symbol *Sym = Symtab->addRegular<ELFT>(Name, StOther, STT_NOTYPE, Val,
                                          /*Size=*/0, Binding, Sec,
                                          /*File=*/nullptr);
-  return cast<DefinedRegular>(Sym);
+  return cast<Defined>(Sym);
 }
 
 // The beginning and the ending of .rel[a].plt section are marked
 // with __rel[a]_iplt_{start,end} symbols if it is a statically linked
 // executable. The runtime needs these symbols in order to resolve
 // all IRELATIVE relocs on startup. For dynamic executables, we don't
 // need these symbols, since IRELATIVE relocs are resolved through GOT
 // and PLT. For details, see http://www.airs.com/blog/archives/403.