ELF: Move Visibility, IsUsedInRegularObj and MustBeInDynSym flags to Symbol.

[pcc]

Summary

These are properties of a symbol name, rather than a particular instance
of a symbol in an object file. We can simplify the code by collecting these
properties in Symbol.

The MustBeInDynSym flag has been renamed ExportDynamic, as its semantics
have been changed to be the same as those of --dynamic-list and
--export-dynamic-symbol, which do not cause hidden symbols to be exported.

[ruiu]

This is a very interesting idea. I have never thought of adding new fields to Symbol, but it seems to make sense because the argument that some properties belongs to names rather than to symbol instances is convincing. One concern would be that now you have to memorize which class have a certain property, Symbol or SymbolBody, but that's probably not a big issue.

There are a few minor comments.

ELF/LTO.cpp

79

Maybe we should make Backref member public then use that member directly and remove getSymbol accessor?

ELF/MarkLive.cpp

115–119

You can remove all curly braces.

ELF/SymbolTable.cpp

300

Please add a newline before this line.

304–312

Can you move this code to a new static function (say, shouldExport) so that you can write

Sym->ExportDynamic ||= shouldExport(New);

313

s/K/SymbolBody::Kind/

ELF/Symbols.cpp

323–324

V is used only in this line, so probably

if (Visibility != STV_DEFAULT && Visibility != STV_PROTECTED)

is better.

[pcc]

Address review comments

[pcc]

• No need to set export dynamic flag on copy relocation aliases; they will be exported anyway

[ruiu]

LGTM with a nit.

ELF/SymbolTable.cpp

281

Remove else after return.

ELF/Driver.cpp

