From bbfe33c6bacd401e713fe12a29ae2d941a3ae4a8 Mon Sep 17 00:00:00 2001
From: Rui Ueyama <ruiu@google.com>
Date: Mon, 25 Sep 2017 00:57:18 +0000
Subject: [PATCH] Move Config->SymbolRenaming to SymbolTable.

In order to keep track of symbol renaming, we used to have
Config->SymbolRenaming, and whether a symbol is in the map or not
affects its symbol attribute (i.e. "LinkeRedefined" bit).

This patch adds "CanInline" bit to Symbol to aggreagate symbol
information in one place and removed the member from Config since
no one except SymbolTable now uses the table.

llvm-svn: 314088
---
 lld/ELF/LTO.cpp         |  2 +-
 lld/ELF/SymbolTable.cpp | 33 ++++++++++++++++++---------------
 lld/ELF/SymbolTable.h   | 10 ++++++++++
 lld/ELF/Symbols.h       |  5 +++++
 4 files changed, 34 insertions(+), 16 deletions(-)

diff --git a/lld/ELF/LTO.cpp b/lld/ELF/LTO.cpp
index 7425bfc..3dac264 100644
--- a/lld/ELF/LTO.cpp
+++ b/lld/ELF/LTO.cpp
@@ -153,7 +153,7 @@ void BitcodeCompiler::add(BitcodeFile &F) {
                             UsedStartStop.count(ObjSym.getSectionName());
     if (R.Prevailing)
       undefine(Sym);
-    R.LinkerRedefined = Config->RenamedSymbols.count(Sym);
+    R.LinkerRedefined = !Sym->CanInline;
   }
   checkError(LTOObj->add(std::move(F.Obj), Resols));
 }
diff --git a/lld/ELF/SymbolTable.cpp b/lld/ELF/SymbolTable.cpp
index e1fcba6..68d84b5 100644
--- a/lld/ELF/SymbolTable.cpp
+++ b/lld/ELF/SymbolTable.cpp
@@ -162,11 +162,10 @@ template <class ELFT> void SymbolTable::addSymbolWrap(StringRef Name) {
   Symbol *Real = addUndefined<ELFT>(Saver.save("__real_" + Name));
   Symbol *Wrap = addUndefined<ELFT>(Saver.save("__wrap_" + Name));
 
-  // Tell LTO not to eliminate this symbol
+  // Tell LTO not to eliminate this symbol.
   Wrap->IsUsedInRegularObj = true;
-
-  Config->RenamedSymbols[Real] = {Sym, Real->Binding};
-  Config->RenamedSymbols[Sym] = {Wrap, Sym->Binding};
+  defsym(Real, Sym);
+  defsym(Sym, Wrap);
 }
 
 // Creates alias for symbol. Used to implement --defsym=ALIAS=SYM.
@@ -177,12 +176,10 @@ void SymbolTable::addSymbolAlias(StringRef Alias, StringRef Name) {
     error("-defsym: undefined symbol: " + Name);
     return;
   }
-  Symbol *Sym = B->symbol();
-  Symbol *AliasSym = addUndefined<ELFT>(Alias);
 
-  // Tell LTO not to eliminate this symbol
-  Sym->IsUsedInRegularObj = true;
-  Config->RenamedSymbols[AliasSym] = {Sym, AliasSym->Binding};
+  // Tell LTO not to eliminate this symbol.
+  B->symbol()->IsUsedInRegularObj = true;
+  defsym(addUndefined<ELFT>(Alias), B->symbol());
 }
 
 // Apply symbol renames created by -wrap and -defsym. The renames are created
@@ -190,12 +187,10 @@ void SymbolTable::addSymbolAlias(StringRef Alias, StringRef Name) {
 // LTO (if LTO is running) not to include these symbols in IPO. Now that the
 // symbols are finalized, we can perform the replacement.
 void SymbolTable::applySymbolRenames() {
-  for (auto &KV : Config->RenamedSymbols) {
-    Symbol *Dst = KV.first;
-    Symbol *Src = KV.second.Target;
-    Dst->body()->copy(Src->body());
-    Dst->File = Src->File;
-    Dst->Binding = KV.second.OriginalBinding;
+  for (SymbolRenaming &S : Defsyms) {
+    S.Dst->body()->copy(S.Src->body());
+    S.Dst->File = S.Src->File;
+    S.Dst->Binding = S.Binding;
   }
 }
 
@@ -233,6 +228,7 @@ std::pair<Symbol *, bool> SymbolTable::insert(StringRef Name) {
     Sym->Visibility = STV_DEFAULT;
     Sym->IsUsedInRegularObj = false;
     Sym->ExportDynamic = false;
+    Sym->CanInline = true;
     Sym->Traced = V.Traced;
     Sym->VersionId = Config->DefaultSymbolVersion;
     SymVector.push_back(Sym);
@@ -525,6 +521,13 @@ SymbolBody *SymbolTable::find(StringRef Name) {
   return SymVector[V.Idx]->body();
 }
 
+void SymbolTable::defsym(Symbol *Dst, Symbol *Src) {
+  // We want to tell LTO not to inline Dst symbol because LTO doesn't
+  // know the final symbol contents after renaming.
+  Dst->CanInline = false;
+  Defsyms.push_back({Dst, Src, Dst->Binding});
+}
+
 template <class ELFT>
 Symbol *SymbolTable::addLazyArchive(ArchiveFile *F,
                                     const object::Archive::Symbol Sym) {
diff --git a/lld/ELF/SymbolTable.h b/lld/ELF/SymbolTable.h
index 6c09407..5f2ff66 100644
--- a/lld/ELF/SymbolTable.h
+++ b/lld/ELF/SymbolTable.h
@@ -95,6 +95,7 @@ public:
 private:
   std::vector<SymbolBody *> findByVersion(SymbolVersion Ver);
   std::vector<SymbolBody *> findAllByVersion(SymbolVersion Ver);
+  void defsym(Symbol *Dst, Symbol *Src);
 
   llvm::StringMap<std::vector<SymbolBody *>> &getDemangledSyms();
   void handleAnonymousVersion();
@@ -132,6 +133,15 @@ private:
   // directive in version scripts.
   llvm::Optional<llvm::StringMap<std::vector<SymbolBody *>>> DemangledSyms;
 
+  struct SymbolRenaming {
+    Symbol *Dst;
+    Symbol *Src;
+    uint8_t Binding;
+  };
+
+  // For -defsym or -wrap.
+  std::vector<SymbolRenaming> Defsyms;
+
   // For LTO.
   std::unique_ptr<BitcodeCompiler> LTO;
 };
diff --git a/lld/ELF/Symbols.h b/lld/ELF/Symbols.h
index fe9457f..54a9b46 100644
--- a/lld/ELF/Symbols.h
+++ b/lld/ELF/Symbols.h
@@ -365,6 +365,11 @@ struct Symbol {
   // --export-dynamic, and by dynamic lists.
   unsigned ExportDynamic : 1;
 
+  // False if LTO shouldn't inline whatever this symbol points to. If a symbol
+  // is overwritten after LTO, LTO shouldn't inline the symbol because it
+  // doesn't know the final contents of the symbol.
+  unsigned CanInline : 1;
+
   // True if this symbol is specified by --trace-symbol option.
   unsigned Traced : 1;
 
-- 
2.7.4