template <class ELFT> void LinkerDriver::link(opt::InputArgList &Args) {
   if (Config->Entry.empty() && !Config->Shared && !Config->Relocatable &&
       Config->EMachine != EM_AMDGPU)
     Config->Entry = Config->EMachine == EM_MIPS ? "__start" : "_start";
 
   if (!Config->Entry.empty()) {
     // Set either EntryAddr (if S is a number) or EntrySym (otherwise).
     StringRef S = Config->Entry;
     if (S.getAsInteger(0, Config->EntryAddr))
-      Config->EntrySym = Symtab.addUndefined(S)->getSymbol();
+      Config->EntrySym = Symtab.addUndefined(S)->Backref;
   }
 
   for (std::unique_ptr<InputFile> &F : Files)
     Symtab.addFile(std::move(F));
   if (HasError)
     return; // There were duplicate symbols or incompatible files
 
   for (StringRef S : Config->Undefined)

ELF/LTO.cpp

static void runLTOPasses(Module &M, TargetMachine &TM) {
   LtoPasses.run(M);
 
   if (Config->SaveTemps)
     saveBCFile(M, ".lto.opt.bc");
 }
 
 static bool shouldInternalize(const SmallPtrSet<GlobalValue *, 8> &Used,
                               SymbolBody &B, GlobalValue *GV) {
-  if (B.isUsedInRegularObj())
+  if (B.Backref->IsUsedInRegularObj)
     return false;
 
   if (Used.count(GV))
     return false;
 
-  return !B.includeInDynsym();
+  return !B.Backref->includeInDynsym();
 }
 
 void BitcodeCompiler::add(BitcodeFile &F) {
   std::unique_ptr<IRObjectFile> Obj =
       check(IRObjectFile::create(F.MB, Context));
   std::vector<GlobalValue *> Keep;
   unsigned BodyIndex = 0;
   ArrayRef<SymbolBody *> Bodies = F.getSymbols();

ELF/MarkLive.cpp

template <class ELFT> void elf::markLive(SymbolTable<ELFT> *Symtab) {
   if (Config->EntrySym)
     MarkSymbol(Config->EntrySym->Body);
   MarkSymbol(Symtab->find(Config->Init));
   MarkSymbol(Symtab->find(Config->Fini));
   for (StringRef S : Config->Undefined)
     MarkSymbol(Symtab->find(S));
 
   // Preserve externally-visible symbols if the symbols defined by this
   // file can interrupt other ELF file's symbols at runtime.
-  if (Config->Shared || Config->ExportDynamic) {
-    for (const Symbol *S : Symtab->getSymbols()) {
-      SymbolBody *B = S->Body;
-      if (B->includeInDynsym())
-        MarkSymbol(B);
-    }
-  }
+  if (Config->Shared || Config->ExportDynamic)
+    for (const Symbol *S : Symtab->getSymbols())
+      if (S->includeInDynsym())
+        MarkSymbol(S->Body);
 
   // Preserve special sections and those which are specified in linker
   // script KEEP command.
   for (const std::unique_ptr<ObjectFile<ELFT>> &F : Symtab->getObjectFiles())
     for (InputSectionBase<ELFT> *Sec : F->getSections())
       if (Sec && Sec != &InputSection<ELFT>::Discarded)
         if (isReserved(Sec) || Script<ELFT>::X->shouldKeep(Sec))
           Enqueue(Sec);

ELF/OutputSections.cpp

static bool sortMipsSymbols(const std::pair<SymbolBody *, unsigned> &L,
   bool LIsInLocalGot = !L.first->isInGot() || !L.first->isPreemptible();
   bool RIsInLocalGot = !R.first->isInGot() || !R.first->isPreemptible();
   if (LIsInLocalGot || RIsInLocalGot)
     return !RIsInLocalGot;
   return L.first->GotIndex < R.first->GotIndex;
 }
 
 static uint8_t getSymbolBinding(SymbolBody *Body) {
-  uint8_t Visibility = Body->getVisibility();
+  uint8_t Visibility = Body->Backref->Visibility;
   if (Visibility != STV_DEFAULT && Visibility != STV_PROTECTED)
     return STB_LOCAL;
   if (Config->NoGnuUnique && Body->Binding == STB_GNU_UNIQUE)
     return STB_GLOBAL;
   return Body->Binding;
 }
 
 template <class ELFT> void SymbolTableSection<ELFT>::finalize() {
for (const std::pair<const DefinedRegular<ELFT> *, size_t> &P :
       ESym->st_name = P.second;
       ESym->st_size = Body.template getSize<ELFT>();
       ESym->setBindingAndType(Body.Binding, Body.Type);
       Buf += sizeof(*ESym);
     }
   }
 }
 
-static uint8_t getSymbolVisibility(SymbolBody *Body) {
-  if (Body->isShared())
-    return STV_DEFAULT;
-  return Body->getVisibility();
-}
-
 template <class ELFT>
 void SymbolTableSection<ELFT>::writeGlobalSymbols(uint8_t *Buf) {
   // Write the internal symbol table contents to the output symbol table
   // pointed by Buf.
   auto *ESym = reinterpret_cast<Elf_Sym *>(Buf);
   for (const std::pair<SymbolBody *, size_t> &P : Symbols) {
     SymbolBody *Body = P.first;
     size_t StrOff = P.second;
 
     uint8_t Type = Body->Type;
     uintX_t Size = Body->getSize<ELFT>();
 
     ESym->setBindingAndType(getSymbolBinding(Body), Type);
     ESym->st_size = Size;
     ESym->st_name = StrOff;
-    ESym->setVisibility(getSymbolVisibility(Body));
+    ESym->setVisibility(Body->Backref->Visibility);
     ESym->st_value = Body->getVA<ELFT>();
 
     if (const OutputSectionBase<ELFT> *OutSec = getOutputSection(Body))
       ESym->st_shndx = OutSec->SectionIndex;
     else if (isa<DefinedRegular<ELFT>>(Body))
       ESym->st_shndx = SHN_ABS;
 
     // On MIPS we need to mark symbol which has a PLT entry and requires pointer

ELF/SymbolTable.cpp

template <class ELFT> void SymbolTable<ELFT>::addCombinedLtoObject() {
   // Replace bitcode symbols.
   for (auto &IF : IFs) {
     ObjectFile<ELFT> *Obj = cast<ObjectFile<ELFT>>(IF.release());
 
     llvm::DenseSet<StringRef> DummyGroups;
     Obj->parse(DummyGroups);
     for (SymbolBody *Body : Obj->getNonLocalSymbols()) {
       Symbol *Sym = insert(Body);
-      Sym->Body->setUsedInRegularObj();
-      if (Sym->Body->isShared())
-        Sym->Body->MustBeInDynSym = true;
-      if (Sym->Body->MustBeInDynSym)
-        Body->MustBeInDynSym = true;
       if (!Sym->Body->isUndefined() && Body->isUndefined())
         continue;
       Sym->Body = Body;
     }
     ObjectFiles.emplace_back(Obj);
   }
 }
 

 }
 
 // Rename SYM as __wrap_SYM. The original symbol is preserved as __real_SYM.
 // Used to implement --wrap.
 template <class ELFT> void SymbolTable<ELFT>::wrap(StringRef Name) {
   if (Symtab.count(Name) == 0)
     return;
   StringSaver Saver(Alloc);
-  Symbol *Sym = addUndefined(Name)->getSymbol();
-  Symbol *Real = addUndefined(Saver.save("__real_" + Name))->getSymbol();
-  Symbol *Wrap = addUndefined(Saver.save("__wrap_" + Name))->getSymbol();
+  Symbol *Sym = addUndefined(Name)->Backref;
+  Symbol *Real = addUndefined(Saver.save("__real_" + Name))->Backref;
+  Symbol *Wrap = addUndefined(Saver.save("__wrap_" + Name))->Backref;
   Real->Body = Sym->Body;
   Sym->Body = Wrap->Body;
 }
 
 // Returns a file from which symbol B was created.
 // If B does not belong to any file, returns a nullptr.
 template <class ELFT> InputFile *SymbolTable<ELFT>::findFile(SymbolBody *B) {
   for (const std::unique_ptr<ObjectFile<ELFT>> &F : ObjectFiles) {
template <class ELFT> void SymbolTable<ELFT>::resolve(SymbolBody *New) {
 
   if (auto *L = dyn_cast<Lazy>(Existing)) {
     if (New->isUndefined()) {
       addMemberFile(New, L);
       return;
     }
     // Found a definition for something also in an archive.
     // Ignore the archive definition.
-    if (L->isUsedInRegularObj())
-      New->setUsedInRegularObj();
     Sym->Body = New;
     return;
   }
 
   if (New->isTls() != Existing->isTls()) {
     error("TLS attribute mismatch for symbol: " + conflictMsg(Existing, New));
     return;
   }
 
   // compare() returns -1, 0, or 1 if the lhs symbol is less preferable,
   // equivalent (conflicting), or more preferable, respectively.
   int Comp = Existing->compare(New);
   if (Comp == 0) {
     std::string S = "duplicate symbol: " + conflictMsg(Existing, New);
     if (Config->AllowMultipleDefinition)
       warning(S);
     else
       error(S);
     return;
   }
   if (Comp < 0)
     Sym->Body = New;
 }
 
+static uint8_t getMinVisibility(uint8_t VA, uint8_t VB) {
+  if (VA == STV_DEFAULT)
+    return VB;
+  if (VB == STV_DEFAULT)
+    return VA;
+  return std::min(VA, VB);
+}
+
+static bool shouldExport(SymbolBody *B) {
+  if (Config->Shared || Config->ExportDynamic) {
+    // Export most symbols except for those that do not need to be exported.
+    return !B->CanOmitFromDynSym;
+  } else {
+    // Make sure we preempt DSO symbols with default visibility.
+    return B->isShared() && B->getVisibility() == STV_DEFAULT;
+  }
+}
+
 // Find an existing symbol or create and insert a new one.
 template <class ELFT> Symbol *SymbolTable<ELFT>::insert(SymbolBody *New) {
   StringRef Name = New->getName();
   unsigned NumSyms = SymVector.size();
   auto P = Symtab.insert(std::make_pair(Name, NumSyms));
   Symbol *Sym;
   if (P.second) {
-    Sym = new (Alloc) Symbol{New};
+    Sym = new (Alloc) Symbol{New, STV_DEFAULT, false, false};
     SymVector.push_back(Sym);
   } else {
     Sym = SymVector[P.first->second];
   }
-  New->setBackref(Sym);
+  New->Backref = Sym;
+
+  // Merge in the new symbol's visibility. DSO symbols do not affect visibility
+  // in the output.
+  if (!New->isShared())
+    Sym->Visibility = getMinVisibility(Sym->Visibility, New->getVisibility());
+  Sym->ExportDynamic = Sym->ExportDynamic || shouldExport(New);
+  SymbolBody::Kind K = New->kind();
+  if (K == SymbolBody::DefinedRegularKind ||
+      K == SymbolBody::DefinedCommonKind ||
+      K == SymbolBody::DefinedSyntheticKind ||
+      K == SymbolBody::UndefinedElfKind)
+    Sym->IsUsedInRegularObj = true;
   return Sym;
 }
 
 template <class ELFT> SymbolBody *SymbolTable<ELFT>::find(StringRef Name) {
   auto It = Symtab.find(Name);
   if (It == Symtab.end())
     return nullptr;
   return SymVector[It->second]->Body;
 }
 
 template <class ELFT> void SymbolTable<ELFT>::addLazy(Lazy *L) {
   Symbol *Sym = insert(L);
   SymbolBody *Cur = Sym->Body;
   if (Cur == L)
     return;
   if (Cur->isUndefined()) {
     Sym->Body = L;
     addMemberFile(Cur, L);
   }
 }
 
 template <class ELFT>
 void SymbolTable<ELFT>::addMemberFile(SymbolBody *Undef, Lazy *L) {
-  if (Undef->isUsedInRegularObj())
-    L->setUsedInRegularObj();
   // Weak undefined symbols should not fetch members from archives.
   // If we were to keep old symbol we would not know that an archive member was
   // available if a strong undefined symbol shows up afterwards in the link.
   // If a strong undefined symbol never shows up, this lazy symbol will
   // get to the end of the link and must be treated as the weak undefined one.
   // We set UsedInRegularObj in a similar way to what is done with shared
   // symbols and copy information to reduce how many special cases are needed.
   if (Undef->isWeak()) {
-    L->setUsedInRegularObj();
     L->Binding = Undef->Binding;
     L->Type = Undef->Type;
 
     // FIXME: Do we need to copy more?
     return;
   }
 
   // Fetch a member file that has the definition for L.

 // We need to put such symbols to the main program's .dynsym so that
 // shared libraries can find them.
 // Except this, we ignore undefined symbols in DSOs.
 template <class ELFT> void SymbolTable<ELFT>::scanShlibUndefined() {
   for (std::unique_ptr<SharedFile<ELFT>> &File : SharedFiles)
     for (StringRef U : File->getUndefinedSymbols())
       if (SymbolBody *Sym = find(U))
         if (Sym->isDefined())
-          Sym->MustBeInDynSym = true;
+          Sym->Backref->ExportDynamic = true;
 }
 
 // This function process the dynamic list option by marking all the symbols
 // to be exported in the dynamic table.
 template <class ELFT> void SymbolTable<ELFT>::scanDynamicList() {
   for (StringRef S : Config->DynamicList)
     if (SymbolBody *B = find(S))
-      B->MustBeInDynSym = true;
+      B->Backref->ExportDynamic = true;
 }
 
 template class elf::SymbolTable<ELF32LE>;
 template class elf::SymbolTable<ELF32BE>;
 template class elf::SymbolTable<ELF64LE>;
 template class elf::SymbolTable<ELF64BE>;

ELF/Symbols.h

 // Returns a demangled C++ symbol name. If Name is not a mangled
 // name or the system does not provide __cxa_demangle function,
 // it returns the unmodified string.
 std::string demangle(StringRef Name);
 
 // A real symbol object, SymbolBody, is usually accessed indirectly
 // through a Symbol. There's always one Symbol for each symbol name.
 // The resolver updates SymbolBody pointers as it resolves symbols.
+// Symbol also holds computed properties of symbol names.
 struct Symbol {
   SymbolBody *Body;
+
+  // Symbol visibility. This is the computed minimum visibility of all
+  // observed non-DSO symbols.
+  unsigned Visibility : 2;
+
+  // True if the symbol was used for linking and thus need to be added to the
+  // output file's symbol table. This is true for all symbols except for
+  // unreferenced DSO symbols and bitcode symbols that are unreferenced except
+  // by other bitcode objects.
+  unsigned IsUsedInRegularObj : 1;
+
+  // If this flag is true and the symbol has protected or default visibility, it
+  // will appear in .dynsym. This flag is set by interposable DSO symbols in
+  // executables, by most symbols in DSOs and executables built with
+  // --export-dynamic, and by dynamic lists.
+  unsigned ExportDynamic : 1;
+
+  bool includeInDynsym() const;
 };
 
 // The base class for real symbol classes.
 class SymbolBody {
   void init();
 
 public:
   enum Kind {
public:
   }
   bool isDefined() const { return SymbolKind <= DefinedLast; }
   bool isCommon() const { return SymbolKind == DefinedCommonKind; }
   bool isLazy() const {
     return SymbolKind == LazyArchiveKind || SymbolKind == LazyObjectKind;
   }
   bool isShared() const { return SymbolKind == SharedKind; }
   bool isLocal() const { return Binding == llvm::ELF::STB_LOCAL; }
-  bool isUsedInRegularObj() const { return IsUsedInRegularObj; }
   bool isPreemptible() const;
 
   // Returns the symbol name.
   StringRef getName() const {
     assert(!isLocal());
     return StringRef(Name.S, Name.Len);
   }
   uint32_t getNameOffset() const {
public:
   uint32_t GotPltIndex = -1;
   uint32_t PltIndex = -1;
   uint32_t ThunkIndex = -1;
   bool hasGlobalDynIndex() { return GlobalDynIndex != uint32_t(-1); }
   bool isInGot() const { return GotIndex != -1U; }
   bool isInPlt() const { return PltIndex != -1U; }
   bool hasThunk() const { return ThunkIndex != -1U; }
 
-  void setUsedInRegularObj() { IsUsedInRegularObj = true; }
-
   template <class ELFT>
   typename ELFT::uint getVA(typename ELFT::uint Addend = 0) const;
 
   template <class ELFT> typename ELFT::uint getGotOffset() const;
   template <class ELFT> typename ELFT::uint getGotVA() const;
   template <class ELFT> typename ELFT::uint getGotPltOffset() const;
   template <class ELFT> typename ELFT::uint getGotPltVA() const;
   template <class ELFT> typename ELFT::uint getPltVA() const;
   template <class ELFT> typename ELFT::uint getThunkVA() const;
   template <class ELFT> typename ELFT::uint getSize() const;
 
   // A SymbolBody has a backreference to a Symbol. Originally they are
   // doubly-linked. A backreference will never change. But the pointer
   // in the Symbol may be mutated by the resolver. If you have a
   // pointer P to a SymbolBody and are not sure whether the resolver
   // has chosen the object among other objects having the same name,
   // you can access P->Backref->Body to get the resolver's result.
-  void setBackref(Symbol *P) { Backref = P; }
   SymbolBody &repl() { return Backref ? *Backref->Body : *this; }
-  Symbol *getSymbol() const { return Backref; }
 
   // Decides which symbol should "win" in the symbol table, this or
   // the Other. Returns 1 if this wins, -1 if the Other wins, or 0 if
   // they are duplicate (conflicting) symbols.
   int compare(SymbolBody *Other);
 
-  bool includeInDynsym() const;
-
 protected:
   SymbolBody(Kind K, StringRef Name, uint8_t Binding, uint8_t StOther,
              uint8_t Type);
 
   SymbolBody(Kind K, uint32_t NameOffset, uint8_t StOther, uint8_t Type);
 
   const unsigned SymbolKind : 8;
 
-  // True if the symbol was used for linking and thus need to be
-  // added to the output file's symbol table. It is usually true,
-  // but if it is a shared symbol that were not referenced by anyone,
-  // it can be false.
-  unsigned IsUsedInRegularObj : 1;
-
 public:
   // True if this symbol can be omitted from the symbol table if nothing else
   // requires it to be there. Right now this is only used for linkonce_odr in
   // LTO, but we could add the feature to ELF. It would be similar to
   // MachO's .weak_def_can_be_hidden.
   unsigned CanOmitFromDynSym : 1;
 
-  // If true, the symbol is added to .dynsym symbol table.
-  unsigned MustBeInDynSym : 1;
-
   // True if the linker has to generate a copy relocation for this shared
   // symbol or if the symbol should point to its plt entry.
   unsigned NeedsCopyOrPltAddr : 1;
 
   unsigned CanKeepUndefined : 1;
 
   // The following fields have the same meaning as the ELF symbol attributes.
   uint8_t Type;    // symbol type
   uint8_t Binding; // symbol binding
   uint8_t StOther; // st_other field value
 
   bool isSection() const { return Type == llvm::ELF::STT_SECTION; }
   bool isTls() const { return Type == llvm::ELF::STT_TLS; }
   bool isFunc() const { return Type == llvm::ELF::STT_FUNC; }
   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; }
-  void setVisibility(uint8_t V) { StOther = (StOther & ~0x3) | V; }
+
+  Symbol *Backref = nullptr;
 
 protected:
   struct Str {
     const char *S;
     size_t Len;
   };
   union {
     Str Name;
     uint32_t NameOffset;
   };
-  Symbol *Backref = nullptr;
 };
 
 // The base class for any defined symbols.
 class Defined : public SymbolBody {
 public:
   Defined(Kind K, StringRef Name, uint8_t Binding, uint8_t StOther,
           uint8_t Type);
   Defined(Kind K, uint32_t NameOffset, uint8_t StOther, uint8_t Type);

ELF/Symbols.cpp

if (SS.isFunc())
       return Body.getPltVA<ELFT>();
     return Out<ELFT>::Bss->getVA() + SS.OffsetInBss;
   }
   case SymbolBody::UndefinedElfKind:
   case SymbolBody::UndefinedBitcodeKind:
     return 0;
   case SymbolBody::LazyArchiveKind:
   case SymbolBody::LazyObjectKind:
-    assert(Body.isUsedInRegularObj() && "lazy symbol reached writer");
+    assert(Body.Backref->IsUsedInRegularObj && "lazy symbol reached writer");
     return 0;
   case SymbolBody::DefinedBitcodeKind:
     llvm_unreachable("should have been replaced");
   }
   llvm_unreachable("invalid symbol kind");
 }
 
 SymbolBody::SymbolBody(Kind K, uint32_t NameOffset, uint8_t StOther,
                        uint8_t Type)
     : SymbolKind(K), Type(Type), Binding(STB_LOCAL), StOther(StOther),
       NameOffset(NameOffset) {
   init();
 }
 
 SymbolBody::SymbolBody(Kind K, StringRef Name, uint8_t Binding, uint8_t StOther,
                        uint8_t Type)
     : SymbolKind(K), Type(Type), Binding(Binding), StOther(StOther),
       Name({Name.data(), Name.size()}) {
   assert(!isLocal());
   init();
 }
 
 void SymbolBody::init() {
-  Kind K = kind();
-  IsUsedInRegularObj = K == DefinedRegularKind || K == DefinedCommonKind ||
-                       K == DefinedSyntheticKind || K == UndefinedElfKind;
   CanKeepUndefined = false;
-  MustBeInDynSym = false;
-  CanOmitFromDynSym = false;
   NeedsCopyOrPltAddr = false;
+  CanOmitFromDynSym = false;
 }
 
 // Returns true if a symbol can be replaced at load-time by a symbol
 // with the same name defined in other ELF executable or DSO.
 bool SymbolBody::isPreemptible() const {
   if (isLocal())
     return false;
 
   if (isShared())
     return true;
 
-  if (getVisibility() != STV_DEFAULT)
+  if (Backref->Visibility != STV_DEFAULT)
     return false;
 
   if (isUndefined()) {
     if (!isWeak())
       return true;
 
     // Ideally the static linker should see a definition for every symbol, but
     // shared object are normally allowed to have undefined references that the
if (const auto *DR = dyn_cast<DefinedRegular<ELFT>>(this))
     return DR->Size;
   if (const auto *S = dyn_cast<SharedSymbol<ELFT>>(this))
     return S->Sym.st_size;
   if (const auto *U = dyn_cast<UndefinedElf<ELFT>>(this))
     return U->Size;
   return 0;
 }
 
-static uint8_t getMinVisibility(uint8_t VA, uint8_t VB) {
-  if (VA == STV_DEFAULT)
-    return VB;
-  if (VB == STV_DEFAULT)
-    return VA;
-  return std::min(VA, VB);
-}
-
 static int compareCommons(DefinedCommon *A, DefinedCommon *B) {
   if (Config->WarnCommon)
     warning("multiple common of " + A->getName());
   A->Alignment = B->Alignment = std::max(A->Alignment, B->Alignment);
   return A->Size < B->Size ? -1 : 1;
 }
 
 // Returns 1, 0 or -1 if this symbol should take precedence
 // over the Other, tie or lose, respectively.
 int SymbolBody::compare(SymbolBody *Other) {
   assert(!isLazy() && !Other->isLazy());
   std::tuple<bool, bool, bool> L(isDefined(), !isShared(), !isWeak());
   std::tuple<bool, bool, bool> R(Other->isDefined(), !Other->isShared(),
                                  !Other->isWeak());
 
   // Normalize
   if (L > R)
     return -Other->compare(this);
 
-  uint8_t V = getMinVisibility(getVisibility(), Other->getVisibility());
-  if (isShared() != Other->isShared()) {
-    SymbolBody *Shared = isShared() ? this : Other;
-    Shared->MustBeInDynSym = true;
-    if (Shared->getVisibility() == STV_DEFAULT &&
-        (V == STV_DEFAULT || V == STV_PROTECTED)) {
-      // We want to export all symbols that exist in the executable and are
-      // preemptable in DSOs, so that the symbols in the executable can
-      // preempt symbols in the DSO at runtime.
-      SymbolBody *NonShared = isShared() ? Other : this;
-      NonShared->MustBeInDynSym = true;
-    }
-  }
-
-  if (!isShared() && !Other->isShared()) {
-    setVisibility(V);
-    Other->setVisibility(V);
-  }
-
-  if (IsUsedInRegularObj || Other->IsUsedInRegularObj)
-    IsUsedInRegularObj = Other->IsUsedInRegularObj = true;
-
-  if (!CanOmitFromDynSym || !Other->CanOmitFromDynSym)
-    CanOmitFromDynSym = Other->CanOmitFromDynSym = false;
-
   if (L != R)
     return -1;
   if (!isDefined() || isShared() || isWeak())
     return 1;
   if (!isCommon() && !Other->isCommon())
     return 0;
   if (isCommon() && Other->isCommon())
     return compareCommons(cast<DefinedCommon>(this),
char *Buf =
       abi::__cxa_demangle(Name.str().c_str(), nullptr, nullptr, nullptr);
   if (!Buf)
     return Name;
   std::string S(Buf);
   free(Buf);
   return S;
 #endif
 }
 
-bool SymbolBody::includeInDynsym() const {
-  if (MustBeInDynSym)
-    return true;
-  uint8_t V = getVisibility();
-  if (V != STV_DEFAULT && V != STV_PROTECTED)
-    return false;
-  if (!Config->ExportDynamic && !Config->Shared)
+bool Symbol::includeInDynsym() const {
+  if (Visibility != STV_DEFAULT && Visibility != STV_PROTECTED)
     return false;
-  return !CanOmitFromDynSym;
+  return ExportDynamic || Body->isShared();
 }
 
 template uint32_t SymbolBody::template getVA<ELF32LE>(uint32_t) const;
 template uint32_t SymbolBody::template getVA<ELF32BE>(uint32_t) const;
 template uint64_t SymbolBody::template getVA<ELF64LE>(uint64_t) const;
 template uint64_t SymbolBody::template getVA<ELF64BE>(uint64_t) const;
 
 template uint32_t SymbolBody::template getGotVA<ELF32LE>() const;

ELF/Writer.cpp

void Writer<ELFT>::addCopyRelSymbol(SharedSymbol<ELFT> *SS) {
   // Look through the DSO's dynamic symbol for aliases and create a dynamic
   // symbol for each one. This causes the copy relocation to correctly interpose
   // any aliases.
   for (SharedSymbol<ELFT> &S : SS->File->getSharedSymbols()) {
     if (S.Sym.st_shndx != Shndx || S.Sym.st_value != Value)
       continue;
     S.OffsetInBss = Off;
     S.NeedsCopyOrPltAddr = true;
-    S.setUsedInRegularObj();
-    S.MustBeInDynSym = true;
+    S.Backref->IsUsedInRegularObj = true;
   }
   Out<ELFT>::RelaDyn->addReloc(
       {Target->CopyRel, Out<ELFT>::Bss, SS->OffsetInBss, false, SS, 0});
 }
 
 template <class ELFT>
 StringRef Writer<ELFT>::getOutputSectionName(InputSectionBase<ELFT> *S) const {
   StringRef Dest = Script<ELFT>::X->getOutputSection(S);
ElfSym<ELFT>::RelaIpltStart =
       addOptionalSynthetic(Symtab, S, *Out<ELFT>::RelaPlt, 0);
 
   S = Config->Rela ? "__rela_iplt_end" : "__rel_iplt_end";
   ElfSym<ELFT>::RelaIpltEnd = addOptionalSynthetic(
       Symtab, S, *Out<ELFT>::RelaPlt, DefinedSynthetic<ELFT>::SectionEnd);
 }
 
 template <class ELFT> static bool includeInSymtab(const SymbolBody &B) {
-  if (!B.isUsedInRegularObj())
+  if (!B.Backref->IsUsedInRegularObj)
     return false;
 
   if (auto *D = dyn_cast<DefinedRegular<ELFT>>(&B)) {
     // Exclude symbols pointing to garbage-collected sections.
     if (D->Section && !D->Section->Live)
       return false;
   }
   return true;
for (Symbol *S : Symtab.getSymbols()) {
     if (auto *C = dyn_cast<DefinedCommon>(Body))
       CommonSymbols.push_back(C);
 
     if (!includeInSymtab<ELFT>(*Body))
       continue;
     if (Out<ELFT>::SymTab)
       Out<ELFT>::SymTab->addSymbol(Body);
 
-    if (isOutputDynamic() && Body->includeInDynsym())
+    if (isOutputDynamic() && S->includeInDynsym())
       Out<ELFT>::DynSymTab->addSymbol(Body);
   }
 
   // Do not proceed if there was an undefined symbol.
   if (HasError)
     return;
 
   addCommonSymbols(CommonSymbols);